HttpClientPoolItem::isDisabled() - Code Metrics - Inspection of "Merge pull request #49 from php-http/revert-47-no-..." - php-http/client-common - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 52b1c2...7b34df )

by Tobias

created 2017-07-11 05:52 UTC

HttpClientPoolItem::isDisabled() A

↳ Parent: HttpClientPoolItem

Complexity

Conditions	4
Paths	3

Size

Total Lines	19
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	4.0218

Importance

Changes

Metric	Value
dl	0
loc	19
ccs	8
cts	9
cp	0.8889
rs	9.2
c	0
b	0
f	0
cc	4
eloc	9
nc	3
nop	0
crap	4.0218

<?php

namespace Http\Client\Common;

use Http\Client\HttpAsyncClient;
use Http\Client\HttpClient;
use Psr\Http\Message\RequestInterface;
use Http\Client\Exception;

/**
 * A HttpClientPoolItem represent a HttpClient inside a Pool.
 *
 * It is disabled when a request failed and can be reenable after a certain number of seconds
 * It also keep tracks of the current number of request the client is currently sending (only usable for async method)
 *
 * @author Joel Wurtz <[email protected]>
 */
class HttpClientPoolItem implements HttpClient, HttpAsyncClient
{
    /**
     * @var int Number of request this client is currently sending
     */
    private $sendingRequestCount = 0;

    /**
     * @var \DateTime|null Time when this client has been disabled or null if enable
     */
    private $disabledAt;

    /**
     * @var int|null Number of seconds after this client is reenable, by default null: never reenable this client
     */
    private $reenableAfter;

    /**
     * @var FlexibleHttpClient A http client responding to async and sync request
     */
    private $client;

    /**
     * @param HttpClient|HttpAsyncClient $client
     * @param null|int                   $reenableAfter Number of seconds after this client is reenable
     */
    public function __construct($client, $reenableAfter = null)
    {
        $this->client = new FlexibleHttpClient($client);
        $this->reenableAfter = $reenableAfter;
    }

    /**
     * {@inheritdoc}
     */
    public function sendRequest(RequestInterface $request)
    {
        if ($this->isDisabled()) {
            throw new Exception\RequestException('Cannot send the request as this client has been disabled', $request);
        }

        try {
            $this->incrementRequestCount();
            $response = $this->client->sendRequest($request);
            $this->decrementRequestCount();
        } catch (Exception $e) {
            $this->disable();
            $this->decrementRequestCount();

            throw $e;
        }

        return $response;
    }

    /**
     * {@inheritdoc}
     */
    public function sendAsyncRequest(RequestInterface $request)
    {
        if ($this->isDisabled()) {
            throw new Exception\RequestException('Cannot send the request as this client has been disabled', $request);
        }

        $this->incrementRequestCount();

        return $this->client->sendAsyncRequest($request)->then(function ($response) {
            $this->decrementRequestCount();

            return $response;
        }, function ($exception) {
            $this->disable();
            $this->decrementRequestCount();

            throw $exception;
        });
    }

    /**
     * Whether this client is disabled or not.
     *
     * Will also reactivate this client if possible
     *
     * @internal
     *
     * @return bool
     */
    public function isDisabled()
    {
        $disabledAt = $this->getDisabledAt();

        if (null !== $this->reenableAfter && null !== $disabledAt) {
            // Reenable after a certain time
            $now = new \DateTime();

            if (($now->getTimestamp() - $disabledAt->getTimestamp()) >= $this->reenableAfter) {
                $this->enable();

                return false;
            }

            return true;
        }

        return null !== $disabledAt;
    }

    /**
     * Get current number of request that is send by the underlying http client.
     *
     * @internal
     *
     * @return int
     */
    public function getSendingRequestCount()
    {
        return $this->sendingRequestCount;
    }

    /**
     * Return when this client has been disabled or null if it's enabled.
     *
     * @return \DateTime|null
     */
    private function getDisabledAt()
    {
        return $this->disabledAt;
    }

    /**
     * Increment the request count.
     */
    private function incrementRequestCount()
    {
        ++$this->sendingRequestCount;
    }

    /**
     * Decrement the request count.
     */
    private function decrementRequestCount()
    {
        --$this->sendingRequestCount;
    }

    /**
     * Enable the current client.
     */
    private function enable()
    {
        $this->disabledAt = null;
    }

    /**
     * Disable the current client.
     */
    private function disable()
    {
        $this->disabledAt = new \DateTime('now');
    }
}


