CacheTool\Console\Application

Complexity

Total Complexity

24

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	35

Test Coverage

Coverage

93.88%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getDefaultCommands()	0	35	3
A	getDefaultInputDefinition()	0	14	1
A	doRun()	0	12	1
A	doRunCommand()	0	9	2
A	buildContainer()	0	19	1
B	parseConfiguration()	0	35	11
A	getAdapter()	0	13	4

<?php

/*
 * This file is part of CacheTool.
 *
 * (c) Samuel Gordalina <samuel.gordalina@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace CacheTool\Console;

use CacheTool\Adapter\FastCGI;
use CacheTool\Adapter\Cli;
use CacheTool\Adapter\Http\FileGetContents;
use CacheTool\Adapter\Web;
use CacheTool\CacheTool;
use CacheTool\Command as CacheToolCommand;
use CacheTool\Monolog\ConsoleHandler;
use Monolog\Logger;
use Symfony\Component\Console\Application as BaseApplication;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\DependencyInjection\ContainerAwareInterface;
use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\Yaml\Parser;

class Application extends BaseApplication
{
    const VERSION = '@package_version@';

    /**
     * @var Config
     */
    protected $config;

    /**
     * @var Logger
     */
    protected $logger;

    /**
     * @param Config $config
     */
    public function __construct(Config $config)
    {
        parent::__construct('CacheTool', self::VERSION);

        $this->config = $config;
        $this->logger = new Logger('cachetool');
    }

    /**
     * {@inheritdoc}
     */
    protected function getDefaultCommands()
    {
        $commands = parent::getDefaultCommands();
        $commands[] = new CacheToolCommand\SelfUpdateCommand();

        if (in_array('apcu', $this->config['extensions'], true)) {
            $commands[] = new CacheToolCommand\ApcuCacheClearCommand();
            $commands[] = new CacheToolCommand\ApcuCacheInfoCommand();
            $commands[] = new CacheToolCommand\ApcuCacheInfoKeysCommand();
            $commands[] = new CacheToolCommand\ApcuKeyDeleteCommand();
            $commands[] = new CacheToolCommand\ApcuKeyExistsCommand();
            $commands[] = new CacheToolCommand\ApcuKeyFetchCommand();
            $commands[] = new CacheToolCommand\ApcuKeyStoreCommand();
            $commands[] = new CacheToolCommand\ApcuSmaInfoCommand();
            $commands[] = new CacheToolCommand\ApcuRegexpDeleteCommand();
        }

        if (in_array('opcache', $this->config['extensions'], true)) {
            $commands[] = new CacheToolCommand\OpcacheConfigurationCommand();
            $commands[] = new CacheToolCommand\OpcacheResetCommand();
            $commands[] = new CacheToolCommand\OpcacheResetFileCacheCommand();
            $commands[] = new CacheToolCommand\OpcacheStatusCommand();
            $commands[] = new CacheToolCommand\OpcacheStatusScriptsCommand();
            $commands[] = new CacheToolCommand\OpcacheInvalidateScriptsCommand();
            $commands[] = new CacheToolCommand\OpcacheCompileScriptsCommand();
            $commands[] = new CacheToolCommand\OpcacheCompileScriptCommand();
        }

        $commands[] = new CacheToolCommand\PhpEvalCommand();
        $commands[] = new CacheToolCommand\StatCacheClearCommand();
        $commands[] = new CacheToolCommand\StatRealpathGetCommand();
        $commands[] = new CacheToolCommand\StatRealpathSizeCommand();

        return $commands;
    }

    /**
     * {@inheritDoc}
     */
    protected function getDefaultInputDefinition()
    {
        $definition = parent::getDefaultInputDefinition();
        $definition->addOption(new InputOption('--fcgi', null, InputOption::VALUE_OPTIONAL, 'If specified, used as a connection string to FastCGI server.'));
        $definition->addOption(new InputOption('--fcgi-chroot', null, InputOption::VALUE_OPTIONAL, 'If specified, used for mapping script path to chrooted FastCGI server. --tmp-dir need to be chrooted too.'));
        $definition->addOption(new InputOption('--cli', null, InputOption::VALUE_NONE, 'If specified, forces adapter to cli'));
        $definition->addOption(new InputOption('--web', null, InputOption::VALUE_NONE, 'If specified, forces adapter to web'));
        $definition->addOption(new InputOption('--web-path', null, InputOption::VALUE_OPTIONAL, 'If specified, used as a information for web adapter'));
        $definition->addOption(new InputOption('--web-url', null, InputOption::VALUE_OPTIONAL, 'If specified, used as a information for web adapter'));
        $definition->addOption(new InputOption('--tmp-dir', '-t', InputOption::VALUE_REQUIRED, 'Temporary directory to write files to'));
        $definition->addOption(new InputOption('--config', '-c', InputOption::VALUE_REQUIRED, 'If specified use this yaml configuration file'));

        return $definition;
    }

    /**
     * {@inheritDoc}
     */
    public function doRun(InputInterface $input, OutputInterface $output)
    {
        $handler = new ConsoleHandler();
        $handler->setOutput($output);
        $this->logger->pushHandler($handler);

        $exitCode = parent::doRun($input, $output);

        $handler->close();

        return $exitCode;
    }

    /**
     * {@inheritDoc}
     */
    public function doRunCommand(Command $command, InputInterface $input, OutputInterface $output)
    {
        if ($command instanceof ContainerAwareInterface) {
            $container = $this->buildContainer($input);
            $command->setContainer($container);
        }

        return parent::doRunCommand($command, $input, $output);
    }

    /**
     * @param  InputInterface     $input
     * @return ContainerInterface
     */
    public function buildContainer(InputInterface $input)
    {
        $this->parseConfiguration($input);

        $this->logger->info(sprintf('CacheTool %s', self::VERSION));
        $this->logger->debug(sprintf('Config: %s', $this->config->toJSON()));

        $cacheTool = CacheTool::factory(
            $this->getAdapter(),
            $this->config['temp_dir'],
            $this->logger
        );

        $container = new Container();
        $container->set('cachetool', $cacheTool);
        $container->set('logger', $this->logger);

        return $container;
    }

    /**
     * @param  InputInterface $input
     */
    private function parseConfiguration(InputInterface $input)
    {
        if ($input->hasParameterOption('--config')) {
            $path = $input->getParameterOption('--config');

            if (!is_file($path)) {
                throw new \RuntimeException("Could not read configuration file: {$path}");
            }

            $this->config = Config::fromFile($path);
        }

        if ($input->hasParameterOption('--cli')) {
            $this->config['adapter'] = 'cli';
        } elseif ($input->hasParameterOption('--fcgi')) {
            $this->config['adapter'] = 'fastcgi';
            $this->config['fastcgiChroot'] = $input->getParameterOption('--fcgi-chroot');

            if (!is_null($input->getParameterOption('--fcgi'))) {
                $this->config['fastcgi'] = $input->getParameterOption('--fcgi');
            }
        } elseif ($input->hasParameterOption('--web')) {
            $this->config['adapter'] = 'web';
            $this->config['webPath'] = $input->getParameterOption('--web-path');
            $this->config['webUrl'] = $input->getParameterOption('--web-url');
        }

        if ($this->config['adapter'] === 'web') {
            $this->config['http'] = new FileGetContents($this->config['webUrl']);
        }

        if ($input->hasParameterOption('--tmp-dir') || $input->hasParameterOption('-t')) {
            $this->config['temp_dir'] = $input->getParameterOption('--tmp-dir') ?: $input->getParameterOption('-t');
        }
    }


    /**
     * @return null|\CacheTool\Adapter\AbstractAdapter
     */
    private function getAdapter()
    {
        switch ($this->config['adapter']) {
            case 'cli':
                return new Cli();
            case 'fastcgi':
                return new FastCGI($this->config['fastcgi'], $this->config['fastcgiChroot']);
            case 'web':
                return new Web($this->config['webPath'], $this->config['http']);
        }

        throw new \RuntimeException("Adapter `{$this->config['adapter']}` is not one of cli, fastcgi or web");
    }
}