├── .php-cs-fixer.dist.php
├── README.md
├── composer.json
└── src
    ├── Clients
        ├── ClientHelper.php
        ├── GuzzleClient.php
        └── SymfonyClient.php
    ├── Contracts
        ├── CircuitBreaker.php
        ├── Client.php
        ├── Event.php
        ├── Exception.php
        ├── Monitoring
        │   ├── Monitor.php
        │   ├── Report.php
        │   └── ReportEntry.php
        ├── Place.php
        ├── Service.php
        ├── Storage.php
        ├── System.php
        ├── ThrowableEvent.php
        └── Transaction.php
    ├── Events
        ├── AvailabilityChecked.php
        ├── Closed.php
        ├── Failed.php
        ├── Initiated.php
        ├── Isolated.php
        ├── Opened.php
        ├── ReOpened.php
        ├── Reseted.php
        ├── TransitionEvent.php
        └── Tried.php
    ├── Exceptions
        ├── InvalidPlace.php
        ├── InvalidSystem.php
        ├── InvalidTransaction.php
        ├── TransactionNotFound.php
        └── UnavailableService.php
    ├── MainCircuitBreaker.php
    ├── MainService.php
    ├── Monitors
        ├── SimpleMonitor.php
        ├── SimpleReport.php
        └── SimpleReportEntry.php
    ├── Places
        ├── Closed.php
        ├── HalfOpened.php
        ├── Isolated.php
        ├── Opened.php
        └── PlaceHelper.php
    ├── States.php
    ├── Storages
        ├── SimpleArray.php
        └── SimpleCache.php
    ├── Systems
        └── MainSystem.php
    ├── Transactions
        └── SimpleTransaction.php
    ├── Transitions.php
    └── Utils
        ├── Assert.php
        └── ErrorFormatter.php


/.php-cs-fixer.dist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $finder = PhpCsFixer\Finder::create()->in([
 4 |     __DIR__.'/src',
 5 |     __DIR__.'/tests',
 6 | ]);
 7 | 
 8 | $config = new PhpCsFixer\Config();
 9 | return $config
