private SecurityGroup getSecurityGroup(
final String nodeId, final SecurityGroupExtension securityApi, final String locationId) {
// Expect to have two security groups on the node: one shared between all nodes in the location,
// that is cached in sharedGroupCache, and one created by Jclouds that is unique to the node.
// Relies on customize having been called before. This should be safe because the arguments
// needed to call this method are not available until post-instance creation.
SecurityGroup machineUniqueSecurityGroup;
Tasks.setBlockingDetails("Loading unique security group for node: " + nodeId);
try {
machineUniqueSecurityGroup =
uniqueGroupCache.get(
nodeId,
new Callable<SecurityGroup>() {
@Override
public SecurityGroup call() throws Exception {
SecurityGroup sg =
getUniqueSecurityGroupForNodeCachingSharedGroupIfPreviouslyUnknown(
nodeId, locationId, securityApi);
if (sg == null) {
throw new IllegalStateException(
"Failed to find machine-unique group on node: " + nodeId);
}
return sg;
}
});
} catch (UncheckedExecutionException e) {
throw Throwables.propagate(new Exception(e.getCause()));
} catch (ExecutionException e) {
throw Throwables.propagate(new Exception(e.getCause()));
} finally {
Tasks.resetBlockingDetails();
}
return machineUniqueSecurityGroup;
}
/**
* Loads the cache result, computing it if needed by executing the query phase and otherwise
* deserializing the cached value into the {@link SearchContext#queryResult() context's query
* result}. The combination of load + compute allows to have a single load operation that will
* cause other requests with the same key to wait till its loaded an reuse the same cache.
*/
public void loadIntoContext(
final ShardSearchRequest request, final SearchContext context, final QueryPhase queryPhase)
throws Exception {
assert canCache(request, context);
Key key = buildKey(request, context);
Loader loader = new Loader(queryPhase, context, key);
Value value = cache.get(key, loader);
if (loader.isLoaded()) {
key.shard.requestCache().onMiss();
// see if its the first time we see this reader, and make sure to register a cleanup key
CleanupKey cleanupKey =
new CleanupKey(
context.indexShard(),
((DirectoryReader) context.searcher().getIndexReader()).getVersion());
if (!registeredClosedListeners.containsKey(cleanupKey)) {
Boolean previous = registeredClosedListeners.putIfAbsent(cleanupKey, Boolean.TRUE);
if (previous == null) {
context.searcher().getIndexReader().addReaderClosedListener(cleanupKey);
}
}
} else {
key.shard.requestCache().onHit();
// restore the cached query result into the context
final QuerySearchResult result = context.queryResult();
result.readFromWithId(context.id(), value.reference.streamInput());
result.shardTarget(context.shardTarget());
}
}
/**
* Creates a valid Period based on the given date. E.g. the given date is February 10. 2007, a
* monthly PeriodType should return February 2007.
*
* @param date the date which is contained by the created period.
* @return the valid Period based on the given date
*/
public Period createPeriod(final Date date) {
try {
return PERIOD_CACHE.get(getCacheKey(date), () -> createPeriod(createCalendarInstance(date)));
} catch (ExecutionException ignored) {
}
return null;
}
/**
* 获取缓存
*
* @param key
* @param callable
* @return
*/
public static Object get(String key, Callable callable) {
Object object = null;
try {
object = cache.get(key, callable);
} catch (ExecutionException e) {
logger.error("cache get error:{}", ExceptionUtils.getMessage(e));
}
return object;
}
public User getUser(final UUID uuid) {
try {
return users.get(uuid.toString());
} catch (ExecutionException ex) {
return null;
} catch (UncheckedExecutionException ex) {
return null;
}
}
@GET
@Timed
@ApiOperation(
value =
"Get a list of all sources (not more than 5000) that have messages in the current indices. "
+ "The result is cached for 10 seconds.",
notes =
"Range: The parameter is in seconds relative to the current time. 86400 means 'in the last day',"
+ "0 is special and means 'across all indices'")
@ApiResponses(value = {@ApiResponse(code = 400, message = "Invalid range parameter provided.")})
@Produces(MediaType.APPLICATION_JSON)
public SourcesList list(
@ApiParam(
name = "range",
value = "Relative timeframe to search in. See method description.",
required = true)
@QueryParam("range")
@Min(0)
final int range,
@ApiParam(
name = "size",
value = "Maximum size of the result set.",
required = false,
defaultValue = "5000")
@QueryParam("size")
@DefaultValue("5000")
@Min(0)
final int size) {
final TermsResult sources;
try {
sources =
CACHE.get(
range,
new Callable<TermsResult>() {
@Override
public TermsResult call() throws Exception {
try {
return searches.terms("source", size, "*", RelativeRange.create(range));
} catch (InvalidRangeParametersException | InvalidRangeFormatException e) {
throw new ExecutionException(e);
}
}
});
} catch (ExecutionException e) {
if (e.getCause() instanceof InvalidRangeParametersException) {
LOG.error("Invalid relative time range: " + range, e);
throw new BadRequestException("Invalid time range: " + range, e);
} else {
LOG.error("Could not calculate list of sources.", e);
throw new InternalServerErrorException(e);
}
}
return SourcesList.create(
sources.getTerms().size(), sources.getTerms(), sources.took().millis(), range);
}
/**
* Creates a valid Period based on the given date. E.g. the given date is February 10. 2007, a
* monthly PeriodType should return February 2007. This method is intended for use in situations
* where a huge number of of periods will be generated and its desirable to re-use the calendar.
*
* @param date the date which is contained by the created period.
* @param calendar the calendar implementation to use.
* @return the valid Period based on the given date
*/
public Period createPeriod(final Date date, final org.hisp.dhis.calendar.Calendar calendar) {
try {
return PERIOD_CACHE.get(
getCacheKey(calendar, date),
() -> createPeriod(calendar.fromIso(DateTimeUnit.fromJdkDate(date)), calendar));
} catch (ExecutionException ignored) {
}
return null;
}
@Override
public String simplify(final String input) {
try {
return cache.get(
input,
new Callable<String>() {
@Override
public String call() throws Exception {
return simplifier.simplify(input);
}
});
} catch (ExecutionException e) {
// Can't happen. Simplifier may not throw checked exceptions
throw new IllegalStateException(e);
}
}
public static Object get(String key) {
Object value = null;
try {
value =
cache.get(
key,
new Callable<Object>() {
@Override
public Object call() throws Exception {
return "from cache :" + key;
}
});
} catch (ExecutionException e) {
e.printStackTrace();
}
return value;
}
@SuppressWarnings("unchecked")
@Override
public T get() {
Cache<EventDAO, Object> cache = CACHE_MAP.get(getClass());
assert cache != null;
try {
return (T)
cache.get(
eventDAO,
new Callable<Object>() {
@Override
public Object call() {
return create(eventDAO);
}
});
} catch (ExecutionException e) {
throw Throwables.propagate(e.getCause());
}
}
@Override
protected Object doInvoke(Object proxy, final Method method, Object[] args) throws Throwable {
M methodResolver = null;
if (methodCaches == null) {
methodResolver = createMethodResolver(method);
} else {
methodResolver =
methodCaches.get(
method,
new Callable<M>() {
@Override
public M call() throws Exception {
return createMethodResolver(method);
}
});
}
return invokeMethod(proxy, methodResolver, args);
}
public SyncProduct createSyncProduct(final I_PMM_Product pmmProduct) {
final String product_uuid = SyncUUIDs.toUUIDString(pmmProduct);
try {
final SyncProduct syncProduct =
syncProductsCache.get(
product_uuid,
new Callable<SyncProduct>() {
@Override
public SyncProduct call() throws Exception {
return createSyncProductNoCache(pmmProduct);
}
});
return syncProduct.copy();
} catch (final ExecutionException ex) {
throw new RuntimeException(
"Failed creating " + SyncProduct.class + " for " + pmmProduct, ex.getCause());
}
}
@Override
public Channel queryUniqueByName(final String name) {
try {
return cacheOnName.get(
name,
new Callable<Channel>() {
@Override
public Channel call() throws Exception {
return (Channel)
getSqlSession().selectOne(getNamespace().concat(".queryUniqueByName"), name);
}
});
} catch (Exception ignore) {
getLogger().error("some error occur when access to the cache on name", ignore);
return null;
}
}
/**
* @param clazz
* @param methodName
* @param parameterTypes
* @return
* @throws NoSuchMethodException
*/
public static Method findMethod(
final Class<?> clazz, final String methodName, final Class<?>[] parameterTypes)
throws NoSuchMethodException {
String key = makeFindMethodCacheKey(clazz, methodName, parameterTypes);
Method method = null;
try {
method =
findMethodCache.get(
key,
new Callable<Method>() {
public Method call() throws Exception {
return _findMethod(clazz, methodName, parameterTypes);
}
});
} catch (ExecutionException e) {
throw new Siren4JRuntimeException(e);
}
return method;
}
/**
* Builds a cache for each URL that determines how it should be processed.
*
* @return
*/
private URLProcessor lookupProcessorFromCache(String requestURIWithoutContextPath)
throws ExecutionException {
if (urlCache == null) {
urlCache =
CacheBuilder.newBuilder()
.maximumSize(maxCacheElements)
.concurrencyLevel(maxCacheConcurrency)
.expireAfterWrite(cacheExpirationSeconds, TimeUnit.SECONDS)
.build(
new CacheLoader<String, URLProcessor>() {
public URLProcessor load(String key) throws IOException, ServletException {
if (LOG.isDebugEnabled()) {
LOG.debug("Loading URL processor into Cache");
}
return determineURLProcessor(key);
}
});
}
return urlCache.get(requestURIWithoutContextPath);
}
private ConfigDataHandler getConfigDataHandler(final String app, final String dataId)
throws ExecutionException {
return cdhs.get(
dataId,
new Callable<ConfigDataHandler>() {
@Override
public ConfigDataHandler call() throws Exception {
return cdhf.getConfigDataHandler(
dataId,
new ConfigDataListener() {
@Override
public void onDataRecieved(String dataId, String data) {
parseConfig(dataId, app, data);
}
});
}
});
}
protected CookieManager getPersonalCookieManager() {
try {
if (!ThreadContext.exists()) return defaultManager;
OrientDbWebSession session = OrientDbWebSession.get();
session.bind();
String id = session.getId();
if (session.isSignedIn()) id = session.getUsername() + '-' + id;
return cache.get(
id,
new Callable<CookieManager>() {
@Override
public CookieManager call() throws Exception {
return new CookieManager();
}
});
} catch (ExecutionException e) {
throw new IllegalStateException("Cookie Manager should be always calculated");
}
}
private void setSecurityGroupOnTemplate(
final JcloudsLocation location,
final Template template,
final SecurityGroupExtension securityApi) {
SecurityGroup shared;
Tasks.setBlockingDetails(
"Loading security group shared by instances in "
+ template.getLocation()
+ " in app "
+ applicationId);
try {
shared =
sharedGroupCache.get(
template.getLocation(),
new Callable<SecurityGroup>() {
@Override
public SecurityGroup call() throws Exception {
return getOrCreateSharedSecurityGroup(template.getLocation(), securityApi);
}
});
} catch (ExecutionException e) {
throw Throwables.propagate(new Exception(e.getCause()));
} finally {
Tasks.resetBlockingDetails();
}
Set<String> originalGroups = template.getOptions().getGroups();
template.getOptions().securityGroups(shared.getName());
if (!originalGroups.isEmpty()) {
LOG.info(
"Replaced configured security groups: configured={}, replaced with={}",
originalGroups,
template.getOptions().getGroups());
} else {
LOG.debug(
"Configured security groups at {} to: {}", location, template.getOptions().getGroups());
}
}
public Object get(final String key, Callable<?> valueLoader) throws ExecutionException {
shouldNotBeWhiteSpace(key, "key");
return cache.get(key, valueLoader);
}
