Kaliop\eZMigrationBundle\Core\MigrationService::executeMigrationInner()

Complexity

Conditions	38
Paths	> 20000

Size

Total Lines	264
Code Lines	129

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	90
CRAP Score	60.5625

Importance

Changes	2
Bugs	1	Features	0

<?php
    protected function executeMigrationInner(Migration $migration, MigrationDefinition $migrationDefinition,
        $migrationContext, $stepOffset = 0, $useTransaction = true, $adminLogin = null)
    {
        /// @todo can we make this validation smarter / move it somewhere else?
        if (array_key_exists('path', $migrationContext) || array_key_exists('contentTypeIdentifier', $migrationContext) ||
            array_key_exists('fieldIdentifier', $migrationContext)) {
            throw new MigrationBundleException("Invalid call to executeMigrationInner: forbidden elements in migrationContext");
        }

        // BC: handling of legacy method call signature
        $useTransaction = array_key_exists('useTransaction', $migrationContext) ? $migrationContext['useTransaction'] : $useTransaction;
        $adminLogin = array_key_exists('adminUserLogin', $migrationContext) ? $migrationContext['adminUserLogin'] : $adminLogin;

        $messageSuffix = '';
        if (isset($migrationContext['forcedReferences']) && count($migrationContext['forcedReferences'])) {
            $messageSuffix = array();
            foreach ($migrationContext['forcedReferences'] as $name => $value) {
                $this->referenceResolver->addReference($name, $value, true);
                $messageSuffix[] = "$name: $value";
            }
            $messageSuffix = 'Injected references: ' . implode(', ', $messageSuffix);
        }

        $this->migrationContext[$migration->name] = array('context' => $migrationContext);

        $steps = array_slice($migrationDefinition->steps->getArrayCopy(), $stepOffset);
        $i = $stepOffset+1;
        $finalStatus = Migration::STATUS_DONE;
        $finalMessage = '';
        $error = null;
        $isCommitting = false;
        $requires = null;

        try {

            if ($useTransaction) {
                /// @todo in case there is already a db transaction running, we should throw - or at least
                ///       give a warning
                try {
                    $this->beginTransaction();
                    $requires = 'commit';
                } catch (\Exception $e) {
                    $finalStatus = Migration::STATUS_FAILED;
                    $finalMessage = 'An exception was thrown while starting the transaction before the migration: ' . $this->getFullExceptionMessage($e, true);

The call to Kaliop\eZMigrationBundle\Core\MigrationService::getFullExceptionMessage() has too many arguments starting with true.

                    /// @todo use a more specific exception?
                    $error = new MigrationBundleException($finalMessage, 0, $e);
                    $steps = array();
                }
            }

            if ($steps) {
                /// @todo catch errors thrown here
                $startTransactionLevel = $this->getDBTransactionNestingLevel();
            }

            try {
                foreach ($steps as $step) {
                    // save enough data in the context to be able to successfully suspend/resume
                    $this->migrationContext[$migration->name]['step'] = $i;

                    $step = $this->injectContextIntoStep($step, array_merge($migrationContext, array('step' => $i)));

                    // we validated the fact that we have a good executor at parsing time
                    $executor = $this->executors[$step->type];

                    $beforeStepExecutionEvent = new BeforeStepExecutionEvent($step, $executor);
                    $this->dispatcher->dispatch($this->eventPrefix . 'before_execution', $beforeStepExecutionEvent);
                    // allow some sneaky trickery here: event listeners can manipulate 'live' the step definition and the executor
                    $executor = $beforeStepExecutionEvent->getExecutor();
                    $step = $beforeStepExecutionEvent->getStep();

                    try {
                        $result = $executor->execute($step);

                        $this->dispatcher->dispatch($this->eventPrefix . 'step_executed', new StepExecutedEvent($step, $result));
                    } catch (MigrationStepSkippedException $e) {
                        continue;
                    }

                    $i++;
                }

            } catch (MigrationAbortedException $e) {
                // allow a migration step (or events) to abort the migration via a specific exception

                $this->dispatcher->dispatch($this->eventPrefix . $this->eventEntity . '_aborted', new MigrationAbortedEvent($step, $e));

                $finalStatus = $e->getCode();
                $finalMessage = "Abort in execution of step $i: " . $e->getMessage();

                /// @todo we should allow another type of migration aborting: one which forces rollback of changes, and
                ///       possibly exits execution with a non-zero code.
                ///       Atm it can be achieved by throwing any exception, which is easy to do in php but hard in yml...
                ///       Eg. distinguish between STATUS_PARTIALLY_DONE and STATUS_FAILED
                /*if ($e->getCode() == Migration::STATUS_FAILED) {
                    $error = $e;
                    if ($requires == 'commit') {
                        $requires = 'rollback';
                    }
                }*/

            } catch (MigrationSuspendedException $e) {
                // allow a migration step (or events) to suspend the migration via a specific exception

                $this->dispatcher->dispatch($this->eventPrefix . $this->eventEntity . '_suspended', new MigrationSuspendedEvent($step, $e));

                // let the context handler store our context, along with context data from any other (tagged) service which has some
                $this->contextHandler->storeCurrentContext($migration->name);

                $finalStatus = Migration::STATUS_SUSPENDED;
                $finalMessage = "Suspended in execution of step $i: " . $e->getMessage();

            } catch (\Exception $e) {
                /// @todo shall we emit a signal as well?

                if ($requires == 'commit') {
                    $requires = 'rollback';
                }

                $finalStatus = Migration::STATUS_FAILED;
                $finalMessage = $this->getFullExceptionMessage($e, true);
                $error = new MigrationStepExecutionException($finalMessage, $i, $e);
                $finalMessage = $error->getMessage();
            }

            /// @todo this test only works if the transaction left pending was opened using the PDO connection.
            ///       If it was opened by a stray/unterminated sql `begin`, it will not be detected, and most likely
            ///       throw an error later when we try to save the migration status (unless the migration is run
            ///       with $useTransaction, in which case the pending transaction just gets committed).
            ///       We could try to use PDO::inTransaction to check for pending transactions, but we'd
            ///       have to first check if it behaves the same way across all db/php-version combinations...
            if ($steps && ($pendingTransactionLevel = $this->getDBTransactionNestingLevel() - $startTransactionLevel) > 0) {

The variable $startTransactionLevel does not seem to be defined for all execution paths leading up to this point.

                // a migration step has opened a transaction and forgotten to close it! For safety, we have to roll back

                // remove extra transaction levels
                for ($i = 0; $i < $pendingTransactionLevel; $i++) {
                    /// @todo catch errors thrown here
                    $this->rollbackDBTransaction();
                }
                // if there was a transaction added by ourselves, let it be rolled back
                if ($requires == 'commit') {
                    $requires = 'rollback';
                }
                // mark the migration as failed
                $finalStatus = Migration::STATUS_FAILED;
                if ($error) {
                    /// @todo re-inject the new message into $error
                    $finalMessage .= '. In addition, the migration had left a database transaction pending';
                } else {
                    // it would be nice to tell the user which step actually has opened the transaction left dangling,
                    // but that could be complicated, taking into account the case of migrations starting a transaction
                    // in step X and closing it in step Y, as well as for the possibility of exceptions being thrown
                    // halfway through a step
                    $finalMessage = 'The migration was rolled back because it had left a database transaction pending';
                    $error = new MigrationBundleException($finalMessage);
                }
            }

            /// @todo in the same way that we check for migration steps having left a pending transaction in the code
            ///       block above, we could check if any transaction has changed the currently logged-in user, and roll
            ///       that back, too

            // in case we are wrapping the migration in a transaction, either commit or roll back
            if ($requires == 'commit') {
                try {
                    // there might be workflows or other actions happening at commit time that fail if we are not admin
                    // when committing
                    $previousUserId = null;

The assignment to $previousUserId is dead and can be removed.

                    $previousUserId = $this->loginUser($this->getAdminUserIdentifier($adminLogin));

It seems like $adminLogin can also be of type false; however, parameter $adminLogin of Kaliop\eZMigrationBundle\Core\MigrationService::getAdminUserIdentifier() does only seem to accept string, maybe add an additional type check?

                    // Note that the repository by design does first execute a db commit, then carries out some other stuff,
                    // such as f.e. sending data to Solr. It is useful to differentiate between errors thrown during the
                    // two phases, as the end results are very different in the db, but it is hard to do so by looking
                    // into the exception that gets thrown here. So we just mark the transaction for rollback in case an
                    // error occurs, and check what happens during rollback later on.
                    $isCommitting = true;
                    $this->commit();
                    $isCommitting = false;
                } catch (\Exception $e) {
                    // When running some DDL queries, some databases (eg. mysql, oracle) do commit any pending transaction.
                    // Since php 8.0, the PDO driver does properly take that into account, and throws an exception
                    // when we try to commit here. Short of analyzing any executed migration step checking for execution
                    // of DDL, all we can do is swallow the error.
                    // NB: what we get is a chain: RuntimeException/RuntimeException/PDOException. Should we validate it fully?
                    if ($e instanceof \RuntimeException && $e->getMessage() == 'There is no active transaction') {
                        $isCommitting = false;
                        $this->resetDBTransaction();
                        // save a warning in the migration status
                        $finalMessage = 'Some migration step committed the transaction halfway';
                    } else {
                        $finalStatus = Migration::STATUS_FAILED;
                        $finalMessage = 'An exception was thrown while committing: ' . $this->getFullExceptionMessage($e, true);
                        $requires = 'rollback';
                        /// @todo use a more specific exception?
                        $error = new MigrationBundleException($finalMessage, 0, $e);
                    }
                } finally {
                    /// @todo wrap any (unlikely) exception from this call in an AfterMigrationExecutionException
                    if ($previousUserId) {

The expression $previousUserId of type false|integer is loosely compared to true; this is ambiguous if the integer can be 0. You might want to explicitly use !== false instead.

                        $this->loginUser($previousUserId);
                    }
                }
            }

            if ($requires == 'rollback') {
                try {
                    // there is no need to be admin here, at least in theory
                    $this->rollBack();
                } catch (\Exception $e) {
                    // This check is not rock-solid, but at the moment is the best we can do to tell apart 2 cases of
                    // exceptions originating above during commit: the case where the commit was successful but handling
                    // of a commit-queue signal failed, from the case where something failed beforehand.
                    // Known cases for signals failing at commit time include fe. https://jira.ez.no/browse/EZP-29333
                    if ($isCommitting && $e instanceof \RuntimeException && $e->getMessage() == 'There is no active transaction') {
                        // since all the migration steps succeeded and it was committed (because there was nothing to roll back),
                        // no use to mark it as failed...
                        $finalStatus = Migration::STATUS_DONE;
                        $finalMessage = 'An exception was thrown after committing, in file: ' .
                            $this->getFullExceptionMessage($error, true);

It seems like $error can also be of type null; however, parameter $e of Kaliop\eZMigrationBundle\Core\MigrationService::getFullExceptionMessage() does only seem to accept Exception, maybe add an additional type check?

                        $error = new AfterMigrationExecutionException($finalMessage, 0, $e);
                    } else {
                        $finalMessage .= '. In addition, an exception was thrown while rolling back, in file ' .
                            $e->getFile() . ' line ' . $e->getLine() . ': ' . $e->getMessage();
                        $errorClass = get_class($error);

It seems like $error can also be of type null; however, parameter $object of get_class() does only seem to accept object, maybe add an additional type check?

                        // we trust the constructor to be fine as error should only be a subclass of MigrationBundleException
                        $error = new $errorClass($finalMessage, $error->getCode(), $error->getPrevious());
                    }
                }
            }

        } finally {

            // save migration status

            $finalMessage = ($finalMessage != '' && $messageSuffix != '') ? $finalMessage . '. '. $messageSuffix : $finalMessage . $messageSuffix;

            try {
                $this->storageHandler->endMigration(new Migration(
                    $migration->name,
                    $migration->md5,
                    $migration->path,
                    $migration->executionDate,
                    $finalStatus,
                    $finalMessage
                ));
            } catch (\Exception $e) {
                // If we get here, the migration will be left in 'executing' state. It might be worth re-trying
                // to store its status for a couple of times, in case the error is transient, but that would
                // overcomplicate the business logic. So we at least give to the end user a specific error message

                if ($error) {
                    /// @todo use a more specific exception
                    $errorMessage = $finalMessage . '. In addition, an exception was thrown while saving migration status after its execution, in file ' .
                        $e->getFile() . ' line ' . $e->getLine() . ': ' . $e->getMessage();
                    $error = new MigrationBundleException($errorMessage, 0, $e);
                } else {
                    $errorMessage = 'An exception was thrown while saving migration status after its execution: ' .
                        $this->getFullExceptionMessage($e, true);
                    $error = new AfterMigrationExecutionException($errorMessage, 0, $e);
                }
            }

            if ($error) {
                throw $error;
            }