responsible\core\throttle\limiter

Complexity

Total Complexity

43

Size/Duplication

Total Lines	330
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	isUnlimited()	0	3	1
A	getCapacity()	0	3	1
A	getTimeframe()	0	3	1
A	getAccount()	0	3	1
A	setCapacity()	0	3	1
A	options()	0	4	1
A	getOptions()	0	3	1
A	setTimeframe()	0	14	3
A	getThrottle()	0	20	4
A	setUnlimited()	0	3	1
A	setAccount()	0	4	1
A	save()	0	17	1
A	getLeakRate()	0	3	1
B	throttleRequest()	0	48	8
A	setLeakRate()	0	3	1
C	setupOptions()	0	35	14
A	getLastAccessDate()	0	7	2

<?php
/**
 * ==================================
 * Responsible PHP API
 * ==================================
 *
 * @link Git https://github.com/vince-scarpa/responsibleAPI.git
 *
 * @api Responible API
 * @package responsible\core\throttle
 *
 * @author Vince scarpa <vince.in2net@gmail.com>
 *
 */
namespace responsible\core\throttle;

use responsible\core\exception;
use responsible\core\throttle;
use responsible\core\user;

class limiter
{
    /**
     * [$capacity Bucket volume]
     * @var integer
     */
    private $capacity = 100;

    /**
     * [$leakRate Constant rate at which the bucket will leak]
     * @var integer
     */
    private $leakRate = 1;

    /**
     * [$unpacked]
     */
    private $unpacked;

    /**
     * [$bucket]
     */
    private $bucket;

    /**
     * [$timeframe Durations are in seconds]
     * @var array
     */
    private static $timeframe = [
        'SECOND' => 1,
        'MINUTE' => 60,
        'HOUR' => 3600,
        'DAY' => 86400,
        'CUSTOM' => 0,
    ];

    /**
     * [$window Timeframe window]
     * @var integer
     */
    private $window;

    /**
     * [$unlimited Rate limiter bypass if true]
     * @var boolean
     */
    private $unlimited = false;

    /**
     * [$scope Set the default scope]
     * @var string
     */
    private $scope = 'private';

    /**
     * [setupOptions Set any Responsible API options]
     * @return self
     */
    public function setupOptions()
    {
        $options = $this->getOptions();

        if (isset($options['rateLimit'])) {
            $this->setCapacity($options['rateLimit']);
        }

        if (isset($options['rateWindow'])) {
            $this->setTimeframe($options['rateWindow']);
        }

        if (isset($options['leak']) && !$options['leak']) {
            $options['leakRate'] = 0;
        }

        if (isset($options['leakRate'])) {
            $this->setLeakRate($options['leakRate']);
        }

        if (isset($options['unlimited']) && ($options['unlimited'] == 1 || $options['unlimited'] == true)) {
            $this->setUnlimited();
        }

        if (isset($options['requestType']) && $options['requestType'] == 'debug') {
            $this->setUnlimited();
        }

        if( isset($this->account->scope) &&
            ($this->account->scope == 'anonymous' || $this->account->scope == 'public')
        ) {
           $this->scope = $this->account->scope;
        }

        return $this;
    }

    /**
     * [throttleRequest Build the Responsible API throttle]
     * @return void
     */
    public function throttleRequest()
    {
        if ($this->isUnlimited() || $this->scope !== 'private') {
            return true;

The expression return true returns the type true which is incompatible with the documented return type void.

        }

        /**
         * [$unpack Unpack the account bucket data]
         */
        $this->unpacked = (new throttle\tokenPack)->unpack(
            $this->getAccount()->bucket
        );
        if (empty($this->unpacked)) {
            $this->unpacked = array(
                'drops' => 1,
                'time' => $this->getAccount()->access,
            );
        }

        $this->bucket = (new throttle\tokenBucket())
            ->setTimeframe($this->getTimeframe())
            ->setCapacity($this->getCapacity())
            ->setLeakRate($this->getLeakRate())
            ->pour($this->unpacked['drops'], $this->unpacked['time'])
        ;

        /**
         * Check if the bucket still has capacity to fill
         */
        if ($this->bucket->capacity()) {
            $this->bucket->pause(false);
            $this->bucket->fill();
        } else {
            if ($this->getLeakRate() <= 0) {
                if ($this->unpacked['pauseAccess'] == false) {
                    $this->bucket->pause(true);
                    $this->save();
                }

                if ($this->bucket->refill($this->getAccount()->access)) {
                    $this->save();
                }
            }

            (new exception\errorException)->error('TOO_MANY_REQUESTS');
        }

        $this->save();
    }

