HttpDispatcher - Code Metrics - Inspection of "Added LiteSpeed support" - FriendsOfSymfony/FOSHttpCache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#444)

by Yanick

created 2019-04-12 13:24 UTC

HttpDispatcher B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	348
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Test Coverage

Coverage

98.95%

Importance

Changes

Metric	Value
wmc	45
lcom	1
cbo	15
dl	0
loc	348
ccs	94
cts	95
cp	0.9895
rs	8.8
c	0
b	0
f	0

10 Methods

Rating	Name	Size	Complexity
B	__construct()	35	6
A	invalidate()	14	5
B	flush()	39	9
A	getServers()	4	1
A	fanOut()	34	4
B	requestToBaseUris()	34	8
A	setServers()	7	2
A	setBaseUris()	12	3
B	filterUri()	29	6
A	getRequestSignature()	7	1

How to fix Complexity

<?php

/*
 * This file is part of the FOSHttpCache package.
 *
 * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace FOS\HttpCache\ProxyClient;

use FOS\HttpCache\Exception\ExceptionCollection;
use FOS\HttpCache\Exception\InvalidArgumentException;
use FOS\HttpCache\Exception\InvalidUrlException;
use FOS\HttpCache\Exception\MissingHostException;
use FOS\HttpCache\Exception\ProxyResponseException;
use FOS\HttpCache\Exception\ProxyUnreachableException;
use Http\Client\Common\Plugin\ErrorPlugin;
use Http\Client\Common\PluginClient;
use Http\Client\Exception\HttpException;
use Http\Client\Exception\RequestException;
use Http\Client\HttpAsyncClient;
use Http\Discovery\HttpAsyncClientDiscovery;
use Http\Discovery\UriFactoryDiscovery;
use Http\Message\UriFactory;
use Http\Promise\Promise;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\UriInterface;

/**
 * Queue and send HTTP requests with a Httplug asynchronous client.
 *
 * @author David Buchmann <[email protected]>
 */
class HttpDispatcher implements Dispatcher
{
    /**
     * @var HttpAsyncClient
     */
    private $httpClient;

    /**
     * @var UriFactory
     */
    private $uriFactory;

    /**
     * Queued requests.
     *
     * @var RequestInterface[]
     */
    private $queue = [];

    /**
     * Caching proxy server host names or IP addresses.
     *
     * @var UriInterface[]
     */
    private $servers;

    /**
     * Application host name and optional base URL.
     *
     * @var UriInterface[]
     */
    private $baseUris;

    /**
     * If you specify a custom HTTP client, make sure that it converts HTTP
     * errors to exceptions.
     *
     * If your proxy server IPs can not be statically configured, extend this
     * class and overwrite getServers. Be sure to have some caching in
     * getServers.
     *
     * @param string[]             $servers    Caching proxy server hostnames or IP
     *                                         addresses, including port if not port 80.
     *                                         E.g. ['127.0.0.1:6081']
     * @param string|string[]      $baseUris   Default application hostnames, optionally
     *                                         including base URL, for purge and refresh
     *                                         requests (optional). At least one is required if
     *                                         you purge and refresh paths instead of
     *                                         absolute URLs. A request will be sent for each
     *                                         base URL.
     * @param HttpAsyncClient|null $httpClient Client capable of sending HTTP requests. If no
     *                                         client is supplied, a default one is created
     * @param UriFactory|null      $uriFactory Factory for PSR-7 URIs. If not specified, a
     *                                         default one is created
     */
    public function __construct(
        array $servers,
        $baseUris = [],
        HttpAsyncClient $httpClient = null,
        UriFactory $uriFactory = null
    ) {
        if (!$httpClient) {
            $httpClient = new PluginClient(
                HttpAsyncClientDiscovery::find(),
                [new ErrorPlugin()]
            );
        }
        $this->httpClient = $httpClient;
        $this->uriFactory = $uriFactory ?: UriFactoryDiscovery::find();

        $this->setServers($servers);

        // Support both, a string or an array of strings (array_filter to kill empty base URLs)
        if (is_string($baseUris)) {
            if ('' === $baseUris) {
                $baseUris = [];
            } else {
                $baseUris = [$baseUris];
            }
        }

        if (!\is_array($baseUris)) {
            throw new \InvalidArgumentException(sprintf(
                'URI parameter must be either a string or an array of strings, %s given',
                gettype($baseUris)
            ));
        }

        $this->setBaseUris($baseUris);
    }

