FrankDeJonge\LockedConsoleCommand\LockedCommandDecorator

Complexity

Total Complexity

42

Size/Duplication

Total Lines	381
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.48%

Importance

Changes	11
Bugs	3	Features	1

32 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	ignoreValidationErrors()	0	4	1
A	setApplication()	0	4	1
A	setHelperSet()	0	4	1
A	getHelperSet()	0	4	1
A	getApplication()	0	4	1
A	isEnabled()	0	4	1
A	setLockName()	0	4	1
A	run()	0	18	2
A	setCode()	0	6	1
A	mergeApplicationDefinition()	0	4	1
A	setDefinition()	0	6	1
A	getDefinition()	0	4	1
A	getNativeDefinition()	0	4	1
A	addArgument()	0	6	1
A	addOption()	0	6	1
A	setName()	0	6	1
A	setProcessTitle()	0	6	1
A	getName()	0	4	1
A	setDescription()	0	6	1
A	getDescription()	0	4	1
A	setHelp()	0	6	1
A	getHelp()	0	4	1
A	getProcessedHelp()	0	4	1
A	setAliases()	0	6	1
A	getAliases()	0	4	1
A	getSynopsis()	0	4	1
A	getHelper()	0	4	1
A	getLockHandler()	0	11	2
A	getLockName()	0	16	4
A	getLockPath()	0	16	4
A	writeLockedMessage()	0	20	3

<?php

namespace FrankDeJonge\LockedConsoleCommand;

use Symfony\Component\Console\Application;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\HelperSet;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\ConsoleOutputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Filesystem\LockHandler;

class LockedCommandDecorator extends Command
{
    /**
     * @var Command
     */
    private $decoratedCommand;

    /**
     * @var string|LockHandler
     */
    private $lockName;

    /**
     * @var string
     */
    private $lockPath;

    /**
     * Constructor.
     *
     * @param Command            $command
     * @param string|LockHandler $lockName
     * @param string             $lockPath
     */
    public function __construct(Command $command, $lockName = null, $lockPath = null)
    {
        $this->decoratedCommand = $command;
        $this->setLockName($lockName);
        $this->lockPath = $lockPath;
    }

    /**
     * {@inheritdoc}
     */
    public function ignoreValidationErrors()
    {
        $this->decoratedCommand->ignoreValidationErrors();
    }

    /**
     * {@inheritdoc}
     */
    public function setApplication(Application $application = null)
    {
        $this->decoratedCommand->setApplication($application);
    }

    /**
     * {@inheritdoc}
     */
    public function setHelperSet(HelperSet $helperSet)
    {
        $this->decoratedCommand->setHelperSet($helperSet);
    }

    /**
     * {@inheritdoc}
     */
    public function getHelperSet()
    {
        return $this->decoratedCommand->getHelperSet();
    }

    /**
     * {@inheritdoc}
     */
    public function getApplication()
    {
        return $this->decoratedCommand->getApplication();
    }

    /**
     * {@inheritdoc}
     */
    public function isEnabled()
    {
        return $this->decoratedCommand->isEnabled();
    }

    /**
     * @param string|LockHandler|null $lockName
     */
    public function setLockName($lockName)
    {
        $this->lockName = $lockName;
    }

