vendor/friendsofsymfony/http-cache/src/ProxyClient/HttpDispatcher.php line 99

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 FOS\HttpCache\Exception\ExceptionCollection;
  15. use FOS\HttpCache\Exception\InvalidArgumentException;
  16. use FOS\HttpCache\Exception\InvalidUrlException;
  17. use FOS\HttpCache\Exception\MissingHostException;
  18. use FOS\HttpCache\Exception\ProxyResponseException;
  19. use FOS\HttpCache\Exception\ProxyUnreachableException;
  20. use Http\Client\Common\Plugin\ErrorPlugin;
  21. use Http\Client\Common\PluginClient;
  22. use Http\Client\Exception\HttpException;
  23. use Http\Client\Exception\NetworkException;
  24. use Http\Client\HttpAsyncClient;
  25. use Http\Discovery\HttpAsyncClientDiscovery;
  26. use Http\Discovery\UriFactoryDiscovery;
  27. use Http\Message\UriFactory;
  28. use Http\Promise\Promise;
  29. use Psr\Http\Message\RequestInterface;
  30. use Psr\Http\Message\UriInterface;
  32. /**
  33. * Queue and send HTTP requests with a Httplug asynchronous client.
  34. *
  35. * @author David Buchmann <mail@davidbu.ch>
  36. */
  37. class HttpDispatcher implements Dispatcher
  38. {
  39. /**
  40. * @var HttpAsyncClient
  41. */
  42. private $httpClient;
  44. /**
  45. * @var UriFactory
  46. */
  47. private $uriFactory;
  49. /**
  50. * Queued requests.
  51. *
  52. * @var RequestInterface[]
  53. */
  54. private $queue = [];
  56. /**
  57. * Caching proxy server host names or IP addresses.
  58. *
  59. * @var UriInterface[]
  60. */
  61. private $servers;
  63. /**
  64. * Application host name and optional base URL.
  65. *
  66. * @var UriInterface
  67. */
  68. private $baseUri;
  70. /**
  71. * If you specify a custom HTTP client, make sure that it converts HTTP
  72. * errors to exceptions.
  73. *
  74. * If your proxy server IPs can not be statically configured, extend this
  75. * class and overwrite getServers. Be sure to have some caching in
  76. * getServers.
  77. *
  78. * @param string[] $servers Caching proxy server hostnames or IP
  79. * addresses, including port if not port 80.
  80. * E.g. ['127.0.0.1:6081']
  81. * @param string $baseUri Default application hostname, optionally
  82. * including base URL, for purge and refresh
  83. * requests (optional). This is required if
  84. * you purge and refresh paths instead of
  85. * absolute URLs
  86. * @param HttpAsyncClient|null $httpClient Client capable of sending HTTP requests. If no
  87. * client is supplied, a default one is created
  88. * @param UriFactory|null $uriFactory Factory for PSR-7 URIs. If not specified, a
  89. * default one is created
  90. */
  91. public function __construct(
  92. array $servers,
  93. $baseUri = '',
  94. ?HttpAsyncClient $httpClient = null,
  95. ?UriFactory $uriFactory = null
  96. ) {
  97. if (!$httpClient) {
  98. $httpClient = new PluginClient(
  99. HttpAsyncClientDiscovery::find(),
  100. [new ErrorPlugin()]
  101. );
  102. }
  103. $this->httpClient = $httpClient;
  104. $this->uriFactory = $uriFactory ?: UriFactoryDiscovery::find();
  106. $this->setServers($servers);
  107. $this->setBaseUri($baseUri);
  108. }
  110. public function invalidate(RequestInterface $invalidationRequest, $validateHost = true)
  111. {
  112. if ($validateHost && !$this->baseUri && !$invalidationRequest->getUri()->getHost()) {
  113. throw MissingHostException::missingHost((string) $invalidationRequest->getUri());
  114. }
  116. $signature = $this->getRequestSignature($invalidationRequest);
  118. if (isset($this->queue[$signature])) {
  119. return;
  120. }
  122. $this->queue[$signature] = $invalidationRequest;
  123. }
  125. public function flush()
  126. {
  127. $queue = $this->queue;
  128. $this->queue = [];
  129. /** @var Promise[] $promises */
  130. $promises = [];
  132. $exceptions = new ExceptionCollection();
  134. foreach ($queue as $request) {
  135. foreach ($this->fanOut($request) as $proxyRequest) {
  136. try {
  137. $promises[] = $this->httpClient->sendAsyncRequest($proxyRequest);
  138. } catch (\Exception $e) {
  139. $exceptions->add(new InvalidArgumentException($e->getMessage(), $e->getCode(), $e));
  140. }
  141. }
  142. }
  144. foreach ($promises as $promise) {
  145. try {
  146. $promise->wait();
  147. } catch (HttpException $exception) {
  148. $exceptions->add(ProxyResponseException::proxyResponse($exception));
  149. } catch (NetworkException $exception) {
  150. $exceptions->add(ProxyUnreachableException::proxyUnreachable($exception));
  151. } catch (\Exception $exception) {
  152. // @codeCoverageIgnoreStart
  153. $exceptions->add(new InvalidArgumentException($exception->getMessage(), $exception->getCode(), $exception));
  154. // @codeCoverageIgnoreEnd
  155. }
  156. }
  158. if (count($exceptions)) {
  159. throw $exceptions;
  160. }
  162. return count($queue);
  163. }
  165. /**
  166. * Get the list of servers to send invalidation requests to.
  167. *
  168. * @return UriInterface[]
  169. */
  170. protected function getServers()
  171. {
  172. return $this->servers;
  173. }
  175. /**
  176. * Duplicate a request for each caching server.
  177. *
  178. * @param RequestInterface $request The request to duplicate for each configured server
  179. *
  180. * @return RequestInterface[]
  181. */
  182. private function fanOut(RequestInterface $request)
  183. {
  184. $requests = [];
  186. $uri = $request->getUri();
  188. // If a base URI is configured, try to make partial invalidation
  189. // requests complete.
  190. if ($this->baseUri) {
  191. if ($uri->getHost()) {
  192. // Absolute URI: does it already have a scheme?
  193. if (!$uri->getScheme() && '' !== $this->baseUri->getScheme()) {
  194. $uri = $uri->withScheme($this->baseUri->getScheme());
  195. }
  196. } else {
  197. // Relative URI
  198. if ('' !== $this->baseUri->getHost()) {
  199. $uri = $uri->withHost($this->baseUri->getHost());
  200. }
  202. if ($this->baseUri->getPort()) {
  203. $uri = $uri->withPort($this->baseUri->getPort());
  204. }
  206. // Base path
  207. if ('' !== $this->baseUri->getPath()) {
  208. $path = $this->baseUri->getPath().'/'.ltrim($uri->getPath(), '/');
  209. $uri = $uri->withPath($path);
  210. }
  211. }
  212. }
  214. // Close connections to make sure invalidation (PURGE/BAN) requests
  215. // will not interfere with content (GET) requests.
  216. $request = $request->withUri($uri)->withHeader('Connection', 'Close');
  218. // Create a request to each caching proxy server
  219. foreach ($this->getServers() as $server) {
  220. $serverUri = $uri
  221. ->withScheme($server->getScheme())
  222. ->withHost($server->getHost())
  223. ->withPort($server->getPort());
  225. if ($userInfo = $server->getUserInfo()) {
  226. $userInfoParts = explode(':', $userInfo, 2);
  227. $serverUri = $serverUri
  228. ->withUserInfo($userInfoParts[0], $userInfoParts[1] ?? null);
  229. }
  231. $requests[] = $request->withUri($serverUri, true); // Preserve application Host header
  232. }
  234. return $requests;
  235. }
  237. /**
  238. * Set caching proxy server URI objects, validating them.
  239. *
  240. * @param string[] $servers Caching proxy proxy server hostnames or IP
  241. * addresses, including port if not port 80.
  242. * E.g. ['127.0.0.1:6081']
  243. *
  244. * @throws InvalidUrlException If server is invalid or contains URL
  245. * parts other than scheme, host, port
  246. */
  247. private function setServers(array $servers)
  248. {
  249. $this->servers = [];
  250. foreach ($servers as $server) {
  251. $this->servers[] = $this->filterUri($server, ['scheme', 'user', 'pass', 'host', 'port']);
  252. }
  253. }
  255. /**
  256. * Set application base URI that will be prefixed to relative purge and
  257. * refresh requests, and validate it.
  258. *
  259. * @param string $uriString Your application’s base URI
  260. *
  261. * @throws InvalidUrlException If the base URI is not a valid URI
  262. */
  263. private function setBaseUri($uriString = null)
  264. {
  265. if (!$uriString) {
  266. $this->baseUri = null;
  268. return;
  269. }
  271. $this->baseUri = $this->filterUri($uriString);
  272. }
  274. /**
  275. * Filter a URL.
  276. *
  277. * Prefix the URL with "http://" if it has no scheme, then check the URL
  278. * for validity. You can specify what parts of the URL are allowed.
  279. *
  280. * @param string $uriString
  281. * @param string[] $allowedParts Array of allowed URL parts (optional)
  282. *
  283. * @return UriInterface Filtered URI (with default scheme if there was no scheme)
  284. *
  285. * @throws InvalidUrlException If URL is invalid, the scheme is not http or
  286. * contains parts that are not expected
  287. */
  288. private function filterUri($uriString, array $allowedParts = [])
  289. {
  290. if (!is_string($uriString)) {
  291. throw new \InvalidArgumentException(sprintf(
  292. 'URI parameter must be a string, %s given',
  293. gettype($uriString)
  294. ));
  295. }
  297. // Creating a PSR-7 URI without scheme (with parse_url) results in the
  298. // original hostname to be seen as path. So first add a scheme if none
  299. // is given.
  300. if (false === strpos($uriString, '://')) {
  301. $uriString = sprintf('%s://%s', 'http', $uriString);
  302. }
  304. try {
  305. $uri = $this->uriFactory->createUri($uriString);
  306. } catch (\InvalidArgumentException $e) {
  307. throw InvalidUrlException::invalidUrl($uriString);
  308. }
  310. if (!$uri->getScheme()) {
  311. throw InvalidUrlException::invalidUrl($uriString, 'empty scheme');
  312. }
  314. if (count($allowedParts) > 0) {
  315. $parts = parse_url((string) $uri);
  316. $diff = array_diff(array_keys($parts), $allowedParts);
  317. if (count($diff) > 0) {
  318. throw InvalidUrlException::invalidUrlParts($uriString, $allowedParts);
  319. }
  320. }
  322. return $uri;
  323. }
  325. /**
  326. * Build a request signature based on the request data. Unique for every different request, identical
  327. * for the same requests.
  328. *
  329. * This signature is used to avoid sending the same invalidation request twice.
  330. *
  331. * @param RequestInterface $request An invalidation request
  332. *
  333. * @return string A signature for this request
  334. */
  335. private function getRequestSignature(RequestInterface $request)
  336. {
  337. $headers = $request->getHeaders();
  338. ksort($headers);
  340. return sha1($request->getMethod()."\n".$request->getUri()."\n".var_export($headers, true));
  341. }
  342. }