MassMigrateCommand::executeAsChild() - Code Metrics - Inspection of "add --force flag to migrate commands" - kaliop-uk/ezmigrationbundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 5b059b...7ec67f )

by Gaetano
created 2019-01-18 09:06 UTC
MassMigrateCommand::executeAsChild() C

↳ Parent: MassMigrateCommand
Complexity

Conditions	10
Paths	24
Size

Total Lines
Duplication

Lines	9
Ratio	11.69 %
Code Coverage

Tests	0
CRAP Score	110
Importance

Changes
Metric	Value
dl	9
loc	77
ccs	0
cts	38
cp	0
rs	6.6351
c	0
b	0
f	0
cc	10
nc	24
nop	5
crap	110
How to fix Long Method Complexity

<?php

namespace Kaliop\eZMigrationBundle\Command;

use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\Output;
use Symfony\Component\Console\Output\OutputInterface;
use Kaliop\eZMigrationBundle\API\Value\Migration;
use Kaliop\eZMigrationBundle\API\Value\MigrationDefinition;
use Symfony\Component\Process\ProcessBuilder;
use Symfony\Component\Process\PhpExecutableFinder;
use Kaliop\eZMigrationBundle\Core\Helper\ProcessManager;
use Symfony\Component\Console\Question\ConfirmationQuestion;

class MassMigrateCommand extends MigrateCommand
{
    const COMMAND_NAME = 'kaliop:migration:mass_migrate';

    protected $migrationsDone = array(0, 0, 0);
    protected $migrationsAlreadyDone = array();

    /**
     * @todo (!important) can we rename the option --separate-process ?
     */
    protected function configure()
    {
        parent::configure();

        $this
            ->setName(self::COMMAND_NAME)
            ->setAliases(array())
            ->setDescription('Executes available migration definitions, using parallelism.')
            ->addOption('concurrency', 'r', InputOption::VALUE_REQUIRED, "The number of executors to run in parallel", 2)
            ->setHelp(<<<EOT
This command is designed to scan recursively a directory for migration files and execute them all in parallel.
One child process will be spawned for each subdirectory found.
The maximum number of processes to run in parallel is specified via the 'concurrency' option.
<info>NB: this command does not guarantee that any given migration will be executed before another. Take care about dependencies.</info>
<info>NB: the rule that each migration filename has to be unique still applies, even if migrations are spread across different directories.</info>
Unlike for the 'normal' migration command, it is not recommended to use the <info>--separate-process</info> option, as it will make execution much slower
EOT
            )
        ;
    }

    /**
     * Execute the command.
     *
     * @param InputInterface $input
     * @param OutputInterface $output
     * @return null|int null or 0 if everything went fine, or an error code
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $start = microtime(true);

        $this->setOutput($output);
        $this->setVerbosity($output->getVerbosity());

        $isChild = $input->getOption('child');

        if ($isChild) {
            $this->setVerbosity(self::VERBOSITY_CHILD);
        }

        $this->getContainer()->get('ez_migration_bundle.step_executed_listener.tracing')->setOutput($output);

        // q: is it worth declaring a new, dedicated migration service ?
        $migrationService = $this->getMigrationService();
        $migrationService->setLoader($this->getContainer()->get('ez_migration_bundle.loader.filesystem_recursive'));

        $force = $input->getOption('force');

        $toExecute = $this->buildMigrationsList($input->getOption('path'), $migrationService, $force, $isChild);

        if (!count($toExecute)) {
            $this->writeln('<info>No migrations to execute</info>');
            return 0;
        }

        if (!$isChild) {
            return $this->executeAsParent($input, $output, $toExecute, $start);

        } else {
            return $this->executeAsChild($input, $output, $toExecute, $force, $migrationService);
        }
    }

    protected function executeAsParent($input, $output, $toExecute, $start)
    {
        $paths = $this->groupMigrationsByPath($toExecute);
        $this->printMigrationsList($toExecute, $input, $output, $paths);

        // ask user for confirmation to make changes
        if (!$this->askForConfirmation($input, $output, null)) {
            return 0;
        }

        $concurrency = $input->getOption('concurrency');
        $this->writeln("Executing migrations using " . count($paths) . " processes with a concurrency of $concurrency");

        $builder = new ProcessBuilder();
        $executableFinder = new PhpExecutableFinder();
        if (false !== ($php = $executableFinder->find())) {
            $builder->setPrefix($php);
        }

        // mandatory args and options
        $builderArgs = $this->createChildProcessArgs($input);

        $processes = array();
        /** @var MigrationDefinition $migrationDefinition */
        foreach($paths as $path => $count) {
            $this->writeln("<info>Queueing processing of: $path ($count migrations)</info>", OutputInterface::VERBOSITY_VERBOSE);

            $process = $builder
                ->setArguments(array_merge($builderArgs, array('--path=' . $path)))
                ->getProcess();

            $this->writeln('<info>Command: ' . $process->getCommandLine() . '</info>', OutputInterface::VERBOSITY_VERBOSE);

            // allow long migrations processes by default
            $process->setTimeout(86400);
            $processes[] = $process;
        }