    /**
     * Runs the command.
     *
     * Before the decorated command is run, a lock is requested.
     * When failed to acquire the lock, the command exits.
     *
     * @param InputInterface  $input  An InputInterface instance
     * @param OutputInterface $output An OutputInterface instance
     *
     * @return int The command exit code
     */
    public function run(InputInterface $input, OutputInterface $output)
    {
        $this->mergeApplicationDefinition();
        $input->bind($this->getDefinition());
        $lock = $this->getLockHandler($input);

        if ( ! $lock->lock()) {
            $this->writeLockedMessage($input, $output);

            return 1;
        }

        try {
            return $this->decoratedCommand->run($input, $output);
        } finally {
            $lock->release();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function setCode(callable $code)
    {
        $this->decoratedCommand->setCode($code);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function mergeApplicationDefinition($mergeArgs = true)
    {
        $this->decoratedCommand->mergeApplicationDefinition($mergeArgs);
    }

    /**
     * {@inheritdoc}
     */
    public function setDefinition($definition)
    {
        $this->decoratedCommand->setDefinition($definition);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getDefinition()
    {
        return $this->decoratedCommand->getDefinition();
    }

    /**
     * {@inheritdoc}
     */
    public function getNativeDefinition()
    {
        return $this->decoratedCommand->getNativeDefinition();
    }

    /**
     * {@inheritdoc}
     */
    public function addArgument($name, $mode = null, $description = '', $default = null)
    {
        $this->decoratedCommand->addArgument($name, $mode, $description, $default);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function addOption($name, $shortcut = null, $mode = null, $description = '', $default = null)
    {
        $this->decoratedCommand->addOption($name, $shortcut, $mode, $description, $default);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function setName($name)
    {
        $this->decoratedCommand->setName($name);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function setProcessTitle($title)
    {
        $this->decoratedCommand->setProcessTitle($title);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return $this->decoratedCommand->getName();
    }

    /**
     * {@inheritdoc}
     */
    public function setDescription($description)
    {
        $this->decoratedCommand->setDescription($description);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getDescription()
    {
        return $this->decoratedCommand->getDescription();
    }

    /**
     * {@inheritdoc}
     */
    public function setHelp($help)
    {
        $this->decoratedCommand->setHelp($help);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getHelp()
    {
        return $this->decoratedCommand->getHelp();
    }

    /**
     * {@inheritdoc}
     */
    public function getProcessedHelp()
    {
        return $this->decoratedCommand->getProcessedHelp();
    }

    /**
     * {@inheritdoc}
     */
    public function setAliases($aliases)
    {
        $this->decoratedCommand->setAliases($aliases);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getAliases()
    {
        return $this->decoratedCommand->getAliases();
    }

    /**
     * {@inheritdoc}
     */
    public function getSynopsis($short = false)
    {
        return $this->decoratedCommand->getSynopsis($short);
    }

    /**
     * {@inheritdoc}
     */
    public function getHelper($name)
    {
        return $this->decoratedCommand->getHelper($name);
    }

    /**
     * Get the locking helper.
     *
     * @param  InputInterface $input
     *
     * @return LockHandler
     */
    private function getLockHandler(InputInterface $input)
    {
        if ($this->lockName instanceof LockHandler) {
            return $this->lockName;
        }

        $lockName = $this->getLockName($input);
        $lockPath = $this->getLockPath($input);

        return new LockHandler($lockName, $lockPath);
    }

    /**
     * Get the name for the lock.
     *
     * @param  InputInterface $input
     *
     * @return string
     */
    public function getLockName(InputInterface $input)
    {
        if (is_string($this->lockName)) {
            return $this->lockName;
        }

        if ($this->lockName instanceof LockHandler) {
            return 'UNKNOWN';
        }

        if ($this->decoratedCommand instanceof SpecifiesLockName) {
            return $this->decoratedCommand->getLockName($input);
        }

        return $this->decoratedCommand->getName();
    }

    /**
     * Get the lock path.
     *
     * @param  InputInterface $input
     *
     * @return null|string
     */
    public function getLockPath(InputInterface $input)
    {
        if ($this->lockName instanceof LockHandler) {
            return 'UNKNOWN';
        }

        if ($this->lockPath !== null) {
            return $this->lockPath;
        }

        if ($this->decoratedCommand instanceof SpecifiesLockPath) {
            return $this->decoratedCommand->getLockPath($input);
        }

        return sys_get_temp_dir();
    }

    /**
     * Write the "is locked" message.
     *
     * @param InputInterface  $input
     * @param OutputInterface $output
     */
    private function writeLockedMessage(InputInterface $input, OutputInterface $output)
    {
        $commandName = $this->decoratedCommand->getName();
        $lockName = $this->getLockName($input);
        $lockPath = $this->getLockPath($input);
        $message = sprintf(
            '<error>Command "%s" is already running, locked with "%s" at path "%s"</error>',
            $commandName,
            $lockName,
            $lockPath
        );

        if ($output instanceof ConsoleOutputInterface) {
            $output = $output->getErrorOutput();
        }

        if ($output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
            $output->writeln($message);
        }
    }
}