hamburgscleanest\GuzzleAdvancedThrottle\RequestLimitGroup

Complexity

Total Complexity

12

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	canRequest()	0	19	4
A	__construct()	0	3	1
A	addRequestLimiter()	0	5	1
A	getRequestLimiterCount()	0	3	1
A	getRetryAfter()	0	3	1
A	create()	0	3	1
A	removeRequestLimiter()	0	5	1
A	addRules()	0	8	2

<?php

namespace hamburgscleanest\GuzzleAdvancedThrottle;

use hamburgscleanest\GuzzleAdvancedThrottle\Cache\Interfaces\StorageInterface;
use Psr\Http\Message\RequestInterface;
use SplObjectStorage;

class RequestLimitGroup
{
    private SplObjectStorage $_requestLimiters;
    private int $_retryAfter = 0;

    public function __construct()
    {
        $this->_requestLimiters = new SplObjectStorage();
    }

    public static function create(): self
    {
        return new static();
    }

    public function getRetryAfter(): int
    {
        return $this->_retryAfter;
    }

    /**
     * We have to cycle through all the limiters (no early return).
     * The timers of each limiter have to be updated despite of another limiter already preventing the request.
     */
    public function canRequest(RequestInterface $request, array $options = []): bool
    {
        $groupCanRequest = true;
        $this->_requestLimiters->rewind();
        while ($this->_requestLimiters->valid()) {
            /** @var RequestLimiter $requestLimiter */
            $requestLimiter = $this->_requestLimiters->current();

            $canRequest = $requestLimiter->canRequest($request, $options);

            if ($groupCanRequest && !$canRequest) {
                $groupCanRequest = false;
                $this->_retryAfter = $requestLimiter->getRemainingSeconds();
            }

            $this->_requestLimiters->next();
        }

        return $groupCanRequest;
    }

    public function addRequestLimiter(RequestLimiter $requestLimiter): self
    {
        $this->_requestLimiters->attach($requestLimiter);

        return $this;
    }

    public function removeRequestLimiter(RequestLimiter $requestLimiter): self
    {
        $this->_requestLimiters->detach($requestLimiter);

        return $this;
    }

    public function getRequestLimiterCount(): int
    {
        return $this->_requestLimiters->count();
    }

    public function addRules(string $host, array $rules, StorageInterface $storage): void
    {
        foreach ($rules as $rule) {
            $this->addRequestLimiter(
                RequestLimiter::createFromRule(
                    $host,
                    $rule,
                    $storage
                )
            );
        }
    }
}