Bei processed fügt das bundle den Request alse Cache-Request hinzu
177832
public function trigger(Event $event) {
    $request = $event->getTarget();
    
    $cachedRequest = new CachedRequest($request->getURL());
    $cachedRequest->setCachedResponse($event->getData()->response);
    $cachedRequest->setHeaders($event->getData()->headers);
    
    $this->addCachedRequest($cachedRequest);
  }
1323662
@Override
	public void processBundles(GlobalPostProcessingContext ctx, List<JoinableResourceBundle> bundles) {

		if (ctx.hasBundleToBeProcessed()) {
			String workingDir = ctx.getRsReaderHandler().getWorkingDirectory();

			if (srcDir == null || destDir == null || tempDir == null || srcZipDir == null || destZipDir == null) {
				srcDir = ctx.getBundleHandler().getBundleTextDirPath();
				srcZipDir = ctx.getBundleHandler().getBundleZipDirPath();
				destDir = workingDir + GOOGLE_CLOSURE_RESULT_TEXT_DIR;
				destZipDir = workingDir + GOOGLE_CLOSURE_RESULT_ZIP_DIR;
				tempDir = workingDir + GOOGLE_CLOSURE_TEMP_DIR;
			}

			// Create result directory
			File dir = new File(destDir);
			if (!dir.exists() && !dir.mkdirs()) {
				throw new BundlingProcessException("Impossible to create temporary directory :" + destDir);
			}

			// Create result directory
			dir = new File(destZipDir);
			if (!dir.exists() && !dir.mkdirs()) {
				throw new BundlingProcessException("Impossible to create temporary directory :" + destZipDir);
			}

			// Create temporary directory
			dir = new File(tempDir);
			if (!dir.exists() && !dir.mkdirs()) {
				throw new BundlingProcessException("Impossible to create temporary directory :" + tempDir);
			}

			// Copy the bundle files in a temp directory
			try {
				FileUtils.copyDirectory(new File(srcDir), new File(tempDir));

				Map<String, String> resultBundleMapping = new HashMap<>();
				JawrClosureCommandLineRunner cmdRunner = new JawrClosureCommandLineRunner(ctx, bundles,
						resultBundleMapping);
				cmdRunner.doRun();
				// Copy compiled bundles
				FileUtils.copyDirectory(new File(destDir), new File(srcDir));

				// Copy zipped compiled bundles
				FileUtils.copyDirectory(new File(destZipDir), new File(srcZipDir));

			} catch (Exception e) {

				throw new BundlingProcessException(e);
			}
		}
	}
239408
@Route(method = HttpMethod.POST, uri = "/{id}")
    public Result updateBundle(@Parameter("id") long id) {
        final Bundle bundle = context.getBundle(id);
        if (bundle == null) {
            return notFound("Bundle " + id + " not found");
        } else {
            return async(new Callable<Result>() {
                @Override
                public Result call() throws Exception {
                    try {
                        logger().info("Updating bundle {} from {}", bundle.getSymbolicName(), bundle.getLocation());
                        bundle.update();
                        return ok();
                    } catch (BundleException e) {
                        logger().error("Cannot update bundle {}", bundle.getSymbolicName(), e);
                        return badRequest(e);
                    }
                }
            });
        }
    }
1111377
public function process(Request $request) {
    // required
    $service = $this->getRegisteredService($request->getPart(1));
    
    $call = new Call(mb_strtolower($request->getMethod()));
    
    // identifier ist optional
    if (($identifier = $request->getPart(2)) !== NULL) {
      $call->addParameter($identifier);

      /* alle Subs weitergeben als weitere Parameter */
      foreach ($request->getPartsFrom(3) as $p) {
        $call->addParameter($p);
      }
    } else {
      $call->setName('index');
    }
    
    if ($request->getMethod() === Request::POST || $request->getMethod() === Request::PUT) {
      $call->addParameter($request->getBody());
    }
    
    $this->call = $call;
    $this->service = $service;
    return $this->call();
  }
748967
protected ResourceBundle[] resolveBundles (HttpServletRequest req)
    {
        // first look to see if we've cached the bundles for this request in the request object
        ResourceBundle[] bundles = null;
        if (req != null) {
            bundles = (ResourceBundle[])req.getAttribute(getBundleCacheName());
        }
        if (bundles != null) {
            return bundles;
        }

        ClassLoader siteLoader = null;
        String siteString = null;
        if (_siteIdent != null) {
            int siteId = _siteIdent.identifySite(req);
            siteString = _siteIdent.getSiteString(siteId);

            // grab our site-specific class loader if we have one
            if (_siteLoader != null) {
                try {
                    siteLoader = _siteLoader.getSiteClassLoader(siteId);
                } catch (IOException ioe) {
                    log.warning("Unable to fetch site-specific classloader", "siteId", siteId,
                                "error", ioe);
                }
            }
        }

        // try looking up the appropriate bundles
        bundles = new ResourceBundle[2];

        // first from the site-specific classloader
        if (siteLoader != null) {
            bundles[0] = resolveBundle(req, _siteBundlePath, siteLoader, false);
        } else if (siteString != null) {
            // or just try prefixing the site string to the normal bundle path and see if that
            // turns something up
            bundles[0] = resolveBundle(req, siteString + "_" + _bundlePath,
                                       getClass().getClassLoader(), true);
        }

        // then from the default classloader
        bundles[1] = resolveBundle(req, _bundlePath, getClass().getClassLoader(), false);

        // if we found either or both bundles, cache 'em
        if (bundles[0] != null || bundles[1] != null && req != null) {
            req.setAttribute(getBundleCacheName(), bundles);
        }

        return bundles;
    }
