/** Clears all entries in the cache. */ public void clear() { lock.lock(); try { for (ClassLoader classLoader : classLoaderDetails.asMap().keySet()) { ClassLoaderUtils.tryClose(classLoader); } classLoaderDetails.invalidateAll(); classLoaderIds.invalidateAll(); } finally { lock.unlock(); } }
@Override public Collection<Notification> retrieveNotifications() { try { return Lists.newArrayList(notifications.asMap().values()); } finally { notifications.invalidateAll(); notifications.cleanUp(); } }
@Override public void close() { while (!regs.isEmpty()) { final FinalizablePhantomReference<?> ref = regs.get(0); ref.finalizeReferent(); } cache.invalidateAll(); queue.close(); }
@Override public <T extends Definition> boolean invalidate(DefDescriptor<T> descriptor) { defs.clear(); if (localDescs != null) { localDescs.clear(); } localDependencies.clear(); accessCache.clear(); securityProvider = null; lastRootDesc = null; depsCache.invalidateAll(); defsCache.invalidateAll(); existsCache.invalidateAll(); descriptorFilterCache.invalidateAll(); return false; }
/* * (non-Javadoc) * * @see org.apache.bookkeeper.mledger.ManagedLedger#close() */ @Override public synchronized void close() throws InterruptedException, ManagedLedgerException { checkFenced(); for (LedgerHandle ledger : ledgerCache.asMap().values()) { log.debug("Closing ledger: {}", ledger.getId()); try { ledger.close(); } catch (BKException e) { throw new ManagedLedgerException(e); } } ledgerCache.invalidateAll(); log.info("Invalidated {} ledgers in cache", ledgerCache.size()); factory.close(this); }
private static void invalidateStaticCaches(DefDescriptor<?> descriptor) { depsCache.invalidateAll(); descriptorFilterCache.invalidateAll(); if (descriptor == null) { defsCache.invalidateAll(); existsCache.invalidateAll(); } else { defsCache.invalidate(descriptor); existsCache.invalidate(descriptor); // invalidate all DDs with the same namespace if its a namespace DD if (descriptor.getDefType() == DefType.NAMESPACE) { invalidateScope(descriptor, true, false); } if (descriptor.getDefType() == DefType.LAYOUTS) { invalidateScope(descriptor, true, true); } } }
@Override public void doFilter( ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest; HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse; String url = httpServletRequest.getRequestURI(); httpServletResponse.setHeader(CACHE_HEADER, CacheState.SKIPPED.toString()); if (!isURLAccepted(url) || !isQueryStringAccepted(httpServletRequest.getQueryString()) || !isUserAgentAccepted(httpServletRequest.getHeader(Constants.HTTP_USER_AGENT_HEADER))) { LOGGER.debug("Skipping Cache filter for: {}?{}", url, httpServletRequest.getQueryString()); LOGGER.debug("URL, QueryString or UserAgent not accepted"); filterChain.doFilter(servletRequest, servletResponse); return; } long now = new Date().getTime(); CacheObject cacheObject = cache.getIfPresent(url); boolean expireCache = httpServletRequest.getParameter(Constants.PARAM_EXPIRE_CACHE) != null; if (expireCache) { LOGGER.trace("Removing Cache for {} due to URL parameter.", url); cache.invalidate(url); } boolean resetCache = httpServletRequest.getParameter(Constants.PARAM_RESET_CACHE) != null || resetTime > 0 && (now - lastResetTime) / 1000 > resetTime; if (resetCache) { LOGGER.trace("Resetting whole Cache for {} due to URL parameter.", url); cache.invalidateAll(); // fixme: we don't need reset since cache values are soft referenced. lastResetTime = now; } boolean skipCache = httpServletRequest.getParameter(Constants.PARAM_DEBUG) != null || httpServletRequest.getParameter(Constants.PARAM_SKIP_CACHE) != null; if (skipCache) { filterChain.doFilter(servletRequest, servletResponse); LOGGER.trace("Skipping Cache for {} due to URL parameter.", url); return; } List<String> requestedResources = findResourcesToMerge(httpServletRequest.getContextPath(), url); ServletContext context = filterConfig.getServletContext(); String extensionOrPath = detectExtension(url); // in case of non js/css files it null if (extensionOrPath == null) { extensionOrPath = requestedResources.get( 0); // non grouped i.e. non css/js file, we refer it's path in that case } JSCSSMergeServlet.ResourceStatus status = JSCSSMergeServlet.isNotModified(context, httpServletRequest, requestedResources, false); if (status.isNotModified()) { LOGGER.trace("Resources Not Modified. Sending 304."); cache.invalidate(url); JSCSSMergeServlet.sendNotModified( httpServletResponse, extensionOrPath, status.getActualETag(), DEFAULT_EXPIRES_MINUTES, DEFAULT_CACHE_CONTROL); return; } boolean cacheFound = false; if (cacheObject != null && cacheObject.getWebUtilitiesResponseWrapper() != null) { if (requestedResources != null && isAnyResourceModifiedSince(requestedResources, cacheObject.getTime(), context)) { LOGGER.trace("Some resources have been modified since last cache: {}", url); cache.invalidate(url); cacheFound = false; } else { LOGGER.trace("Found valid cached response."); // cacheObject.increaseAccessCount(); cacheFound = true; } } if (cacheFound) { LOGGER.debug("Returning Cached response."); cacheObject.getWebUtilitiesResponseWrapper().fill(httpServletResponse); httpServletResponse.setHeader(CACHE_HEADER, CacheState.FOUND.toString()); // fillResponseFromCache(httpServletResponse, cacheObject.getModuleResponse()); } else { LOGGER.trace("Cache not found or invalidated"); httpServletResponse.setHeader(CACHE_HEADER, CacheState.NOT_FOUND.toString()); WebUtilitiesResponseWrapper wrapper = new WebUtilitiesResponseWrapper(httpServletResponse); filterChain.doFilter(servletRequest, wrapper); // some filters return no status code, but we believe that it is "200 OK" if (wrapper.getStatus() == 0) { wrapper.setStatus(200); } if (isMIMEAccepted(wrapper.getContentType()) && !expireCache && !resetCache && wrapper.getStatus() == 200) { // Cache only 200 status response cache.put(url, new CacheObject(getLastModifiedFor(requestedResources, context), wrapper)); LOGGER.debug("Cache added for: {}", url); httpServletResponse.setHeader(CACHE_HEADER, CacheState.ADDED.toString()); } else { LOGGER.trace("Cache NOT added for: {}", url); LOGGER.trace("is MIME not accepted: {}", isMIMEAccepted(wrapper.getContentType())); LOGGER.trace("is expireCache: {}", expireCache); LOGGER.trace("is resetCache: {}", resetCache); } wrapper.fill(httpServletResponse); } }
public void close() { reaper.close(); cache.invalidateAll(); }
/** {@inheritDoc} */ @Override public void clear() { cache.invalidateAll(); }
@Override public void removeAll(Iterable<String> keys) { cache.invalidateAll(keys); }
/** {@inheritDoc} */ @Override public void removeAll(String... keys) { cache.invalidateAll(Arrays.asList(keys)); }
public void invalidateAll() { users.invalidateAll(); }
/** * Invalidates all entries in {@link #sharedGroupCache} and {@link #uniqueGroupCache}. Use to * simulate the effects of rebinding Brooklyn to a deployment. */ @VisibleForTesting void clearSecurityGroupCaches() { LOG.info("Clearing security group caches"); sharedGroupCache.invalidateAll(); uniqueGroupCache.invalidateAll(); }
public static final void invalidateKeys(Collection<String> keys) { if (singleCache != null) { singleCache.invalidateAll(keys); } }