    /**
     * [updateBucket Store the buckets token data and user access time]
     * @return void
     */
    private function save()
    {
        $this->packed = (new throttle\tokenPack)->pack(

The property packed does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            $this->bucket->getTokenData()
        );

        /**
         * [Update account access]
         */
        /*$user = (new user\account($this->getAccount()->account_id))
            ->setBucketToken($this->packed)
            ->updateAccountAccess();*/

        $user = (new user\user)

The assignment to $user is dead and can be removed.

Are you sure the assignment to $user is correct as new responsible\core\user\user()->setAccountID($this->getAccount()->account_id)->setBucketToken($this->packed)->updateAccountAccess() targeting responsible\core\user\user::updateAccountAccess() seems to always return null.

            ->setAccountID($this->getAccount()->account_id)
            ->setBucketToken($this->packed)
            ->updateAccountAccess()
        ;
    }

    /**
     * [getThrottle Return a list of the throttled results]
     * @return array
     */
    public function getThrottle()
    {
        if ($this->isUnlimited() || $this->scope !== 'private') {
            return array(
                'unlimited' => true,
            );
        }

        $windowFrame = (is_string($this->getTimeframe()))

The condition is_string($this->getTimeframe()) is always false.

        ? $this->getTimeframe()
        : $this->getTimeframe() . 'secs'
        ;

        return array(
            'limit' => $this->getCapacity(),
            'leakRate' => $this->getLeakRate(),
            'leak' => $this->bucket->getLeakage(),
            'lastAccess' => $this->getLastAccessDate(),
            'description' => $this->getCapacity() . ' requests per ' . $windowFrame,
            'bucket' => $this->bucket->getTokenData(),
        );
    }

    /**
     * [getLastAccessDate Get the last recorded access in date format]
     * @return string
     */
    private function getLastAccessDate()
    {
        if (isset($this->bucket->getTokenData()['time'])) {
            return date('m/d/y h:i:sa', $this->bucket->getTokenData()['time']);
        }

        return 'Can\'t be converted';
    }

    /**
     * [setAccount Set the requests account]
     */
    public function setAccount($account)
    {
        $this->account = $account;

The property account does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        return $this;
    }

    /**
     * [getAccount Get the requests account]
     */
    public function getAccount()
    {
        return $this->account;
    }

    /**
     * [options Responsible API options]
     * @param array $options
     */
    public function options($options)
    {
        $this->options = $options;

The property options does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        return $this;
    }

    /**
     * [getOptions Get the stored Responsible API options]
     * @return array
     */
    private function getOptions()
    {
        return $this->options;
    }

    /**
     * [setCapacity Set the buckets capacity]
     * @param integer $capacity
     */
    public function setCapacity($capacity)
    {
        $this->capacity = $capacity;
    }

    /**
     * [getCapacity Get the buckets capacity]
     * @return integer
     */
    public function getCapacity()
    {
        return $this->capacity;
    }

    /**
     * [setTimeframe Set the window timeframe]
     * @param string|integer $timeframe
     */
    public function setTimeframe($timeframe)
    {
        if (is_numeric($timeframe)) {
            self::$timeframe['CUSTOM'] = $timeframe;
            $this->window = self::$timeframe['CUSTOM'];

It seems like self::timeframe['CUSTOM'] can also be of type string. However, the property $window is declared as type integer. Maybe add an additional type check?

            return;
        }

        if (isset(self::$timeframe[$timeframe])) {
            $this->window = self::$timeframe[$timeframe];
            return;
        }

        $this->window = self::$timeframe['MINUTE'];
    }

    /**
     * [getTimeframe Get the timeframe window]
     * @return integer
     */
    public function getTimeframe()
    {
        return $this->window;
    }

    /**
     * [setLeakRate Set the buckets leak rate]
     * Options: slow, medium, normal, default, fast or custom positive integer
     * @param string|integer $leakRate
     */
    private function setLeakRate($leakRate)
    {
        $this->leakRate = $leakRate;

It seems like $leakRate can also be of type string. However, the property $leakRate is declared as type integer. Maybe add an additional type check?

    }

    /**
     * [getLeakRate Get the buckets leak rate]
     * @return string|integer
     */
    private function getLeakRate()
    {
        return $this->leakRate;
    }

    /**
     * [setUnlimited Rate limiter bypass]
     */
    private function setUnlimited()
    {
        $this->unlimited = true;
    }

    /**
     * [isUnlimited Check if the Responsible API is set to unlimited]
     * @return boolean
     */
    private function isUnlimited()
    {
        return $this->unlimited;
    }
}