Kaliop\eZMigrationBundle\Core\Executor\ProcessExecutor

Complexity

Total Complexity

23

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Test Coverage

Coverage

86.44%

Importance

Changes	3
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	run()	0	53	11
A	execute()	0	17	3
B	setReferences()	0	30	8
A	__construct()	0	3	1

<?php

namespace Kaliop\eZMigrationBundle\Core\Executor;

use Kaliop\eZMigrationBundle\API\Exception\InvalidStepDefinitionException;
use Kaliop\eZMigrationBundle\API\Exception\MigrationBundleException;
use Kaliop\eZMigrationBundle\API\ReferenceResolverBagInterface;
use Kaliop\eZMigrationBundle\API\Value\MigrationStep;
use Kaliop\eZMigrationBundle\Core\Process\ProcessBuilder;
use Symfony\Component\Process\Process;

/**
 * @property ReferenceResolverBagInterface $referenceResolver
 */
class ProcessExecutor extends AbstractExecutor
{
    use IgnorableStepExecutorTrait;

The trait Kaliop\eZMigrationBundle\Core\Executor\IgnorableStepExecutorTrait requires the property $dsl which is not provided by Kaliop\eZMigrationBundle\Core\Executor\ProcessExecutor.

    use ReferenceSetterTrait;

    protected $supportedStepTypes = array('process');
    protected $supportedActions = array('run');

    protected $defaultTimeout = 86400;

    /**
     * @param ReferenceResolverBagInterface $referenceResolver
     */
    public function __construct(ReferenceResolverBagInterface $referenceResolver)
    {
        $this->referenceResolver = $referenceResolver;
    }

    /**
     * @param MigrationStep $step
     * @return mixed
     * @throws \Exception
     */
    public function execute(MigrationStep $step)
    {
        parent::execute($step);

        if (!isset($step->dsl['mode'])) {
            throw new InvalidStepDefinitionException("Invalid step definition: missing 'mode'");
        }

        $action = $step->dsl['mode'];

        if (!in_array($action, $this->supportedActions)) {
            throw new InvalidStepDefinitionException("Invalid step definition: value '$action' is not allowed for 'mode'");
        }

        $this->skipStepIfNeeded($step);

        return $this->$action($step->dsl, $step->context);
    }

    /**
     * @param $dsl
     * @param array|null $context
     * @return \Symfony\Component\Process\Process
     * @throws \Exception
     * @todo add more options supported by Sf Process
     */
    protected function run($dsl, $context)
    {
        if (!isset($dsl['command'])) {
            throw new InvalidStepDefinitionException("Can not run process: command missing");
        }

        $builder = new ProcessBuilder();

        // mandatory args and options
        $builderArgs = array($this->resolveReference($dsl['command']));

        if (isset($dsl['arguments'])) {
            foreach ($dsl['arguments'] as $arg) {
                /// @todo should this be recursive?
                $builderArgs[] = $this->resolveReference($arg);
            }
        }

        $process = $builder
            ->setArguments($builderArgs)
            ->getProcess();

        // allow long migrations processes by default
        $timeout = $this->defaultTimeout;
        if (isset($dsl['timeout'])) {
            $timeout = $this->resolveReference($dsl['timeout']);
        }
        $process->setTimeout($timeout);

        if (isset($dsl['working_directory'])) {
            $process->setWorkingDirectory($this->resolveReference($dsl['working_directory']));
        }

        /// @todo should we support false/true ?
        if (isset($dsl['disable_output'])) {
            $process->disableOutput();

The method disableOutput() does not exist on Kaliop\eZMigrationBundle\Core\Process\Process.

        }

        if (isset($dsl['environment'])) {
            $process->setEnv($this->resolveReference($dsl['environment']));
        }

        $process->run();

        if (isset($dsl['fail_on_error']) && $this->resolveReference($dsl['fail_on_error'])) {
            if (($exitCode = $process->getExitCode()) != 0) {

It seems like you are loosely comparing $exitCode = $process->getExitCode() of type integer|null to 0; this is ambiguous as not only 0 == 0 is true, but null == 0 is true, too. Consider using a strict comparison ===.

                throw new MigrationBundleException("Process failed with exit code: $exitCode", $exitCode);
            }
        }

        $this->setReferences($process, $dsl);

        return $process;
    }

    /**
     * @param Process $process
     * @param $dsl
     * @return bool
     * @throws InvalidStepDefinitionException
     */
    protected function setReferences(Process $process, $dsl)
    {
        if (!array_key_exists('references', $dsl) || !count($dsl['references'])) {
            return false;
        }

        foreach ($dsl['references'] as $key => $reference) {
            $reference = $this->parseReferenceDefinition($key, $reference);
            switch ($reference['attribute']) {
                case 'error_output':
                    $value = rtrim($process->getErrorOutput(), "\r\n");
                    break;
                case 'exit_code':
                    $value = $process->getExitCode();
                    break;
                case 'output':
                    $value = rtrim($process->getOutput(), "\r\n");
                    break;
                default:
                    throw new InvalidStepDefinitionException('Process executor does not support setting references for attribute ' . $reference['attribute']);
            }

            $overwrite = false;
            if (isset($reference['overwrite'])) {
                $overwrite = $reference['overwrite'];
            }
            $this->addReference($reference['identifier'], $value, $overwrite);
        }

        return true;
    }
}