MultiplexerClient::purge() - Code Metrics - Inspection of "Make MultiplexerClient implement TagCapable" - FriendsOfSymfony/FOSHttpCache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#342)

by David de

created 2017-02-01 07:43 UTC

MultiplexerClient::purge() A

↳ Parent: MultiplexerClient

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	3
cts	3
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	2
crap	1

<?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\UnsupportedProxyOperationException;
use FOS\HttpCache\ProxyClient\Invalidation\BanCapable;
use FOS\HttpCache\ProxyClient\Invalidation\PurgeCapable;
use FOS\HttpCache\ProxyClient\Invalidation\RefreshCapable;
use FOS\HttpCache\ProxyClient\Invalidation\TagCapable;

/**
 * This class forwards invalidation to all attached clients.
 *
 * @author Emanuele Panzeri <[email protected]>
 */
class MultiplexerClient implements BanCapable, PurgeCapable, RefreshCapable, TagCapable
{
    /**
     * @var ProxyClient[]
     */
    private $proxyClients;

    /**
     * MultiplexerClient constructor.
     *
     * @param ProxyClient[] $proxyClients The list of Proxy clients
     */
    public function __construct(array $proxyClients)
    {
        foreach ($proxyClients as $proxyClient) {
            if (!$proxyClient instanceof ProxyClient) {
                throw new InvalidArgumentException(
                    'Expected ProxyClientInterface, got: '.
                    (is_object($proxyClient) ? get_class($proxyClient) : gettype($proxyClient))
                );
            }
        }

        $this->proxyClients = $proxyClients;
    }

    /**
     * Forwards to all clients.
     *
     * @param array $headers HTTP headers that path must match to be banned
     *
     * @return $this
     */
    public function ban(array $headers)
    {
        $this->invoke(BanCapable::class, 'ban', [$headers]);

        return $this;
    }

    /**
     * Forwards to all clients.
     *
     * @param string       $path        Regular expression pattern for URI to invalidate
     * @param string       $contentType Regular expression pattern for the content type to limit banning, for instance
     *                                  'text'
     * @param array|string $hosts       Regular expression of a host name or list of exact host names to limit banning
     *
     * @return $this
     */
    public function banPath($path, $contentType = null, $hosts = null)
    {
        $this->invoke(BanCapable::class, 'banPath', [$path, $contentType, $hosts]);

        return $this;
    }

    /**
     * Forwards to all clients.
     *
     * @throws ExceptionCollection If any errors occurred during flush
     *
     * @return int The number of cache invalidations performed per caching server
     */
    public function flush()
    {
        $count = 0;
        foreach ($this->proxyClients as $proxyClient) {
            $count += $proxyClient->flush();
        }

        return $count;
    }

    /**
     * {@inheritdoc}
     */
    public function getTagsHeaderValue(array $tags)
    {
        return $this->invokeFirst(TagCapable::class, 'getTagsHeaderValue', [$tags]);
    }

    /**
     * {@inheritdoc}
     */
    public function getTagsHeaderName()
    {
        return $this->invokeFirst(TagCapable::class, 'getTagsHeaderName', []);
    }

    /**
     * Forwards tag invalidation request to all clients.
     *
     * {@inheritdoc}
     *
     * @param array $tags
     *
     * @return $this
     */
    public function invalidateTags(array $tags)
    {
        $this->invoke(TagCapable::class, 'invalidateTags', [$tags]);

        return $this;
    }

    /**
     * Forwards to all clients.
     *
     * @param string $url     Path or URL to purge
     * @param array  $headers Extra HTTP headers to send to the caching proxy (optional)
     *
     * @return $this
     */
    public function purge($url, array $headers = array())
    {
        $this->invoke(PurgeCapable::class, 'purge', [$url, $headers]);

        return $this;
    }

