ProcessExecutor::execute() - Code Metrics - Inspection of "[WIP] prepare bash script loading" - shopwareLabs/psh - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#82)

by Jan Philipp

created 2019-02-07 21:37 UTC

ProcessExecutor::execute() A

↳ Parent: ProcessExecutor

Complexity

Conditions	2
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	16
rs	9.7333
c	0
b	0
f	0
cc	2
nc	3
nop	2

<?php declare(strict_types=1);


namespace Shopware\Psh\ScriptRuntime\Execution;

use Shopware\Psh\Listing\Script;
use Shopware\Psh\ScriptRuntime\BashCommand;
use Shopware\Psh\ScriptRuntime\Command;
use Shopware\Psh\ScriptRuntime\DeferredProcessCommand;
use Shopware\Psh\ScriptRuntime\ProcessCommand;
use Shopware\Psh\ScriptRuntime\SynchronusProcessCommand;
use Shopware\Psh\ScriptRuntime\TemplateCommand;
use Shopware\Psh\ScriptRuntime\WaitCommand;
use Symfony\Component\Process\Process;

/**
 * Execute a command in a separate process
 */
class ProcessExecutor
{
    /**
     * @var ProcessEnvironment
     */
    private $environment;

    /**
     * @var TemplateEngine
     */
    private $templateEngine;

    /**
     * @var Logger
     */
    private $logger;

    /**
     * @var string
     */
    private $applicationDirectory;

    /**
     * @var DeferredProcess[]
     */
    private $deferredProcesses = [];

    /**
     * ProcessExecutor constructor.
     * @param ProcessEnvironment $environment
     * @param TemplateEngine $templateEngine
     * @param Logger $logger
     * @param string $applicationDirectory
     */
    public function __construct(
        ProcessEnvironment $environment,
        TemplateEngine $templateEngine,
        Logger $logger,
        string $applicationDirectory
    ) {
        $this->environment = $environment;
        $this->templateEngine = $templateEngine;
        $this->logger = $logger;
        $this->applicationDirectory = $applicationDirectory;
    }

    /**
     * @param Script $script
     * @param Command[] $commands
     */
    public function execute(Script $script, array $commands)
    {
        $this->logger->startScript($script);

        $this->executeTemplateRendering();

        try {
            foreach ($commands as $index => $command) {
                $this->executeCommand($command, $index, count($commands));
            }
        } finally {
            $this->waitForDeferredProcesses();
        }

        $this->logger->finishScript($script);
    }

    /**
     * @param Command $command
     * @param int $index
     * @param int $totalCount
     */
    private function executeCommand(Command $command, int $index, int $totalCount)
    {
        switch ($command) {
            case $command instanceof BashCommand:
                $originalContent = file_get_contents($command->getScript()->getPath());
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

                try {
                    file_put_contents($command->getScript()->getPath(), $this->templateEngine->render($originalContent, $this->environment->getAllValues()));
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

                    $process = $this->environment->createProcess($command->getScript()->getPath());
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                    $this->setProcessDefaults($process, false);

                    $this->logger->logStart(
                        'Executing',
                        $command->getScript()->getPath(),
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                        $command->getLineNumber(),
                        false,
                        $index,
                        $totalCount
                    );

                    $this->runProcess($process);
                    $this->testProcessResultValid($process, false);
                } finally {
                    file_put_contents($command->getScript()->getPath(), $originalContent);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                }


                break;
            case $command instanceof SynchronusProcessCommand:

                $parsedCommand = $this->getParsedShellCommand($command);

                $process = $this->environment->createProcess($parsedCommand);
                $this->setProcessDefaults($process, $command->isTTy());
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

                $this->logger->logStart(
                    'Starting',
                    $parsedCommand,
                    $command->getLineNumber(),
                    $command->isIgnoreError(),
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                    $index,
                    $totalCount
                );

                $this->runProcess($process);
                $this->testProcessResultValid($process, $command->isIgnoreError());
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

                break;


            case $command instanceof DeferredProcessCommand:

                $parsedCommand = $this->getParsedShellCommand($command);

                $process = $this->environment->createProcess($parsedCommand);
                $this->setProcessDefaults($process, $command->isTTy());
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

                $this->logger->logStart(
                    'Defering',
                    $parsedCommand,
                    $command->getLineNumber(),
                    $command->isIgnoreError(),
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                    $index,
                    $totalCount
                );
                $this->deferProcess($parsedCommand, $command, $process);


                break;


            case $command instanceof TemplateCommand:
                    $template = $command->createTemplate();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

                $this->logger->logStart(
                    'Template',
                    $template->getDestination(),
                    $command->getLineNumber(),
                    false,
                    $index,
                    $totalCount
                );

                $this->renderTemplate($template);
                break;

            case $command instanceof WaitCommand:
                $this->logger->logStart(
                    'Waiting',
                    '',
                    $command->getLineNumber(),
                    false,
                    $index,
                    $totalCount
                );

                $this->waitForDeferredProcesses();
                break;
        }
    }