10 |     ->setRiskyAllowed(true)
11 |     ->setRules([
12 |         '@Symfony' => true,
13 |         'concat_space' => [
14 |             'spacing' => 'one',
15 |         ],
16 |         'cast_spaces' => [
17 |             'space' => 'single',
18 |         ],
19 |         'error_suppression' => [
20 |             'mute_deprecation_error' => false,
21 |             'noise_remaining_usages' => false,
22 |             'noise_remaining_usages_exclude' => [],
23 |         ],
24 |         'function_to_constant' => false,
25 |         'no_alias_functions' => false,
26 |         'non_printable_character' => false,
27 |         'phpdoc_summary' => false,
28 |         'phpdoc_align' => [
29 |             'align' => 'left',
30 |         ],
31 |         'protected_to_private' => false,
32 |         'self_accessor' => false,
33 |         'yoda_style' => false,
34 |         'non_printable_character' => true,
35 |         'phpdoc_no_empty_return' => false,
36 |         'php_unit_test_case_static_method_calls' => ['call_type' => 'self'],
37 |     ])
38 |     ->setFinder($finder)
39 |     ->setCacheFile(__DIR__.'/.php_cs.cache')
40 | ;
41 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Resiliency, an implementation for resilient and modern PHP applications
  2 | 
  3 | [![codecov](https://codecov.io/gh/loveOSS/resiliency/branch/master/graph/badge.svg)](https://codecov.io/gh/loveOSS/resiliency) [![PHPStan](https://img.shields.io/badge/PHPStan-Level%20max-brightgreen.svg?style=flat&logo=php)](https://shields.io/#/) [![Psalm](https://img.shields.io/badge/Psalm-Level%20Max-brightgreen.svg?style=flat&logo=php)](https://shields.io/#/) [![Build Status](https://travis-ci.com/loveOSS/resiliency.svg?branch=master)](https://travis-ci.com/loveOSS/resiliency) 
  4 | 
  5 | ## Main principles
  6 | 
  7 | ![circuit breaker](https://user-images.githubusercontent.com/1247388/49721725-438bd700-fc63-11e8-8498-82ca681b15fb.png)
  8 | 
  9 | This library is compatible with PHP 7.4+.
 10 | 
 11 | ## Installation
 12 | 
 13 | ```
 14 | composer require love-oss/resiliency
 15 | ```
 16 | 
 17 | ## Use
 18 | 
 19 | You need to configure a system for the Circuit Breaker:
 20 | 
 21 | * the **failures**: define how many times we try to access the service;
 22 | * the **timeout**: define how long we wait (in ms) before consider the service unreachable;
 23 | * the **stripped timeout**: define how long we wait (in ms) before consider the service unreachable, once we're in half open state;
 24 | * the **threshold**: define how long we wait (in ms) before trying to access again the service;
 25 | * the (HTTP|HTTPS) **client** that will be used to reach the services;
 26 | * the **fallback** callback will be used if the distant service is unreachable when the Circuit Breaker is Open (means "is used"). 
 27 | 
 28 | > You'd better return the same type of response expected from your distant call.
 29 | 
 30 | ```php
 31 | use Resiliency\MainCircuitBreaker;
 32 | use Resiliency\Systems\MainSystem;
 33 | use Resiliency\Storages\SimpleArray;
 34 | use Resiliency\Clients\SymfonyClient;
 35 | use Symfony\Component\HttpClient\HttpClient;
 36 | 
 37 | $client = new SymfonyClient(HttpClient::create());
 38 | 
 39 | $mainSystem = MainSystem::createFromArray([
 40 |     'failures' => 2,
 41 |     'timeout' => 100,
 42 |     'stripped_timeout' => 200,
 43 |     'threshold' => 10000,
 44 | ], $client);
 45 | 
 46 | $storage = new SimpleArray();
 47 | 
 48 | // Any PSR-14 Event Dispatcher implementation.
 49 | $dispatcher = new Symfony\Component\EventDispatcher\EventDispatcher;
 50 | 
 51 | $circuitBreaker = new MainCircuitBreaker(
 52 |     $mainSystem,
 53 |     $storage,
 54 |     $dispatcher
 55 | );
 56 | 
 57 | /**
 58 |  * @var Service $service
 59 |  */
 60 | $fallbackResponse = function ($service) {
 61 |     return '{}';
 62 | };
 63 | 
 64 | $circuitBreaker->call(
 65 |     'https://api.domain.com',
 66 |     $fallbackResponse,
 67 |     [
 68 |         'query' => [
 69 |             '_token' => '123456789',
 70 |         ]
 71 |     ]
 72 | );
 73 | ```
 74 | 
 75 | ### Clients
 76 | 
 77 | Resiliency library supports both [Guzzle (v6 & v7)](http://docs.guzzlephp.org/en/stable/index.html) and HttpClient Component from [Symfony (v4 & v5)](https://symfony.com/doc/current/components/http_client.html).
 78 | 
 79 | ### Monitoring
 80 | 
 81 | This library provides a minimalist system to help you monitor your circuits.
 82 | 
 83 | ```php
 84 | $monitor = new SimpleMonitor();
 85 | 
 86 | // Collect information while listening
 87 | // to some circuit breaker events...
 88 | function listener(Event $event) {
 89 |     $monitor->add($event);
 90 | };
 91 | 
 92 | // Retrieve a complete report for analysis or storage
 93 | $report = $monitor->getReport();
 94 | ```
 95 | 
 96 | ## Tests
 97 | 
 98 | ```
 99 | composer test
100 | ```
101 | 
102 | ## Code quality
103 | 
104 | This library has high quality standards:
105 | 
106 | ```
107 | composer cs-fix && composer phpstan && composer psalm && composer phpqa
108 | ```
109 | 
110 | We also use [PHPQA](https://github.com/EdgedesignCZ/phpqa#phpqa) to check the Code quality
111 | during the CI management of the contributions:
112 | 
113 | ```
114 | composer phpqa
115 | ```
116 | 
117 |  ## I've heard of the PrestaShop Circuit Breaker: what library should I use ?
118 |  
119 |  Welcome, that's an interesting question !
120 |  
121 |  Above all, I must say that I'm the former author of the PrestaShop [Circuit Breaker](https://github.com/PrestaShop/circuit-breaker) library
122 |  and I have decided to fork my own library to be able to improve it without the constraints of the PrestaShop CMS main project.
123 |  
124 |  As of now (June, 2021), these libraries have a lot in common !
125 |  
126 | They share almost the same API, and the PrestaShop Core Team have created multiple implementations of [Circuit Breaker interface](https://github.com/PrestaShop/circuit-breaker/blob/develop/src/AdvancedCircuitBreaker.php) and [Factory](https://github.com/PrestaShop/circuit-breaker/blob/develop/src/AdvancedCircuitBreakerFactory.php) :
127 | 
128 | * SimpleCircuitBreaker
129 | * AdvancedCircuitBreaker
130 | * PartialCircuitBreaker
131 | * SymfonyCircuitBreaker
132 | 
133 | 
134 | 1. They maintain a version compatible with PHP 7.2+ and Symfony 4 but not (yet ?) with PHP 8 and Symfony 5 ;
135 | 2. They have a dependency on their own package named [php-dev-tools](https://github.com/PrestaShop/php-dev-tools) ;
136 | 3. They maintain an implementation of [Storage](https://github.com/PrestaShop/circuit-breaker/blob/v4.0.0/src/Storage/DoctrineCache.php) using Doctrine Cache library ;
137 | 4. They don't have a Symfony HttpClient implementation ;
138 | 5. For the events, I'm not sure as their implementation make the list difficult to establish ;
139 | 6. They don't provide a mecanism to reset and restore a Circuit Breaker ;
140 | 7. They don't provide a mecanism to monitor the activity of a Circuit Breaker ;
141 | 8. They have removed [Psalm](https://psalm.dev/) from their CI and they don't use [PHPQA](https://github.com/EdgedesignCZ/phpqa) ;
142 | 9. They have added `declare(strict_types=1);` on all the files ;
143 | 10. They don't declare a `.gitattributes` file, this means that all tests are downloaded when [we require](https://madewithlove.com/blog/software-engineering/gitattributes/) their library ;
144 | 
145 | > All right ... but this don't tell me what library should I use in my project !
146 | 
147 | * If you need PHP 5.6, use Circuit Breaker v3
148 | * If you need PHP 7.2, use Circuit Breaker v4
149 | * If you need PHP 7.4+, use Resiliency
150 | * If you need a library maintained by a team of developers, use PrestaShop
151 | * If you trust [me](https://github.com/mickaelandrieu) to maintain this package _almost_ all alone, use Resiliency !
152 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "love-oss/resiliency",
 3 |     "description": "A circuit breaker implementation for PHP 7.4+",
 4 |     "type": "library",
 5 |     "license": "MIT",
 6 |     "authors": [
 7 |         {
 8 |             "name": "Mickaël Andrieu",
 9 |             "email": "mickael.andrieu@solvolabs.com"
10 |         },
11 |         {
12 |             "name": "Resiliency Community",
13 |             "homepage": "https://github.com/loveOSS/resiliency/graphs/contributors"
14 |         }
15 |     ],
16 |     "require": {
17 |         "php": "^7.4|^8.0",
18 |         "ext-json": "*",
19 |         "psr/event-dispatcher": "^1.0",
20 |         "psr/simple-cache": "^1.0"
21 |     },
22 |     "require-dev": {
23 |         "edgedesign/phpqa": "^v1.24",
24 |         "friendsofphp/php-cs-fixer": "^3.5",
25 |         "guzzlehttp/guzzle": "^6.3|^7.0",
26 |         "php-parallel-lint/php-parallel-lint": "^1.0",
27 |         "phpstan/phpstan": "^1.2",
28 |         "phpstan/phpstan-phpunit": "^1.0",
29 |         "phpunit/phpunit": "^9.0",
30 |         "symfony/cache": "~4.4|~5.4|~6.0",
31 |         "symfony/http-client": "^4.4|~5.4|~6.0",
32 |         "vimeo/psalm": "^4.3"
33 |     },
34 |     "suggest": {
35 |         "ext-apcu": "Allows use of APCu adapter (performant) to store transactions",
36 |         "guzzlehttp/guzzle": "Allows use of Guzzle 6 HTTP Client",
37 |         "symfony/cache": "Allows use of Symfony Cache adapters to store transactions",
38 |         "symfony/http-client": "Allows use of any Symfony HTTP Clients"
39 |     },
40 |     "autoload": {
41 |         "psr-4": {
42 |             "Resiliency\\": "src/"
43 |         }
44 |     },
45 |     "autoload-dev": {
46 |         "psr-4": {
47 |             "Tests\\Resiliency\\": "tests/"
48 |         }
49 |     },
50 |     "scripts": {
51 |         "cs-fix": "@php ./vendor/bin/php-cs-fixer fix",
52 |         "phpqa": "@php ./vendor/bin/phpqa --report --tools phpcs:0,phpmetrics,phploc,pdepend,security-checker:0,parallel-lint:0 --ignoredDirs tests,vendor",
53 |         "phpstan": "@php ./vendor/bin/phpstan analyse src --level max -c extension.neon",
54 |         "psalm": "@php ./vendor/bin/psalm --threads=8 --diff",
55 |         "test": "@php ./vendor/bin/phpunit"
56 |     },
57 |     "scripts-descriptions": {
58 |         "cs-fix": "Check and fix coding styles using PHP CS Fixer",
59 |         "phpqa": "Execute PHQA toolsuite analysis",
60 |         "phpstan": "Execute PHPStan analysis",
61 |         "psalm": "Execute Psalm analysis",
62 |         "test": "Launch PHPUnit test suite"
63 |     },
64 |     "config": {
65 |         "sort-packages": true
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Clients/ClientHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Clients;
 4 | 
 5 | use Resiliency\Contracts\Client;
 6 | use Resiliency\Contracts\Place;
 7 | use Resiliency\Contracts\Service;
 8 | 
 9 | abstract class ClientHelper implements Client
10 | {
11 |     protected array $mainOptions;
12 | 
13 |     public function __construct(array $mainOptions = [])
14 |     {
15 |         $this->mainOptions = $mainOptions;
16 |     }
17 | 
18 |     /**
19 |      * @param array $options the list of options
20 |      *
21 |      * @return string the method
22 |      */
23 |     protected function defineMethod(array $options): string
24 |     {
25 |         if (isset($this->mainOptions['method'])) {
26 |             return (string) $this->mainOptions['method'];
27 |         }
28 | 
29 |         if (isset($options['method'])) {
30 |             return (string) $options['method'];
31 |         }
32 | 
33 |         return self::DEFAULT_METHOD;
34 |     }
35 | 
36 |     protected function convertToSeconds(int $milliseconds): float
37 |     {
38 |         return $milliseconds / 1_000;
39 |     }
40 | 
41 |     /**
42 |      * {@inheritdoc}
43 |      */
44 |     abstract public function request(Service $service, Place $place): string;
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Clients/GuzzleClient.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Clients;
 4 | 
 5 | use Exception;
 6 | use GuzzleHttp\Client as OriginalGuzzleClient;
 7 | use Resiliency\Contracts\Place;
 8 | use Resiliency\Contracts\Service;
 9 | use Resiliency\Exceptions\UnavailableService;
10 | 
11 | /**
12 |  * Guzzle implementation of client.
13 |  * The possibility of extending this client is intended.
14 |  */
15 | class GuzzleClient extends ClientHelper
16 | {
17 |     /**
18 |      * {@inheritdoc}
19 |      */
20 |     public function request(Service $service, Place $place): string
21 |     {
22 |         $options = [];
23 |         try {
24 |             $client = new OriginalGuzzleClient($this->mainOptions);
25 |             $method = $this->defineMethod($service->getParameters());
26 |             $options['http_errors'] = true;
27 |             $options['connect_timeout'] = $this->convertToSeconds($place->getTimeout());
28 |             $options['timeout'] = $this->convertToSeconds($place->getTimeout());
29 | 
30 |             $clientParameters = array_merge($service->getParameters(), $options);
31 | 
32 |             return (string) $client->request($method, $service->getURI(), $clientParameters)->getBody();
33 |         } catch (Exception $exception) {
34 |             throw new UnavailableService($exception->getMessage(), (int) $exception->getCode(), $exception);
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Clients/SymfonyClient.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Clients;
 4 | 
 5 | use Resiliency\Contracts\Place;
 6 | use Resiliency\Contracts\Service;
 7 | use Resiliency\Exceptions\UnavailableService;
 8 | use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
 9 | use Symfony\Contracts\HttpClient\HttpClientInterface;
10 | 
11 | /**
12 |  * Symfony implementation of client.
13 |  * The possibility of extending this client is intended.
14 |  */
15 | class SymfonyClient extends ClientHelper
16 | {
17 |     private HttpClientInterface $httpClient;
18 | 
19 |     public function __construct(
20 |         HttpClientInterface $httpClient,
21 |         array $mainOptions = []
22 |     ) {
23 |         $this->httpClient = $httpClient;
24 |         parent::__construct($mainOptions);
25 |     }
26 | 
27 |     /**
28 |      * {@inheritdoc}
29 |      */
30 |     public function request(Service $service, Place $place): string
31 |     {
32 |         $options = [];
33 |         try {
34 |             $method = $this->defineMethod($service->getParameters());
35 |             $options['timeout'] = $this->convertToSeconds($place->getTimeout());
36 | 
37 |             $clientParameters = array_merge($service->getParameters(), $options);
38 |             unset($clientParameters['method']);
39 | 
40 |             return $this->httpClient->request($method, $service->getURI(), $clientParameters)->getContent();
41 |         } catch (TransportExceptionInterface $exception) {
42 |             throw new UnavailableService($exception->getMessage(), (int) $exception->getCode(), $exception);
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Contracts/CircuitBreaker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | use Psr\EventDispatcher\EventDispatcherInterface;
 6 | 
 7 | /**
 8 |  * A circuit breaker is used to provide
 9 |  * an alternative response when a tiers service
10 |  * is unreachable.
11 |  */
12 | interface CircuitBreaker
13 | {
14 |     /**
15 |      * @return Place the circuit breaker state
16 |      */
17 |     public function getState(): Place;
18 | 
19 |     /**
20 |      * @return Storage the circuit breaker storage
21 |      */
22 |     public function getStorage(): Storage;
23 | 
24 |     /**
25 |      * @return EventDispatcherInterface the circuit breaker dispatcher
26 |      */
27 |     public function getDispatcher(): EventDispatcherInterface;
28 | 
29 |     /**
30 |      * The function that try to reach the uri.
31 |      *
32 |      * @param string $uri the uri to call
33 |      * @param array $uriParameters the uri parameters
34 |      * @param callable $fallback if the service is unavailable, rely on the fallback
35 |      *
36 |      * @throws Exception in case of failure, throws an exception
37 |      */
38 |     public function call(string $uri, callable $fallback, array $uriParameters = []): string;
39 | 
40 |     /**
41 |      * Manually open (and hold open) the Circuit Breaker
42 |      * This can be used for example to take it offline for maintenance.
43 |      *
44 |      * @param string $uri the service URI to call
45 |      */
46 |     public function isolate(string $uri): self;
47 | 
48 |     /**
49 |      * Reset the breaker to closed state to start accepting actions again.
50 |      *
51 |      * @param string $uri the service URI to call
52 |      */
53 |     public function reset(string $uri): self;
54 | 
55 |     /**
56 |      * Update the circuit breaker state
57 |      *
58 |      * @param string $state the Place state
59 |      * @param Service $service the service
60 |      */
61 |     public function moveStateTo($state, Service $service): self;
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Contracts/Client.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | use Resiliency\Exceptions\UnavailableService;
 6 | 
 7 | /**
 8 |  * In charge of calling the resource and return a response.
 9 |  * Must throw UnavailableService exception if not reachable.
10 |  */
11 | interface Client
12 | {
13 |     /**
14 |      * @var string by default, calls are sent using GET method
15 |      */
16 |     public const DEFAULT_METHOD = 'GET';
17 | 
18 |     /**
19 |      * @param Service $service the Service
20 |      * @param Place $place the place
21 |      *
22 |      * @throws UnavailableService
23 |      */
24 |     public function request(Service $service, Place $place): string;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contracts/Event.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | /**
 6 |  * For every transition reached, an event can be dispatched by the system.
 7 |  */
 8 | interface Event
 9 | {
10 |     /**
11 |      * @return CircuitBreaker the Circuit Breaker
12 |      */
13 |     public function getCircuitBreaker(): CircuitBreaker;
14 | 
15 |     /**
16 |      * @return Service the Service
17 |      */
18 |     public function getService(): Service;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Contracts/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | use Throwable;
 6 | 
 7 | /**
 8 |  * Define any Resiliency exception.
 9 |  */
10 | interface Exception extends Throwable
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Contracts/Monitoring/Monitor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts\Monitoring;
 4 | 
 5 | use Resiliency\Contracts\Event;
 6 | 
 7 | /**
 8 |  * If you need to monitor and collect information about the circuit breaker
 9 |  * use the monitor to collect the information when events are dispatched.
10 |  */
11 | interface Monitor
12 | {
13 |     /**
14 |      * @param Event $event the dispatched event
15 |      */
16 |     public function collect(Event $event): void;
17 | 
18 |     /**
19 |      * @return Report the Monitor Report
20 |      */
21 |     public function getReport(): Report;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Contracts/Monitoring/Report.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts\Monitoring;
 4 | 
 5 | /**
 6 |  * The Monitor report
 7 |  */
 8 | interface Report
 9 | {
10 |     /**
11 |      * @param ReportEntry $reportEntry the report entry
12 |      */
13 |     public function add(ReportEntry $reportEntry): self;
14 | 
15 |     /**
16 |      * @return array the list of report entries
17 |      */
18 |     public function all(): array;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Contracts/Monitoring/ReportEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts\Monitoring;
 4 | 
 5 | use Resiliency\Contracts\CircuitBreaker;
 6 | use Resiliency\Contracts\Service;
 7 | 
 8 | /**
 9 |  * A report entry store information used to generate a report
10 |  * about Circuit Breaker activity over time.
11 |  */
12 | interface ReportEntry
13 | {
14 |     /**
15 |      * @return Service the service called
16 |      */
17 |     public function getService(): Service;
18 | 
19 |     /**
20 |      * @return CircuitBreaker the circuit breaker used
21 |      */
22 |     public function getCircuitBreaker(): CircuitBreaker;
23 | 
24 |     /**
25 |      * @return string the current transition of the circuit breaker
26 |      */
27 |     public function getTransition(): string;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Contracts/Place.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | /**
 6 |  * A circuit breaker can be in 4 places: closed, half open, open or isolated.
 7 |  * Each place have its own properties and behaviors.
 8 |  */
 9 | interface Place
10 | {
11 |     /**
12 |      * Return the state.
13 |      */
14 |     public function getState(): string;
15 | 
16 |     /**
17 |      * @return int the number of failures
18 |      */
19 |     public function getFailures(): int;
20 | 
21 |     /**
22 |      * @return int the allowed timeout (in ms) before try to reach the service
23 |      */
24 |     public function getThreshold(): int;
25 | 
26 |     /**
27 |      * @return int the allowed timeout (in ms)
28 |      */
29 |     public function getTimeout(): int;
30 | 
31 |     /**
32 |      * The function that execute the service.
33 |      *
34 |      * @param Transaction $transaction the service transaction
35 |      * @param callable $fallback if the service is unavailable, rely on the fallback
36 |      *
37 |      * @throws Exception in case of failure, throws an exception
38 |      */
39 |     public function call(Transaction $transaction, callable $fallback): string;
40 | 
41 |     /**
42 |      * Set the Circuit Breaker to the place.
43 |      *
44 |      * @param CircuitBreaker $circuitBreaker the circuit breaker
45 |      */
46 |     public function setCircuitBreaker(CircuitBreaker $circuitBreaker): self;
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Contracts/Service.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | /**
 6 |  * Describe what is a service for the Resiliency library.
 7 |  */
 8 | interface Service
 9 | {
10 |     /**
11 |      * @return string the URI we try to reach
12 |      */
13 |     public function getURI(): string;
14 | 
15 |     /**
16 |      * @return array the URI parameters
17 |      */
18 |     public function getParameters(): array;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Contracts/Storage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | use Resiliency\Exceptions\TransactionNotFound;
 6 | 
 7 | /**
 8 |  * Store the transaction between the Circuit Breaker
 9 |  * and the tiers service.
10 |  */
11 | interface Storage
12 | {
13 |     /**
14 |      * Save the CircuitBreaker transaction.
15 |      *
16 |      * @param string $serviceUri The service name
17 |      * @param Transaction $transaction The transaction
18 |      */
19 |     public function saveTransaction(string $serviceUri, Transaction $transaction): bool;
20 | 
21 |     /**
22 |      * Retrieve the CircuitBreaker transaction for a specific service.
23 |      *
24 |      * @param string $serviceUri the service name
25 |      *
26 |      *@throws TransactionNotFound
27 |      */
28 |     public function getTransaction(string $serviceUri): Transaction;
29 | 
30 |     /**
31 |      * Checks if the transaction exists.
32 |      *
33 |      * @param string $serviceUri the service name
34 |      */
35 |     public function hasTransaction(string $serviceUri): bool;
36 | 
37 |     /**
38 |      * Clear the Circuit Breaker storage.
39 |      */
40 |     public function clear(): bool;
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Contracts/System.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | /**
 6 |  * The System define the places available
 7 |  * for the Circuit Breaker and the initial Place.
 8 |  */
 9 | interface System
10 | {
11 |     /**
12 |      * @return Place[] the list of places of the system
13 |      */
14 |     public function getPlaces(): array;
15 | 
16 |     /**
17 |      * @return Place the initial place of the system
18 |      */
19 |     public function getInitialPlace(): Place;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Contracts/ThrowableEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | /**
 6 |  * Specific event in case of failure.
 7 |  */
 8 | interface ThrowableEvent extends Event
 9 | {
10 |     /**
11 |      * @return Exception the Exception
12 |      */
13 |     public function getException(): Exception;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Contracts/Transaction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Contracts;
 4 | 
 5 | use DateTime;
 6 | 
 7 | /**
 8 |  * Once the circuit breaker call a service,
 9 |  * a transaction is initialized and stored.
10 |  */
11 | interface Transaction
12 | {
13 |     /**
14 |      * @return Service the service
15 |      */
16 |     public function getService(): Service;
17 | 
18 |     /**
19 |      * @return int the number of failures to call the service
20 |      */
21 |     public function getFailures(): int;
22 | 
23 |     /**
24 |      * @return string the current state of the Circuit Breaker
25 |      */
26 |     public function getState(): string;
27 | 
28 |     /**
29 |      * @return DateTime the time when the circuit breaker move
30 |      *                  from open to half open state
31 |      */
32 |     public function getThresholdDateTime(): DateTime;
33 | 
34 |     /**
35 |      * Every time the service call fails, increment the number of failures.
36 |      */
37 |     public function incrementFailures(): int;
38 | 
39 |     /**
40 |      * If the service is up again, reset the number of failures to 0.
41 |      */
42 |     public function clearFailures(): bool;
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Events/AvailabilityChecked.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Resiliency\Events;
4 | 
5 | final class AvailabilityChecked extends TransitionEvent
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Events/Closed.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Resiliency\Events;
4 | 
5 | final class Closed extends TransitionEvent
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Events/Failed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Events;
 4 | 
 5 | use Resiliency\Contracts\CircuitBreaker;
 6 | use Resiliency\Contracts\Exception;
 7 | use Resiliency\Contracts\Service;
 8 | use Resiliency\Contracts\ThrowableEvent;
 9 | 
10 | final class Failed extends TransitionEvent implements ThrowableEvent
11 | {
12 |     /**
13 |      * We need to understand why a call have failed.
14 |      *
15 |      * @var Exception the exception
16 |      */
17 |     private $exception;
18 | 
19 |     /**
20 |      * @param CircuitBreaker $circuitBreaker the circuit breaker
21 |      * @param Service $service the Service
22 |      */
23 |     public function __construct(CircuitBreaker $circuitBreaker, Service $service, Exception $exception)
24 |     {
25 |         $this->exception = $exception;
26 | 
27 |         parent::__construct($circuitBreaker, $service);
28 |     }
29 | 
30 |     public function getException(): Exception
31 |     {
32 |         return $this->exception;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Events/Initiated.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Resiliency\Events;
4 | 
5 | final class Initiated extends TransitionEvent
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Events/Isolated.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Resiliency\Events;
4 | 
5 | final class Isolated extends TransitionEvent
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Events/Opened.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Resiliency\Events;
4 | 
5 | final class Opened extends TransitionEvent
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Events/ReOpened.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Resiliency\Events;
4 | 
5 | final class ReOpened extends TransitionEvent
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Events/Reseted.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Resiliency\Events;
4 | 
5 | final class Reseted extends TransitionEvent
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Events/TransitionEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Events;
 4 | 
 5 | use Resiliency\Contracts\CircuitBreaker;
 6 | use Resiliency\Contracts\Event;
 7 | use Resiliency\Contracts\Service;
 8 | 
 9 | abstract class TransitionEvent implements Event
10 | {
11 |     private CircuitBreaker $circuitBreaker;
12 |     private Service $service;
13 | 
14 |     /**
15 |      * @param CircuitBreaker $circuitBreaker the circuit breaker
16 |      * @param Service $service the Service
17 |      */
18 |     public function __construct(CircuitBreaker $circuitBreaker, Service $service)
19 |     {
20 |         $this->circuitBreaker = $circuitBreaker;
21 |         $this->service = $service;
22 |     }
23 | 
24 |     /**
25 |      * @return CircuitBreaker the Circuit Breaker
26 |      */
27 |     public function getCircuitBreaker(): CircuitBreaker
28 |     {
29 |         return $this->circuitBreaker;
30 |     }
31 | 
32 |     /**
33 |      * @return Service the Service
34 |      */
35 |     public function getService(): Service
36 |     {
37 |         return $this->service;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Events/Tried.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Resiliency\Events;
4 | 
5 | final class Tried extends TransitionEvent
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidPlace.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Exceptions;
 4 | 
 5 | use Exception;
 6 | use Resiliency\Contracts\Exception as ResiliencyException;
 7 | use Resiliency\Utils\ErrorFormatter;
 8 | 
 9 | final class InvalidPlace extends Exception implements ResiliencyException
10 | {
11 |     /**
12 |      * @param mixed $failures the failures
13 |      * @param mixed $timeout the timeout
14 |      * @param mixed $threshold the threshold
15 |      */
16 |     public static function invalidSettings($failures, $timeout, $threshold): self
17 |     {
18 |         $exceptionMessage = 'Invalid settings for Place' . PHP_EOL .
19 |             ErrorFormatter::format('failures', $failures, 'isPositiveInteger', 'a positive integer') .
20 |             ErrorFormatter::format('timeout', $timeout, 'isPositiveValue', 'a float') .
21 |             ErrorFormatter::format('threshold', $threshold, 'isPositiveInteger', 'a positive integer');
22 | 
23 |         return new self($exceptionMessage);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidSystem.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Exceptions;
 4 | 
 5 | use Exception;
 6 | use Resiliency\Contracts\Exception as ResiliencyException;
 7 | 
 8 | final class InvalidSystem extends Exception implements ResiliencyException
 9 | {
10 |     private const REQUIRED_SETTINGS = [
11 |         'timeout',
12 |         'stripped_timeout',
13 |         'failures',
14 |         'threshold',
15 |     ];
16 | 
17 |     public static function missingSettings(array $systemSettings): self
18 |     {
19 |         $exceptionMessage = 'Missing settings for System:' . PHP_EOL;
20 | 
21 |         foreach (self::REQUIRED_SETTINGS as $setting) {
22 |             if (!array_key_exists($setting, $systemSettings)) {
23 |                 $exceptionMessage .= sprintf(
24 |                     'The setting "%s" is missing from configuration',
25 |                     $setting
26 |                 ) . PHP_EOL;
27 |             }
28 |         }
29 | 
30 |         return new self($exceptionMessage);
31 |     }
32 | 
33 |     public static function phpTimeoutExceeded(): self
34 |     {
35 |         $exceptionMessage = 'The configuration timeout exceeds the PHP timeout' . PHP_EOL;
36 |         $exceptionMessage .= sprintf(
37 |             'Configure `max_execution_time` to a higher value, got: "%ss".',
38 |             ini_get('max_execution_time')
39 |         );
40 | 
41 |         return new self($exceptionMessage);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidTransaction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Exceptions;
 4 | 
 5 | use Exception;
 6 | use Resiliency\Contracts\Exception as ResiliencyException;
 7 | use Resiliency\Utils\ErrorFormatter;
 8 | 
 9 | final class InvalidTransaction extends Exception implements ResiliencyException
10 | {
11 |     /**
12 |      * @param mixed $serviceURI the service URI
13 |      * @param mixed $failures the failures
14 |      * @param mixed $state the Circuit Breaker
15 |      * @param mixed $threshold the threshold
16 |      */
17 |     public static function invalidParameters($serviceURI, $failures, $state, $threshold): self
18 |     {
19 |         $exceptionMessage = 'Invalid parameters for Transaction' . PHP_EOL .
20 |             ErrorFormatter::format('service', $serviceURI, 'isAService', 'an instance of Service') .
21 |             ErrorFormatter::format('failures', $failures, 'isPositiveInteger', 'a positive integer') .
22 |             ErrorFormatter::format('state', $state, 'isString', 'a string') .
23 |             ErrorFormatter::format('threshold', $threshold, 'isPositiveInteger', 'a positive integer');
24 | 
25 |         return new self($exceptionMessage);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Exceptions/TransactionNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Exceptions;
 4 | 
 5 | use Exception;
 6 | use Resiliency\Contracts\Exception as ResiliencyException;
 7 | 
 8 | final class TransactionNotFound extends Exception implements ResiliencyException
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Exceptions/UnavailableService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Exceptions;
 4 | 
 5 | use Exception;
 6 | use Resiliency\Contracts\Exception as ResiliencyException;
 7 | 
 8 | final class UnavailableService extends Exception implements ResiliencyException
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/src/MainCircuitBreaker.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Resiliency;
  4 | 
  5 | use Psr\EventDispatcher\EventDispatcherInterface;
  6 | use Resiliency\Contracts\CircuitBreaker;
  7 | use Resiliency\Contracts\Place;
  8 | use Resiliency\Contracts\Service;
  9 | use Resiliency\Contracts\Storage;
 10 | use Resiliency\Contracts\System;
 11 | use Resiliency\Contracts\Transaction;
 12 | use Resiliency\Events\Initiated;
 13 | use Resiliency\Events\Isolated;
 14 | use Resiliency\Events\Reseted;
 15 | use Resiliency\Transactions\SimpleTransaction;
 16 | 
 17 | /**
 18 |  * Main implementation of the Circuit Breaker.
 19 |  */
 20 | final class MainCircuitBreaker implements CircuitBreaker
 21 | {
 22 |     public function __construct(
 23 |         System $system,
 24 |         Storage $storage,
 25 |         EventDispatcherInterface $dispatcher
 26 |     ) {
 27 |         $this->currentPlace = $system->getInitialPlace();
 28 |         $this->currentPlace->setCircuitBreaker($this);
 29 |         $this->places = $system->getPlaces();
 30 |         $this->storage = $storage;
 31 |         $this->dispatcher = $dispatcher;
 32 |     }
 33 | 
 34 |     private Place $currentPlace;
 35 | 
 36 |     /**
 37 |      * @var Place[] the Circuit Breaker places
 38 |      */
 39 |     private array $places;
 40 |     private Storage $storage;
 41 |     private EventDispatcherInterface $dispatcher;
 42 | 
 43 |     /**
 44 |      * {@inheritdoc}
 45 |      */
 46 |     public function call(string $uri, callable $fallback, array $uriParameters = []): string
 47 |     {
 48 |         $service = new MainService($uri, $uriParameters);
 49 |         $transaction = $this->initTransaction($service);
 50 | 
 51 |         return $this->currentPlace->call($transaction, $fallback);
 52 |     }
 53 | 
 54 |     /**
 55 |      * {@inheritdoc}
 56 |      */
 57 |     public function getState(): Place
 58 |     {
 59 |         return $this->currentPlace;
 60 |     }
 61 | 
 62 |     /**
 63 |      * {@inheritdoc}
 64 |      */
 65 |     public function getStorage(): Storage
 66 |     {
 67 |         return $this->storage;
 68 |     }
 69 | 
 70 |     /**
 71 |      * {@inheritdoc}
 72 |      */
 73 |     public function getDispatcher(): EventDispatcherInterface
 74 |     {
 75 |         return $this->dispatcher;
 76 |     }
 77 | 
 78 |     /**
 79 |      * {@inheritdoc}
 80 |      */
 81 |     public function isolate(string $uri): CircuitBreaker
 82 |     {
 83 |         $service = $this->storage
 84 |             ->getTransaction($uri)
 85 |             ->getService()
 86 |         ;
 87 | 
 88 |         $this->dispatcher->dispatch(new Isolated($this, $service));
 89 |         $this->moveStateTo(States::ISOLATED_STATE, $service);
 90 | 
 91 |         return $this;
 92 |     }
 93 | 
 94 |     /**
 95 |      * {@inheritdoc}
 96 |      */
 97 |     public function reset(string $uri): CircuitBreaker
 98 |     {
 99 |         $service = $this->storage
100 |             ->getTransaction($uri)
101 |             ->getService()
102 |         ;
103 | 
104 |         $this->dispatcher->dispatch(new Reseted($this, $service));
105 |         $this->moveStateTo(States::CLOSED_STATE, $service);
106 | 
107 |         return $this;
108 |     }
109 | 
110 |     /**
111 |      * {@inheritdoc}
112 |      */
113 |     public function moveStateTo($state, Service $service): CircuitBreaker
114 |     {
115 |         $this->currentPlace = $this->places[$state];
116 |         $this->currentPlace->setCircuitBreaker($this);
117 |         $transaction = SimpleTransaction::createFromPlace(
118 |             $this->currentPlace,
119 |             $service
120 |         );
121 | 
122 |         $this->storage->saveTransaction($service->getURI(), $transaction);
123 | 
124 |         return $this;
125 |     }
126 | 
127 |     /**
128 |      * @todo: refactor to remove this function in favor of moveStateTo
129 |      *
130 |      * @param Service $service the service
131 |      */
132 |     private function initTransaction(Service $service): Transaction
133 |     {
134 |         if ($this->storage->hasTransaction($service->getURI())) {
135 |             $transaction = $this->storage->getTransaction($service->getURI());
136 |             $this->currentPlace = $this->places[$transaction->getState()];
137 |             $this->currentPlace->setCircuitBreaker($this);
138 |         } else {
139 |             $transaction = SimpleTransaction::createFromPlace(
140 |                 $this->currentPlace,
141 |                 $service
142 |             );
143 | 
144 |             $this->dispatcher->dispatch(new Initiated($this, $service));
145 |             $this->storage->saveTransaction($service->getURI(), $transaction);
146 |         }
147 | 
148 |         return $transaction;
149 |     }
150 | }
151 | 


--------------------------------------------------------------------------------
/src/MainService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency;
 4 | 
 5 | use Resiliency\Contracts\Service;
 6 | 
 7 | /**
 8 |  * Represents a service
 9 |  */
10 | final class MainService implements Service
11 | {
12 |     /**
13 |      * @var string the Service URI
14 |      */
15 |     private string $uri;
16 | 
17 |     /**
18 |      * @var array the Service parameters
19 |      */
20 |     private array $parameters;
21 | 
22 |     public function __construct(string $uri, array $parameters)
23 |     {
24 |         $this->uri = $uri;
25 |         $this->parameters = $parameters;
26 |     }
27 | 
28 |     /**
29 |      * {@inheritdoc}
30 |      */
31 |     public function getURI(): string
32 |     {
33 |         return $this->uri;
34 |     }
35 | 
36 |     /**
37 |      * {@inheritdoc}
38 |      */
39 |     public function getParameters(): array
40 |     {
41 |         return $this->parameters;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Monitors/SimpleMonitor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Monitors;
 4 | 
 5 | use Resiliency\Contracts\Event;
 6 | use Resiliency\Contracts\Monitoring\Monitor;
 7 | use Resiliency\Contracts\Monitoring\Report;
 8 | 
 9 | final class SimpleMonitor implements Monitor
10 | {
11 |     private Report $report;
12 | 
13 |     public function __construct()
14 |     {
15 |         $this->report = new SimpleReport();
16 |     }
17 | 
18 |     /**
19 |      * {@inheritdoc}
20 |      */
21 |     public function collect(Event $event): void
22 |     {
23 |         $reportEntry = new SimpleReportEntry(
24 |             $event->getService(),
25 |             $event->getCircuitBreaker(),
26 |             get_class($event)
27 |         );
28 | 
29 |         $this->report->add($reportEntry);
30 |     }
31 | 
32 |     /**
33 |      * {@inheritdoc}
34 |      */
35 |     public function getReport(): Report
36 |     {
37 |         return $this->report;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Monitors/SimpleReport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Monitors;
 4 | 
 5 | use Resiliency\Contracts\Monitoring\Report;
 6 | use Resiliency\Contracts\Monitoring\ReportEntry;
 7 | 
 8 | final class SimpleReport implements Report
 9 | {
10 |     private array $reportEntries;
11 | 
12 |     public function __construct()
13 |     {
14 |         $this->reportEntries = [];
15 |     }
16 | 
17 |     /**
18 |      * {@inheritdoc}
19 |      */
20 |     public function add(ReportEntry $reportEntry): Report
21 |     {
22 |         $this->reportEntries[] = $reportEntry;
23 | 
24 |         return $this;
25 |     }
26 | 
27 |     /**
28 |      * {@inheritdoc}
29 |      */
30 |     public function all(): array
31 |     {
32 |         return $this->reportEntries;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Monitors/SimpleReportEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Monitors;
 4 | 
 5 | use Resiliency\Contracts\CircuitBreaker;
 6 | use Resiliency\Contracts\Monitoring\ReportEntry;
 7 | use Resiliency\Contracts\Service;
 8 | 
 9 | final class SimpleReportEntry implements ReportEntry
10 | {
11 |     private Service $service;
12 |     private CircuitBreaker $circuitBreaker;
13 | 
14 |     /**
15 |      * @var string the Circuit Breaker transition
16 |      */
17 |     private string $transition;
18 | 
19 |     public function __construct(Service $service, CircuitBreaker $circuitBreaker, string $transition)
20 |     {
21 |         $this->service = $service;
22 |         $this->circuitBreaker = $circuitBreaker;
23 |         $this->transition = $transition;
24 |     }
25 | 
26 |     /**
27 |      * {@inheritdoc}
28 |      */
29 |     public function getService(): Service
30 |     {
31 |         return $this->service;
32 |     }
33 | 
34 |     /**
35 |      * {@inheritdoc}
36 |      */
37 |     public function getCircuitBreaker(): CircuitBreaker
38 |     {
39 |         return $this->circuitBreaker;
40 |     }
41 | 
42 |     /**
43 |      * {@inheritdoc}
44 |      */
45 |     public function getTransition(): string
46 |     {
47 |         return $this->transition;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Places/Closed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Places;
 4 | 
 5 | use Resiliency\Contracts\Client;
 6 | use Resiliency\Contracts\Transaction;
 7 | use Resiliency\Events\Failed;
 8 | use Resiliency\Events\Tried;
 9 | use Resiliency\Exceptions\UnavailableService;
10 | use Resiliency\States;
11 | 
12 | /**
13 |  * The circuit initially starts closed. When the circuit is closed:
14 |  *
15 |  * The circuit-breaker executes actions placed through it, measuring the failures and successes of those actions.
16 |  * If the failures exceed a certain threshold, the circuit will break (open).
17 |  */
18 | final class Closed extends PlaceHelper
19 | {
20 |     private Client $client;
21 | 
22 |     public function __construct(Client $client, int $failures, int $timeout)
23 |     {
24 |         $this->client = $client;
25 |         parent::__construct($failures, $timeout, 0);
26 |     }
27 | 
28 |     /**
29 |      * {@inheritdoc}
30 |      */
31 |     public function getState(): string
32 |     {
33 |         return States::CLOSED_STATE;
34 |     }
35 | 
36 |     /**
37 |      * {@inheritdoc}
38 |      */
39 |     public function call(Transaction $transaction, callable $fallback): string
40 |     {
41 |         $service = $transaction->getService();
42 |         $storage = $this->circuitBreaker->getStorage();
43 | 
44 |         if (!$this->isAllowedToRetry($transaction)) {
45 |             $transaction->clearFailures();
46 |             $this->circuitBreaker->moveStateTo(States::OPEN_STATE, $service);
47 | 
48 |             return parent::call($transaction, $fallback);
49 |         }
50 | 
51 |         $this->dispatch(new Tried($this->circuitBreaker, $service));
52 | 
53 |         try {
54 |             $response = $this->client->request($service, $this);
55 |             $storage->saveTransaction($service->getUri(), $transaction);
56 | 
57 |             return $response;
58 |         } catch (UnavailableService $exception) {
59 |             $this->dispatch(new Failed($this->circuitBreaker, $service, $exception));
60 |             $transaction->incrementFailures();
61 |             $storage->saveTransaction($service->getUri(), $transaction);
62 | 
63 |             return parent::call($transaction, $fallback);
64 |         }
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Places/HalfOpened.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Places;
 4 | 
 5 | use Resiliency\Contracts\Client;
 6 | use Resiliency\Contracts\Transaction;
 7 | use Resiliency\Events\AvailabilityChecked;
 8 | use Resiliency\Events\Closed;
 9 | use Resiliency\Events\ReOpened;
10 | use Resiliency\Exceptions\UnavailableService;
11 | use Resiliency\States;
12 | 
13 | /**
14 |  * When the circuit is half-opened:
15 |  *
16 |  * the next action will be treated as a trial, to determine the circuit's health.
17 |  *
18 |  * If this call throws a handled exception, that exception is rethrown,
19 |  * and the circuit transitions immediately back to open, and remains open again for the configured timespan.
20 |  *
21 |  * If the call throws no exception, the circuit transitions back to closed.
22 |  */
23 | final class HalfOpened extends PlaceHelper
24 | {
25 |     private Client $client;
26 | 
27 |     public function __construct(Client $client, int $timeout)
28 |     {
29 |         $this->client = $client;
30 |         parent::__construct(0, $timeout, 0);
31 |     }
32 | 
33 |     /**
34 |      * {@inheritdoc}
35 |      */
36 |     public function getState(): string
37 |     {
38 |         return States::HALF_OPEN_STATE;
39 |     }
40 | 
41 |     /**
42 |      * {@inheritdoc}
43 |      */
44 |     public function call(Transaction $transaction, callable $fallback): string
45 |     {
46 |         $service = $transaction->getService();
47 |         $this->dispatch(new AvailabilityChecked($this->circuitBreaker, $service));
48 | 
49 |         try {
50 |             $response = $this->client->request($service, $this);
51 | 
52 |             $this->dispatch(new Closed($this->circuitBreaker, $service));
53 |             $this->circuitBreaker->moveStateTo(States::CLOSED_STATE, $service);
54 |             $transaction->clearFailures();
55 |             $this->circuitBreaker->getStorage()->saveTransaction($service->getUri(), $transaction);
56 | 
57 |             return $response;
58 |         } catch (UnavailableService $exception) {
59 |             $transaction->incrementFailures();
60 |             $this->circuitBreaker->getStorage()->saveTransaction($service->getUri(), $transaction);
61 | 
62 |             if (!$this->isAllowedToRetry($transaction)) {
63 |                 $this->dispatch(new ReOpened($this->circuitBreaker, $service));
64 |                 $this->circuitBreaker->moveStateTo(States::OPEN_STATE, $service);
65 |             }
66 | 
67 |             return parent::call($transaction, $fallback);
68 |         }
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/Places/Isolated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Places;
 4 | 
 5 | use Resiliency\Contracts\Transaction;
 6 | use Resiliency\States;
 7 | 
 8 | /**
 9 |  * This state is manually triggered to ensure the Circuit Breaker
10 |  * remains open until we reset it.
11 |  */
12 | class Isolated extends PlaceHelper
13 | {
14 |     public function __construct()
15 |     {
16 |         parent::__construct(0, 0, 0);
17 |     }
18 | 
19 |     /**
20 |      * {@inheritdoc}
21 |      */
22 |     public function getState(): string
23 |     {
24 |         return States::ISOLATED_STATE;
25 |     }
26 | 
27 |     /**
28 |      * {@inheritdoc}
29 |      */
30 |     public function call(Transaction $transaction, callable $fallback): string
31 |     {
32 |         return $this->useFallback($transaction, $fallback);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Places/Opened.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Places;
 4 | 
 5 | use Resiliency\Contracts\Transaction;
 6 | use Resiliency\Events\Opened as OpenedEvent;
 7 | use Resiliency\States;
 8 | 
 9 | /**
10 |  * While the circuit is in an open state: every call to the service
11 |  * won't be executed and the fallback callback is executed.
12 |  */
13 | final class Opened extends PlaceHelper
14 | {
15 |     public function __construct(int $threshold)
16 |     {
17 |         parent::__construct(0, 0, $threshold);
18 |     }
19 | 
20 |     /**
21 |      * {@inheritdoc}
22 |      */
23 |     public function getState(): string
24 |     {
25 |         return States::OPEN_STATE;
26 |     }
27 | 
28 |     /**
29 |      * {@inheritdoc}
30 |      */
31 |     public function call(Transaction $transaction, callable $fallback): string
32 |     {
33 |         $service = $transaction->getService();
34 |         $this->dispatch(new OpenedEvent($this->circuitBreaker, $service));
35 | 
36 |         if (!$this->haveWaitedLongEnough($transaction)) {
37 |             return $this->useFallback($transaction, $fallback);
38 |         }
39 | 
40 |         $this->circuitBreaker->moveStateTo(States::HALF_OPEN_STATE, $service);
41 | 
42 |         return parent::call($transaction, $fallback);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Places/PlaceHelper.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Resiliency\Places;
  4 | 
  5 | use DateTime;
  6 | use Resiliency\Contracts\CircuitBreaker;
  7 | use Resiliency\Contracts\Event;
  8 | use Resiliency\Contracts\Place;
  9 | use Resiliency\Contracts\Transaction;
 10 | use Resiliency\Exceptions\InvalidPlace;
 11 | use Resiliency\Utils\Assert;
 12 | 
 13 | abstract class PlaceHelper implements Place
 14 | {
 15 |     private int $failures;
 16 |     private int $timeout;
 17 |     private int $threshold;
 18 |     protected CircuitBreaker $circuitBreaker;
 19 | 
 20 |     public function __construct(int $failures, int $timeout, int $threshold)
 21 |     {
 22 |         $this->validate($failures, $timeout, $threshold);
 23 | 
 24 |         $this->failures = $failures;
 25 |         $this->timeout = $timeout;
 26 |         $this->threshold = $threshold;
 27 |     }
 28 | 
 29 |     /**
 30 |      * {@inheritdoc}
 31 |      */
 32 |     abstract public function getState(): string;
 33 | 
 34 |     /**
 35 |      * {@inheritdoc}
 36 |      */
 37 |     public function getFailures(): int
 38 |     {
 39 |         return $this->failures;
 40 |     }
 41 | 
 42 |     /**
 43 |      * {@inheritdoc}
 44 |      */
 45 |     public function getTimeout(): int
 46 |     {
 47 |         return $this->timeout;
 48 |     }
 49 | 
 50 |     /**
 51 |      * {@inheritdoc}
 52 |      */
 53 |     public function getThreshold(): int
 54 |     {
 55 |         return $this->threshold;
 56 |     }
 57 | 
 58 |     /**
 59 |      * {@inheritdoc}
 60 |      */
 61 |     public function setCircuitBreaker(CircuitBreaker $circuitBreaker): Place
 62 |     {
 63 |         $this->circuitBreaker = $circuitBreaker;
 64 | 
 65 |         return $this;
 66 |     }
 67 | 
 68 |     /**
 69 |      * {@inheritdoc}
 70 |      */
 71 |     public function call(Transaction $transaction, callable $fallback): string
 72 |     {
 73 |         $service = $transaction->getService();
 74 | 
 75 |         return $this->circuitBreaker->call($service->getURI(), $fallback, $service->getParameters());
 76 |     }
 77 | 
 78 |     /**
 79 |      * @param Transaction $transaction the Transaction
 80 |      */
 81 |     public function isAllowedToRetry(Transaction $transaction): bool
 82 |     {
 83 |         return $transaction->getFailures() < $this->failures;
 84 |     }
 85 | 
 86 |     /**
 87 |      * @param Transaction $transaction the Transaction
 88 |      */
 89 |     public function haveWaitedLongEnough(Transaction $transaction): bool
 90 |     {
 91 |         return $transaction->getThresholdDateTime() < new DateTime();
 92 |     }
 93 | 
 94 |     /**
 95 |      * Helper to dispatch transition events.
 96 |      *
 97 |      * @param Event $event the circuit breaker event
 98 |      */
 99 |     protected function dispatch(Event $event): void
100 |     {
101 |         $this->circuitBreaker
102 |             ->getDispatcher()
103 |             ->dispatch($event)
104 |         ;
105 |     }
106 | 
107 |     /**
108 |      * Helper to return the fallback Response.
109 |      */
110 |     protected function useFallback(Transaction $transaction, callable $fallback): string
111 |     {
112 |         $service = $transaction->getService();
113 | 
114 |         return (string) $fallback($service);
115 |     }
116 | 
117 |     /**
118 |      * Ensure the place is valid
119 |      *
120 |      * @throws InvalidPlace
121 |      */
122 |     private function validate(int $failures, int $timeout, int $threshold): bool
123 |     {
124 |         $assertionsAreValid = Assert::isPositiveInteger($failures)
125 |             && Assert::isPositiveInteger($timeout)
126 |             && Assert::isPositiveInteger($threshold);
127 | 
128 |         if ($assertionsAreValid) {
129 |             return true;
130 |         }
131 | 
132 |         throw InvalidPlace::invalidSettings($failures, $timeout, $threshold);
133 |     }
134 | }
135 | 


--------------------------------------------------------------------------------
/src/States.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency;
 4 | 
 5 | /**
 6 |  * Define the available states of the Circuit Breaker;.
 7 |  */
 8 | final class States
 9 | {
10 |     /**
11 |      * Once opened, a circuit breaker doesn't do any call
12 |      * to third-party services. Only the alternative call is done.
13 |      */
14 |     public const OPEN_STATE = 'OPEN';
15 | 
16 |     /**
17 |      * After some conditions are valid, the circuit breaker
18 |      * try to access the third-party service. If the service is valid,
19 |      * the circuit breaker go to CLOSED state. If it's not, the circuit breaker
20 |      * go to OPEN state.
21 |      */
22 |     public const HALF_OPEN_STATE = 'HALF OPEN';
23 | 
24 |     /**
25 |      * On the first call of the service, or if the service is valid
26 |      * the circuit breaker is in CLOSED state. This means that the callable
27 |      * to evaluate is done and not the alternative call.
28 |      */
29 |     public const CLOSED_STATE = 'CLOSED';
30 | 
31 |     /**
32 |      * Once isolated, the circuit breaker stays in OPEN state and
33 |      * won't accept any requests, even when the threshold is reached.
34 |      */
35 |     public const ISOLATED_STATE = 'ISOLATED';
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Storages/SimpleArray.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Storages;
 4 | 
 5 | use Resiliency\Contracts\Storage;
 6 | use Resiliency\Contracts\Transaction;
 7 | use Resiliency\Exceptions\TransactionNotFound;
 8 | 
 9 | /**
10 |  * Very simple implementation of Storage using a simple PHP array.
11 |  */
12 | final class SimpleArray implements Storage
13 | {
14 |     public array $transactions = [];
15 | 
16 |     /**
17 |      * {@inheritdoc}
18 |      */
19 |     public function saveTransaction(string $serviceUri, Transaction $transaction): bool
20 |     {
21 |         $key = $this->getKey($serviceUri);
22 | 
23 |         $this->transactions[$key] = $transaction;
24 | 
25 |         return true;
26 |     }
27 | 
28 |     /**
29 |      * {@inheritdoc}
30 |      */
31 |     public function getTransaction(string $serviceUri): Transaction
32 |     {
33 |         $key = $this->getKey($serviceUri);
34 | 
35 |         if ($this->hasTransaction($serviceUri)) {
36 |             $transaction = $this->transactions[$key];
37 | 
38 |             if ($transaction instanceof Transaction) {
39 |                 return $transaction;
40 |             }
41 |         }
42 | 
43 |         throw new TransactionNotFound();
44 |     }
45 | 
46 |     /**
47 |      * {@inheritdoc}
48 |      */
49 |     public function hasTransaction(string $serviceUri): bool
50 |     {
51 |         $key = $this->getKey($serviceUri);
52 | 
53 |         return array_key_exists($key, $this->transactions);
54 |     }
55 | 
56 |     /**
57 |      * {@inheritdoc}
58 |      */
59 |     public function clear(): bool
60 |     {
61 |         $this->transactions = [];
62 | 
63 |         return true;
64 |     }
65 | 
66 |     /**
67 |      * Helper method to properly store the transaction.
68 |      *
69 |      * @param string $service the service URI
70 |      *
71 |      * @return string the transaction unique identifier
72 |      */
73 |     private function getKey(string $service): string
74 |     {
75 |         return md5($service);
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Storages/SimpleCache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Storages;
 4 | 
 5 | use Psr\SimpleCache\CacheInterface;
 6 | use Resiliency\Contracts\Storage;
 7 | use Resiliency\Contracts\Transaction;
 8 | use Resiliency\Exceptions\TransactionNotFound;
 9 | 
10 | /**
11 |  * Implementation of Storage on PSR-16 using the Symfony Cache Component.
12 |  */
13 | final class SimpleCache implements Storage
14 | {
15 |     private CacheInterface $psr16Cache;
16 | 
17 |     public function __construct(CacheInterface $psr16Cache)
18 |     {
19 |         $this->psr16Cache = $psr16Cache;
20 |     }
21 | 
22 |     /**
23 |      * {@inheritdoc}
24 |      */
25 |     public function saveTransaction(string $serviceUri, Transaction $transaction): bool
26 |     {
27 |         $key = $this->getKey($serviceUri);
28 | 
29 |         return $this->psr16Cache->set($key, $transaction);
30 |     }
31 | 
32 |     /**
33 |      * {@inheritdoc}
34 |      */
35 |     public function getTransaction(string $serviceUri): Transaction
36 |     {
37 |         $key = $this->getKey($serviceUri);
38 | 
39 |         if ($this->hasTransaction($serviceUri)) {
40 |             $transaction = $this->psr16Cache->get($key);
41 | 
42 |             if ($transaction instanceof Transaction) {
43 |                 return $transaction;
44 |             }
45 |         }
46 | 
47 |         throw new TransactionNotFound();
48 |     }
49 | 
50 |     /**
51 |      * {@inheritdoc}
52 |      */
53 |     public function hasTransaction(string $serviceUri): bool
54 |     {
55 |         $key = $this->getKey($serviceUri);
56 | 
57 |         return $this->psr16Cache->has($key);
58 |     }
59 | 
60 |     /**
61 |      * {@inheritdoc}
62 |      */
63 |     public function clear(): bool
64 |     {
65 |         return $this->psr16Cache->clear();
66 |     }
67 | 
68 |     /**
69 |      * Helper method to properly store the transaction.
70 |      *
71 |      * @param string $service the service URI
72 |      *
73 |      * @return string the transaction unique identifier
74 |      */
75 |     private function getKey(string $service): string
76 |     {
77 |         return md5($service);
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/Systems/MainSystem.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Resiliency\Systems;
  4 | 
  5 | use Resiliency\Contracts\Client;
  6 | use Resiliency\Contracts\Place;
  7 | use Resiliency\Contracts\System;
  8 | use Resiliency\Exceptions\InvalidSystem;
  9 | use Resiliency\Places\Closed;
 10 | use Resiliency\Places\HalfOpened;
 11 | use Resiliency\Places\Isolated;
 12 | use Resiliency\Places\Opened;
 13 | use Resiliency\States;
 14 | 
 15 | /**
 16 |  * The main system is built with 4 places:
 17 |  * - A Closed place
 18 |  * - A Half Opened Place
 19 |  * - An Opened Place
 20 |  * - An Isolated Place
 21 |  */
 22 | final class MainSystem implements System
 23 | {
 24 |     /**
 25 |      * @var Place[] the list of System places
 26 |      */
 27 |     private array $places;
 28 | 
 29 |     public function __construct(
 30 |         Client $client,
 31 |         int $failures,
 32 |         int $timeout,
 33 |         int $strippedTimeout,
 34 |         int $threshold
 35 |     ) {
 36 |         $closedPlace = new Closed($client, $failures, $timeout);
 37 |         $halfOpenPlace = new HalfOpened($client, $strippedTimeout);
 38 |         $openPlace = new Opened($threshold);
 39 |         $isolatedPlace = new Isolated();
 40 | 
 41 |         $this->places = [
 42 |             $closedPlace->getState() => $closedPlace,
 43 |             $halfOpenPlace->getState() => $halfOpenPlace,
 44 |             $openPlace->getState() => $openPlace,
 45 |             $isolatedPlace->getState() => $isolatedPlace,
 46 |         ];
 47 |     }
 48 | 
 49 |     /**
 50 |      * {@inheritdoc}
 51 |      */
 52 |     public function getInitialPlace(): Place
 53 |     {
 54 |         return $this->places[States::CLOSED_STATE];
 55 |     }
 56 | 
 57 |     /**
 58 |      * {@inheritdoc}
 59 |      */
 60 |     public function getPlaces(): array
 61 |     {
 62 |         return $this->places;
 63 |     }
 64 | 
 65 |     /**
 66 |      * @throws InvalidSystem
 67 |      */
 68 |     public static function createFromArray(array $settings, Client $client): self
 69 |     {
 70 |         if (self::validate($settings)) {
 71 |             $timeout = (int) $settings['timeout'];
 72 |             if (self::validateTimeout($timeout)) {
 73 |                 return new self(
 74 |                     $client,
 75 |                     (int) $settings['failures'],
 76 |                     $timeout,
 77 |                     (int) $settings['stripped_timeout'],
 78 |                     (int) $settings['threshold']
 79 |                 );
 80 |             }
 81 | 
 82 |             throw InvalidSystem::phpTimeoutExceeded();
 83 |         }
 84 | 
 85 |         throw InvalidSystem::missingSettings($settings);
 86 |     }
 87 | 
 88 |     private static function validate(array $settings): bool
 89 |     {
 90 |         return isset(
 91 |             $settings['failures'],
 92 |             $settings['timeout'],
 93 |             $settings['stripped_timeout'],
 94 |             $settings['threshold']
 95 |         );
 96 |     }
 97 | 
 98 |     private static function validateTimeout(int $timeout): bool
 99 |     {
100 |         // @doc https://www.php.net/manual/info.configuration.php the timeout is in seconds
101 |         $maxExecutionTime = ini_get('max_execution_time');
102 | 
103 |         $timeoutInSeconds = (int) ($timeout / 1000);
104 | 
105 |         return (0 === (int) $maxExecutionTime) || ($maxExecutionTime >= $timeoutInSeconds);
106 |     }
107 | }
108 | 


--------------------------------------------------------------------------------
/src/Transactions/SimpleTransaction.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Resiliency\Transactions;
  4 | 
  5 | use DateTime;
  6 | use Exception;
  7 | use Resiliency\Contracts\Place;
  8 | use Resiliency\Contracts\Service;
  9 | use Resiliency\Contracts\Transaction;
 10 | use Resiliency\Exceptions\InvalidTransaction;
 11 | use Resiliency\Utils\Assert;
 12 | 
 13 | /**
 14 |  * Main implementation of Circuit Breaker transaction.
 15 |  */
 16 | final class SimpleTransaction implements Transaction
 17 | {
 18 |     private Service $service;
 19 |     private int $failures;
 20 |     private string $state;
 21 |     private DateTime $thresholdDateTime;
 22 | 
 23 |     /**
 24 |      * @throws InvalidTransaction
 25 |      */
 26 |     public function __construct(Service $service, int $failures, string $state, int $threshold)
 27 |     {
 28 |         $this->validate($service, $failures, $state, $threshold);
 29 | 
 30 |         $this->service = $service;
 31 |         $this->failures = $failures;
 32 |         $this->state = $state;
 33 |         $this->initThresholdDateTime($threshold);
 34 |     }
 35 | 
 36 |     /**
 37 |      * {@inheritdoc}
 38 |      */
 39 |     public function getService(): Service
 40 |     {
 41 |         return $this->service;
 42 |     }
 43 | 
 44 |     /**
 45 |      * {@inheritdoc}
 46 |      */
 47 |     public function getFailures(): int
 48 |     {
 49 |         return $this->failures;
 50 |     }
 51 | 
 52 |     /**
 53 |      * {@inheritdoc}
 54 |      */
 55 |     public function getState(): string
 56 |     {
 57 |         return $this->state;
 58 |     }
 59 | 
 60 |     /**
 61 |      * {@inheritdoc}
 62 |      */
 63 |     public function getThresholdDateTime(): DateTime
 64 |     {
 65 |         return $this->thresholdDateTime;
 66 |     }
 67 | 
 68 |     /**
 69 |      * {@inheritdoc}
 70 |      */
 71 |     public function incrementFailures(): int
 72 |     {
 73 |         ++$this->failures;
 74 | 
 75 |         return $this->failures;
 76 |     }
 77 | 
 78 |     /**
 79 |      * {@inheritdoc}
 80 |      */
 81 |     public function clearFailures(): bool
 82 |     {
 83 |         $this->failures = 0;
 84 | 
 85 |         return true;
 86 |     }
 87 | 
 88 |     /**
 89 |      * @throws InvalidTransaction
 90 |      */
 91 |     public static function createFromPlace(Place $place, Service $service): self
 92 |     {
 93 |         $threshold = $place->getThreshold();
 94 | 
 95 |         return new self(
 96 |             $service,
 97 |             0,
 98 |             $place->getState(),
 99 |             $threshold
100 |         );
101 |     }
102 | 
103 |     /**
104 |      * Set the right DateTime from the threshold value.
105 |      *
106 |      * @throws Exception
107 |      */
108 |     private function initThresholdDateTime(int $threshold): void
109 |     {
110 |         $thresholdDateTime = new DateTime();
111 |         $thresholdInSeconds = $threshold / 1_000;
112 |         $thresholdDateTime->modify("+$thresholdInSeconds second");
113 | 
114 |         $this->thresholdDateTime = $thresholdDateTime;
115 |     }
116 | 
117 |     /**
118 |      * @throws InvalidTransaction
119 |      */
120 |     private function validate(Service $service, int $failures, string $state, int $threshold): bool
121 |     {
122 |         $assertionsAreValid = Assert::isAService($service)
123 |             && Assert::isPositiveInteger($failures)
124 |             && Assert::isString($state)
125 |             && Assert::isPositiveInteger($threshold);
126 | 
127 |         if ($assertionsAreValid) {
128 |             return true;
129 |         }
130 | 
131 |         throw InvalidTransaction::invalidParameters($service, $failures, $state, $threshold);
132 |     }
133 | }
134 | 


--------------------------------------------------------------------------------
/src/Transitions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency;
 4 | 
 5 | /**
 6 |  * Define the available transitions of the Circuit Breaker;.
 7 |  */
 8 | final class Transitions
 9 | {
10 |     /**
11 |      * Happened only once when calling the Circuit Breaker.
12 |      */
13 |     public const INITIATING_TRANSITION = 'INITIATING';
14 | 
15 |     /**
16 |      * Happened when we open the Circuit Breaker.
17 |      * This means once the Circuit Breaker is in failure.
18 |      */
19 |     public const OPENING_TRANSITION = 'OPENING';
20 | 
21 |     /**
22 |      * Happened once the conditions of retry are met
23 |      * in OPEN state to move to HALF_OPEN state in the
24 |      * Circuit Breaker.
25 |      */
26 |     public const CHECKING_AVAILABILITY_TRANSITION = 'CHECKING AVAILABILITY';
27 | 
28 |     /**
29 |      * Happened when we come back to OPEN state
30 |      * in the Circuit Breaker from the HALF_OPEN state.
31 |      */
32 |     public const REOPENING_TRANSITION = 'REOPENING';
33 | 
34 |     /**
35 |      * Happened if the service is available again.
36 |      */
37 |     public const CLOSING_TRANSITION = 'CLOSING';
38 | 
39 |     /**
40 |      * Happened on each try to call the service.
41 |      */
42 |     public const TRIAL_TRANSITION = 'TRIAL';
43 | 
44 |     /**
45 |      * Happened when the Circuit Breaker is isolated.
46 |      */
47 |     public const ISOLATING_TRANSITION = 'ISOLATING';
48 | 
49 |     /**
50 |      *  Happened when the Circuit Breaker is reset.
51 |      */
52 |     public const RESETTING_TRANSITION = 'RESETTING';
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Utils/Assert.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Utils;
 4 | 
 5 | use Resiliency\Contracts\Service;
 6 | 
 7 | /**
 8 |  * Utils class to handle object validation.
 9 |  */
10 | final class Assert
11 | {
12 |     /**
13 |      * @param mixed $value the value to evaluate
14 |      */
15 |     public static function isPositiveValue($value): bool
16 |     {
17 |         return !\is_string($value) && is_numeric($value) && $value >= 0;
18 |     }
19 | 
20 |     /**
21 |      * @param mixed $value the value to evaluate
22 |      */
23 |     public static function isPositiveInteger($value): bool
24 |     {
25 |         return self::isPositiveValue($value) && \is_int($value);
26 |     }
27 | 
28 |     /**
29 |      * @param mixed $value the value to evaluate
30 |      */
31 |     public static function isURI($value): bool
32 |     {
33 |         return null !== $value
34 |             && !is_numeric($value)
35 |             && !\is_bool($value)
36 |             && false !== filter_var($value, FILTER_SANITIZE_URL);
37 |     }
38 | 
39 |     /**
40 |      * @param mixed $value the value to evaluate
41 |      */
42 |     public static function isString($value): bool
43 |     {
44 |         return !empty($value) && \is_string($value);
45 |     }
46 | 
47 |     /**
48 |      * @param object $object the object to evaluate
49 |      */
50 |     public static function isAService(object $object): bool
51 |     {
52 |         return is_a($object, Service::class);
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Utils/ErrorFormatter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Resiliency\Utils;
 4 | 
 5 | /**
 6 |  * Helper to provide complete and easy to read
 7 |  * error messages.
 8 |  * Mostly used to build Exceptions messages.
 9 |  */
10 | final class ErrorFormatter
11 | {
12 |     /**
13 |      * Format error message.
14 |      *
15 |      * @param string $parameter the parameter to evaluate
16 |      * @param mixed $valueToFormat the value to format
17 |      * @param string $validationFunction the validation function
18 |      * @param string $expectedType the expected type
19 |      */
20 |     public static function format(
21 |         string $parameter,
22 |         $valueToFormat,
23 |         string $validationFunction,
24 |         string $expectedType
25 |     ): string {
26 |         $errorMessage = '';
27 |         $isValid = (bool) Assert::$validationFunction($valueToFormat);
28 |         $type = \gettype($valueToFormat);
29 |         $hasStringValue = \in_array($type, ['integer', 'float', 'string'], true);
30 | 
31 |         if (!$isValid) {
32 |             $errorMessage = sprintf(
33 |                 'Excepted %s to be %s, got %s',
34 |                 $parameter,
35 |                 $expectedType,
36 |                 $type
37 |             );
38 | 
39 |             if ($hasStringValue) {
40 |                 $errorMessage .= sprintf(' (%s)', (string) $valueToFormat);
41 |             }
42 | 
43 |             $errorMessage .= PHP_EOL;
44 |         }
45 | 
46 |         return $errorMessage;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------