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. }