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

Complexity

Conditions	14
Paths	2806

Size

Total Lines

137

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	210

Importance

Changes

0

<?php
    protected function executeMigrationInner(Migration $migration, MigrationDefinition $migrationDefinition,
        $migrationContext, $stepOffset = 0, $useTransaction = true, $adminLogin = null)
    {
        if ($useTransaction) {
            $this->repository->beginTransaction();
        }

        $this->migrationContext[$migration->name] = array('context' => $migrationContext);
        $previousUserId = null;
        $steps = array_slice($migrationDefinition->steps->getArrayCopy(), $stepOffset);

        try {

            $i = $stepOffset+1;
            $finalStatus = Migration::STATUS_DONE;
            $finalMessage = null;

            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, $migrationContext);

                    // 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();
            } 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();
            }

            // in case we have an exception thrown in the commit phase after the last step, make sure we report the correct step
            $i--;

            // set migration as done
            $this->storageHandler->endMigration(new Migration(
                $migration->name,
                $migration->md5,
                $migration->path,
                $migration->executionDate,
                $finalStatus,
                $finalMessage
            ));

            if ($useTransaction) {
                // there might be workflows or other actions happening at commit time that fail if we are not admin
                $previousUserId = $this->loginUser($this->getAdminUserIdentifier($adminLogin));

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

        } catch (\Exception $e) {

            $errorMessage = $this->getFullExceptionMessage($e) . ' in file ' . $e->getFile() . ' line ' . $e->getLine();
            $finalStatus = Migration::STATUS_FAILED;
            $exception = null;

            if ($useTransaction) {
                try {
                    // cater to the case where the $this->repository->commit() call above throws an exception
                    if ($previousUserId) {
                        $this->loginUser($previousUserId);
                    }

                    // there is no need to become admin here, at least in theory
                    $this->repository->rollBack();

                } catch (\Exception $e2) {
                    // This check is not rock-solid, but at the moment is all we can do to tell apart 2 cases of
                    // exceptions originating above: 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 ($previousUserId && $e2->getMessage() == 'There is no active transaction.') {
                        // since the migration succeeded and it was committed, no use to mark it as failed...
                        $finalStatus = Migration::STATUS_DONE;
                        $errorMessage = 'An exception was thrown after committing, in file ' .
                            $e->getFile() . ' line ' . $e->getLine() . ': ' . $this->getFullExceptionMessage($e);
                        $exception = new AfterMigrationExecutionException($errorMessage, $i, $e);
                    } else {
                        $errorMessage .= '. In addition, an exception was thrown while rolling back, in file ' .
                            $e2->getFile() . ' line ' . $e2->getLine() . ': ' . $this->getFullExceptionMessage($e2);
                    }
                }
            }

            // set migration as failed
            // NB: we use the 'force' flag here because we might be catching an exception happened during the call to
            // $this->repository->commit() above, in which case the Migration might already be in the DB with a status 'done'
            $this->storageHandler->endMigration(
                new Migration(
                    $migration->name,
                    $migration->md5,
                    $migration->path,
                    $migration->executionDate,
                    $finalStatus,
                    $errorMessage
                ),
                true
            );

            throw $exception ? $exception : new MigrationStepExecutionException($errorMessage, $i, $e);
        }
    }