    /**
     * {@inheritdoc}
     */
    public function invalidate(RequestInterface $invalidationRequest, $validateHost = true)
    {
        if ($validateHost && 0 === \count($this->baseUris) && !$invalidationRequest->getUri()->getHost()) {
            throw MissingHostException::missingHost((string) $invalidationRequest->getUri());
        }

        $signature = $this->getRequestSignature($invalidationRequest);

        if (isset($this->queue[$signature])) {
            return;
        }

        $this->queue[$signature] = $invalidationRequest;
    }

    /**
     * {@inheritdoc}
     */
    public function flush()
    {
        $queue = $this->queue;
        $this->queue = [];
        /** @var Promise[] $promises */
        $promises = [];

        $exceptions = new ExceptionCollection();

        foreach ($queue as $request) {
            foreach ($this->fanOut($request) as $proxyRequest) {
                try {
                    $promises[] = $this->httpClient->sendAsyncRequest($proxyRequest);
                } catch (\Exception $e) {
                    $exceptions->add(new InvalidArgumentException($e));
                }
            }
        }

        foreach ($promises as $promise) {
            try {
                $promise->wait();
            } catch (HttpException $exception) {
                $exceptions->add(ProxyResponseException::proxyResponse($exception));
            } catch (RequestException $exception) {
                $exceptions->add(ProxyUnreachableException::proxyUnreachable($exception));
            } catch (\Exception $exception) {
                // @codeCoverageIgnoreStart
                $exceptions->add(new InvalidArgumentException($exception));
                // @codeCoverageIgnoreEnd
            }
        }

        if (count($exceptions)) {
            throw $exceptions;
        }

        return count($queue);
    }

    /**
     * Get the list of servers to send invalidation requests to.
     *
     * @return UriInterface[]
     */
    protected function getServers()
    {
        return $this->servers;
    }

    /**
     * Duplicate a request for each caching server.
     *
     * @param RequestInterface $request The request to duplicate for each configured server
     *
     * @return RequestInterface[]
     */
    private function fanOut(RequestInterface $request)
    {
        $serverRequests = [];

        if (0 !== \count($this->baseUris)) {
            // If base URIs are configured, try to make partial invalidation
            // requests complete and send out a request for every base URI
            $requests = $this->requestToBaseUris($request);
        } else {
            /** @var RequestInterface[] $requests */
            $requests = [$request];
        }

        // Create all requests to each caching proxy server
        foreach ($requests as $request) {
            $uri = $request->getUri();

            // Close connections to make sure invalidation (PURGE/BAN) requests
            // will not interfere with content (GET) requests.
            $requests[] = $request->withUri($uri)->withHeader('Connection', 'Close');

            foreach ($this->getServers() as $server) {
                $serverRequests[] = $request->withUri(
                    $uri
                        ->withScheme($server->getScheme())
                        ->withHost($server->getHost())
                        ->withPort($server->getPort()),
                    true    // Preserve application Host header
                );
            }
        }

        return $serverRequests;
    }

    /**
     * Looks at a given request and returns an array of requests incorporating
     * every configured base URI.
     *
     * @param RequestInterface $request The request to modify for every configured base URI
     *
     * @return RequestInterface[]
     */
    private function requestToBaseUris(RequestInterface $request)
    {
        $requests = [];

        foreach ($this->baseUris as $baseUri) {
            $uri = $request->getUri();

            if ($uri->getHost()) {
                // Absolute URI: does it already have a scheme?
                if (!$uri->getScheme() && '' !== $baseUri->getScheme()) {
                    $uri = $uri->withScheme($baseUri->getScheme());
                }
            } else {
                // Relative URI
                if ('' !== $baseUri->getHost()) {
                    $uri = $uri->withHost($baseUri->getHost());
                }

                if ($baseUri->getPort()) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
                    $uri = $uri->withPort($baseUri->getPort());
                }

                // Base path
                if ('' !== $baseUri->getPath()) {
                    $path = $baseUri->getPath().'/'.ltrim($uri->getPath(), '/');
                    $uri = $uri->withPath($path);
                }
            }

            $requests[] = $request->withUri($uri);
        }

