AbstractBackoffStrategy::getBackoffPeriod() - Code Metrics - ForkNetwork/guzzle3 - Measure and Improve Code Quality continuously with Scrutinizer

AbstractBackoffStrategy::getBackoffPeriod() D
last analyzed 2016-12-06 13:37 UTC

↳ Parent: AbstractBackoffStrategy

Complexity

Conditions	10
Paths	11

Size

Total Lines	30
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	30
rs	4.8196
c	0
b	0
f	0
cc	10
eloc	22
nc	11
nop	4

How to fix Complexity

<?php

namespace Guzzle\Plugin\Backoff;

use Guzzle\Http\Message\RequestInterface;
use Guzzle\Http\Message\Response;
use Guzzle\Http\Exception\HttpException;

/**
 * Abstract backoff strategy that allows for a chain of responsibility
 */
abstract class AbstractBackoffStrategy implements BackoffStrategyInterface
{
    /** @var AbstractBackoffStrategy Next strategy in the chain */
    protected $next;

    /** @param AbstractBackoffStrategy $next Next strategy in the chain */
    public function setNext(AbstractBackoffStrategy $next)
    {
        $this->next = $next;
    }

    /**
     * Get the next backoff strategy in the chain
     *
     * @return AbstractBackoffStrategy|null
     */
    public function getNext()
    {
        return $this->next;
    }

    public function getBackoffPeriod(
        $retries,
        RequestInterface $request,
        Response $response = null,
        HttpException $e = null
    ) {
        $delay = $this->getDelay($retries, $request, $response, $e);
        if ($delay === false) {
            // The strategy knows that this must not be retried
            return false;
        } elseif ($delay === null) {
            // If the strategy is deferring a decision and the next strategy will not make a decision then return false
            return !$this->next || !$this->next->makesDecision()
                ? false
                : $this->next->getBackoffPeriod($retries, $request, $response, $e);
        } elseif ($delay === true) {
            // if the strategy knows that it must retry but is deferring to the next to determine the delay
            if (!$this->next) {
                return 0;
            } else {
                $next = $this->next;
                while ($next->makesDecision() && $next->getNext()) {
                    $next = $next->getNext();
                }
                return !$next->makesDecision() ? $next->getBackoffPeriod($retries, $request, $response, $e) : 0;
            }
        } else {
            return $delay;
        }
    }

    /**
     * Check if the strategy does filtering and makes decisions on whether or not to retry.
     *
     * Strategies that return false will never retry if all of the previous strategies in a chain defer on a backoff
     * decision.
     *
     * @return bool
     */
    abstract public function makesDecision();

    /**
     * Implement the concrete strategy
     *
     * @param int              $retries  Number of retries of the request
     * @param RequestInterface $request  Request that was sent
     * @param Response         $response Response that was received. Note that there may not be a response
     * @param HttpException    $e        Exception that was encountered if any
     *
     * @return bool|int|null Returns false to not retry or the number of seconds to delay between retries. Return true
     *                       or null to defer to the next strategy if available, and if not, return 0.
     */
    abstract protected function getDelay(
        $retries,
        RequestInterface $request,
        Response $response = null,
        HttpException $e = null
    );
}


1			<?php
2
3			namespace Guzzle\Plugin\Backoff;
4
5			use Guzzle\Http\Message\RequestInterface;
6			use Guzzle\Http\Message\Response;
7			use Guzzle\Http\Exception\HttpException;
8
9			/**
10			* Abstract backoff strategy that allows for a chain of responsibility
11			*/
12			abstract class AbstractBackoffStrategy implements BackoffStrategyInterface
13			{
14			/** @var AbstractBackoffStrategy Next strategy in the chain */
15			protected $next;
16
17			/** @param AbstractBackoffStrategy $next Next strategy in the chain */
18			public function setNext(AbstractBackoffStrategy $next)
19			{
20			$this->next = $next;
21			}
22
23			/**
24			* Get the next backoff strategy in the chain
25			*
26			* @return AbstractBackoffStrategy\|null
27			*/
28			public function getNext()
29			{
30			return $this->next;
31			}
32
33			public function getBackoffPeriod(
34			$retries,
35			RequestInterface $request,
36			Response $response = null,
37			HttpException $e = null
38			) {
39			$delay = $this->getDelay($retries, $request, $response, $e);
40			if ($delay === false) {
41			// The strategy knows that this must not be retried
42			return false;
43			} elseif ($delay === null) {
44			// If the strategy is deferring a decision and the next strategy will not make a decision then return false
45			return !$this->next \|\| !$this->next->makesDecision()
46			? false
47			: $this->next->getBackoffPeriod($retries, $request, $response, $e);
48			} elseif ($delay === true) {
49			// if the strategy knows that it must retry but is deferring to the next to determine the delay
50			if (!$this->next) {
51			return 0;
52			} else {
53			$next = $this->next;
54			while ($next->makesDecision() && $next->getNext()) {
55			$next = $next->getNext();
56			}
57			return !$next->makesDecision() ? $next->getBackoffPeriod($retries, $request, $response, $e) : 0;
58			}
59			} else {
60			return $delay;
61			}
62			}
63
64			/**
65			* Check if the strategy does filtering and makes decisions on whether or not to retry.
66			*
67			* Strategies that return false will never retry if all of the previous strategies in a chain defer on a backoff
68			* decision.
69			*
70			* @return bool
71			*/
72			abstract public function makesDecision();
73
74			/**
75			* Implement the concrete strategy
76			*
77			* @param int $retries Number of retries of the request
78			* @param RequestInterface $request Request that was sent
79			* @param Response $response Response that was received. Note that there may not be a response
80			* @param HttpException $e Exception that was encountered if any
81			*
82			* @return bool\|int\|null Returns false to not retry or the number of seconds to delay between retries. Return true
83			* or null to defer to the next strategy if available, and if not, return 0.
84			*/
85			abstract protected function getDelay(
86			$retries,
87			RequestInterface $request,
88			Response $response = null,
89			HttpException $e = null
90			);
91			}
92

ForkNetwork / guzzle3

AbstractBackoffStrategy::getBackoffPeriod() D last analyzed 2016-12-06 13:37 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

AbstractBackoffStrategy::getBackoffPeriod() D
last analyzed 2016-12-06 13:37 UTC