    /**
     * Forwards to all clients.
     *
     * @param string $url     Path or URL to refresh
     * @param array  $headers Extra HTTP headers to send to the caching proxy (optional)
     *
     * @return $this
     */
    public function refresh($url, array $headers = [])
    {
        $this->invoke(RefreshCapable::class, 'refresh', [$url, $headers]);

        return $this;
    }

    /**
     * Invoke the given $method on all available ProxyClients implementing the
     * given $interface.
     *
     * @param string $interface The FQN of the interface
     * @param string $method    The method to invoke
     * @param array  $arguments The arguments to be passed to the method
     */
    private function invoke($interface, $method, array $arguments)
    {
        foreach ($this->getProxyClients($interface) as $proxyClient) {
            call_user_func_array([$proxyClient, $method], $arguments);
        }
    }

    /**
     * Invoke the given $method on the first available ProxyClient implementing
     * the given $interface.
     *
     * @param string $interface The FQN of the interface
     * @param string $method    The method to invoke
     * @param array  $arguments The arguments to be passed to the method
     *
     * @return mixed Return value of ProxyClient method call
     * @throws UnsupportedProxyOperationException
     */
    private function invokeFirst($interface, $method, array $arguments)
    {
        foreach ($this->getProxyClients($interface) as $proxyClient) {
            return call_user_func_array([$proxyClient, $method], $arguments);
        }

        throw UnsupportedProxyOperationException::cacheDoesNotImplement($interface);
    }

