Eljam\CircuitBreaker\Breaker

Complexity

Total Complexity

25

Size/Duplication

Total Lines	226
Duplicated Lines	13.27 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes	4
Bugs	0	Features	2

10 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	26	4
D	protect()	0	34	9
A	addListener()	0	4	1
A	isClosed()	10	10	2
A	isOpen()	10	10	2
A	isHalfOpen()	10	10	2
A	success()	0	7	1
A	failure()	0	8	1
A	loadCircuit()	0	12	2
A	writeToStore()	0	4	1

<?php

/*
 * This file is part of the circuit-breaker package
 *
 * Copyright (c) 2016 Guillaume Cavana
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Feel free to edit as you please, and have fun.
 *
 * @author Guillaume Cavana <guillaume.cavana@gmail.com>
 */

namespace Eljam\CircuitBreaker;

use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Cache\Cache;
use Eljam\CircuitBreaker\Event\CircuitEvent;
use Eljam\CircuitBreaker\Event\CircuitEvents;
use Eljam\CircuitBreaker\Exception\CircuitOpenException;
use Eljam\CircuitBreaker\Handler\Handler;
use Eljam\CircuitBreaker\Handler\HandlerInterface;
use Eljam\CircuitBreaker\Util\Utils;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

/**
 * Class Breaker.
 */
class Breaker
{
    /**
     * $cache.
     *
     * @var Cache
     */
    protected $store;

    /**
     * $config.
     *
     * @var array
     */
    protected $config;

    /**
     * $handler.
     *
     * @var HandlerInterface
     */
    protected $handler;

    /**
     * $dispatcher.
     *
     * @var EventDispatcherInterface
     */
    protected $dispatcher;

    /**
     * Constructor.
     *
     * @param string                   $name
     * @param array                    $config
     * @param Cache                    $store
     * @param Handler                  $handler
     * @param EventDispatcherInterface $dispatcher
     */
    public function __construct(
        $name,
        array $config = [],
        Cache $store = null,
        HandlerInterface $handler = null,
        EventDispatcherInterface $dispatcher = null
    ) {
        $resolver = new OptionsResolver();
        $resolver->setDefaults([
            'max_failure' => 5,
            'reset_timeout' => 5,
            'exclude_exceptions' => [],
            'ignore_exceptions' => false,
        ]);

        $resolver->setAllowedTypes('exclude_exceptions', 'array');
        $resolver->setAllowedTypes('max_failure', 'int');
        $resolver->setAllowedTypes('reset_timeout', 'int');

        $this->config = $resolver->resolve($config);
        $this->store = null !== $store ? $store : (new ArrayCache());
        $this->handler = null !== $handler ? $handler($this->config) : new Handler($this->config);
        $this->dispatcher = null !== $dispatcher ? $dispatcher : new EventDispatcher();
        $name = Utils::snakeCase($name);
        $this->circuit = $this->loadCircuit($name);

The property circuit does not exist. Did you maybe forget to declare it?

    }

    /**
     * protect.
     *
     * @param \Closure $closure
     * @throw  \Exception
     *
     * @return mixed
     */
    public function protect(\Closure $closure)
    {
        try {
            $result = null;
            $circuitOpenException = null;

            if ($this->isClosed($this->circuit) || $this->isHalfOpen($this->circuit)) {
                $result = $closure();
                $this->success($this->circuit);
            } elseif ($this->isOpen($this->circuit)) {
                $circuitOpenException = new CircuitOpenException();
            }
        } catch (\Exception $e) {
            $this->failure($this->circuit);

            if (!$this->config['ignore_exceptions']) {
                if (!in_array(get_class($e), $this->config['exclude_exceptions'])) {
                    $result = $e;
                }
            }
        }

        // Throw circuit exception when it is opened
        if (null !== $circuitOpenException) {
            throw $circuitOpenException;
        }

        //Throw closure exception
        if ($result instanceof \Exception) {
            throw $result;
        }

        return $result;
    }

    /**
     * addListener.
     *
     * @param string         $eventName
     * @param \Closure|array $listener
     */
    public function addListener($eventName, $listener)
    {
        $this->dispatcher->addListener($eventName, $listener);
    }

    /**
     * isClosed.
     *
     * @param Circuit $circuit
     *
     * @return bool
     */
    protected function isClosed($circuit)

This method seems to be duplicated in your project.

    {
        if ($this->handler->isClosed($circuit)) {

$circuit is of type object<Eljam\CircuitBreaker\Circuit>, but the function expects a object<Eljam\CircuitBreaker\Handler\Circuit>.

            $this->dispatcher->dispatch(CircuitEvents::CLOSED, (new CircuitEvent($circuit)));

            return true;
        }

        return;
    }

    /**
     * isOpen.
     *
     * @param Circuit $circuit
     *
     * @return bool
     */
    protected function isOpen($circuit)

This method seems to be duplicated in your project.

    {
        if ($this->handler->isOpen($circuit)) {

$circuit is of type object<Eljam\CircuitBreaker\Circuit>, but the function expects a object<Eljam\CircuitBreaker\Handler\Circuit>.

            $this->dispatcher->dispatch(CircuitEvents::OPEN, (new CircuitEvent($circuit)));

            return true;
        }

        return;
    }

    /**
     * isHalfOpen.
     *
     * @param Circuit $circuit
     *
     * @return bool
     */
    protected function isHalfOpen($circuit)

This method seems to be duplicated in your project.

    {
        if ($this->handler->isHalfOpen($circuit)) {

$circuit is of type object<Eljam\CircuitBreaker\Circuit>, but the function expects a object<Eljam\CircuitBreaker\Handler\Circuit>.

            $this->dispatcher->dispatch(CircuitEvents::HALF_OPEN, (new CircuitEvent($circuit)));

            return true;
        }

        return;
    }

    /**
     * success.
     *
     * @param Circuit $circuit
     */
    protected function success($circuit)
    {
        $circuit->resetFailture();

        $this->dispatcher->dispatch(CircuitEvents::SUCCESS, (new CircuitEvent($circuit)));
        $this->writeToStore($circuit);
    }

    /**
     * failure.
     *
     * @param Circuit $circuit
     */
    protected function failure(Circuit $circuit)
    {
        $circuit->incrementFailure();
        $circuit->setLastFailure(time());

        $this->dispatcher->dispatch(CircuitEvents::FAILURE, (new CircuitEvent($circuit)));
        $this->writeToStore($circuit);
    }

    /**
     * loadCircuit.
     *
     * @param string $name
     *
     * @return Circuit
     */
    protected function loadCircuit($name)
    {
        if ($this->store->contains($name)) {
            $circuit = $this->store->fetch($name);
        } else {
            $circuit = new Circuit($name);
        }

        $this->writeToStore($circuit);

        return $circuit;
    }

    protected function writeToStore(Circuit $circuit)
    {
        $this->store->save($circuit->getName(), $circuit);
    }
}