        return $requests;
    }

    /**
     * Set caching proxy server URI objects, validating them.
     *
     * @param string[] $servers Caching proxy proxy server hostnames or IP
     *                          addresses, including port if not port 80.
     *                          E.g. ['127.0.0.1:6081']
     *
     * @throws InvalidUrlException If server is invalid or contains URL
     *                             parts other than scheme, host, port
     */
    private function setServers(array $servers)
    {
        $this->servers = [];
        foreach ($servers as $server) {
            $this->servers[] = $this->filterUri($server, ['scheme', 'host', 'port']);
        }
    }

    /**
     * Set application base URI that will be prefixed to relative purge and
     * refresh requests, and validate it.
     *
     * @param array $baseUris Your application’s base URIs
     *
     * @throws InvalidUrlException If the base URI is not a valid URI
     */
    private function setBaseUris(array $baseUris = [])
    {
        if (0 === \count($baseUris)) {
            $this->baseUris = [];

            return;
        }

        foreach ($baseUris as $baseUri) {
            $this->baseUris[] = $this->filterUri($baseUri);
        }
    }

    /**
     * Filter a URL.
     *
     * Prefix the URL with "http://" if it has no scheme, then check the URL
     * for validity. You can specify what parts of the URL are allowed.
     *
     * @param string   $uriString
     * @param string[] $allowedParts Array of allowed URL parts (optional)
     *
     * @return UriInterface Filtered URI (with default scheme if there was no scheme)
     *
     * @throws InvalidUrlException If URL is invalid, the scheme is not http or
     *                             contains parts that are not expected
     */
    private function filterUri($uriString, array $allowedParts = [])
    {
        // Creating a PSR-7 URI without scheme (with parse_url) results in the
        // original hostname to be seen as path. So first add a scheme if none
        // is given.
        if (false === strpos($uriString, '://')) {
            $uriString = sprintf('%s://%s', 'http', $uriString);
        }

        try {
            $uri = $this->uriFactory->createUri($uriString);
        } catch (\InvalidArgumentException $e) {
            throw InvalidUrlException::invalidUrl($uriString);
        }

        if (!$uri->getScheme()) {
            throw InvalidUrlException::invalidUrl($uriString, 'empty scheme');
        }

        if (count($allowedParts) > 0) {
            $parts = parse_url((string) $uri);
            $diff = array_diff(array_keys($parts), $allowedParts);
            if (count($diff) > 0) {
                throw InvalidUrlException::invalidUrlParts($uriString, $allowedParts);
            }
        }

        return $uri;
    }

    /**
     * Build a request signature based on the request data. Unique for every different request, identical
     * for the same requests.
     *
     * This signature is used to avoid sending the same invalidation request twice.
     *
     * @param RequestInterface $request An invalidation request
     *
     * @return string A signature for this request
     */
    private function getRequestSignature(RequestInterface $request)
    {
        $headers = $request->getHeaders();
        ksort($headers);

        return sha1($request->getMethod()."\n".$request->getUri()."\n".var_export($headers, true));
    }
}


