Tarantool\Queue\Queue

Complexity

Total Complexity

20

Size/Duplication

Total Lines	119
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getClient()	0	3	1
A	getName()	0	3	1
A	touch()	0	5	2
A	put()	0	4	1
A	take()	0	5	2
A	delete()	0	4	1
A	release()	0	4	1
A	bury()	0	4	1
A	truncate()	0	3	1
A	kick()	0	3	1
A	ack()	0	4	1
A	peek()	0	4	1
A	call()	0	3	1
A	stats()	0	16	4

<?php

/**
 * This file is part of the tarantool/queue package.
 *
 * (c) Eugene Leonovich <gen.work@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Tarantool\Queue;

use Tarantool\Client\Client;

class Queue
{
    private $client;
    private $name;

    public function __construct(Client $client, string $name)
    {
        $this->client = $client;
        $this->name = $name;
    }

    public function getClient() : Client
    {
        return $this->client;
    }

    public function getName() : string
    {
        return $this->name;
    }

    /**
     * @param mixed $data
     */
    public function put($data, array $options = []) : Task
    {
        return Task::fromTuple(
            $this->client->call("queue.tube.$this->name:put", $data, $options)[0]
        );
    }

    public function take(float $timeout = null) : ?Task
    {
        $result = $this->client->call("queue.tube.$this->name:take", $timeout);

        return empty($result[0]) ? null : Task::fromTuple($result[0]);
    }

    public function touch(int $taskId, float $increment) : ?Task
    {
        $result = $this->client->call("queue.tube.$this->name:touch", $taskId, $increment);

        return empty($result[0]) ? null : Task::fromTuple($result[0]);
    }

    public function ack(int $taskId) : Task
    {
        return Task::fromTuple(
            $this->client->call("queue.tube.$this->name:ack", $taskId)[0]
        );
    }

    public function release(int $taskId, array $options = []) : Task
    {
        return Task::fromTuple(
            $this->client->call("queue.tube.$this->name:release", $taskId, $options)[0]
        );
    }

    public function peek(int $taskId) : Task
    {
        return Task::fromTuple(
            $this->client->call("queue.tube.$this->name:peek", $taskId)[0]
        );
    }

    public function bury(int $taskId) : Task
    {
        return Task::fromTuple(
            $this->client->call("queue.tube.$this->name:bury", $taskId)[0]
        );
    }

    public function kick(int $count) : int
    {
        return $this->client->call("queue.tube.$this->name:kick", $count)[0];
    }

    public function delete(int $taskId) : Task
    {
        return Task::fromTuple(
            $this->client->call("queue.tube.$this->name:delete", $taskId)[0]
        );
    }

    public function truncate() : void
    {
        $this->client->call("queue.tube.$this->name:truncate");
    }

    /**
     * @throws \InvalidArgumentException
     *
     * @return array|int
     */
    public function stats(?string $path = null)
    {
        [$stats] = $this->client->call('queue.stats', $this->name);

        if (null === $path) {
            return $stats;
        }

        foreach (\explode('.', $path) as $key) {
            if (!isset($stats[$key])) {
                throw new \InvalidArgumentException(\sprintf('Invalid path "%s"', $path));
            }
            $stats = $stats[$key];
        }

        return $stats;
    }

    /**
     * @param mixed ...$args
     */
    public function call(string $methodName, ...$args) : array
    {
        return $this->client->call("queue.tube.$this->name:$methodName", ...$args);
    }
}