Db3v4l\Command\SQLExecutingCommand

Complexity

Total Complexity

41

Size/Duplication

Total Lines	285
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	formatResults()	0	14	6
A	__construct()	0	10	1
A	addCommonOptions()	0	12	1
A	writeResults()	0	16	6
A	writeResultsToFile()	0	4	1
F	executeSqlAction()	0	148	24
A	parseCommonOptions()	0	18	2

<?php

Missing file doc comment

namespace Db3v4l\Command;

use Db3v4l\API\Interfaces\SqlAction\CommandAction;
use Db3v4l\API\Interfaces\SqlAction\FileAction;
use Db3v4l\Core\DatabaseSchemaManager;
use Db3v4l\Service\DatabaseConfigurationManager;
use Db3v4l\Service\ProcessManager;
use Db3v4l\Service\SqlExecutorFactory;
use Db3v4l\Util\Process;
use Symfony\Component\Console\Input\InputInterface;

The type Symfony\Component\Console\Input\InputInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Symfony\Component\Console\Input\InputOption;

The type Symfony\Component\Console\Input\InputOption was not found. Maybe you did not declare it correctly or list all dependencies?

use Symfony\Component\Console\Output\OutputInterface;

The type Symfony\Component\Console\Output\OutputInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Symfony\Component\Yaml\Yaml;

The type Symfony\Component\Yaml\Yaml was not found. Maybe you did not declare it correctly or list all dependencies?

abstract class SQLExecutingCommand extends BaseCommand

Missing doc comment for class SQLExecutingCommand

