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.     /**
  67.      * {@inheritdoc}
  68.      */
  69.     public function flush()
  70.     {
  71.         return $this->httpDispatcher->flush();
  72.     }
  74.     /**
  75.      * Get options resolver with default settings.
  76.      *
  77.      * @return OptionsResolver
  78.      */
  79.     protected function configureOptions()
  80.     {
  81.         return new OptionsResolver();
  82.     }
  84.     /**
  85.      * Create a request and queue it with the HTTP dispatcher.
  86.      *
  87.      * @param string                               $method
  88.      * @param string|UriInterface                  $url
  89.      * @param bool                                 $validateHost see Dispatcher::invalidate
  90.      * @param resource|string|StreamInterface|null $body
  91.      */
  92.     protected function queueRequest($method, $url, array $headers, $validateHost = true, $body = null)
  93.     {
  94.         $this->httpDispatcher->invalidate(
  95.             $this->requestFactory->createRequest($method, $url, $headers, $body),
  96.             $validateHost
  97.         );
  98.     }
  100.     /**
  101.      * Make sure that the tags are valid.
  102.      *
  103.      * Reusable function for proxy clients.
  104.      * Escapes `,` and `\n` (newline) characters.
  105.      *
  106.      * Note: This is not a safe escaping function, it can lead to collisions,
  107.      * e.g. between "foo,bar" and "foo_bar". But from the nature of the data,
  108.      * such collisions are unlikely, and from the function of cache tagging,
  109.      * collisions would in the worst case lead to unintended invalidations,
  110.      * which is not a bug.
  111.      *
  112.      * @param array $tags The tags to escape
  113.      *
  114.      * @return array Sane tags
  115.      */
  116.     protected function escapeTags(array $tags)
  117.     {
  118.         array_walk($tags, function (&$tag) {
  119.             // WARNING: changing the list of characters that are escaped is a BC break for existing installations,
  120.             // as existing tags on the cache would not be invalidated anymore if they contain a character that is
  121.             // newly escaped
  122.             $tag = str_replace([',', "\n"], '_', $tag);
  123.         });
  125.         return $tags;
  126.     }
  128.     /**
  129.      * Calculate how many tags fit into the header.
  130.      *
  131.      * This assumes that the tags are separated by one character.
  132.      *
  133.      * @param string[] $escapedTags
  134.      * @param string   $glue        The concatenation string to use
  135.      *
  136.      * @return int Number of tags per tag invalidation request
  137.      */
  138.     protected function determineTagsPerHeader($escapedTags, $glue)
  139.     {
  140.         if (mb_strlen(implode($glue, $escapedTags)) < $this->options['header_length']) {
  141.             return count($escapedTags);
  142.         }
  144.         /*
  145.          * estimate the amount of tags to invalidate by dividing the max
  146.          * header length by the largest tag (minus the glue length)
  147.          */
  148.         $tagsize = max(array_map('mb_strlen', $escapedTags));
  150.         return floor($this->options['header_length'] / ($tagsize + strlen($glue))) ?: 1;
  151.     }
  152. }