Zicht\Bundle\FrameworkExtraBundle\Command\AbstractCronCommand

Complexity

Total Complexity

22

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	run()	0	23	4
A	getMutexFile()	0	13	3
A	doParentRun()	0	3	1
A	setLogger()	0	22	4
A	cleanup()	0	5	1
A	exceptionHandler()	0	4	1
A	errorHandler()	0	16	6
A	endOfScript()	0	4	2

<?php
/**
 * @author Gerard van Helden <gerard@zicht.nl>
 * @copyright Zicht Online <http://zicht.nl>
 */
namespace Zicht\Bundle\FrameworkExtraBundle\Command;

use Exception;

use Monolog\Logger;

The type Monolog\Logger was not found. Maybe you did not declare it correctly or list all dependencies?

use Monolog\Handler\StreamHandler;

The type Monolog\Handler\StreamHandler was not found. Maybe you did not declare it correctly or list all dependencies?

use Monolog\Processor\MemoryUsageProcessor;

The type Monolog\Processor\MemoryUsageProcessor was not found. Maybe you did not declare it correctly or list all dependencies?

use Monolog\Processor\MemoryPeakUsageProcessor;

The type Monolog\Processor\MemoryPeakUsageProcessor was not found. Maybe you did not declare it correctly or list all dependencies?

use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Input\InputInterface;
use Zicht\Util\Mutex;
use Zicht\Util\Str;

/**
 * Simple utility class for console applications. Uses Monolog for logging and error/exception reporting.
 * @deprecated Locking should be done by exonet and the logging can be done simpler using the GetStdLoggerTrait
 */
abstract class AbstractCronCommand extends ContainerAwareCommand
{
    /**
     * If the application was neatly cleaned up, this is set to true, and the endOfScript() method will not issue
     * an error
     *
     * @var bool
     */
    private $isFinishedCleanly = false;

    /**
     * Logger instance
     *
     * @var \Monolog\Logger
     */
    protected $logger;

    /**
     * Set this to a filename if a mutex should be used.
     *
     * @var bool
     */
    protected $mutex = false;

    /**
     * Initialize the logger and attach it to error/exception handling and the clean shutdown function.
     *
     * @param \Monolog\Logger $logger
     * @param int $verbosity
     * @param bool $paranoid Whether or not non-clean shutdown should be logged.
     * @return void
     */
    public function setLogger(Logger $logger, $verbosity = 0, $paranoid = true)
    {
        $this->logger = $logger;
        if ($paranoid) {
            register_shutdown_function(array($this, 'endOfScript'));
        }
        set_error_handler(array($this, 'errorHandler'));
        set_exception_handler(array($this, 'exceptionHandler'));

        if ($verbosity == OutputInterface::VERBOSITY_VERBOSE) {
            $logger->pushHandler(
                new StreamHandler(fopen('php://stdout', 'w'), Logger::DEBUG, false)
            );
            $logger->pushProcessor(new MemoryUsageProcessor);
            $logger->pushProcessor(new MemoryPeakUsageProcessor);
        }
        if ($verbosity == OutputInterface::VERBOSITY_NORMAL) {
            $logger->pushHandler(
                new StreamHandler(fopen('php://stdout', 'w'), Logger::INFO, false)
            );
        }
        $logger->pushHandler(new StreamHandler(fopen('php://stderr', 'w'), Logger::WARNING));
    }


    /**
     * Exception handler; will log the exception and exit the script.
     *
     * @param \Exception $exception
     * @return void
     */
    public function exceptionHandler(Exception $exception)
    {
        $this->logger->addError($exception->getMessage(), array($exception->getFile(), $exception->getLine()));
        exit(-1);

Using exit here is not recommended.

    }


    /**
     * Error handler; will log the error and exit the script.
     *
     * @param int $errno
     * @param string $errstr
     * @param string $file
     * @param int $line
     * @return void
     */
    public function errorHandler($errno, $errstr, $file, $line)
    {
        switch ($errno) {
            case E_USER_ERROR:
            case E_ERROR:
            case E_RECOVERABLE_ERROR:
                $this->logger->addError($errstr, array($file, $line));
                exit();

Using exit here is not recommended.

                break;
            case E_WARNING:
            case E_USER_WARNING:
                $this->logger->addWarning($errstr, array($file, $line));
                break;
            default:
                $this->logger->addInfo($errstr, array($file, $line));
                break;
        }
    }


    /**
     * Triggered on shutddown of the script.
     *
     * @return void
     */
    public function endOfScript()
    {
        if (!$this->isFinishedCleanly) {
            $this->logger->addCritical('Unexpected end of script!');
        }
    }


    /**
     * Tells the app that the end was reached without trouble.
     *
     * @return void
     */
    public function cleanup()
    {
        $this->isFinishedCleanly = true;
        restore_error_handler();
        restore_exception_handler();
    }


    /**
     * Run the command.
     *
     * @param \Symfony\Component\Console\Input\InputInterface $input
     * @param \Symfony\Component\Console\Output\OutputInterface $output
     * @return int
     */
    public function run(InputInterface $input, OutputInterface $output)
    {
        $this->isFinishedCleanly = false;
        if ($mutexFile = $this->getMutexFile()) {
            $self = $this;
            $result = null;

            $mutex = new Mutex($mutexFile, false);

It seems like $mutexFile can also be of type true; however, parameter $file of Zicht\Util\Mutex::__construct() does only seem to accept string, maybe add an additional type check?

            $isLockAcquired = false;
            $mutex->run(
                function () use ($self, $input, $output, &$result) {

The import $result is not used and could be removed.

                    return $self->doParentRun($input, $output);
                },
                $isLockAcquired
            );
            if (!$isLockAcquired && $this->logger) {
                $this->logger->addWarning("Mutex failed in " . get_class($this) . ", job was not run");
            }
        } else {
            $result = $this->doParentRun($input, $output);
        }
        $this->cleanup();
        return $result;
    }


    /**
     * Wrapped in a separate method so we can call it from the mutex closure.
     *
     * @param InputInterface $input
     * @param OutputInterface $output
     * @return int
     */
    final public function doParentRun(InputInterface $input, OutputInterface $output)
    {
        return parent::run($input, $output);
    }


    /**
     * Returns a path to the file which can be used as a mutex.
     *
     * @return bool|string
     */
    protected function getMutexFile()
    {
        $file = false;

        if (true === $this->mutex) {
            $file = $this->getContainer()->getParameter('kernel.cache_dir')
                . '/'
                . Str::dash(lcfirst(Str::classname(get_class($this))))
                . '.lock';
        } elseif ($this->mutex) {
            $file = $this->mutex;
        }
        return $file;
    }
}