1		<?php
2
3		namespace Http\Client\Common;
4
5		use Http\Client\HttpAsyncClient;
6		use Http\Client\HttpClient;
7		use Psr\Http\Message\RequestInterface;
8		use Http\Client\Exception;
9
10		/**
11		* A HttpClientPoolItem represent a HttpClient inside a Pool.
12		*
13		* It is disabled when a request failed and can be reenable after a certain number of seconds
14		* It also keep tracks of the current number of request the client is currently sending (only usable for async method)
15		*
16		* @author Joel Wurtz <[email protected]>
17		*/
18		class HttpClientPoolItem implements HttpClient, HttpAsyncClient
19		{
20		/**
21		* @var int Number of request this client is currently sending
22		*/
23		private $sendingRequestCount = 0;
24
25		/**
26		* @var \DateTime\|null Time when this client has been disabled or null if enable
27		*/
28		private $disabledAt;
29
30		/**
31		* @var int\|null Number of seconds after this client is reenable, by default null: never reenable this client
32		*/
33		private $reenableAfter;
34
35		/**
36		* @var FlexibleHttpClient A http client responding to async and sync request
37		*/
38		private $client;
39
40		/**
41		* @param HttpClient\|HttpAsyncClient $client
42		* @param null\|int $reenableAfter Number of seconds after this client is reenable
43		*/
44	23	public function __construct($client, $reenableAfter = null)
45		{
46	23	$this->client = new FlexibleHttpClient($client);
47	23	$this->reenableAfter = $reenableAfter;
48	23	}
49
50		/**
51		* {@inheritdoc}
52		*/
53	13	public function sendRequest(RequestInterface $request)
54		{
55	13	if ($this->isDisabled()) {
56	1	throw new Exception\RequestException('Cannot send the request as this client has been disabled', $request);
57		}
58
59		try {
60	13	$this->incrementRequestCount();
61	13	$response = $this->client->sendRequest($request);
62	5	$this->decrementRequestCount();
63	13	} catch (Exception $e) {
64	8	$this->disable();
65	8	$this->decrementRequestCount();
66
67	8	throw $e;
68		}
69
70	5	return $response;
71		}
72
73		/**
74		* {@inheritdoc}
75		*/
76	8	public function sendAsyncRequest(RequestInterface $request)
77		{
78	8	if ($this->isDisabled()) {
79	1	throw new Exception\RequestException('Cannot send the request as this client has been disabled', $request);
80		}
81
82	8	$this->incrementRequestCount();
83
84		return $this->client->sendAsyncRequest($request)->then(function ($response) {
85	1	$this->decrementRequestCount();
86
87	1	return $response;
88	8	}, function ($exception) {
89	2	$this->disable();
90	2	$this->decrementRequestCount();
91
92	2	throw $exception;
93	8	});
94		}
95
96		/**
97		* Whether this client is disabled or not.
98		*
99		* Will also reactivate this client if possible
100		*
101		* @internal
102		*
103		* @return bool
104		*/
105	21	public function isDisabled()
106		{
107	21	$disabledAt = $this->getDisabledAt();
108
109	21	if (null !== $this->reenableAfter && null !== $disabledAt) {
110		// Reenable after a certain time
111	5	$now = new \DateTime();
112
113	5	if (($now->getTimestamp() - $disabledAt->getTimestamp()) >= $this->reenableAfter) {
114	5	$this->enable();
115
116	5	return false;
117		}
118
119		return true;
120		}
121
122	21	return null !== $disabledAt;
123		}
124
125		/**
126		* Get current number of request that is send by the underlying http client.
127		*
128		* @internal
129		*
130		* @return int
131		*/
132	2	public function getSendingRequestCount()
133		{
134	2	return $this->sendingRequestCount;
135		}
136
137		/**
138		* Return when this client has been disabled or null if it's enabled.
139		*
140		* @return \DateTime\|null
141		*/
142	21	private function getDisabledAt()
143		{
144	21	return $this->disabledAt;
145		}
146
147		/**
148		* Increment the request count.
149		*/
150	21	private function incrementRequestCount()
151		{
152	21	++$this->sendingRequestCount;
153	21	}
154
155		/**
156		* Decrement the request count.
157		*/
158	16	private function decrementRequestCount()
159		{
160	16	--$this->sendingRequestCount;
161	16	}
162
163		/**
164		* Enable the current client.
165		*/
166	5	private function enable()
167		{
168	5	$this->disabledAt = null;
169	5	}
170
171		/**
172		* Disable the current client.
173		*/
174	10	private function disable()
175		{
176	10	$this->disabledAt = new \DateTime('now');
177	10	}
178		}
179

php-http / client-common

Push — master ( 52b1c2...7b34df )

HttpClientPoolItem::isDisabled() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like