vendor/friendsofsymfony/http-cache/src/ProxyClient/HttpProxyClient.php line 56

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the FOSHttpCache package.
  5.  *
  6.  * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace FOS\HttpCache\ProxyClient;
  14. use Http\Discovery\MessageFactoryDiscovery;
  15. use Http\Message\RequestFactory;
  16. use Psr\Http\Message\StreamInterface;
  17. use Psr\Http\Message\UriInterface;
  18. use Symfony\Component\OptionsResolver\OptionsResolver;
  20. /**
  21.  * Base class for HTTP based caching proxy client.
  22.  *
  23.  * @author David de Boer <david@driebit.nl>
  24.  */
  25. abstract class HttpProxyClient implements ProxyClient
  26. {
  27.     /**
  28.      * Dispatcher for invalidation HTTP requests.
  29.      *
  30.      * @var HttpDispatcher
  31.      */
  32.     private $httpDispatcher;
  34.     /**
  35.      * @var RequestFactory
  36.      */
  37.     private $requestFactory;
  39.     /**
  40.      * The options configured in the constructor argument or default values.
  41.      *
  42.      * @var array The resolved options
  43.      */
  44.     protected $options;
  46.     /**
  47.      * Constructor.
  48.      *
  49.      * The base class has no options.
  50.      *
  51.      * @param Dispatcher          $httpDispatcher Helper to send HTTP requests to caching proxy
  52.      * @param array               $options        Options for this client
  53.      * @param RequestFactory|null $messageFactory Factory for PSR-7 messages. If none supplied,
  54.      *                                            a default one is created
  55.      */
  56.     public function __construct(
  57.         Dispatcher $httpDispatcher,
  58.         array $options = [],
  59.         RequestFactory $messageFactory = null
  60.     ) {
  61.         $this->httpDispatcher = $httpDispatcher;
  62.         $this->options = $this->configureOptions()->resolve($options);
  63.         $this->requestFactory = $messageFactory ?: MessageFactoryDiscovery::find();
  64.     }
  66.     public function flush()
  67.     {
  68.         return $this->httpDispatcher->flush();
  69.     }
  71.     /**
  72.      * Get options resolver with default settings.
  73.      *
  74.      * @return OptionsResolver
  75.      */
  76.     protected function configureOptions()
  77.     {
  78.         return new OptionsResolver();
  79.     }
  81.     /**
  82.      * Create a request and queue it with the HTTP dispatcher.
  83.      *
  84.      * @param string                               $method
  85.      * @param string|UriInterface                  $url
  86.      * @param bool                                 $validateHost see Dispatcher::invalidate
  87.      * @param resource|string|StreamInterface|null $body
  88.      */
  89.     protected function queueRequest($method, $url, array $headers, $validateHost = true, $body = null)
  90.     {
  91.         $this->httpDispatcher->invalidate(
  92.             $this->requestFactory->createRequest($method, $url, $headers, $body),
  93.             $validateHost
  94.         );
  95.     }
  97.     /**
  98.      * Make sure that the tags are valid.
  99.      *
  100.      * Reusable function for proxy clients.
  101.      * Escapes `,` and `\n` (newline) characters.
  102.      *
  103.      * Note: This is not a safe escaping function, it can lead to collisions,
  104.      * e.g. between "foo,bar" and "foo_bar". But from the nature of the data,
  105.      * such collisions are unlikely, and from the function of cache tagging,
  106.      * collisions would in the worst case lead to unintended invalidations,
  107.      * which is not a bug.
  108.      *
  109.      * @param array $tags The tags to escape
  110.      *
  111.      * @return array Sane tags
  112.      */
  113.     protected function escapeTags(array $tags)
  114.     {
  115.         array_walk($tags, function (&$tag) {
  116.             // WARNING: changing the list of characters that are escaped is a BC break for existing installations,
  117.             // as existing tags on the cache would not be invalidated anymore if they contain a character that is
  118.             // newly escaped
  119.             $tag = str_replace([',', "\n"], '_', $tag);
  120.         });
  122.         return $tags;
  123.     }
  125.     /**
  126.      * Calculate how many tags fit into the header.
  127.      *
  128.      * This assumes that the tags are separated by one character.
  129.      *
  130.      * @param string[] $escapedTags
  131.      * @param string   $glue        The concatenation string to use
  132.      *
  133.      * @return int Number of tags per tag invalidation request
  134.      */
  135.     protected function determineTagsPerHeader($escapedTags, $glue)
  136.     {
  137.         if (mb_strlen(implode($glue, $escapedTags)) < $this->options['header_length']) {
  138.             return count($escapedTags);
  139.         }
  141.         /*
  142.          * estimate the amount of tags to invalidate by dividing the max
  143.          * header length by the largest tag (minus the glue length)
  144.          */
  145.         $tagsize = max(array_map('mb_strlen', $escapedTags));
  147.         return floor($this->options['header_length'] / ($tagsize + strlen($glue))) ?: 1;
  148.     }
  149. }