    /**
     * Get proxy clients that implement a feature interface.
     *
     * @param string $interface
     *
     * @return ProxyClient[]
     */
    private function getProxyClients($interface)
    {
        return array_filter(
            $this->proxyClients,
            function ($proxyClient) use ($interface) {
                return is_subclass_of($proxyClient, $interface);
            }
        );
    }
}


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\UnsupportedProxyOperationException;
17		use FOS\HttpCache\ProxyClient\Invalidation\BanCapable;
18		use FOS\HttpCache\ProxyClient\Invalidation\PurgeCapable;
19		use FOS\HttpCache\ProxyClient\Invalidation\RefreshCapable;
20		use FOS\HttpCache\ProxyClient\Invalidation\TagCapable;
21
22		/**
23		* This class forwards invalidation to all attached clients.
24		*
25		* @author Emanuele Panzeri <[email protected]>
26		*/
27		class MultiplexerClient implements BanCapable, PurgeCapable, RefreshCapable, TagCapable
28		{
29		/**
30		* @var ProxyClient[]
31		*/
32		private $proxyClients;
33
34		/**
35		* MultiplexerClient constructor.
36		*
37		* @param ProxyClient[] $proxyClients The list of Proxy clients
38		*/
39	11	public function __construct(array $proxyClients)
40		{
41	11	foreach ($proxyClients as $proxyClient) {
42	10	if (!$proxyClient instanceof ProxyClient) {
43	2	throw new InvalidArgumentException(
44		'Expected ProxyClientInterface, got: '.
45	10	(is_object($proxyClient) ? get_class($proxyClient) : gettype($proxyClient))
46		);
47		}
48		}
49
50	9	$this->proxyClients = $proxyClients;
51	9	}
52
53		/**
54		* Forwards to all clients.
55		*
56		* @param array $headers HTTP headers that path must match to be banned
57		*
58		* @return $this
59		*/
60	1	public function ban(array $headers)
61		{
62	1	$this->invoke(BanCapable::class, 'ban', [$headers]);
63
64	1	return $this;
65		}
66
67		/**
68		* Forwards to all clients.
69		*
70		* @param string $path Regular expression pattern for URI to invalidate
71		* @param string $contentType Regular expression pattern for the content type to limit banning, for instance
72		* 'text'
73		* @param array\|string $hosts Regular expression of a host name or list of exact host names to limit banning
74		*
75		* @return $this
76		*/
77	1	public function banPath($path, $contentType = null, $hosts = null)
78		{
79	1	$this->invoke(BanCapable::class, 'banPath', [$path, $contentType, $hosts]);
80
81	1	return $this;
82		}
83
84		/**
85		* Forwards to all clients.
86		*
87		* @throws ExceptionCollection If any errors occurred during flush
88		*
89		* @return int The number of cache invalidations performed per caching server
90		*/
91	1	public function flush()
92		{
93	1	$count = 0;
94	1	foreach ($this->proxyClients as $proxyClient) {
95	1	$count += $proxyClient->flush();
96		}
97
98	1	return $count;
99		}
100
101		/**
102		* {@inheritdoc}
103		*/
104	1	public function getTagsHeaderValue(array $tags)
105		{
106	1	return $this->invokeFirst(TagCapable::class, 'getTagsHeaderValue', [$tags]);
107		}
108
109		/**
110		* {@inheritdoc}
111		*/
112	2	public function getTagsHeaderName()
113		{
114	2	return $this->invokeFirst(TagCapable::class, 'getTagsHeaderName', []);
115		}
116
117		/**
118		* Forwards tag invalidation request to all clients.
119		*
120		* {@inheritdoc}
121		*
122		* @param array $tags
123		*
124		* @return $this
125		*/
126	1	public function invalidateTags(array $tags)
127		{
128	1	$this->invoke(TagCapable::class, 'invalidateTags', [$tags]);
129
130	1	return $this;
131		}
132
133		/**
134		* Forwards to all clients.
135		*
136		* @param string $url Path or URL to purge
137		* @param array $headers Extra HTTP headers to send to the caching proxy (optional)
138		*
139		* @return $this
140		*/
141	1	public function purge($url, array $headers = array())
142		{
143	1	$this->invoke(PurgeCapable::class, 'purge', [$url, $headers]);
144
145	1	return $this;
146		}
147
148		/**
149		* Forwards to all clients.
150		*
151		* @param string $url Path or URL to refresh
152		* @param array $headers Extra HTTP headers to send to the caching proxy (optional)
153		*
154		* @return $this
155		*/
156	1	public function refresh($url, array $headers = [])
157		{
158	1	$this->invoke(RefreshCapable::class, 'refresh', [$url, $headers]);
159
160	1	return $this;
161		}
162
163		/**
164		* Invoke the given $method on all available ProxyClients implementing the
165		* given $interface.
166		*
167		* @param string $interface The FQN of the interface
168		* @param string $method The method to invoke
169		* @param array $arguments The arguments to be passed to the method
170		*/
171	5	private function invoke($interface, $method, array $arguments)
172		{
173	5	foreach ($this->getProxyClients($interface) as $proxyClient) {
174	5	call_user_func_array([$proxyClient, $method], $arguments);
175		}
176	5	}
177
178		/**
179		* Invoke the given $method on the first available ProxyClient implementing
180		* the given $interface.
181		*
182		* @param string $interface The FQN of the interface
183		* @param string $method The method to invoke
184		* @param array $arguments The arguments to be passed to the method
185		*
186		* @return mixed Return value of ProxyClient method call
187		* @throws UnsupportedProxyOperationException
188		*/
189	3	private function invokeFirst($interface, $method, array $arguments)
190		{
191	3	foreach ($this->getProxyClients($interface) as $proxyClient) {
192	2	return call_user_func_array([$proxyClient, $method], $arguments);
193		}
194
195	1	throw UnsupportedProxyOperationException::cacheDoesNotImplement($interface);
196		}
197
198		/**
199		* Get proxy clients that implement a feature interface.
200		*
201		* @param string $interface
202		*
203		* @return ProxyClient[]
204		*/
205	8	private function getProxyClients($interface)
206		{
207	8	return array_filter(
208	8	$this->proxyClients,
209	8	function ($proxyClient) use ($interface) {
210	7	return is_subclass_of($proxyClient, $interface);
211	8	}
212		);
213		}
214		}
215

FriendsOfSymfony / FOSHttpCache

Pull Request — master (#342)

MultiplexerClient::purge() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like