877892
public function processRequest()
    {
        // get version cache file
        $version = $this->getVersion();

        // get class data from the compiled cache files
        $classData = $this->compilerCache->getCacheContent($this->api, $this->class, $version);

        // match request
        return $this->matchRequest($classData);
    }
116274
public function buildCache()
    {
        if (!empty($this->viewDirectories) || !empty($this->configDirectories) || !empty($this->resourceDirectories)) {
            return;
        }

        foreach ($this->orderReference as $namespace)
        {
            /**
             * @var \Slab\Components\BundleInterface $bundle
             */
            $bundle =& $this->bundleReference[$namespace];

            $this->viewDirectories[] = $bundle->getViewDirectory();
            $this->configDirectories[] = $bundle->getConfigDirectory();
            $this->resourceDirectories[] = $bundle->getResourceDirectory();
        }
    }
493586
public function cacheResponseByTypo3Cache(
        $requestUri,
        array $requestGetData,
        array $apiMethodInfoMetadata,
        $responseData,
        $responseFormatClass,
        array $responseHeaders
    ) {
        $identifier = $this->buildIdentifier($requestUri, $requestGetData);
        $frontendCacheExpires = (integer) $apiMethodInfoMetadata['expires'];
        $typo3CacheExpires = (integer) $apiMethodInfoMetadata[self::API_METHOD_TYPO3CACHE_EXPIRES];
        $typo3CacheTags = explode(',', $apiMethodInfoMetadata[self::API_METHOD_TYPO3CACHE_TAGS]);

        $cacheData = array();
        $cacheData['requestUri'] = $requestUri;
        $cacheData['requestGetData'] = $requestGetData;
        $cacheData['responseData'] = $responseData;
        $cacheData['responseFormatClass'] = $responseFormatClass;
        $cacheData['responseHeaders'] = $responseHeaders;
        $cacheData['frontendCacheExpires'] = $frontendCacheExpires;

        $this->cache->set($identifier, $cacheData, $typo3CacheTags, $typo3CacheExpires);
    }
395386
@SuppressWarnings({ "unchecked" })
    /* package */<T> HystrixCachedObservable<T> get(String cacheKey) {
        ValueCacheKey key = getRequestCacheKey(cacheKey);
        if (key != null) {
            ConcurrentHashMap<ValueCacheKey, HystrixCachedObservable<?>> cacheInstance = requestVariableForCache.get(concurrencyStrategy);
            if (cacheInstance == null) {
                throw new IllegalStateException("Request caching is not available. Maybe you need to initialize the HystrixRequestContext?");
            }
            /* look for the stored value */
            return (HystrixCachedObservable<T>) cacheInstance.get(key);
        }
        return null;
    }
193840
def download(self, request, **kwargs):
        

        # method check to avoid bad requests
        self.method_check(request, allowed=['get'])

        # create a basic bundle object for self.get_cached_obj_get.
        basic_bundle = self.build_bundle(request=request)

        # using the primary key defined in the url, obtain the tileset
        tileset = self.cached_obj_get(
            bundle=basic_bundle,
            **self.remove_api_resource_names(kwargs))

        filename = helpers.get_tileset_filename(tileset)
        filename = os.path.abspath(filename)
        if os.path.isfile(filename):
            response = serve(request, os.path.basename(filename), os.path.dirname(filename))
            response['Content-Disposition'] = 'attachment; filename="{}"'.format(os.path.basename(filename))
        else:
            response = self.create_response(request, {'status': 'not generated'})
        return response
894502
def process_request(self, req, resp):
        

        key = req.env['REMOTE_PORT'] + req.env['REMOTE_ADDR']
        val = self.cache.get(key, 0)

        if val == self.count:
            abort(exceptions.TooManyRequests(headers=self._error_headers))
        else:
            self.cache[key] = val + 1
982307
private void addToCache(BundleInfo bInfo) {
        List<Resource> info = _cacheBySymbolicName.get(bInfo.symbolicName);
        if (info == null) {
            info = new ArrayList<Resource>();
            info.add(bInfo);
        }

        info = _cacheBySymbolicName.putIfAbsent(bInfo.symbolicName, info);

        if (info != null) {
            synchronized (info) {
                info.add(bInfo);
            }
        }

        _bundleLocations.add(bInfo.file);
    }
261810
def dispatch(self, request, *args, **kwargs):
        
        if not graphql_api_settings.CACHE_ACTIVE:
            return self.super_call(request, *args, **kwargs)

        cache = caches["default"]
        operation_ast = self.get_operation_ast(request)
        if operation_ast and operation_ast.operation == "mutation":
            cache.clear()
            return self.super_call(request, *args, **kwargs)

        cache_key = "_graplql_{}".format(self.fetch_cache_key(request))
        response = cache.get(cache_key)

        if not response:
            response = self.super_call(request, *args, **kwargs)

            # cache key and value
            cache.set(cache_key, response, timeout=graphql_api_settings.CACHE_TIMEOUT)

        return response
416706
function bundle(location, opts, callback) {
    var b
    if (opts.watchify) {
        b = getFromCache(location, opts);
    } else {
        b = getBundle(location, opts)
    }

    b.bundle(function onPayload(err, payload) {
        if (err) {
            return callback(err);
        }

        payload = embedNodeEnv() + payload;

        callback(null, payload);
    });
}
634142
public boolean shouldCache(String requestUri) {
		String uri = requestUri.toLowerCase();
		return checkContains(uri, cacheIdentifiers) || checkSuffixes(uri, cacheSuffixes);
	}
1016658
@Route(method = HttpMethod.GET, uri = BROWSER_WATCH_BUNDLES)
	public Result bundles() {
		return ok(render(template));
	}
670410
private Data getCurrencyData(ULocale locale) {
        CompactDecimalDataCache.DataBundle bundle = cache.get(locale);
            return bundle.shortCurrencyData;
    }