1		<?php
2
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		*/
11
12		namespace FOS\HttpCache\ProxyClient;
13
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\RequestException;
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;
31
32		/**
33		* Queue and send HTTP requests with a Httplug asynchronous client.
34		*
35		* @author David Buchmann <[email protected]>
36		*/
37		class HttpDispatcher implements Dispatcher
38		{
39		/**
40		* @var HttpAsyncClient
41		*/
42		private $httpClient;
43
44		/**
45		* @var UriFactory
46		*/
47		private $uriFactory;
48
49		/**
50		* Queued requests.
51		*
52		* @var RequestInterface[]
53		*/
54		private $queue = [];
55
56		/**
57		* Caching proxy server host names or IP addresses.
58		*
59		* @var UriInterface[]
60		*/
61		private $servers;
62
63		/**
64		* Application host name and optional base URL.
65		*
66		* @var UriInterface[]
67		*/
68		private $baseUris;
69
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\|string[] $baseUris Default application hostnames, optionally
82		* including base URL, for purge and refresh
83		* requests (optional). At least one is required if
84		* you purge and refresh paths instead of
85		* absolute URLs. A request will be sent for each
86		* base URL.
87		* @param HttpAsyncClient\|null $httpClient Client capable of sending HTTP requests. If no
88		* client is supplied, a default one is created
89		* @param UriFactory\|null $uriFactory Factory for PSR-7 URIs. If not specified, a
90		* default one is created
91	38	*/
92		public function __construct(
93		array $servers,
94		$baseUris = [],
95		HttpAsyncClient $httpClient = null,
96		UriFactory $uriFactory = null
97	38	) {
98	26	if (!$httpClient) {
99	26	$httpClient = new PluginClient(
100	26	HttpAsyncClientDiscovery::find(),
101		[new ErrorPlugin()]
102		);
103	38	}
104	38	$this->httpClient = $httpClient;
105		$this->uriFactory = $uriFactory ?: UriFactoryDiscovery::find();
106	38
107	35	$this->setServers($servers);
108	34
109		// Support both, a string or an array of strings (array_filter to kill empty base URLs)
110		if (is_string($baseUris)) {
111		if ('' === $baseUris) {
112		$baseUris = [];
113		} else {
114		$baseUris = [$baseUris];
115		}
116		}
117
118	33	if (!\is_array($baseUris)) {
119		throw new \InvalidArgumentException(sprintf(
120	33	'URI parameter must be either a string or an array of strings, %s given',
121	1	gettype($baseUris)
122		));
123		}
124	32
125		$this->setBaseUris($baseUris);
126	32	}
127	1
128		/**
129		* {@inheritdoc}
130	32	*/
131	32	public function invalidate(RequestInterface $invalidationRequest, $validateHost = true)
132		{
133		if ($validateHost && 0 === \count($this->baseUris) && !$invalidationRequest->getUri()->getHost()) {
134		throw MissingHostException::missingHost((string) $invalidationRequest->getUri());
135		}
136
137		$signature = $this->getRequestSignature($invalidationRequest);
138
139		if (isset($this->queue[$signature])) {
140	33	return;
141		}
142	33
143	33	$this->queue[$signature] = $invalidationRequest;
144		}
145	33
146		/**
147	33	* {@inheritdoc}
148		*/
149	33	public function flush()
150	32	{
151		$queue = $this->queue;
152	32	$this->queue = [];
153	1	/** @var Promise[] $promises */
154	32	$promises = [];
155
156		$exceptions = new ExceptionCollection();
157
158		foreach ($queue as $request) {
159	33	foreach ($this->fanOut($request) as $proxyRequest) {
160		try {
161	32	$promises[] = $this->httpClient->sendAsyncRequest($proxyRequest);
162	4	} catch (\Exception $e) {
163	2	$exceptions->add(new InvalidArgumentException($e));
164	2	}
165	2	}
166		}
167
168		foreach ($promises as $promise) {
169		try {
170		$promise->wait();
171		} catch (HttpException $exception) {
172		$exceptions->add(ProxyResponseException::proxyResponse($exception));
173	33	} catch (RequestException $exception) {
174	5	$exceptions->add(ProxyUnreachableException::proxyUnreachable($exception));
175		} catch (\Exception $exception) {
176		// @codeCoverageIgnoreStart
177	31	$exceptions->add(new InvalidArgumentException($exception));
178		// @codeCoverageIgnoreEnd
179		}
180		}
181
182		if (count($exceptions)) {
183		throw $exceptions;
184		}
185	32
186		return count($queue);
187	32	}
188
189		/**
190		* Get the list of servers to send invalidation requests to.
191		*
192		* @return UriInterface[]
193		*/
194		protected function getServers()
195		{
196		return $this->servers;
197	32	}
198
199	32	/**
200		* Duplicate a request for each caching server.
201	32	*
202		* @param RequestInterface $request The request to duplicate for each configured server
203		*
204		* @return RequestInterface[]
205	32	*/
206	30	private function fanOut(RequestInterface $request)
207		{
208	5	$serverRequests = [];
209	5
210		if (0 !== \count($this->baseUris)) {
211		// If base URIs are configured, try to make partial invalidation
212		// requests complete and send out a request for every base URI
213	25	$requests = $this->requestToBaseUris($request);
214	25	} else {
215		/** @var RequestInterface[] $requests */
216		$requests = [$request];
217	25	}
218	16
219		// Create all requests to each caching proxy server
220		foreach ($requests as $request) {
221		$uri = $request->getUri();
222	25
223	1	// Close connections to make sure invalidation (PURGE/BAN) requests
224	1	// will not interfere with content (GET) requests.
225		$requests[] = $request->withUri($uri)->withHeader('Connection', 'Close');
226
227		foreach ($this->getServers() as $server) {
228		$serverRequests[] = $request->withUri(
229		$uri
230		->withScheme($server->getScheme())
231	32	->withHost($server->getHost())
232		->withPort($server->getPort()),
233		true // Preserve application Host header
234	32	);
235	32	}
236		}
237	32
238	32	return $serverRequests;
239	32	}
240	32
241		/**
242		* Looks at a given request and returns an array of requests incorporating
243		* every configured base URI.
244	32	*
245		* @param RequestInterface $request The request to modify for every configured base URI
246		*
247		* @return RequestInterface[]
248		*/
249		private function requestToBaseUris(RequestInterface $request)
250		{
251		$requests = [];
252
253		foreach ($this->baseUris as $baseUri) {
254		$uri = $request->getUri();
255
256		if ($uri->getHost()) {
257	38	// Absolute URI: does it already have a scheme?
258		if (!$uri->getScheme() && '' !== $baseUri->getScheme()) {
259	38	$uri = $uri->withScheme($baseUri->getScheme());
260	38	}
261	38	} else {
262		// Relative URI
263	35	if ('' !== $baseUri->getHost()) {
264		$uri = $uri->withHost($baseUri->getHost());
265		}
266
267		if ($baseUri->getPort()) {
		0 ignored issues – show Bug Best Practice introduced 2019-03-20 18:04 UTC by Report Bug Copy Issue Report The expression `$baseUri->getPort()` of type `null\|integer` is loosely compared to `true`; this is ambiguous if the integer can be zero. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
268		$uri = $uri->withPort($baseUri->getPort());
269		}
270
271		// Base path
272		if ('' !== $baseUri->getPath()) {
273	35	$path = $baseUri->getPath().'/'.ltrim($uri->getPath(), '/');
274		$uri = $uri->withPath($path);
275	35	}
276	3	}
277
278	3	$requests[] = $request->withUri($uri);
279		}
280
281	32	return $requests;
282	31	}
283
284		/**
285		* Set caching proxy server URI objects, validating them.
286		*
287		* @param string[] $servers Caching proxy proxy server hostnames or IP
288		* addresses, including port if not port 80.
289		* E.g. ['127.0.0.1:6081']
290		*
291		* @throws InvalidUrlException If server is invalid or contains URL
292		* parts other than scheme, host, port
293		*/
294		private function setServers(array $servers)
295		{
296		$this->servers = [];
297		foreach ($servers as $server) {
298	38	$this->servers[] = $this->filterUri($server, ['scheme', 'host', 'port']);
299		}
300	38	}
301	1
302	1	/**
303	1	* Set application base URI that will be prefixed to relative purge and
304		* refresh requests, and validate it.
305		*
306		* @param array $baseUris Your application’s base URIs
307		*
308		* @throws InvalidUrlException If the base URI is not a valid URI
309		*/
310	38	private function setBaseUris(array $baseUris = [])
311	34	{
312		if (0 === \count($baseUris)) {
313		$this->baseUris = [];
314
315	38	return;
316	1	}
317	1
318		foreach ($baseUris as $baseUri) {
319		$this->baseUris[] = $this->filterUri($baseUri);
320	37	}
321	1	}
322
323		/**
324	36	* Filter a URL.
325	36	*
326	36	* Prefix the URL with "http://" if it has no scheme, then check the URL
327	36	* for validity. You can specify what parts of the URL are allowed.
328	1	*
329		* @param string $uriString
330		* @param string[] $allowedParts Array of allowed URL parts (optional)
331		*
332	35	* @return UriInterface Filtered URI (with default scheme if there was no scheme)
333		*
334		* @throws InvalidUrlException If URL is invalid, the scheme is not http or
335		* contains parts that are not expected
336		*/
337		private function filterUri($uriString, array $allowedParts = [])
338		{
339		// Creating a PSR-7 URI without scheme (with parse_url) results in the
340		// original hostname to be seen as path. So first add a scheme if none
341		// is given.
342		if (false === strpos($uriString, '://')) {
343		$uriString = sprintf('%s://%s', 'http', $uriString);
344		}
345	32
346		try {
347	32	$uri = $this->uriFactory->createUri($uriString);
348	32	} catch (\InvalidArgumentException $e) {
349		throw InvalidUrlException::invalidUrl($uriString);
350	32	}
351
352		if (!$uri->getScheme()) {
353		throw InvalidUrlException::invalidUrl($uriString, 'empty scheme');
354		}
355
356		if (count($allowedParts) > 0) {
357		$parts = parse_url((string) $uri);
358		$diff = array_diff(array_keys($parts), $allowedParts);
359		if (count($diff) > 0) {
360		throw InvalidUrlException::invalidUrlParts($uriString, $allowedParts);
361		}
362		}
363
364		return $uri;
365		}
366
367		/**
368		* Build a request signature based on the request data. Unique for every different request, identical
369		* for the same requests.
370		*
371		* This signature is used to avoid sending the same invalidation request twice.
372		*
373		* @param RequestInterface $request An invalidation request
374		*
375		* @return string A signature for this request
376		*/
377		private function getRequestSignature(RequestInterface $request)
378		{
379		$headers = $request->getHeaders();
380		ksort($headers);
381
382		return sha1($request->getMethod()."\n".$request->getUri()."\n".var_export($headers, true));
383		}
384		}
385

FriendsOfSymfony / FOSHttpCache

Pull Request — master (#444)

HttpDispatcher B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

10 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like