Example usage for java.util.concurrent TimeUnit DAYS

Introduction

In this page you can find the example usage for java.util.concurrent TimeUnit DAYS.

Prototype

TimeUnit DAYS

To view the source code for java.util.concurrent TimeUnit DAYS.

Click Source Link

Document

Time unit representing twenty four hours.

Usage

From source file:ch.cern.db.flume.sink.elasticsearch.ElasticSearchSink.java

private long parseTTL(String ttl) {
    matcher = matcher.reset(ttl);//ww  w.  jav  a  2 s .  c  o m
    while (matcher.find()) {
        if (matcher.group(2).equals("ms")) {
            return Long.parseLong(matcher.group(1));
        } else if (matcher.group(2).equals("s")) {
            return TimeUnit.SECONDS.toMillis(Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("m")) {
            return TimeUnit.MINUTES.toMillis(Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("h")) {
            return TimeUnit.HOURS.toMillis(Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("d")) {
            return TimeUnit.DAYS.toMillis(Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("w")) {
            return TimeUnit.DAYS.toMillis(7 * Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("")) {
            logger.info("TTL qualifier is empty. Defaulting to day qualifier.");
            return TimeUnit.DAYS.toMillis(Integer.parseInt(matcher.group(1)));
        } else {
            logger.debug("Unknown TTL qualifier provided. Setting TTL to 0.");
            return 0;
        }
    }
    logger.info("TTL not provided. Skipping the TTL config by returning 0.");
    return 0;
}

---

From source file:org.apps8os.motivator.ui.MoodHistoryActivity.java

/**
 * Used to set the selected day and week of the sprint in the activity.
 * @param dayInMillis/*from w  w w. ja  v  a  2s.  co m*/
 */
public void setSelectedDay(long dayInMillis) {
    // Calculate the selected day position in the viewpager
    mSelectedDay = (int) TimeUnit.DAYS.convert(dayInMillis - mSprintStartDateInMillis, TimeUnit.MILLISECONDS);
    Calendar selectedDayAsCalendar = Calendar.getInstance();
    selectedDayAsCalendar.setFirstDayOfWeek(Calendar.MONDAY);
    selectedDayAsCalendar.setTimeInMillis(dayInMillis);
    // Calculate the selected day position as week in the viewpager
    mSelectedWeek = selectedDayAsCalendar.get(Calendar.WEEK_OF_YEAR) - mStartDate.get(Calendar.WEEK_OF_YEAR);
    // Take into account change of year.
    if (mSelectedWeek < 0) {
        mSelectedWeek = 52 - mStartDate.get(Calendar.WEEK_OF_YEAR)
                + selectedDayAsCalendar.get(Calendar.WEEK_OF_YEAR);
    } else {
    }
    // Set the day or week depending on orientation.
    if (mRes.getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {
        mViewPager.setCurrentItem(mSelectedDay);
    } else if (mRes.getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
        mViewPager.setCurrentItem(mSelectedWeek);
    }
}

---

From source file:com.asakusafw.operation.tools.hadoop.fs.CleanTest.java

private Clean createService(long days) {
    Clean service = new Clean(TimeUnit.DAYS.toMillis(days));
    service.setConf(new Configuration());
    return service;
}

---

From source file:de.tudarmstadt.lt.seg.app.Segmenter.java

private void run_parallel() throws Exception {

    InputStream in = System.in;
    if (!"-".equals(_filename_in))
        in = new FileInputStream(_filename_in);
    Stream<String> liter = new BufferedReader(new InputStreamReader(in, Charset.defaultCharset())).lines();

    ThreadLocal<ISentenceSplitter> sentenceSplitter = ThreadLocal.withInitial(() -> {
        try {/*from w  w w.j  a v a 2 s  .c  o  m*/
            return newSentenceSplitter();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    });
    ThreadLocal<ITokenizer> tokenizer = ThreadLocal.withInitial(() -> {
        try {
            return newTokenizer();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    });

    final PrintWriter[] w = new PrintWriter[_parallelism];
    // init writers
    for (int i = 0; i < _parallelism; i++) {
        OutputStream out = System.out;
        if (!"-".equals(_filename_out)) {
            out = new FileOutputStream(String.format("%s_%d", _filename_out, i));
        }
        w[i] = new PrintWriter(new OutputStreamWriter(out, Charset.defaultCharset()));
    }

    BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(_parallelism * 2, true);
    ExecutorService es = new ThreadPoolExecutor(_parallelism, _parallelism, 0L, TimeUnit.MILLISECONDS, queue);

    AtomicLong lc = new AtomicLong(0);
    liter.forEach((line) -> {
        // don't try to submit new threads, wait until the thread queue has some capacity again
        while (queue.remainingCapacity() == 0)
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                /**/}
        es.submit(() -> {
            final long docid = lc.incrementAndGet();
            if (docid % 1000 == 0)
                System.err.format("Processing line %d ('%s')%n", docid, _filename_in);
            final int w_i = (int) (docid % _parallelism);
            split_and_tokenize(new StringReader(line.trim()), String.format("%s:%d", _filename_in, docid),
                    sentenceSplitter.get(), tokenizer.get(), _level_filter, _level_normalize, _merge_types,
                    _merge_tokens, _separator_sentence, _separator_token, _separator_desc, w[w_i]);

        });
    });
    es.shutdown();
    es.awaitTermination(Integer.MAX_VALUE, TimeUnit.DAYS);

    // TODO: the stream parallelism version does not work because it submits too many threads at once
    //      AtomicLong lc = new AtomicLong(0);
    //      ForkJoinPool forkJoinPool = new ForkJoinPool(_parallelism);
    //      forkJoinPool.submit(() -> 
    //         liter.parallel().forEach((line) -> {
    //            final long docid = lc.incrementAndGet();
    //            if(docid % 1000 == 0)
    //               System.err.format("Processing line %d ('%s')%n", docid, _filename_in);
    //   
    //            String l = line.replace("\\t", "\t").replace("\\n", "\n");
    //            split_and_tokenize(
    //                  new StringReader(l),
    //                  String.format("%s:%d", _filename_in, docid),
    //                  sentenceSplitter.get(), 
    //                  tokenizer.get(), 
    //                  _level_filter,
    //                  _level_normalize,
    //                  _merge_types,
    //                  _merge_tokens,
    //                  _separator_sentence,
    //                  _separator_token,
    //                  _separator_desc,
    //                  w);
    //      })).get();

}

---

From source file:org.gaul.s3proxy.S3ProxyHandler.java

public final void doHandle(HttpServletRequest baseRequest, HttpServletRequest request,
        HttpServletResponse response, InputStream is) throws IOException, S3Exception {
    String method = request.getMethod();
    String uri = request.getRequestURI();

    if (!this.servicePath.isEmpty()) {
        if (uri.length() > this.servicePath.length()) {
            uri = uri.substring(this.servicePath.length());
        }//  ww  w . ja  va 2 s .  co  m
    }

    logger.debug("request: {}", request);
    String hostHeader = request.getHeader(HttpHeaders.HOST);
    if (hostHeader != null && virtualHost.isPresent()) {
        hostHeader = HostAndPort.fromString(hostHeader).getHostText();
        String virtualHostSuffix = "." + virtualHost.get();
        if (!hostHeader.equals(virtualHost.get())) {
            if (hostHeader.endsWith(virtualHostSuffix)) {
                String bucket = hostHeader.substring(0, hostHeader.length() - virtualHostSuffix.length());
                uri = "/" + bucket + uri;
            } else {
                String bucket = hostHeader.toLowerCase();
                uri = "/" + bucket + uri;
            }
        }
    }

    boolean hasDateHeader = false;
    boolean hasXAmzDateHeader = false;
    for (String headerName : Collections.list(request.getHeaderNames())) {
        for (String headerValue : Collections.list(request.getHeaders(headerName))) {
            logger.trace("header: {}: {}", headerName, Strings.nullToEmpty(headerValue));
        }
        if (headerName.equalsIgnoreCase(HttpHeaders.DATE)) {
            hasDateHeader = true;
        } else if (headerName.equalsIgnoreCase("x-amz-date")) {
            hasXAmzDateHeader = true;
        }
    }

    // when access information is not provided in request header,
    // treat it as anonymous, return all public accessible information
    if (!anonymousIdentity && (method.equals("GET") || method.equals("HEAD") || method.equals("POST"))
            && request.getHeader(HttpHeaders.AUTHORIZATION) == null
            && request.getParameter("X-Amz-Algorithm") == null && request.getParameter("AWSAccessKeyId") == null
            && defaultBlobStore != null) {
        doHandleAnonymous(request, response, is, uri, defaultBlobStore);
        return;
    }

    if (!anonymousIdentity && !hasDateHeader && !hasXAmzDateHeader && request.getParameter("X-Amz-Date") == null
            && request.getParameter("Expires") == null) {
        throw new S3Exception(S3ErrorCode.ACCESS_DENIED,
                "AWS authentication requires a valid Date or" + " x-amz-date header");
    }

    // TODO: apply sanity checks to X-Amz-Date
    if (hasDateHeader) {
        long date;
        try {
            date = request.getDateHeader(HttpHeaders.DATE);
        } catch (IllegalArgumentException iae) {
            throw new S3Exception(S3ErrorCode.ACCESS_DENIED, iae);
        }
        if (date < 0) {
            throw new S3Exception(S3ErrorCode.ACCESS_DENIED);
        }
        long now = System.currentTimeMillis();
        if (now + TimeUnit.DAYS.toMillis(1) < date || now - TimeUnit.DAYS.toMillis(1) > date) {
            throw new S3Exception(S3ErrorCode.REQUEST_TIME_TOO_SKEWED);
        }
    }

    BlobStore blobStore;
    String requestIdentity = null;
    String headerAuthorization = request.getHeader(HttpHeaders.AUTHORIZATION);
    S3AuthorizationHeader authHeader = null;
    boolean presignedUrl = false;

    if (!anonymousIdentity) {
        if (headerAuthorization == null) {
            String algorithm = request.getParameter("X-Amz-Algorithm");
            if (algorithm == null) {
                String identity = request.getParameter("AWSAccessKeyId");
                String signature = request.getParameter("Signature");
                if (identity == null || signature == null) {
                    throw new S3Exception(S3ErrorCode.ACCESS_DENIED);
                }
                headerAuthorization = "AWS " + identity + ":" + signature;
                presignedUrl = true;
            } else if (algorithm.equals("AWS4-HMAC-SHA256")) {
                String credential = request.getParameter("X-Amz-Credential");
                String signedHeaders = request.getParameter("X-Amz-SignedHeaders");
                String signature = request.getParameter("X-Amz-Signature");
                if (credential == null || signedHeaders == null || signature == null) {
                    throw new S3Exception(S3ErrorCode.ACCESS_DENIED);
                }
                headerAuthorization = "AWS4-HMAC-SHA256" + " Credential=" + credential
                        + ", requestSignedHeaders=" + signedHeaders + ", Signature=" + signature;
                presignedUrl = true;
            }
        }

        try {
            authHeader = new S3AuthorizationHeader(headerAuthorization);
        } catch (IllegalArgumentException iae) {
            throw new S3Exception(S3ErrorCode.INVALID_ARGUMENT, iae);
        }
        requestIdentity = authHeader.identity;
    }

    String[] path = uri.split("/", 3);
    for (int i = 0; i < path.length; i++) {
        path[i] = URLDecoder.decode(path[i], "UTF-8");
    }

    Map.Entry<String, BlobStore> provider = blobStoreLocator.locateBlobStore(requestIdentity,
            path.length > 1 ? path[1] : null, path.length > 2 ? path[2] : null);
    if (anonymousIdentity) {
        blobStore = provider.getValue();
        String contentSha256 = request.getHeader("x-amz-content-sha256");
        if ("STREAMING-AWS4-HMAC-SHA256-PAYLOAD".equals(contentSha256)) {
            is = new ChunkedInputStream(is);
        }
    } else if (requestIdentity == null) {
        throw new S3Exception(S3ErrorCode.ACCESS_DENIED);
    } else {
        if (provider == null) {
            throw new S3Exception(S3ErrorCode.INVALID_ACCESS_KEY_ID);
        }

        String credential = provider.getKey();
        blobStore = provider.getValue();

        String expiresString = request.getParameter("Expires");
        if (expiresString != null) {
            long expires = Long.parseLong(expiresString);
            long nowSeconds = System.currentTimeMillis() / 1000;
            if (nowSeconds >= expires) {
                throw new S3Exception(S3ErrorCode.ACCESS_DENIED);
            }
        }

        String dateString = request.getParameter("X-Amz-Date");
        expiresString = request.getParameter("X-Amz-Expires");
        if (dateString != null && expiresString != null) {
            long date = parseIso8601(dateString);
            long expires = Long.parseLong(expiresString);
            long nowSeconds = System.currentTimeMillis() / 1000;
            if (nowSeconds >= date + expires) {
                throw new S3Exception(S3ErrorCode.ACCESS_DENIED, "Request has expired");
            }
        }

        switch (authHeader.authenticationType) {
        case AWS_V2:
            switch (authenticationType) {
            case AWS_V2:
            case AWS_V2_OR_V4:
            case NONE:
                break;
            default:
                throw new S3Exception(S3ErrorCode.ACCESS_DENIED);
            }
            break;
        case AWS_V4:
            switch (authenticationType) {
            case AWS_V4:
            case AWS_V2_OR_V4:
            case NONE:
                break;
            default:
                throw new S3Exception(S3ErrorCode.ACCESS_DENIED);
            }
            break;
        case NONE:
            break;
        default:
            throw new IllegalArgumentException("Unhandled type: " + authHeader.authenticationType);
        }

        String expectedSignature = null;

        // When presigned url is generated, it doesn't consider service path
        String uriForSigning = presignedUrl ? uri : this.servicePath + uri;
        if (authHeader.hmacAlgorithm == null) {
            expectedSignature = createAuthorizationSignature(request, uriForSigning, credential);
        } else {
            String contentSha256 = request.getHeader("x-amz-content-sha256");
            try {
                byte[] payload;
                if (request.getParameter("X-Amz-Algorithm") != null) {
                    payload = new byte[0];
                } else if ("STREAMING-AWS4-HMAC-SHA256-PAYLOAD".equals(contentSha256)) {
                    payload = new byte[0];
                    is = new ChunkedInputStream(is);
                } else if ("UNSIGNED-PAYLOAD".equals(contentSha256)) {
                    payload = new byte[0];
                } else {
                    // buffer the entire stream to calculate digest
                    payload = ByteStreams.toByteArray(ByteStreams.limit(is, v4MaxNonChunkedRequestSize + 1));
                    if (payload.length == v4MaxNonChunkedRequestSize + 1) {
                        throw new S3Exception(S3ErrorCode.MAX_MESSAGE_LENGTH_EXCEEDED);
                    }
                    is = new ByteArrayInputStream(payload);
                }
                expectedSignature = createAuthorizationSignatureV4(baseRequest, authHeader, payload,
                        uriForSigning, credential);
            } catch (InvalidKeyException | NoSuchAlgorithmException e) {
                throw new S3Exception(S3ErrorCode.INVALID_ARGUMENT, e);
            }
        }

        if (!expectedSignature.equals(authHeader.signature)) {
            logger.debug("fail to validate signature");
            throw new S3Exception(S3ErrorCode.SIGNATURE_DOES_NOT_MATCH);
        }
    }

    for (String parameter : Collections.list(request.getParameterNames())) {
        if (UNSUPPORTED_PARAMETERS.contains(parameter)) {
            logger.error("Unknown parameters {} with URI {}", parameter, request.getRequestURI());
            throw new S3Exception(S3ErrorCode.NOT_IMPLEMENTED);
        }
    }

    // emit NotImplemented for unknown x-amz- headers
    for (String headerName : Collections.list(request.getHeaderNames())) {
        if (ignoreUnknownHeaders) {
            continue;
        }
        if (!headerName.startsWith("x-amz-")) {
            continue;
        }
        if (headerName.startsWith("x-amz-meta-")) {
            continue;
        }
        if (!SUPPORTED_X_AMZ_HEADERS.contains(headerName.toLowerCase())) {
            logger.error("Unknown header {} with URI {}", headerName, request.getRequestURI());
            throw new S3Exception(S3ErrorCode.NOT_IMPLEMENTED);
        }
    }

    String uploadId = request.getParameter("uploadId");
    switch (method) {
    case "DELETE":
        if (path.length <= 2 || path[2].isEmpty()) {
            handleContainerDelete(response, blobStore, path[1]);
            return;
        } else if (uploadId != null) {
            handleAbortMultipartUpload(response, blobStore, path[1], path[2], uploadId);
            return;
        } else {
            handleBlobRemove(response, blobStore, path[1], path[2]);
            return;
        }
    case "GET":
        if (uri.equals("/")) {
            handleContainerList(response, blobStore);
            return;
        } else if (path.length <= 2 || path[2].isEmpty()) {
            if ("".equals(request.getParameter("acl"))) {
                handleGetContainerAcl(response, blobStore, path[1]);
                return;
            } else if ("".equals(request.getParameter("location"))) {
                handleContainerLocation(response, blobStore, path[1]);
                return;
            } else if ("".equals(request.getParameter("uploads"))) {
                handleListMultipartUploads(request, response, blobStore, path[1]);
                return;
            }
            handleBlobList(request, response, blobStore, path[1]);
            return;
        } else {
            if ("".equals(request.getParameter("acl"))) {
                handleGetBlobAcl(response, blobStore, path[1], path[2]);
                return;
            } else if (uploadId != null) {
                handleListParts(request, response, blobStore, path[1], path[2], uploadId);
                return;
            }
            handleGetBlob(request, response, blobStore, path[1], path[2]);
            return;
        }
    case "HEAD":
        if (path.length <= 2 || path[2].isEmpty()) {
            handleContainerExists(blobStore, path[1]);
            return;
        } else {
            handleBlobMetadata(request, response, blobStore, path[1], path[2]);
            return;
        }
    case "POST":
        if ("".equals(request.getParameter("delete"))) {
            handleMultiBlobRemove(response, is, blobStore, path[1]);
            return;
        } else if ("".equals(request.getParameter("uploads"))) {
            handleInitiateMultipartUpload(request, response, blobStore, path[1], path[2]);
            return;
        } else if (uploadId != null && request.getParameter("partNumber") == null) {
            handleCompleteMultipartUpload(response, is, blobStore, path[1], path[2], uploadId);
            return;
        }
        break;
    case "PUT":
        if (path.length <= 2 || path[2].isEmpty()) {
            if ("".equals(request.getParameter("acl"))) {
                handleSetContainerAcl(request, response, is, blobStore, path[1]);
                return;
            }
            handleContainerCreate(request, response, is, blobStore, path[1]);
            return;
        } else if (uploadId != null) {
            if (request.getHeader("x-amz-copy-source") != null) {
                handleCopyPart(request, response, blobStore, path[1], path[2], uploadId);
            } else {
                handleUploadPart(request, response, is, blobStore, path[1], path[2], uploadId);
            }
            return;
        } else if (request.getHeader("x-amz-copy-source") != null) {
            handleCopyBlob(request, response, is, blobStore, path[1], path[2]);
            return;
        } else {
            if ("".equals(request.getParameter("acl"))) {
                handleSetBlobAcl(request, response, is, blobStore, path[1], path[2]);
                return;
            }
            handlePutBlob(request, response, is, blobStore, path[1], path[2]);
            return;
        }
    default:
        break;
    }
    logger.error("Unknown method {} with URI {}", method, request.getRequestURI());
    throw new S3Exception(S3ErrorCode.NOT_IMPLEMENTED);
}

---

From source file:org.apache.marmotta.kiwi.infinispan.embedded.InfinispanEmbeddedCacheManager.java

/**
 * Return the prefix -> namespace cache from the cache manager. Used for looking up namespaces
 * @return// w w w  .  j  a v a  2  s.  c  o  m
 */
public Map getNamespacePrefixCache() {
    if (nsPrefixCache == null) {
        if (isClustered()) {
            Configuration nsprefixConfiguration = new ConfigurationBuilder().read(defaultConfiguration)
                    .clustering().cacheMode(CacheMode.REPL_ASYNC).eviction()
                    .maxEntries(config.getNamespaceCacheSize()).expiration().lifespan(1, TimeUnit.DAYS).build();
            cacheManager.defineConfiguration(NS_PREFIX_CACHE, nsprefixConfiguration);

        } else {
            Configuration nsprefixConfiguration = new ConfigurationBuilder().read(defaultConfiguration)
                    .eviction().maxEntries(config.getNamespaceCacheSize()).expiration()
                    .lifespan(1, TimeUnit.HOURS).build();
            cacheManager.defineConfiguration(NS_PREFIX_CACHE, nsprefixConfiguration);

        }
        nsPrefixCache = cacheManager.getCache(NS_PREFIX_CACHE).getAdvancedCache().withFlags(Flag.SKIP_LOCKING,
                Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP);
    }
    return nsPrefixCache;
}

---

From source file:kaist.gs1.pms.initialPedigree.java

private String getExpirationDate(String expirationDate) {
    //    gtin  ? ?(day) ?? ?
    // ? initial pedigree ?      ?
    long time = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(Integer.parseInt(expirationDate));
    SimpleDateFormat dayTime = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");
    return dayTime.format(new Date(time));
}

---

From source file:org.eclipse.skalli.core.rest.admin.StatisticsQueryTest.java

private void assertFromPeriodQuery(String period, int value, TimeUnit unit) {
    Calendar cal = Calendar.getInstance();
    long now = cal.getTimeInMillis();
    long fromMillis = now - TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS);
    cal.setTimeInMillis(fromMillis);/*from   www  . java  2s.c om*/
    String fromStr = DatatypeConverter.printDateTime(cal);
    StatisticsQuery query = new StatisticsQuery(getParams(fromStr, null, period), now);
    Assert.assertEquals(fromMillis, query.getFrom());
    Assert.assertEquals(fromMillis + TimeUnit.MILLISECONDS.convert(value, unit), query.getTo());
}

---

From source file:com.frontier45.flume.sink.elasticsearch2.ElasticSearchSink.java

private long parseTTL(String ttl) {
    matcher = matcher.reset(ttl);// ww  w. ja v a2  s. com
    while (matcher.find()) {
        if (matcher.group(2).equals("ms")) {
            return Long.parseLong(matcher.group(1));
        } else if (matcher.group(2).equals("s")) {
            return TimeUnit.SECONDS.toMillis(Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("m")) {
            return TimeUnit.MINUTES.toMillis(Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("h")) {
            return TimeUnit.HOURS.toMillis(Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("d")) {
            return TimeUnit.DAYS.toMillis(Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("w")) {
            return TimeUnit.DAYS.toMillis(7L * Integer.parseInt(matcher.group(1)));
        } else if (matcher.group(2).equals("")) {
            logger.info("TTL qualifier is empty. Defaulting to day qualifier.");
            return TimeUnit.DAYS.toMillis(Integer.parseInt(matcher.group(1)));
        } else {
            logger.debug("Unknown TTL qualifier provided. Setting TTL to 0.");
            return 0;
        }
    }
    logger.info("TTL not provided. Skipping the TTL config by returning 0.");
    return 0;
}

---

From source file:com.atypon.wayf.guice.WayfGuiceModule.java

@Provides
@Named("passwordSaltCache")
@Singleton// w  ww  . j  a va 2s.  co m
public Cache<String, String> getAdminSaltLoadingCache(CacheManager cacheManager,
        PasswordCredentialsFacade passwordCredentialsFacade,
        @Named("passwordSaltRedisDao") RedisDao<String, String> passwordSaltRedisDao,
        @Named("passwordSaltCacheGroup") String passwordSaltCacheGroup) {

    LoadingCacheRedisImpl<String, String> l2Cache = new LoadingCacheRedisImpl<>();
    l2Cache.setRedisDao(passwordSaltRedisDao);
    l2Cache.setCacheLoader((email) -> passwordCredentialsFacade.getSaltForEmail(email).toMaybe());

    LoadingCacheGuavaImpl<String, String> l1Cache = new LoadingCacheGuavaImpl<>();
    l1Cache.setGuavaCache(CacheBuilder.newBuilder().expireAfterWrite(1, TimeUnit.DAYS).build());
    l1Cache.setCacheLoader(l2Cache::get);

    cacheManager.registerCacheGroup(passwordSaltCacheGroup, l1Cache, l2Cache);

    return l1Cache;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• »