Beanie\Worker

Complexity

Total Complexity

13

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	8
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	watch()	0	10	2
A	ignore()	0	5	1
A	quit()	0	4	1
A	reserve()	0	19	3
A	reserveOath()	0	7	1
A	getServer()	0	4	1
A	__toString()	0	4	1
A	reconnect()	0	4	1
A	disconnect()	0	4	1

<?php


namespace Beanie;


use Beanie\Command\CommandFactory;
use Beanie\Command\CommandInterface;
use Beanie\Exception\TimedOutException;
use Beanie\Job\Job;
use Beanie\Job\JobFactory;
use Beanie\Job\JobOath;
use Beanie\Server\Server;
use Beanie\Server\TubeAwareTrait;
use Beanie\Tube\TubeAwareInterface;
use Beanie\Tube\TubeStatus;

class Worker implements TubeAwareInterface
{
    use TubeAwareTrait;

    /** @var Server */
    protected $server;

    /** @var CommandFactory */
    protected $commandFactory;

    /** @var JobFactory */
    protected $jobFactory;

    /**
     * @param Server $server
     */
    public function __construct(Server $server)
    {
        $this->server = $server;
        $this->tubeStatus = new TubeStatus();
        $this->commandFactory = CommandFactory::instance();
        $this->jobFactory = JobFactory::instance();
    }

    /**
     * @param string $tubeName
     * @param bool|false $onlyThisTube
     * @return $this
     */
    public function watch($tubeName, $onlyThisTube = false)
    {
        if ($onlyThisTube) {
            $this->tubeStatus->setWatchedTubes([$tubeName]);
        } else {
            $this->tubeStatus->addWatchedTube($tubeName);
        }

        return $this;
    }

    /**
     * @param string $tubeName
     * @return $this
     */
    public function ignore($tubeName)
    {
        $this->tubeStatus->removeWatchedTube($tubeName);
        return $this;
    }

    /**
     * @throws Exception\InvalidArgumentException
     */
    public function quit()
    {
        $this->server->dispatchCommand($this->commandFactory->create(CommandInterface::COMMAND_QUIT));
    }

    /**
     * @param null|int $timeout
     * @return Job|null
     */
    public function reserve($timeout = null)
    {
        $command = CommandInterface::COMMAND_RESERVE;
        $arguments = [];

        if (!is_null($timeout)) {
            $command = CommandInterface::COMMAND_RESERVE_WITH_TIMEOUT;
            $arguments[] = $timeout;
        }

        try {
            return $this->jobFactory->createFromCommand(
                $this->commandFactory->create($command, $arguments),
                $this->server->transformTubeStatusTo($this->getTubeStatus())
            )->invoke();
        } catch (TimedOutException $timeOut) {
            return null;
        }
    }

    /**
     * @return JobOath
     * @throws Exception\InvalidArgumentException
     */
    public function reserveOath()
    {
        return $this->jobFactory->createFromCommand(
            $this->commandFactory->create(CommandInterface::COMMAND_RESERVE),
            $this->server->transformTubeStatusTo($this->getTubeStatus(), TubeStatus::TRANSFORM_WATCHED)
        );
    }

    /**
     * @return Server
     */
    public function getServer()
    {
        return $this->server;
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return (string) $this->server;
    }

    public function reconnect()
    {
        $this->getServer()->connect();
    }

    public function disconnect()
    {
        $this->getServer()->disconnect();
    }
}