CheckerState::retryIsAllowed() - Code Metrics - Inspection of "Delete .scrutinizer.yml" - protonemedia/laravel-api-health - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 00bfc7...d09317 )

by Pascal
created 2022-01-19 08:49 UTC
CheckerState::retryIsAllowed() A

↳ Parent: CheckerState
Complexity

Conditions	6
Paths	5
Size

Total Lines	21
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	6
eloc	10
nc	5
nop	0
dl	0
loc	21
rs	9.2222
c	0
b	0
f	0
<?php

namespace ProtoneMedia\ApiHealth\Storage;

use Illuminate\Notifications\Notification;
use Illuminate\Support\Facades\Cache;
use ProtoneMedia\ApiHealth\Checkers\Checker;
use ProtoneMedia\ApiHealth\Checkers\CheckerAllowsForRetries;
use ProtoneMedia\ApiHealth\Checkers\CheckerHasFailed;
use ProtoneMedia\ApiHealth\Events\CheckerHasFailed as CheckerHasFailedEvent;
use ProtoneMedia\ApiHealth\Events\CheckerHasRecovered;
use ProtoneMedia\ApiHealth\Events\CheckerIsStillFailing;

class CheckerState
{
    /**
     * The checker.
     *
     * @var \ProtoneMedia\ApiHealth\Checkers\Checker
     */
    private $checker;

    /**
     * The cache driver instance.
     *
     * @var \Illuminate\Contracts\Cache\Repository
     */
    private $cache;

    public function __construct(Checker $checker)
    {
        $this->checker = $checker;

        $this->cache = Cache::driver(config('api-health.cache_driver'));
    }

    /**
     * Shortcut for creating an instance with the given checker class.
     *
     * @param  string $checkerClass
     * @return \ProtoneMedia\ApiHealth\Storage\CheckerState
     */
    public static function make(string $checkerClass)
    {
        return new static($checkerClass::create());
    }

    /**
     * Returns the cache key for this checker.
     *
     * @return string
     */
    private function key(): string
    {
        return 'laravel-api-checker.' . $this->checker->id();
    }

    /**
     * Returns a boolean wether any data has been stored.
     *
     * @return bool
     */
    public function exists(): bool
    {
        return $this->cache->has($this->key());
    }

    /**
     * Stores the given data into the cache repository.
     *
     * @param  array  $data
     * @return null
     */
    private function store(array $data)
    {
        $this->cache->forever($this->key(), $data);
    }

    /**
     * Returns all stored data.
     *
     * @return array
     */
    public function data(): array
    {
        return $this->cache->get($this->key());
    }

    /**
     * Returns a boolean wether the state is set to failed.
     *
     * @return bool
     */
    public function isFailing(): bool
    {
        return $this->data()['failed_at'] ? true : false;
    }

    /**
     * Returns a boolean wether the state is set to passes.
     *
     * @return bool
     */
    public function isPassing(): bool
    {
        return $this->data()['passed_at'] ? true : false;
    }

    /**
     * Determinates if a failed notification should be sent.
     *
     * @return bool
     */
    public function shouldSentFailedNotification(): bool
    {
        $sentNotifications = collect($this->data()['notifications_sent']);

        if ($sentNotifications->isEmpty()) {
            return true;
        }

        if (!$resendAfterMinutes = $this->checker->resendFailedNotificationAfterMinutes()) {
        if (!$resendAfterMinutes = $this->checker->/** @scrutinizer ignore-call */ resendFailedNotificationAfterMinutes()) {
            return false;
        }

        $diffInSeconds = now()->getTimestamp() - $sentNotifications->last()['sent_at'];

        return $diffInSeconds >= ($resendAfterMinutes * 60);
    }

    /**
     * Determinates wether the checker is allowed to do another retry.
     *
     * @return bool
     */
    public function retryIsAllowed(): bool
    {
        if (!$this->checker instanceof CheckerAllowsForRetries) {
            return false;
        }

        if ($this->exists() && $this->isFailing()) {
            return false;
        }

        if (!$allowedRetries = $this->checker->allowedRetries()) {
            return false;
        }

        if (!$this->exists()) {
            return true;
        }

        $retries = $this->data()['retried_at'];

        return $allowedRetries > count($retries);
    }

    /**
     * Set the state to failed with the given exception message.
     *
     * @param \ProtoneMedia\ApiHealth\Checkers\CheckerHasFailed $exception
     */
    public function setToFailed(CheckerHasFailed $exception)
    {
        $this->store($failedData = [
            'exception_message'  => $exception->getMessage(),
            'passed_at'          => null,
            'failed_at'          => [now()->getTimestamp()],
            'notifications_sent' => [],
        ]);

        event(new CheckerHasFailedEvent($this->checker, $exception, $failedData));
    }

    /**
     * Adds the current timestamp to the failed state.
     *
     * @param \ProtoneMedia\ApiHealth\Checkers\CheckerHasFailed $exception
     */
    public function addFailedTimestamp(CheckerHasFailed $exception)
    {
        $failedData = $this->data();

        $failedData['failed_at'][] = now()->getTimestamp();

        $this->store($failedData);

        event(new CheckerIsStillFailing($this->checker, $exception, $failedData));
    }

    /**
     * Adds the current timestamp to the retry array.
     *
     * @return null
     */
    public function addRetryTimestamp()
    {
        $data = $this->data();

        $data['retried_at'][] = now()->getTimestamp();

        $this->store($data);
    }

    /**
     * Adds the current timestamp to the array of sent notifications.
     *
     * @param  \Illuminate\Notifications\Notification $notification
     * @return null
     */
    public function markSentFailedNotification(Notification $notification)
    {
        $data = $this->data();

        $data['notifications_sent'][] = [
            'notification_type' => get_class($notification),
            'sent_at'           => now()->getTimestamp(),
        ];

        $this->store($data);
    }

    /**
     * Set the state to passes.
     * @return null
     */
    public function setToPassing()
    {
        $failedData = ($this->exists() && $this->isFailing()) ? $this->data() : null;

        $this->store([
            'exception_message'  => null,
            'passed_at'          => now()->getTimestamp(),
            'failed_at'          => null,
            'notifications_sent' => [],
            'retried_at'         => [],
        ]);

        $failedData ? event(new CheckerHasRecovered($this->checker, $failedData)) : null;
    }
}

protonemedia / laravel-api-health

GitHub Access Token became invalid

Push — master ( 00bfc7...d09317 )

CheckerState::retryIsAllowed() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
