Gruberro\MongoDbMigrations\Console\Command\MigrationsCommand::execute()

Complexity

Conditions	24
Paths	11441

Size

Total Lines	145
Code Lines	88

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	93
CRAP Score	24.1975

Importance

Changes	1
Bugs	0	Features	0

<?php
    protected function execute(Console\Input\InputInterface $input, Console\Output\OutputInterface $output)
    {
        $client = new \MongoClient($input->getOption('server'));
        $db = $client->selectDB($input->getArgument('database'));
        $output->writeln("<info>✓ Successfully established database connection</info>", $output::VERBOSITY_VERBOSE);

        $directories = $input->getArgument('migration-directories');
        foreach ($directories as $directory) {
            if (! is_dir($directory)) {
                throw new Console\Exception\InvalidArgumentException("'{$directory}' is no valid directory");
            }

            $output->writeln("<comment>Iterating '{$directory}' for potential migrations classes</comment>", $output::VERBOSITY_DEBUG);
            $iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($directory), \RecursiveIteratorIterator::LEAVES_ONLY);

            /** @var \SplFileInfo $file */
            foreach ($iterator as $file) {
                if ($file->getBasename('.php') === $file->getBasename()) {
                    continue;
                }

                require_once $file->getRealPath();

                $output->writeln("<comment>Loaded potential migration '{$file->getRealPath()}'</comment>", $output::VERBOSITY_DEBUG);
            }
        }

        /** @var MongoDbMigrations\MigrationInterface[] $migrations */
        $migrations = [];
        foreach (get_declared_classes() as $className) {
            $reflectionClass = new \ReflectionClass($className);

            if ($reflectionClass->implementsInterface(MongoDbMigrations\MigrationInterface::class)) {
                /** @var MongoDbMigrations\MigrationInterface $newInstance */
                $newInstance = $reflectionClass->newInstance();
                $id = md5($newInstance->getId());

                if (isset($migrations[$id])) {
                    $existingMigrationClass = get_class($migrations[$id]);
                    throw new Console\Exception\RuntimeException("Found a non unique migration id '{$newInstance->getId()}' in '{$reflectionClass->getName()}', already defined by migration class '{$existingMigrationClass}'");

Consider using $reflectionClass->name. There is an issue with getName() and APC-enabled PHP versions.

                }

                $migrations[$id] = $newInstance;

                $output->writeln("<comment>Found valid migration class '{$reflectionClass->getName()}'</comment>", $output::VERBOSITY_DEBUG);

Consider using $reflectionClass->name. There is an issue with getName() and APC-enabled PHP versions.

            }
        }

        $migrationClassesCount = count($migrations);
        $output->writeln("<info>✓ Found {$migrationClassesCount} valid migration classes</info>", $output::VERBOSITY_VERBOSE);

        uasort($migrations, function (MongoDbMigrations\MigrationInterface $a, MongoDbMigrations\MigrationInterface $b) {
            if ($a->getCreateDate() === $b->getCreateDate()) {
                return 0;
            }

            return $a->getCreateDate() < $b->getCreateDate() ? -1 : 1;
        });

        $output->writeln("<info>✓ Reordered all migration classes according to their create date</info>", $output::VERBOSITY_VERBOSE);

        $databaseMigrationsLockCollection = $db->selectCollection('DATABASE_MIGRATIONS_LOCK');

        $currentLock = $databaseMigrationsLockCollection->findAndModify(['locked' => ['$exists' => true]], ['locked' => true, 'last_locked_date' => new \MongoDate()], [], ['upsert' => true]);
        if ($currentLock !== null && $currentLock['locked'] === true) {
            throw new Console\Exception\RuntimeException('Concurrent migrations are not allowed');
        }

        try {
            $output->writeln("<info>✓ Successfully acquired migration lock</info>", $output::VERBOSITY_VERBOSE);

            $databaseMigrationsCollection = $db->selectCollection('DATABASE_MIGRATIONS');

            if (count($databaseMigrationsCollection->getIndexInfo()) <= 1) {
                $databaseMigrationsCollection->createIndex(['migration_id' => 1],
                    ['unique' => true, 'background' => false]);
            }

            $progress = new Console\Helper\ProgressBar($output, count($migrations));

            switch ($output->getVerbosity()) {
                case $output::VERBOSITY_VERBOSE:
                    $format = 'verbose';
                    break;
                case $output::VERBOSITY_VERY_VERBOSE:
                    $format = 'very_verbose';
                    break;
                case $output::VERBOSITY_DEBUG:
                    $format = 'debug';
                    break;
                default:
                    $format = 'normal';
            }

            $progress->setFormat($format);
            $progress->start();
            $executedMigrations = 0;

            foreach ($migrations as $id => $migration) {
                $progress->advance();

                if ($migration instanceof MongoDbMigrations\ContextualMigrationInterface && $input->getOption('contexts') !== []) {
                    if (array_intersect($migration->getContexts(), $input->getOption('contexts')) === []) {
                        continue;
                    }
                }

                if (!$migration instanceof MongoDbMigrations\RunAlwaysMigrationInterface) {
                    if ($databaseMigrationsCollection->count(['migration_id' => $id]) > 0) {
                        continue;
                    }
                }

                $migration->execute($db);
                $executedMigrations++;

                $migrationInfo = [
                    'migration_id' => $id,
                    'migration_class' => get_class($migration),
                    'last_execution_date' => new \MongoDate(),
                    'run_always' => $migration instanceof MongoDbMigrations\RunAlwaysMigrationInterface,
                ];

                if ($migration instanceof MongoDbMigrations\ContextualMigrationInterface) {
                    $migrationInfo['contexts'] = $migration->getContexts();
                }

                $databaseMigrationsCollection->update(
                    ['migration_id' => $id],
                    $migrationInfo,
                    ['upsert' => true]
                );
            }

            $progress->finish();
            $output->writeln('');

            $output->writeln("<info>✓ Successfully executed {$executedMigrations} migrations</info>");
        } catch (\Exception $e) {
            throw new Console\Exception\RuntimeException('Error while executing migrations', $e->getCode(), $e);
        } finally {
            $databaseMigrationsLockCollection->update(['locked' => true], ['$set' => ['locked' => false]]);
            $output->writeln("<info>✓ Successfully released migration lock</info>", $output::VERBOSITY_VERBOSE);
        }
    }
}