vendor/symfony/http-kernel/HttpCache/HttpCache.php line 344

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <[email protected]>
  6.  *
  7.  * This code is partially based on the Rack-Cache library by Ryan Tomayko,
  8.  * which is released under the MIT license.
  9.  * (based on commit 02d2b48d75bcb63cf1c0c7149c077ad256542801)
  10.  *
  11.  * For the full copyright and license information, please view the LICENSE
  12.  * file that was distributed with this source code.
  13.  */
  14. namespace Symfony\Component\HttpKernel\HttpCache;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpFoundation\Response;
  17. use Symfony\Component\HttpKernel\HttpKernelInterface;
  18. use Symfony\Component\HttpKernel\TerminableInterface;
  19. /**
  20.  * Cache provides HTTP caching.
  21.  *
  22.  * @author Fabien Potencier <[email protected]>
  23.  */
  24. class HttpCache implements HttpKernelInterfaceTerminableInterface
  25. {
  26.     private $kernel;
  27.     private $store;
  28.     private $request;
  29.     private $surrogate;
  30.     private $surrogateCacheStrategy;
  31.     private $options = [];
  32.     private $traces = [];
  33.     /**
  34.      * Constructor.
  35.      *
  36.      * The available options are:
  37.      *
  38.      *   * debug                  If true, exceptions are thrown when things go wrong. Otherwise, the cache
  39.      *                            will try to carry on and deliver a meaningful response.
  40.      *
  41.      *   * trace_level            May be one of 'none', 'short' and 'full'. For 'short', a concise trace of the
  42.      *                            master request will be added as an HTTP header. 'full' will add traces for all
  43.      *                            requests (including ESI subrequests). (default: 'full' if in debug; 'none' otherwise)
  44.      *
  45.      *   * trace_header           Header name to use for traces. (default: X-Symfony-Cache)
  46.      *
  47.      *   * default_ttl            The number of seconds that a cache entry should be considered
  48.      *                            fresh when no explicit freshness information is provided in
  49.      *                            a response. Explicit Cache-Control or Expires headers
  50.      *                            override this value. (default: 0)
  51.      *
  52.      *   * private_headers        Set of request headers that trigger "private" cache-control behavior
  53.      *                            on responses that don't explicitly state whether the response is
  54.      *                            public or private via a Cache-Control directive. (default: Authorization and Cookie)
  55.      *
  56.      *   * allow_reload           Specifies whether the client can force a cache reload by including a
  57.      *                            Cache-Control "no-cache" directive in the request. Set it to ``true``
  58.      *                            for compliance with RFC 2616. (default: false)
  59.      *
  60.      *   * allow_revalidate       Specifies whether the client can force a cache revalidate by including
  61.      *                            a Cache-Control "max-age=0" directive in the request. Set it to ``true``
  62.      *                            for compliance with RFC 2616. (default: false)
  63.      *
  64.      *   * stale_while_revalidate Specifies the default number of seconds (the granularity is the second as the
  65.      *                            Response TTL precision is a second) during which the cache can immediately return
  66.      *                            a stale response while it revalidates it in the background (default: 2).
  67.      *                            This setting is overridden by the stale-while-revalidate HTTP Cache-Control
  68.      *                            extension (see RFC 5861).
  69.      *
  70.      *   * stale_if_error         Specifies the default number of seconds (the granularity is the second) during which
  71.      *                            the cache can serve a stale response when an error is encountered (default: 60).
  72.      *                            This setting is overridden by the stale-if-error HTTP Cache-Control extension
  73.      *                            (see RFC 5861).
  74.      */
  75.     public function __construct(HttpKernelInterface $kernelStoreInterface $storeSurrogateInterface $surrogate null, array $options = [])
  76.     {
  77.         $this->store $store;
  78.         $this->kernel $kernel;
  79.         $this->surrogate $surrogate;
  80.         // needed in case there is a fatal error because the backend is too slow to respond
  81.         register_shutdown_function([$this->store'cleanup']);
  82.         $this->options array_merge([
  83.             'debug' => false,
  84.             'default_ttl' => 0,
  85.             'private_headers' => ['Authorization''Cookie'],
  86.             'allow_reload' => false,
  87.             'allow_revalidate' => false,
  88.             'stale_while_revalidate' => 2,
  89.             'stale_if_error' => 60,
  90.             'trace_level' => 'none',
  91.             'trace_header' => 'X-Symfony-Cache',
  92.         ], $options);
  93.         if (!isset($options['trace_level'])) {
  94.             $this->options['trace_level'] = $this->options['debug'] ? 'full' 'none';
  95.         }
  96.     }
  97.     /**
  98.      * Gets the current store.
  99.      *
  100.      * @return StoreInterface A StoreInterface instance
  101.      */
  102.     public function getStore()
  103.     {
  104.         return $this->store;
  105.     }
  106.     /**
  107.      * Returns an array of events that took place during processing of the last request.
  108.      *
  109.      * @return array An array of events
  110.      */
  111.     public function getTraces()
  112.     {
  113.         return $this->traces;
  114.     }
  115.     private function addTraces(Response $response)
  116.     {
  117.         $traceString null;
  118.         if ('full' === $this->options['trace_level']) {
  119.             $traceString $this->getLog();
  120.         }
  121.         if ('short' === $this->options['trace_level'] && $masterId array_key_first($this->traces)) {
  122.             $traceString implode('/'$this->traces[$masterId]);
  123.         }
  124.         if (null !== $traceString) {
  125.             $response->headers->add([$this->options['trace_header'] => $traceString]);
  126.         }
  127.     }
  128.     /**
  129.      * Returns a log message for the events of the last request processing.
  130.      *
  131.      * @return string A log message
  132.      */
  133.     public function getLog()
  134.     {
  135.         $log = [];
  136.         foreach ($this->traces as $request => $traces) {
  137.             $log[] = sprintf('%s: %s'$requestimplode(', '$traces));
  138.         }
  139.         return implode('; '$log);
  140.     }
  141.     /**
  142.      * Gets the Request instance associated with the master request.
  143.      *
  144.      * @return Request A Request instance
  145.      */
  146.     public function getRequest()
  147.     {
  148.         return $this->request;
  149.     }
  150.     /**
  151.      * Gets the Kernel instance.
  152.      *
  153.      * @return HttpKernelInterface An HttpKernelInterface instance
  154.      */
  155.     public function getKernel()
  156.     {
  157.         return $this->kernel;
  158.     }
  159.     /**
  160.      * Gets the Surrogate instance.
  161.      *
  162.      * @return SurrogateInterface A Surrogate instance
  163.      *
  164.      * @throws \LogicException
  165.      */
  166.     public function getSurrogate()
  167.     {
  168.         return $this->surrogate;
  169.     }
  170.     /**
  171.      * {@inheritdoc}
  172.      */
  173.     public function handle(Request $request$type HttpKernelInterface::MASTER_REQUEST$catch true)
  174.     {
  175.         // FIXME: catch exceptions and implement a 500 error page here? -> in Varnish, there is a built-in error page mechanism
  176.         if (HttpKernelInterface::MASTER_REQUEST === $type) {
  177.             $this->traces = [];
  178.             // Keep a clone of the original request for surrogates so they can access it.
  179.             // We must clone here to get a separate instance because the application will modify the request during
  180.             // the application flow (we know it always does because we do ourselves by setting REMOTE_ADDR to 127.0.0.1
  181.             // and adding the X-Forwarded-For header, see HttpCache::forward()).
  182.             $this->request = clone $request;
  183.             if (null !== $this->surrogate) {
  184.                 $this->surrogateCacheStrategy $this->surrogate->createCacheStrategy();
  185.             }
  186.         }
  187.         $this->traces[$this->getTraceKey($request)] = [];
  188.         if (!$request->isMethodSafe()) {
  189.             $response $this->invalidate($request$catch);
  190.         } elseif ($request->headers->has('expect') || !$request->isMethodCacheable()) {
  191.             $response $this->pass($request$catch);
  192.         } elseif ($this->options['allow_reload'] && $request->isNoCache()) {
  193.             /*
  194.                 If allow_reload is configured and the client requests "Cache-Control: no-cache",
  195.                 reload the cache by fetching a fresh response and caching it (if possible).
  196.             */
  197.             $this->record($request'reload');
  198.             $response $this->fetch($request$catch);
  199.         } else {
  200.             $response $this->lookup($request$catch);
  201.         }
  202.         $this->restoreResponseBody($request$response);
  203.         if (HttpKernelInterface::MASTER_REQUEST === $type) {
  204.             $this->addTraces($response);
  205.         }
  206.         if (null !== $this->surrogate) {
  207.             if (HttpKernelInterface::MASTER_REQUEST === $type) {
  208.                 $this->surrogateCacheStrategy->update($response);
  209.             } else {
  210.                 $this->surrogateCacheStrategy->add($response);
  211.             }
  212.         }
  213.         $response->prepare($request);
  214.         $response->isNotModified($request);
  215.         return $response;
  216.     }
  217.     /**
  218.      * {@inheritdoc}
  219.      */
  220.     public function terminate(Request $requestResponse $response)
  221.     {
  222.         if ($this->getKernel() instanceof TerminableInterface) {
  223.             $this->getKernel()->terminate($request$response);
  224.         }
  225.     }
  226.     /**
  227.      * Forwards the Request to the backend without storing the Response in the cache.
  228.      *
  229.      * @param bool $catch Whether to process exceptions
  230.      *
  231.      * @return Response A Response instance
  232.      */
  233.     protected function pass(Request $request$catch false)
  234.     {
  235.         $this->record($request'pass');
  236.         return $this->forward($request$catch);
  237.     }
  238.     /**
  239.      * Invalidates non-safe methods (like POST, PUT, and DELETE).
  240.      *
  241.      * @param bool $catch Whether to process exceptions
  242.      *
  243.      * @return Response A Response instance
  244.      *
  245.      * @throws \Exception
  246.      *
  247.      * @see RFC2616 13.10
  248.      */
  249.     protected function invalidate(Request $request$catch false)
  250.     {
  251.         $response $this->pass($request$catch);
  252.         // invalidate only when the response is successful
  253.         if ($response->isSuccessful() || $response->isRedirect()) {
  254.             try {
  255.                 $this->store->invalidate($request);
  256.                 // As per the RFC, invalidate Location and Content-Location URLs if present
  257.                 foreach (['Location''Content-Location'] as $header) {
  258.                     if ($uri $response->headers->get($header)) {
  259.                         $subRequest Request::create($uri'get', [], [], [], $request->server->all());
  260.                         $this->store->invalidate($subRequest);
  261.                     }
  262.                 }
  263.                 $this->record($request'invalidate');
  264.             } catch (\Exception $e) {
  265.                 $this->record($request'invalidate-failed');
  266.                 if ($this->options['debug']) {
  267.                     throw $e;
  268.                 }
  269.             }
  270.         }
  271.         return $response;
  272.     }
  273.     /**
  274.      * Lookups a Response from the cache for the given Request.
  275.      *
  276.      * When a matching cache entry is found and is fresh, it uses it as the
  277.      * response without forwarding any request to the backend. When a matching
  278.      * cache entry is found but is stale, it attempts to "validate" the entry with
  279.      * the backend using conditional GET. When no matching cache entry is found,
  280.      * it triggers "miss" processing.
  281.      *
  282.      * @param bool $catch Whether to process exceptions
  283.      *
  284.      * @return Response A Response instance
  285.      *
  286.      * @throws \Exception
  287.      */
  288.     protected function lookup(Request $request$catch false)
  289.     {
  290.         try {
  291.             $entry $this->store->lookup($request);
  292.         } catch (\Exception $e) {
  293.             $this->record($request'lookup-failed');
  294.             if ($this->options['debug']) {
  295.                 throw $e;
  296.             }
  297.             return $this->pass($request$catch);
  298.         }
  299.         if (null === $entry) {
  300.             $this->record($request'miss');
  301.             return $this->fetch($request$catch);
  302.         }
  303.         if (!$this->isFreshEnough($request$entry)) {
  304.             $this->record($request'stale');
  305.             return $this->validate($request$entry$catch);
  306.         }
  307.         if ($entry->headers->hasCacheControlDirective('no-cache')) {
  308.             return $this->validate($request$entry$catch);
  309.         }
  310.         $this->record($request'fresh');
  311.         $entry->headers->set('Age'$entry->getAge());
  312.         return $entry;
  313.     }
  314.     /**
  315.      * Validates that a cache entry is fresh.
  316.      *
  317.      * The original request is used as a template for a conditional
  318.      * GET request with the backend.
  319.      *
  320.      * @param bool $catch Whether to process exceptions
  321.      *
  322.      * @return Response A Response instance
  323.      */
  324.     protected function validate(Request $requestResponse $entry$catch false)
  325.     {
  326.         $subRequest = clone $request;
  327.         // send no head requests because we want content
  328.         if ('HEAD' === $request->getMethod()) {
  329.             $subRequest->setMethod('GET');
  330.         }
  331.         // add our cached last-modified validator
  332.         if ($entry->headers->has('Last-Modified')) {
  333.             $subRequest->headers->set('if_modified_since'$entry->headers->get('Last-Modified'));
  334.         }
  335.         // Add our cached etag validator to the environment.
  336.         // We keep the etags from the client to handle the case when the client
  337.         // has a different private valid entry which is not cached here.
  338.         $cachedEtags $entry->getEtag() ? [$entry->getEtag()] : [];
  339.         $requestEtags $request->getETags();
  340.         if ($etags array_unique(array_merge($cachedEtags$requestEtags))) {
  341.             $subRequest->headers->set('if_none_match'implode(', '$etags));
  342.         }
  343.         $response $this->forward($subRequest$catch$entry);
  344.         if (304 == $response->getStatusCode()) {
  345.             $this->record($request'valid');
  346.             // return the response and not the cache entry if the response is valid but not cached
  347.             $etag $response->getEtag();
  348.             if ($etag && \in_array($etag$requestEtags) && !\in_array($etag$cachedEtags)) {
  349.                 return $response;
  350.             }
  351.             $entry = clone $entry;
  352.             $entry->headers->remove('Date');
  353.             foreach (['Date''Expires''Cache-Control''ETag''Last-Modified'] as $name) {
  354.                 if ($response->headers->has($name)) {
  355.                     $entry->headers->set($name$response->headers->get($name));
  356.                 }
  357.             }
  358.             $response $entry;
  359.         } else {
  360.             $this->record($request'invalid');
  361.         }
  362.         if ($response->isCacheable()) {
  363.             $this->store($request$response);
  364.         }
  365.         return $response;
  366.     }
  367.     /**
  368.      * Unconditionally fetches a fresh response from the backend and
  369.      * stores it in the cache if is cacheable.
  370.      *
  371.      * @param bool $catch Whether to process exceptions
  372.      *
  373.      * @return Response A Response instance
  374.      */
  375.     protected function fetch(Request $request$catch false)
  376.     {
  377.         $subRequest = clone $request;
  378.         // send no head requests because we want content
  379.         if ('HEAD' === $request->getMethod()) {
  380.             $subRequest->setMethod('GET');
  381.         }
  382.         // avoid that the backend sends no content
  383.         $subRequest->headers->remove('if_modified_since');
  384.         $subRequest->headers->remove('if_none_match');
  385.         $response $this->forward($subRequest$catch);
  386.         if ($response->isCacheable()) {
  387.             $this->store($request$response);
  388.         }
  389.         return $response;
  390.     }
  391.     /**
  392.      * Forwards the Request to the backend and returns the Response.
  393.      *
  394.      * All backend requests (cache passes, fetches, cache validations)
  395.      * run through this method.
  396.      *
  397.      * @param bool          $catch Whether to catch exceptions or not
  398.      * @param Response|null $entry A Response instance (the stale entry if present, null otherwise)
  399.      *
  400.      * @return Response A Response instance
  401.      */
  402.     protected function forward(Request $request$catch falseResponse $entry null)
  403.     {
  404.         if ($this->surrogate) {
  405.             $this->surrogate->addSurrogateCapability($request);
  406.         }
  407.         // always a "master" request (as the real master request can be in cache)
  408.         $response SubRequestHandler::handle($this->kernel$requestHttpKernelInterface::MASTER_REQUEST$catch);
  409.         /*
  410.          * Support stale-if-error given on Responses or as a config option.
  411.          * RFC 7234 summarizes in Section 4.2.4 (but also mentions with the individual
  412.          * Cache-Control directives) that
  413.          *
  414.          *      A cache MUST NOT generate a stale response if it is prohibited by an
  415.          *      explicit in-protocol directive (e.g., by a "no-store" or "no-cache"
  416.          *      cache directive, a "must-revalidate" cache-response-directive, or an
  417.          *      applicable "s-maxage" or "proxy-revalidate" cache-response-directive;
  418.          *      see Section 5.2.2).
  419.          *
  420.          * https://tools.ietf.org/html/rfc7234#section-4.2.4
  421.          *
  422.          * We deviate from this in one detail, namely that we *do* serve entries in the
  423.          * stale-if-error case even if they have a `s-maxage` Cache-Control directive.
  424.          */
  425.         if (null !== $entry
  426.             && \in_array($response->getStatusCode(), [500502503504])
  427.             && !$entry->headers->hasCacheControlDirective('no-cache')
  428.             && !$entry->mustRevalidate()
  429.         ) {
  430.             if (null === $age $entry->headers->getCacheControlDirective('stale-if-error')) {
  431.                 $age $this->options['stale_if_error'];
  432.             }
  433.             /*
  434.              * stale-if-error gives the (extra) time that the Response may be used *after* it has become stale.
  435.              * So we compare the time the $entry has been sitting in the cache already with the
  436.              * time it was fresh plus the allowed grace period.
  437.              */
  438.             if ($entry->getAge() <= $entry->getMaxAge() + $age) {
  439.                 $this->record($request'stale-if-error');
  440.                 return $entry;
  441.             }
  442.         }
  443.         /*
  444.             RFC 7231 Sect. 7.1.1.2 says that a server that does not have a reasonably accurate
  445.             clock MUST NOT send a "Date" header, although it MUST send one in most other cases
  446.             except for 1xx or 5xx responses where it MAY do so.
  447.             Anyway, a client that received a message without a "Date" header MUST add it.
  448.         */
  449.         if (!$response->headers->has('Date')) {
  450.             $response->setDate(\DateTime::createFromFormat('U'time()));
  451.         }
  452.         $this->processResponseBody($request$response);
  453.         if ($this->isPrivateRequest($request) && !$response->headers->hasCacheControlDirective('public')) {
  454.             $response->setPrivate();
  455.         } elseif ($this->options['default_ttl'] > && null === $response->getTtl() && !$response->headers->getCacheControlDirective('must-revalidate')) {
  456.             $response->setTtl($this->options['default_ttl']);
  457.         }
  458.         return $response;
  459.     }
  460.     /**
  461.      * Checks whether the cache entry is "fresh enough" to satisfy the Request.
  462.      *
  463.      * @return bool true if the cache entry if fresh enough, false otherwise
  464.      */
  465.     protected function isFreshEnough(Request $requestResponse $entry)
  466.     {
  467.         if (!$entry->isFresh()) {
  468.             return $this->lock($request$entry);
  469.         }
  470.         if ($this->options['allow_revalidate'] && null !== $maxAge $request->headers->getCacheControlDirective('max-age')) {
  471.             return $maxAge && $maxAge >= $entry->getAge();
  472.         }
  473.         return true;
  474.     }
  475.     /**
  476.      * Locks a Request during the call to the backend.
  477.      *
  478.      * @return bool true if the cache entry can be returned even if it is staled, false otherwise
  479.      */
  480.     protected function lock(Request $requestResponse $entry)
  481.     {
  482.         // try to acquire a lock to call the backend
  483.         $lock $this->store->lock($request);
  484.         if (true === $lock) {
  485.             // we have the lock, call the backend
  486.             return false;
  487.         }
  488.         // there is already another process calling the backend
  489.         // May we serve a stale response?
  490.         if ($this->mayServeStaleWhileRevalidate($entry)) {
  491.             $this->record($request'stale-while-revalidate');
  492.             return true;
  493.         }
  494.         // wait for the lock to be released
  495.         if ($this->waitForLock($request)) {
  496.             // replace the current entry with the fresh one
  497.             $new $this->lookup($request);
  498.             $entry->headers $new->headers;
  499.             $entry->setContent($new->getContent());
  500.             $entry->setStatusCode($new->getStatusCode());
  501.             $entry->setProtocolVersion($new->getProtocolVersion());
  502.             foreach ($new->headers->getCookies() as $cookie) {
  503.                 $entry->headers->setCookie($cookie);
  504.             }
  505.         } else {
  506.             // backend is slow as hell, send a 503 response (to avoid the dog pile effect)
  507.             $entry->setStatusCode(503);
  508.             $entry->setContent('503 Service Unavailable');
  509.             $entry->headers->set('Retry-After'10);
  510.         }
  511.         return true;
  512.     }
  513.     /**
  514.      * Writes the Response to the cache.
  515.      *
  516.      * @throws \Exception
  517.      */
  518.     protected function store(Request $requestResponse $response)
  519.     {
  520.         try {
  521.             $this->store->write($request$response);
  522.             $this->record($request'store');
  523.             $response->headers->set('Age'$response->getAge());
  524.         } catch (\Exception $e) {
  525.             $this->record($request'store-failed');
  526.             if ($this->options['debug']) {
  527.                 throw $e;
  528.             }
  529.         }
  530.         // now that the response is cached, release the lock
  531.         $this->store->unlock($request);
  532.     }
  533.     /**
  534.      * Restores the Response body.
  535.      */
  536.     private function restoreResponseBody(Request $requestResponse $response)
  537.     {
  538.         if ($response->headers->has('X-Body-Eval')) {
  539.             ob_start();
  540.             if ($response->headers->has('X-Body-File')) {
  541.                 include $response->headers->get('X-Body-File');
  542.             } else {
  543.                 eval('; ?>'.$response->getContent().'<?php ;');
  544.             }
  545.             $response->setContent(ob_get_clean());
  546.             $response->headers->remove('X-Body-Eval');
  547.             if (!$response->headers->has('Transfer-Encoding')) {
  548.                 $response->headers->set('Content-Length', \strlen($response->getContent()));
  549.             }
  550.         } elseif ($response->headers->has('X-Body-File')) {
  551.             // Response does not include possibly dynamic content (ESI, SSI), so we need
  552.             // not handle the content for HEAD requests
  553.             if (!$request->isMethod('HEAD')) {
  554.                 $response->setContent(file_get_contents($response->headers->get('X-Body-File')));
  555.             }
  556.         } else {
  557.             return;
  558.         }
  559.         $response->headers->remove('X-Body-File');
  560.     }
  561.     protected function processResponseBody(Request $requestResponse $response)
  562.     {
  563.         if (null !== $this->surrogate && $this->surrogate->needsParsing($response)) {
  564.             $this->surrogate->process($request$response);
  565.         }
  566.     }
  567.     /**
  568.      * Checks if the Request includes authorization or other sensitive information
  569.      * that should cause the Response to be considered private by default.
  570.      */
  571.     private function isPrivateRequest(Request $request): bool
  572.     {
  573.         foreach ($this->options['private_headers'] as $key) {
  574.             $key strtolower(str_replace('HTTP_'''$key));
  575.             if ('cookie' === $key) {
  576.                 if (\count($request->cookies->all())) {
  577.                     return true;
  578.                 }
  579.             } elseif ($request->headers->has($key)) {
  580.                 return true;
  581.             }
  582.         }
  583.         return false;
  584.     }
  585.     /**
  586.      * Records that an event took place.
  587.      */
  588.     private function record(Request $requeststring $event)
  589.     {
  590.         $this->traces[$this->getTraceKey($request)][] = $event;
  591.     }
  592.     /**
  593.      * Calculates the key we use in the "trace" array for a given request.
  594.      */
  595.     private function getTraceKey(Request $request): string
  596.     {
  597.         $path $request->getPathInfo();
  598.         if ($qs $request->getQueryString()) {
  599.             $path .= '?'.$qs;
  600.         }
  601.         return $request->getMethod().' '.$path;
  602.     }
  603.     /**
  604.      * Checks whether the given (cached) response may be served as "stale" when a revalidation
  605.      * is currently in progress.
  606.      */
  607.     private function mayServeStaleWhileRevalidate(Response $entry): bool
  608.     {
  609.         $timeout $entry->headers->getCacheControlDirective('stale-while-revalidate');
  610.         if (null === $timeout) {
  611.             $timeout $this->options['stale_while_revalidate'];
  612.         }
  613.         return abs($entry->getTtl()) < $timeout;
  614.     }
  615.     /**
  616.      * Waits for the store to release a locked entry.
  617.      */
  618.     private function waitForLock(Request $request): bool
  619.     {
  620.         $wait 0;
  621.         while ($this->store->isLocked($request) && $wait 100) {
  622.             usleep(50000);
  623.             ++$wait;
  624.         }
  625.         return $wait 100;
  626.     }
  627. }