responsible\core\throttle\tokenBucket

Complexity

Total Complexity

32

Size/Duplication

Total Lines	269
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	capacity()	0	7	2
A	fill()	0	3	1
A	pour()	0	5	1
A	leak()	0	11	4
A	__construct()	0	3	1
A	getLeakage()	0	3	1
A	pause()	0	3	1
A	timeNow()	0	3	1
A	refill()	0	15	2
B	setLeakRate()	0	41	10
A	setTimeframe()	0	4	1
A	getDrops()	0	6	2
A	getTimeframe()	0	3	1
A	getCapacity()	0	3	1
A	getTokenData()	0	6	1
A	setCapacity()	0	4	1
A	full()	0	4	1

<?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;

class tokenBucket
{
    /**
     * [$capacity The Buckets limit]
     * @var integer
     */
    private $capacity;

    /**
     * [$drops How many drops in a bucket]
     * @var integer
     */
    private $drops = 0;

    /**
     * [$leakage Leak rate]
     * @var float
     */
    private $leakage;

    /**
     * [$lastAccess Timestamp of lat access]
     * @var integer
     */
    private $lastAccess;

    /**
     * [$timeframe The window timeframe]
     * @var integer|string
     */
    private $timeframe;

    /**
     * [$pauseAccess Pause access for a given period]
     * @var boolean
     */
    private $pauseAccess = false;

    /**
     * [__construct Set the last access this overridden if already accessed]
     */
    public function __construct()
    {
        $this->lastAccess = $this->timeNow();
    }

    /**
     * [capacity Check if the bucket can still be filled]
     * @return boolean
     */
    public function capacity()
    {
        if ($this->full()) {
            $this->leak();
        }

        return (floor($this->drops) < $this->capacity);
    }

    /**
     * [leak Create a leak in the bucket]
     * @return void
     */
    public function leak()
    {
        $now = $this->timeNow();
        $difference = $now - $this->lastAccess;

        if ($difference > 0 && $this->getLeakage() > 0) {
            $this->drops -= ($difference * $this->leakage);
            $this->lastAccess = $now;

            if ($this->drops < 0) {
                $this->drops = 0;
            }
        }
    }

    /**
     * [pour Pour drops in the bucket, essentially filling the bucket with drops]
     * @param  integer $drops
     * @param  integer $lastAccess
     * @return self
     */
    public function pour($drops, $lastAccess)
    {
        $this->fill($drops);
        $this->lastAccess = $lastAccess;
        return $this;
    }

    /**
     * [fill fill the bucket with drops]
     * @param integer $drops
     */
    public function fill($drops = 1)
    {
        $this->drops += $drops;
    }

    /**
     * [full Check if the bucket is full]
     * @return boolean
     */
    public function full()
    {
        $isFull = ceil($this->drops) >= $this->capacity;
        return $isFull;
    }

    /**
     * [refill Refill the bucket tokens]
     * @return array|boolean
     */
    public function refill($accessed)
    {
        $now = $this->timeNow();
        $difference = $now - $accessed;

        if (($difference + 1) > $this->getTimeframe()) {
            $this->drops = 0;
            $this->lastAccess = $now;
            return [
                'drops' => $this->drops,
                'time' => $this->lastAccess,
                'pauseAccess' => $this->pauseAccess,
            ];
        }
        return;
    }

    /**
     * [pause Pause access to the bucket]
     * @param  boolean $state
     */
    public function pause($state = false)
    {
        $this->pauseAccess = $state;
    }

    /**
     * [timeNow Create a timestamp of now]
     * @return integer
     */
    public function timeNow()
    {
        return (new \DateTime('now'))->getTimestamp();
    }

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

    /**
     * [setLeakRate Set the buckets leak rate]
     * @param string|integer $leakRate
     * @return self
     */
    public function setLeakRate($leakRate = null)
    {
        $capacity = $this->getCapacity();
        $timeframe = $this->getTimeframe();

        if (!is_null($leakRate)) {
            if (is_string($leakRate)) {
                switch ($leakRate) {
                    case 'slow':
                        $this->leakage = ($capacity / $timeframe) / 4;
                        break;

                    case 'medium':
                        $this->leakage = (($capacity / $timeframe) / 2);
                        break;

                    case 'normal':
                    case 'default':
                        $this->leakage = ($capacity / $timeframe);
                        break;

                    case 'fast':
                        $this->leakage = 1;
                        break;

                    default:
                        $this->leakage = ($capacity / $timeframe);
                        break;
                }
            }

            if (is_numeric($leakRate)) {
                $nLeakRate = $leakRate;
                if ($nLeakRate < 0) {
                    $nLeakRate = 0;
                }
                $this->leakage = (float)$nLeakRate;
            }
        }

        return $this;
    }

    /**
     * [setTimeframe Set the buckets window access]
     * @param string|integer $timeframe
     */
    public function setTimeframe($timeframe)
    {
        $this->timeframe = $timeframe;
        return $this;
    }

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

    /**
     * [getLeakage Get the buckets leak rate]
     * @return integer|float
     */
    public function getLeakage()
    {
        return $this->leakage;
    }

    /**
     * [getDrops Get the buckets current drops]
     * @param  boolean $leak
     * @return integer
     */
    public function getDrops($leak = true)
    {
        if ($leak) {
            $this->leak();
        }
        return $this->drops;
    }

    /**
     * [getTokenData Get the token data]
     * @return array
     */
    public function getTokenData()
    {
        return [
            'drops' => floor($this->getDrops()),
            'time' => $this->lastAccess,
            'pauseAccess' => $this->pauseAccess,
        ];
    }

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