{
    /** @var DatabaseConfigurationManager $dbConfigurationManager */

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

    protected $dbConfigurationManager;
    /** @var SqlExecutorFactory $executorFactory */

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

    protected $executorFactory;
    protected $processManager;

    const DEFAULT_OUTPUT_FORMAT = 'text';
    const DEFAULT_PARALLEL_PROCESSES = 16;
    const DEFAULT_PROCESS_TIMEOUT = 600;
    const DEFAULT_EXECUTOR_TYPE = 'NativeClient';

    protected $outputFormat;
    protected $outputFile;
    protected $maxParallelProcesses;
    protected $processTimeout;
    protected $executionStrategy;
    protected $executeInProcess;

    public function __construct(

Missing doc comment for function __construct()

        DatabaseConfigurationManager $dbConfigurationManager,
        SqlExecutorFactory $executorFactory,
        ProcessManager $processManager)

The closing parenthesis of a multi-line function declaration must be on a new line

    {

The closing parenthesis and the opening brace of a multi-line function declaration must be on the same line

        $this->dbConfigurationManager = $dbConfigurationManager;
        $this->executorFactory = $executorFactory;
        $this->processManager = $processManager;

        parent::__construct();
    }

    protected function addCommonOptions()

Missing doc comment for function addCommonOptions()

    {
        $this
            ->addOption('only-instances', 'o', InputOption::VALUE_REQUIRED|InputOption::VALUE_IS_ARRAY, 'Filter the database servers to run this command against. Usage of * and ? wildcards is allowed. To see all instances available, use `instance:list`', null)
            ->addOption('except-instances', 'x', InputOption::VALUE_REQUIRED|InputOption::VALUE_IS_ARRAY, 'Filter the database servers to run this command against', null)
            ->addOption('output-type', null, InputOption::VALUE_REQUIRED, 'The format for the output: json, php, text or yml', self::DEFAULT_OUTPUT_FORMAT)
            ->addOption('output-file', null, InputOption::VALUE_REQUIRED, 'Save output to a file instead of writing it to stdout. NB: take care that dbconsole runs in a container, which has a different view of the filesystem. A good dir for output is ./shared')
            ->addOption('timeout', null, InputOption::VALUE_REQUIRED, 'The maximum time to wait for subprocess execution (secs)', self::DEFAULT_PROCESS_TIMEOUT)
            ->addOption('max-parallel', null, InputOption::VALUE_REQUIRED, 'The maximum number of subprocesses to run in parallel', self::DEFAULT_PARALLEL_PROCESSES)
            ->addOption('dont-force-enabled-sigchild', null, InputOption::VALUE_NONE, "When using a separate process to run each sql command, do not force Symfony to believe that php was compiled with --enable-sigchild option")
            ->addOption('execution-strategy', null, InputOption::VALUE_REQUIRED, "EXPERIMENTAL. Internal usage", self::DEFAULT_EXECUTOR_TYPE)
            ->addOption('execute-in-process', null, InputOption::VALUE_NONE, "EXPERIMENTAL. Internal usage")

Space after closing parenthesis of function call prohibited

        ;
    }

    /**

Missing short description in doc comment

     * @param InputInterface $input

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @return string[][] the list of instances to use. key: name, value: connection spec

Tag @return cannot be grouped with parameter tags in a doc comment

     */
    protected function parseCommonOptions(InputInterface $input)
    {
        $this->outputFormat = $input->getOption('output-type');
        $this->outputFile = $input->getOption('output-file');
        $this->processTimeout = $input->getOption('timeout');
        $this->maxParallelProcesses = $input->getOption('max-parallel');
        $this->executionStrategy = $input->getOption('execution-strategy');
        $this->executeInProcess = $input->getOption('execute-in-process');

        // On Debian, which we use by default, SF has troubles understanding that php was compiled with --enable-sigchild
        // We thus force it, but give end users an option to disable this
        // For more details, see comment 12 at https://bugs.launchpad.net/ubuntu/+source/php5/+bug/516061
        if (! $input->getOption('dont-force-enabled-sigchild')) {
            Process::forceSigchildEnabled(true);
        }

        return $this->dbConfigurationManager->getInstancesConfiguration(
            $this->dbConfigurationManager->listInstances($input->getOption('only-instances'), $input->getOption('except-instances'))
        );
    }

    /**

Missing short description in doc comment

     * @param string[][] $instanceList list of instances to execute the action on. Key: instance name, value: connection spec

Expected 10 spaces after parameter name; 1 found

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param string $actionName used to build error messages

Expected 5 spaces after parameter type; 1 found

Expected 12 spaces after parameter name; 1 found

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param callable $getSqlActionCallable the method used to retrieve the desired SqlAction.

Expected 3 spaces after parameter type; 1 found

Expected 2 spaces after parameter name; 1 found

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     *                                       It will be passed as arguments the SchemaManager and instance name, and should return a CommandAction or FileAction
     * @param bool $timed whether to use a timed executor

Expected 7 spaces after parameter type; 1 found

Expected 17 spaces after parameter name; 1 found

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param callable $onForkedProcessOutput a callback invoked when forked processes produce output

Expected 3 spaces after parameter type; 1 found

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @return array 'succeeded': int, 'failed': int, 'data': mixed[]

Tag @return cannot be grouped with parameter tags in a doc comment

     * @throws \Exception

Tag @throws cannot be grouped with parameter tags in a doc comment

     */
    protected function executeSqlAction($instanceList, $actionName, $getSqlActionCallable, $timed = false, $onForkedProcessOutput = null)
    {
        $processes = [];
        $callables = [];
        $outputFilters = [];
        $tempSQLFileNames = [];
        $executors = [];

        try {

            foreach ($instanceList as $instanceName => $dbConnectionSpec) {

                $schemaManager = new DatabaseSchemaManager($dbConnectionSpec);

                /** @var CommandAction|FileAction $sqlAction */

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

                $sqlAction = call_user_func_array($getSqlActionCallable, [$schemaManager, $instanceName]);

                if ($sqlAction instanceof CommandAction) {
                    $filename = null;
                    $sql = $sqlAction->getCommand();
                } else if ($sqlAction instanceof FileAction) {
                    $filename = $sqlAction->getFilename();
                    $sql = null;
                } else {
                    // this is a coding error, not a sql execution error
                    throw new \Exception("Unsupported action type: " . get_class($sqlAction));
                }
                $filterCallable = $sqlAction->getResultsFilterCallable();

                if ($filename === null && $sql === null) {
                    // no sql to execute as forked process - we run the 'filter' functions in a separate loop
                    $callables[$instanceName] = $filterCallable;
                } else {
                    $outputFilters[$instanceName] = $filterCallable;

                    if ($filename === null && !$sqlAction->isSingleStatement()) {

The method isSingleStatement() does not exist on Db3v4l\API\Interfaces\SqlAction\FileAction.

                        $filename = tempnam(sys_get_temp_dir(), 'db3v4l_') . '.sql';
                        file_put_contents($filename, $sql);
                        $tempSQLFileNames[] = $filename;
                    }

                    if ($this->executeInProcess) {
                        $executor = $this->executorFactory->createInProcessExecutor($instanceName, $dbConnectionSpec, $this->executionStrategy, $timed);
                        if ($filename === null) {
                            $callables[$instanceName] = $executor->getExecuteCommandCallable($sql);
                        } else {
                            $callables[$instanceName] = $executor->getExecuteFileCallable($filename);

The method getExecuteFileCallable() does not exist on Db3v4l\Core\SqlExecutor\InProcess\Doctrine.

The method getExecuteFileCallable() does not exist on Db3v4l\Core\SqlExecutor\InProcess\PDO.

                        }
                    } else {
                        $executor = $this->executorFactory->createForkedExecutor($instanceName, $dbConnectionSpec, $this->executionStrategy, $timed);
                        $executors[$instanceName] = $executor;

                        if ($filename === null) {
                            $process = $executor->getExecuteStatementProcess($sql);
                        } else {
                            $process = $executor->getExecuteFileProcess($filename);
                        }

                        if ($this->outputFormat === 'text') {
                            $this->writeln('Command line: ' . $process->getCommandLine(), OutputInterface::VERBOSITY_VERY_VERBOSE);
                        }

                        $process->setTimeout($this->processTimeout);

                        $processes[$instanceName] = $process;
                    }
                }
            }

            /// @todo refactor the filtering loop so that filters can be applied as well to inProcess executors

            $succeeded = 0;
            $failed = 0;
            $results = [];

            foreach ($callables as $instanceName => $callable) {
                try {
                    $results[$instanceName] = call_user_func($callable);
                    $succeeded++;
                } catch (\Throwable $t) {
                    $failed++;
                    $this->writeErrorln("\n<error>$actionName in instance '$instanceName' failed! Reason: " . $t->getMessage() . "</error>\n", OutputInterface::VERBOSITY_NORMAL);
                }
            }

            if (count($processes)) {
                if ($this->outputFormat === 'text') {
                    $this->writeln('<info>Starting parallel execution...</info>', OutputInterface::VERBOSITY_VERY_VERBOSE);
                }
                $this->processManager->runParallel($processes, $this->maxParallelProcesses, 100, $onForkedProcessOutput);

                foreach ($processes as $instanceName => $process) {
                    if ($process->isSuccessful()) {
                        /// @todo is it necessary to have rtrim here ? shall we maybe move it to the executor ?
                        $output = rtrim($process->getOutput());
                        if (isset($outputFilters[$instanceName])) {
                            try {
                                $output = call_user_func_array($outputFilters[$instanceName], [$output, $executors[$instanceName]]);
                            } catch (\Throwable $t) {
                                /// @todo shall we reset $result to null or not?
                                //$result = null;
                                $failed++;
                                $succeeded--;
                                $this->writeErrorln("\n<error>$actionName in instance '$instanceName' failed! Reason: " . $t->getMessage() . "</error>\n", OutputInterface::VERBOSITY_NORMAL);
                            }
                        }
                        $results[$instanceName] = $output;
                        $succeeded++;
                    } else {
                        $results[$instanceName] = [
                            'stderr' => trim($process->getErrorOutput()),
                            'exitcode' => $process->getExitCode()
                        ];
                        $failed++;
                        $this->writeErrorln("\n<error>$actionName in instance '$instanceName' failed! Reason: " . $process->getErrorOutput() . "</error>\n", OutputInterface::VERBOSITY_NORMAL);
                    }
                }
            }

        } finally {
            // make sure that we clean up temp files, as they might contain sensitive data
            foreach($tempSQLFileNames as $tempSQLFileName) {

Expected "foreach (...) {\n"; found "foreach(...) {\n"

                unlink($tempSQLFileName);
            }
        }

        uksort($results, function ($a, $b) {

The opening parenthesis of a multi-line function call should be the last content on the line.

            $aParts = explode('_', $a, 2);
            $bParts = explode('_', $b, 2);
            $cmp = strcasecmp($aParts[0], $bParts[0]);
            if ($cmp !== 0) {
                return $cmp;
            }
            if (count($aParts) == 1) {
                return -1;
            }
            if (count($bParts) == 1) {
                return 1;
            }
            $aVersion = str_replace('_', '.', $aParts[1]);
            $bVersion = str_replace('_', '.', $bParts[1]);
            return version_compare($aVersion, $bVersion);
        });

For multi-line function calls, the closing parenthesis should be on a new line.

        return [
            'succeeded' => $succeeded,
            'failed' => $failed,
            'data' => $results
        ];
    }

    /**

Missing short description in doc comment

     * @param array $results

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @return string

Tag @return cannot be grouped with parameter tags in a doc comment

     * @throws \OutOfBoundsException for unsupported output formats

Tag @throws cannot be grouped with parameter tags in a doc comment

     */
    protected function formatResults(array $results)
    {
        switch ($this->outputFormat) {
            case 'json':

Line indented incorrectly; expected 8 spaces, found 12

                return json_encode($results['data'], JSON_PRETTY_PRINT);
            case 'php':

Line indented incorrectly; expected 8 spaces, found 12

                return var_export($results['data'], true);
            case 'text':

Line indented incorrectly; expected 8 spaces, found 12

            case 'yml':

Line indented incorrectly; expected 8 spaces, found 12

            case 'yaml':

Line indented incorrectly; expected 8 spaces, found 12

                return Yaml::dump($results['data'], 2, 4, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK);
            default:

Line indented incorrectly; expected 8 spaces, found 12

                throw new \OutOfBoundsException("Unsupported output format: '{$this->outputFormat}'");
                break;
        }
    }

    /**

Missing short description in doc comment

     * @param array $results should contain elements: succeeded(int) failed(int), data(mixed)

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param float $time execution time in seconds

Expected 4 spaces after parameter name; 1 found

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @throws \Exception for unsupported formats

Tag @throws cannot be grouped with parameter tags in a doc comment

     * @todo since we use could be using forked processes, we can not measure total memory used... is it worth measuring just ours?

Tag @todo cannot be grouped with parameter tags in a doc comment

Tag value for @todo tag indented incorrectly; expected 3 spaces but found 1

     */

Missing @return tag in function comment

    protected function writeResults(array $results, $time = null)
    {
        if ($this->outputFile != null) {
            $this->writeResultsToFile($results);
        } else {
            $formattedResults = $this->formatResults($results);
            $this->writeln($formattedResults, OutputInterface::VERBOSITY_QUIET,  OutputInterface::OUTPUT_RAW);
        }

        if ($this->outputFormat === 'text' || $this->outputFile != null) {
            $this->writeln($results['succeeded'] . ' succeeded, ' . $results['failed'] . ' failed');
            if ($this->outputFile != null) {
                $this->writeln("Results saved to file {$this->outputFile}");
            }
            if ($time !== null) {
                $this->writeln("<info>Time taken: ".sprintf('%.2f', $time)." secs</info>");
            }
        }
    }

    protected function writeResultsToFile(array $results)

Missing doc comment for function writeResultsToFile()

    {
        $formattedResults = $this->formatResults($results);
        file_put_contents($this->outputFile, $formattedResults);
    }
}