Merge pull request #28 from justbetter/feature/availability

Add availability

Author: VincentBean

README.md

@@ -347,6 +347,10 @@ Http::fake([
 $item = Item::query()->first();
 ```
 
+## Availability
+
+This client can prevent requests from going to Dynamics when it is giving HTTP status codes 503, 504 or timeouts. This can be configured per connection in the `availability` settings. Enable the `throw` option to prevent any requests from going to Dynamics.
+
 ## Contributing
 
 Please see [CONTRIBUTING](.github/CONTRIBUTING.md) for details.

config/dynamics.php

@@ -32,6 +32,22 @@
             'options' => [
                 'connect_timeout' => 5,
             ],
+            'availability' => [
+                /* The response codes that should trigger the availability check in addition to connection timeouts */
+                'codes' => [502, 503, 504],
+
+                /* The amount of failed requests before the service is marked as unavailable. */
+                'threshold' => 10,
+
+                /* The timespan in minutes in which the failed requests should occur. */
+                'timespan' => 10,
+
+                /* The cooldown in minutes after the threshold is reached. */
+                'cooldown' => 2,
+
+                /* Throw an exception that prevents calls to Dynamics when unavailable */
+                'throw' => false,
+            ],
         ],
     ],
 

src/Actions/Availability/CheckAvailability.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace JustBetter\DynamicsClient\Actions\Availability;
+
+use JustBetter\DynamicsClient\Contracts\Availability\ChecksAvailability;
+
+class CheckAvailability implements ChecksAvailability
+{
+    const AVAILABLE_KEY = 'dynamics-client:availability:';
+
+    public function check(string $connection): bool
+    {
+        return cache()->get(static::AVAILABLE_KEY.$connection, true);
+    }
+
+    public static function bind(): void
+    {
+        app()->singleton(ChecksAvailability::class, static::class);
+    }
+}

src/Actions/Availability/RegisterUnavailability.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace JustBetter\DynamicsClient\Actions\Availability;
+
+use JustBetter\DynamicsClient\Contracts\Availability\RegistersUnavailability;
+
+class RegisterUnavailability implements RegistersUnavailability
+{
+    public const COUNT_KEY = 'dynamics-client:unavailable-count:';
+
+    public function register(string $connection): void
+    {
+        $countKey = static::COUNT_KEY.$connection;
+
+        /** @var int $count */
+        $count = cache()->get($countKey, 0);
+        $count++;
+
+        /** @var int $threshold */
+        $threshold = config('dynamics.connections.'.$connection.'.availability.threshold', 10);
+
+        /** @var int $timespan */
+        $timespan = config('dynamics.connections.'.$connection.'.availability.timespan', 10);
+
+        /** @var int $cooldown */
+        $cooldown = config('dynamics.connections.'.$connection.'.availability.cooldown', 2);
+
+        cache()->put($countKey, $count, now()->addMinutes($timespan));
+
+        if ($count >= $threshold) {
+            cache()->put(CheckAvailability::AVAILABLE_KEY.$connection, false, now()->addMinutes($cooldown));
+
+            cache()->forget($countKey);
+        }
+    }
+
+    public static function bind(): void
+    {
+        app()->singleton(RegistersUnavailability::class, static::class);
+    }
+}

src/Client/ClientFactory.php

@@ -117,7 +117,7 @@ public function oauth(string $connection, array $config): static
 
     public function fabricate(): ODataClient
     {
-        $httpProvider = new ClientHttpProvider;
+        $httpProvider = new ClientHttpProvider($this->connection);
         $httpProvider->setExtraOptions($this->options);
 
         return new ODataClient($this->url, null, $httpProvider);
@@ -131,4 +131,9 @@ public function when(bool $condition, Closure $callback): ClientFactory
 
         return $this;
     }
+
+    public static function bind(): void
+    {
+        app()->bind(ClientFactoryContract::class, static::class);
+    }
 }

src/Client/ClientHttpProvider.php

@@ -2,19 +2,35 @@
 
 namespace JustBetter\DynamicsClient\Client;
 
+use Illuminate\Http\Client\ConnectionException;
 use Illuminate\Http\Client\RequestException;
 use Illuminate\Support\Facades\Http;
+use JustBetter\DynamicsClient\Contracts\Availability\ChecksAvailability;
+use JustBetter\DynamicsClient\Events\DynamicsResponseEvent;
+use JustBetter\DynamicsClient\Events\DynamicsTimeoutEvent;
 use JustBetter\DynamicsClient\Exceptions\DynamicsException;
 use JustBetter\DynamicsClient\Exceptions\ModifiedException;
 use JustBetter\DynamicsClient\Exceptions\NotFoundException;
+use JustBetter\DynamicsClient\Exceptions\UnavailableException;
 use Psr\Http\Message\ResponseInterface;
 use SaintSystems\OData\GuzzleHttpProvider;
 use SaintSystems\OData\HttpRequestMessage;
 
 class ClientHttpProvider extends GuzzleHttpProvider
 {
+    public function __construct(protected string $connection)
+    {
+        parent::__construct();
+    }
+
     public function send(HttpRequestMessage $request): ResponseInterface
     {
+        $throw = config('dynamics.connections.'.$this->connection.'.availability.throw', false);
+
+        if ($throw && ! $this->available()) {
+            throw new UnavailableException('The Dynamics connection "'.$this->connection.'" is currently unavailable.');
+        }
+
         try {
             $options = $this->extra_options;
 
@@ -23,6 +39,8 @@ public function send(HttpRequestMessage $request): ResponseInterface
             }
 
             $response = Http::send($request->method, $request->requestUri, $options);
+            DynamicsResponseEvent::dispatch($response, $this->connection);
+
             $response->throw();
 
             return $response->toPsrResponse();
@@ -42,6 +60,18 @@ public function send(HttpRequestMessage $request): ResponseInterface
             throw $dynamicsException
                 ->setRequest($request)
                 ->setResponse($exception->response);
+        } catch (ConnectionException $e) {
+            DynamicsTimeoutEvent::dispatch($this->connection);
+
+            throw $e;
         }
     }
+
+    protected function available(): bool
+    {
+        /** @var ChecksAvailability $checker */
+        $checker = app(ChecksAvailability::class);
+
+        return $checker->check($this->connection);
+    }
 }

src/Contracts/Availability/ChecksAvailability.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace JustBetter\DynamicsClient\Contracts\Availability;
+
+interface ChecksAvailability
+{
+    public function check(string $connection): bool;
+}

src/Contracts/Availability/RegistersUnavailability.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace JustBetter\DynamicsClient\Contracts\Availability;
+
+interface RegistersUnavailability
+{
+    public function register(string $connection): void;
+}

src/Events/DynamicsResponseEvent.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace JustBetter\DynamicsClient\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Http\Client\Response;
+
+class DynamicsResponseEvent
+{
+    use Dispatchable;
+
+    public function __construct(
+        public Response $response,
+        public string $connection,
+    ) {}
+}

src/Events/DynamicsTimeoutEvent.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace JustBetter\DynamicsClient\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+
+class DynamicsTimeoutEvent
+{
+    use Dispatchable;
+
+    public function __construct(
+        public string $connection,
+    ) {}
+}