Cmp\CircuitBreaker\CircuitBreaker

Complexity

Total Complexity

20

Size/Duplication

Total Lines	178
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getLastTest()	0	4	1
A	__construct()	0	7	2
A	getCacheKey()	0	4	1
A	getService()	0	7	2
A	getFailures()	0	4	1
A	setFailures()	0	5	1
A	trackService()	0	7	2
B	isAvailable()	0	26	4
A	reportFailure()	0	9	2
A	reportSuccess()	0	17	4

<?php

namespace Cmp\CircuitBreaker;

use Cmp\CircuitBreaker\Exception\ServiceAlreadyTrackedException;
use Cmp\CircuitBreaker\Exception\ServiceNotTrackedException;
use Psr\Log\NullLogger;
use Psr\SimpleCache\CacheInterface;
use Psr\Log\LoggerInterface;

/**
 * Class CircuitBreaker
 *
 * @package Cmp\CircuitBreaker
 */
class CircuitBreaker
{
    /**
     * @var CacheInterface
     */
    protected $cache;

    /**
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * @var Service[]
     */
    protected $services    = [];

    /**
     * @var string
     */
    protected $cachePrefix = 'cb';

    /**
     * @var int
     */
    protected $ttl         = 3360;

    /**
     * CircuitBreaker constructor.
     *
     * @param CacheInterface       $cache       Cache to store the failures and times
     * @param LoggerInterface|null $logger      To log stuff
     */
    public function __construct(
        CacheInterface $cache,
        LoggerInterface $logger
    ) {
        $this->cache       = $cache;
        $this->logger      = $logger instanceof LoggerInterface ? $logger : new NullLogger();
    }

    /**
     * @param string $serviceName Name of the service
     * @param string $field       Field you want to fetch
     *
     * @return string
     */
    protected function getCacheKey($serviceName, $field)
    {
        return $this->cachePrefix.'-'.$serviceName.'-'.$field;
    }

    /**
     * @param $serviceName
     * @return Service|null
     */
    protected function getService($serviceName)
    {
        if (array_key_exists($serviceName, $this->services)) {
            return $this->services[$serviceName];
        }
        return null;
    }

    /**
     * @param string $serviceName Name of the service
     *
     * @return int
     */
    protected function getFailures($serviceName)
    {
        return (int) $this->cache->get($this->getCacheKey($serviceName, 'failures'));
    }

    /**
     * @param string $serviceName Name of the service
     *
     * @return int
     */
    protected function getLastTest($serviceName)
    {
        return (int) $this->cache->get($this->getCacheKey($serviceName, 'lastTest'));
    }

    /**
     * @param string $serviceName Name of the service
     * @param int    $newValue    New value to store
     */
    protected function setFailures($serviceName, $newValue)
    {
        $this->cache->set($this->getCacheKey($serviceName, 'failures'), $newValue, $this->ttl);
        $this->cache->set($this->getCacheKey($serviceName, 'lastTest'), time(), $this->ttl);
    }

    /**
     * @param Service $service Service to track
     *
     * @throws ServiceAlreadyTrackedException
     */
    public function trackService(Service $service)
    {
        if ($this->getService($service->getName()) !== null) {
            throw new ServiceAlreadyTrackedException($service->getName());
        }
        $this->services[$service->getName()] = $service;
    }

    /**
     * @param string $serviceName Name of the service
     *
     * @return bool
     * @throws ServiceNotTrackedException
     */
    public function isAvailable($serviceName)
    {
        $service = $this->getService($serviceName);
        if ($service == null) {
            throw new ServiceNotTrackedException($serviceName);
        }

        $failures    = $this->getFailures($serviceName);
        $maxFailures = $service->getMaxFailures();

        if ($failures < $maxFailures) {
            return true;
        }

        $lastTest     = $this->getLastTest($serviceName);
        $retryTimeout = $service->getRetryTimeout();

        if (($lastTest + $retryTimeout) < time()) {
            $this->setFailures($serviceName, $failures);
            $this->logger->info('Attempting service '.$serviceName.' one more time');

            return true;
        }

        return false;
    }

    /**
     * @param string $serviceName Name of the service
     *
     * @throws ServiceNotTrackedException
     */
    public function reportFailure($serviceName)
    {
        if ($this->getService($serviceName) == null) {
            throw new ServiceNotTrackedException($serviceName);
        }

        $this->setFailures($serviceName, $this->getFailures($serviceName) + 1);
        $this->logger->warning('Service '.$serviceName.' is shaky');
    }

    /**
     * @param string $serviceName Name of the service
     *
     * @throws ServiceNotTrackedException
     */
    public function reportSuccess($serviceName)
    {
        $service = $this->getService($serviceName);
        if ($service == null) {
            throw new ServiceNotTrackedException($serviceName);
        }

        $failures    = $this->getFailures($serviceName);
        $maxFailures = $service->getMaxFailures();

        if ($failures > $maxFailures) {
            $this->setFailures($serviceName, $maxFailures - 1);
            $this->logger->alert('Service '.$serviceName.' is down');
        } elseif ($failures > 0) {
            $this->setFailures($serviceName, $failures - 1);
        }
    }
}