Count::validate() - Code Metrics - ackintosh/ganesha - Measure and Improve Code Quality continuously with Scrutinizer

Count::validate() A
last analyzed 2020-02-25 11:58 UTC

↳ Parent: Count

Complexity

Conditions	4
Paths	5

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	5
c	0
b	0
f	0
nc	5
nop	1
dl	0
loc	10
rs	10

<?php
namespace Ackintosh\Ganesha\Strategy;

use Ackintosh\Ganesha;
use Ackintosh\Ganesha\Configuration;
use Ackintosh\Ganesha\Exception\StorageException;
use Ackintosh\Ganesha\Storage;
use Ackintosh\Ganesha\StrategyInterface;
use InvalidArgumentException;
use LogicException;

class Count implements StrategyInterface
{
    /**
     * @var Configuration
     */
    private $configuration;

    /**
     * @var Storage
     */
    private $storage;

    /**
     * @var array
     */
    private static $requirements = [
        'adapter',
        'failureCountThreshold',
        'intervalToHalfOpen',
    ];

    /**
     * @param Configuration $configuration
     * @param Storage $storage
     */
    private function __construct(Configuration $configuration, Storage $storage)
    {
        $this->configuration = $configuration;
        $this->storage = $storage;
    }

    /**
     * @param array $params
     * @throws LogicException
     */
    public static function validate(array $params): void
    {
        foreach (self::$requirements as $r) {
            if (!isset($params[$r])) {
                throw new LogicException($r . ' is required');
            }
        }

        if (!call_user_func([$params['adapter'], 'supportCountStrategy'])) {
            throw new InvalidArgumentException(get_class($params['adapter'])  . " doesn't support Count Strategy.");
        }
    }

    /**
     * @param Configuration $configuration
     * @return Count
     */
    public static function create(Configuration $configuration): StrategyInterface
    {
        return new self(
            $configuration,
            new Storage(
                $configuration['adapter'],
                /** @scrutinizer ignore-type */ $configuration['adapter'],
                $configuration['storageKeys'],
                /** @scrutinizer ignore-type */ $configuration['storageKeys'],
                null
            )
        );
    }

    /**
     * @param string $service
     * @return int
     */
    public function recordFailure(string $service): int
    {
        $this->storage->setLastFailureTime($service, time());
        $this->storage->incrementFailureCount($service);

        if ($this->storage->getFailureCount($service) >= $this->configuration['failureCountThreshold']
            && $this->storage->getStatus($service) === Ganesha::STATUS_CALMED_DOWN
        ) {
            $this->storage->setStatus($service, Ganesha::STATUS_TRIPPED);
            return Ganesha::STATUS_TRIPPED;
        }

        return Ganesha::STATUS_CALMED_DOWN;
    }

    /**
     * @param string $service
     * @return int
     */
    public function recordSuccess(string $service): ?int
    {
        $this->storage->decrementFailureCount($service);

        $status = $this->storage->getStatus($service);
        if ($this->storage->getFailureCount($service) === 0
            && $status === Ganesha::STATUS_TRIPPED
        ) {
            $this->storage->setStatus($service, Ganesha::STATUS_CALMED_DOWN);
            return Ganesha::STATUS_CALMED_DOWN;
        }

        return null;
    }

    /**
     * @return void
     */
    public function reset(): void
    {
        $this->storage->reset();
    }

    /**
     * @param string $service
     * @return bool
     */
    public function isAvailable(string $service): bool
    {
        return $this->isClosed($service) || $this->isHalfOpen($service);
    }

    /**
     * @param string $service
     * @return bool
     * @throws StorageException
     */
    private function isClosed(string $service): bool
    {
        return $this->storage->getFailureCount($service) < $this->configuration['failureCountThreshold'];
    }

    /**
     * @param string $service
     * @return bool
     * @throws StorageException
     */
    private function isHalfOpen(string $service): bool
    {
        if (is_null($lastFailureTime = $this->storage->getLastFailureTime($service))) {
            return false;
        }

        if ((time() - $lastFailureTime) > $this->configuration['intervalToHalfOpen']) {
            $this->storage->setFailureCount($service, $this->configuration['failureCountThreshold']);
            $this->storage->setFailureCount($service, /** @scrutinizer ignore-type */ $this->configuration['failureCountThreshold']);
            $this->storage->setLastFailureTime($service, time());
            return true;
        }

        return false;
    }
}


ackintosh / ganesha

Count::validate() A last analyzed 2020-02-25 11:58 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Count::validate() A
last analyzed 2020-02-25 11:58 UTC