        $this->writeln("Starting queued processes...");

        $this->migrationsDone = array(0, 0, 0);

        $processManager = new ProcessManager();
        $processManager->runParallel($processes, $concurrency, 500, array($this, 'onSubProcessOutput'));

        $failed = 0;
        foreach ($processes as $i => $process) {
            if (!$process->isSuccessful()) {
                $output->writeln("\n<error>Subprocess $i failed! Reason: " . $process->getErrorOutput() . "</error>\n");
                $failed++;
            }
        }

        if ($input->getOption('clear-cache')) {

            $command = $this->getApplication()->find('cache:clear');
            $inputArray = new ArrayInput(array('command' => 'cache:clear'));
            $command->run($inputArray, $output);
        }

        $time = microtime(true) - $start;

        $this->writeln('<info>'.$this->migrationsDone[0].' migrations executed, '.$this->migrationsDone[1].' failed, '.$this->migrationsDone[2].' skipped</info>');

        // since we use subprocesses, we can not measure max memory used
        $this->writeln("Time taken: ".sprintf('%.2f', $time)." secs");

        return $failed;
    }

    protected function executeAsChild($input, $output, $toExecute, $force, $migrationService)
    {
        // @todo disable signal slots that are harmful during migrations, if any

        if ($input->getOption('separate-process')) {

            $builder = new ProcessBuilder();
            $executableFinder = new PhpExecutableFinder();
            if (false !== $php = $executableFinder->find()) {
                $builder->setPrefix($php);
            }

            $builderArgs = parent::createChildProcessArgs($input);
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
        }

        $failed = 0;
        $executed = 0;
        $skipped = 0;
        $total = count($toExecute);

        foreach ($toExecute as  $name => $migrationDefinition) {
            // let's skip migrations that we know are invalid - user was warned and he decided to proceed anyway
            if ($migrationDefinition->status == MigrationDefinition::STATUS_INVALID) {
                $this->writeln("<comment>Skipping migration (invalid definition?) Path: ".$migrationDefinition->path."</comment>", self::VERBOSITY_CHILD);
                $skipped++;
                continue;
            }

            if ($input->getOption('separate-process')) {

                try {
                    $this->executeMigrationInSeparateProcess($migrationDefinition, $migrationService, $builder, $builderArgs, false);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}

                    $executed++;
                } catch (\Exception $e) {
                    if ($input->getOption('ignore-failures')) {
                        $output->writeln("\n<error>Migration failed! Reason: " . $e->getMessage() . "</error>\n");
                        $failed++;
                        continue;
                    }
                    $output->writeln("\n<error>Migration aborted! Path: " . $migrationDefinition->path . ", Reason: " . $e->getMessage() . "</error>");

                    $missed = $total - $executed - $failed - $skipped;
                    $this->writeln("Migrations executed: $executed, failed: $failed, skipped: $skipped, to do: $missed");

                    return 1;
                }

            } else {

                try {
                    $this->executeMigrationInProcess($migrationDefinition, $force, $migrationService, $input);

                    $executed++;
                } catch(\Exception $e) {
                    $failed++;
                    if ($input->getOption('ignore-failures')) {
                        $this->writeln("<error>Migration failed! Path: " . $migrationDefinition->path . ", Reason: " . $e->getMessage() . "</error>", self::VERBOSITY_CHILD);
                        continue;
                    }

                    $this->writeln("<error>Migration aborted! Path: " . $migrationDefinition->path . ", Reason: " . $e->getMessage() . "</error>", self::VERBOSITY_CHILD);

                    $missed = $total - $executed - $failed - $skipped;
                    $this->writeln("Migrations executed: $executed, failed: $failed, skipped: $skipped, to do: $missed");

                    return 1;
                }

            }
        }

        $this->writeln("Migrations executed: $executed, failed: $failed, skipped: $skipped", self::VERBOSITY_CHILD);

        // We do not return an error code > 0 if migrations fail, but only on proper fatals.
        // The parent will analyze the output of the child process to gather the number of executed/failed migrations anyway
        //return $failed;
    }

    public function onSubProcessOutput($type, $buffer, $process=null)
    {
        $lines = explode("\n", trim($buffer));

        foreach ($lines as $line) {
            if (preg_match('/Migrations executed: ([0-9]+), failed: ([0-9]+), skipped: ([0-9]+)/', $line, $matches)) {
                $this->migrationsDone[0] += $matches[1];
                $this->migrationsDone[1] += $matches[2];
                $this->migrationsDone[2] += $matches[3];

                // swallow these lines unless we are in verbose mode
                if ($this->verbosity <= Output::VERBOSITY_NORMAL) {
                    return;
                }
            }

            // we tag the output from the different processes
            if (trim($line) !== '') {
                echo '[' . ($process ? $process->getPid() : ''). '] ' . trim($line) . "\n";
            }
        }
    }

    /**
     * @param string $paths
     * @param $migrationService
     * @param bool $force
     * @param bool $isChild when not in child mode, do not waste time parsing migrations
     * @return MigrationDefinition[] parsed or unparsed, depending on
     *
     * @todo this does not scale well with many definitions or migrations
     */
    protected function buildMigrationsList($paths, $migrationService, $force = false, $isChild = false)
    {
        $migrationDefinitions = $migrationService->getMigrationsDefinitions($paths);
        $migrations = $migrationService->getMigrations();

        $this->migrationsAlreadyDone = array(Migration::STATUS_DONE => 0, Migration::STATUS_FAILED => 0, Migration::STATUS_SKIPPED => 0, Migration::STATUS_STARTED => 0);

        $allowedStatuses = array(Migration::STATUS_TODO);
        if ($force) {

            $allowedStatuses = array_merge($allowedStatuses, array(Migration::STATUS_DONE, Migration::STATUS_FAILED, Migration::STATUS_SKIPPED));
        }

        // filter away all migrations except 'to do' ones
        $toExecute = array();
        foreach($migrationDefinitions as $name => $migrationDefinition) {
            if (!isset($migrations[$name]) || (($migration = $migrations[$name]) && in_array($migration->status, $allowedStatuses))) {

                $toExecute[$name] = $isChild ? $migrationService->parseMigrationDefinition($migrationDefinition) : $migrationDefinition;
            }
            // save the list of non-executable migrations as well (even when using 'force')
            if (!$isChild && isset($migrations[$name]) && (($migration = $migrations[$name]) && $migration->status != Migration::STATUS_TODO)) {
                $this->migrationsAlreadyDone[$migration->status]++;
            }
        }

        // if user wants to execute 'all' migrations: look for some which are registered in the database even if not
        // found by the loader
        if (empty($paths)) {

            foreach ($migrations as $migration) {
                if (in_array($migration->status, $allowedStatuses) && !isset($toExecute[$migration->name])) {
                    $migrationDefinitions = $migrationService->getMigrationsDefinitions(array($migration->path));
                    if (count($migrationDefinitions)) {
                        $migrationDefinition = reset($migrationDefinitions);
                        $toExecute[$migration->name] = $isChild ? $migrationService->parseMigrationDefinition($migrationDefinition) : $migrationDefinition;
                    } else {
                        // q: shall we raise a warning here ?
                    }
                }
            }
        }

        ksort($toExecute);

        return $toExecute;
    }

    /**
     * We use a more compact output when there are *many* migrations
     * @param MigrationDefinition[] $toExecute
     * @param array $paths
     * @param InputInterface $input
     * @param OutputInterface $output
     */
    protected function printMigrationsList($toExecute, InputInterface $input, OutputInterface $output, $paths = array())
    {
        $output->writeln('Found ' . count($toExecute) . ' migrations in ' . count($paths) . ' directories');
        $output->writeln('In the same directories, migrations previously executed: ' . $this->migrationsAlreadyDone[Migration::STATUS_DONE] .
            ', failed: ' . $this->migrationsAlreadyDone[Migration::STATUS_FAILED] . ', skipped: '. $this->migrationsAlreadyDone[Migration::STATUS_SKIPPED]);
        if ($this->migrationsAlreadyDone[Migration::STATUS_STARTED]) {
            $output->writeln('<info>In the same directories, migrations currently executing: ' . $this->migrationsAlreadyDone[Migration::STATUS_STARTED] . '</info>');
        }
    }

    /**
     * @param MigrationDefinition[] $toExecute
     * @return array key: folder name, value: number of migrations found
     */
    protected function groupMigrationsByPath($toExecute)
    {
        $paths = array();
        foreach($toExecute as $name => $migrationDefinition) {
            $path = dirname($migrationDefinition->path);
            if (!isset($paths[$path])) {
                $paths[$path] = 1;
            } else {
                $paths[$path]++;
            }
        }

        ksort($paths);

        return $paths;
    }

    /**
     * Returns the command-line arguments needed to execute a migration in a separate subprocess (omitting 'path')
     * @param InputInterface $input
     * @return array
     */
    protected function createChildProcessArgs(InputInterface $input)
    {
        $kernel = $this->getContainer()->get('kernel');

        // mandatory args and options
        $builderArgs = array(
            $_SERVER['argv'][0], // sf console
            self::COMMAND_NAME, // name of sf command. Can we get it from the Application instead of hardcoding?
            '--env=' . $kernel-> getEnvironment(), // sf env
            '--child'
        );
        // sf/ez env options
        if (!$kernel->isDebug()) {
            $builderArgs[] = '--no-debug';
        }
        if ($input->getOption('siteaccess')) {
            $builderArgs[] = '--siteaccess=' . $input->getOption('siteaccess');
        }
        // 'optional' options
        // note: options 'clear-cache', 'no-interaction', 'path' we never propagate
        if ($input->getOption('admin-login')) {
            $builderArgs[] = '--admin-login=' . $input->getOption('admin-login');
        }
        if ($input->getOption('default-language')) {
            $builderArgs[] = '--default-language=' . $input->getOption('default-language');
        }
        if ($input->getOption('force')) {
            $builderArgs[] = '--force';
        }
        if ($input->getOption('ignore-failures')) {
            $builderArgs[] = '--ignore-failures';
        }
        if ($input->getOption('no-transactions')) {
            $builderArgs[] = '--no-transactions';
        }
        if ($input->getOption('separate-process')) {
            $builderArgs[] = '--separate-process';
        }

    }
}

Push — master ( 5b059b...7ec67f )

MassMigrateCommand::executeAsChild() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

kaliop-uk / ezmigrationbundle

Push — master ( 5b059b...7ec67f )

MassMigrateCommand::executeAsChild() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