    private function executeTemplateRendering()
    {
        foreach ($this->environment->getTemplates() as $template) {
            $this->renderTemplate($template);
        }
    }

    /**
     * @param ProcessCommand $command
     * @return string
     */
    protected function getParsedShellCommand(ProcessCommand $command): string
    {
        $rawShellCommand = $command->getShellCommand();

        $parsedCommand = $this->templateEngine->render(
            $rawShellCommand,
            $this->environment->getAllValues()
        );

        return $parsedCommand;
    }

    /**
     * @param Process $process
     * @param bool $isTty
     */
    private function setProcessDefaults(Process $process, bool $isTty)
    {
        $process->setWorkingDirectory($this->applicationDirectory);
        $process->setTimeout(0);
        $process->setTty($isTty);
    }

    /**
     * @param Process $process
     */
    private function runProcess(Process $process)
    {
        $process->run(function ($type, $response) {
            $this->logger->log(new LogMessage($response, $type === Process::ERR));
        });
    }

    /**
     * @param Process $process
     * @param bool $ignoreError
     */
    protected function testProcessResultValid(Process $process, bool $ignoreError)
    {
        if (!$this->isProcessResultValid($process, $ignoreError)) {
            throw new ExecutionErrorException('Command exited with Error');
        }
    }

    /**
     * @param $template
     */
    private function renderTemplate(Template $template)
    {
        $renderedTemplateDestination = $this->templateEngine
            ->render($template->getDestination(), $this->environment->getAllValues());

        $template->setDestination($renderedTemplateDestination);

        $renderedTemplateContent = $this->templateEngine
            ->render($template->getContent(), $this->environment->getAllValues());

        $template->setContents($renderedTemplateContent);
    }

    private function waitForDeferredProcesses()
    {
        if (count($this->deferredProcesses) === 0) {
            return;
        }

        $this->logger->logWait();

        foreach ($this->deferredProcesses as $index => $deferredProcess) {
            $deferredProcess->getProcess()->wait();

            $this->logger->logStart(
                'Output from',
                $deferredProcess->getParsedCommand(),
                $deferredProcess->getCommand()->getLineNumber(),
                $deferredProcess->getCommand()->isIgnoreError(),
                $index,
                count($this->deferredProcesses)
            );

            foreach ($deferredProcess->getLog() as $logMessage) {
                $this->logger->log($logMessage);
            }

            if ($this->isProcessResultValid($deferredProcess->getProcess(), $deferredProcess->getCommand()->isIgnoreError())) {
                $this->logger->logSuccess();
            } else {
                $this->logger->logFailure();
            }
        }

        foreach ($this->deferredProcesses as $deferredProcess) {
            $this->testProcessResultValid($deferredProcess->getProcess(), $deferredProcess->getCommand()->isIgnoreError());
        }

        $this->deferredProcesses = [];
    }

    /**
     * @param string $parsedCommand
     * @param DeferredProcessCommand $command
     * @param Process $process
     */
    private function deferProcess(string $parsedCommand, DeferredProcessCommand $command, Process $process)
    {
        $deferredProcess = new DeferredProcess($parsedCommand, $command, $process);

        $process->start(function ($type, $response) use ($deferredProcess) {
            $deferredProcess->log(new LogMessage($response, $type === Process::ERR));
        });

        $this->deferredProcesses[] = $deferredProcess;
    }

    /**
     * @param Process $process
     * @param bool $ignoreError
     * @return bool
     */
    protected function isProcessResultValid(Process $process, bool $ignoreError): bool
    {
        return $ignoreError || $process->isSuccessful();
    }
}


Pull Request — master (#82)

ProcessExecutor::execute() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php declare(strict_types=1);
2
3
4			namespace Shopware\Psh\ScriptRuntime\Execution;
5
6			use Shopware\Psh\Listing\Script;
7			use Shopware\Psh\ScriptRuntime\BashCommand;
8			use Shopware\Psh\ScriptRuntime\Command;
9			use Shopware\Psh\ScriptRuntime\DeferredProcessCommand;
10			use Shopware\Psh\ScriptRuntime\ProcessCommand;
11			use Shopware\Psh\ScriptRuntime\SynchronusProcessCommand;
12			use Shopware\Psh\ScriptRuntime\TemplateCommand;
13			use Shopware\Psh\ScriptRuntime\WaitCommand;
14			use Symfony\Component\Process\Process;
15
16			/**
17			* Execute a command in a separate process
18			*/
19			class ProcessExecutor
20			{
21			/**
22			* @var ProcessEnvironment
23			*/
24			private $environment;
25
26			/**
27			* @var TemplateEngine
28			*/
29			private $templateEngine;
30
31			/**
32			* @var Logger
33			*/
34			private $logger;
35
36			/**
37			* @var string
38			*/
39			private $applicationDirectory;
40

shopwareLabs / psh

Pull Request — master (#82)

ProcessExecutor::execute() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like