ParallelExec::run() - Code Metrics - consolidation/robo - Measure and Improve Code Quality continuously with Scrutinizer

ParallelExec::run() C
last analyzed 2020-08-27 17:44 UTC

↳ Parent: ParallelExec

Complexity

Conditions	14
Paths	222

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	56
rs	5.1583
c	0
b	0
f	0
cc	14
nc	222
nop	0

How to fix Long Method Complexity

<?php

namespace Robo\Task\Base;

use Robo\Contract\CommandInterface;
use Robo\Contract\PrintedInterface;
use Robo\Result;
use Robo\Task\BaseTask;
use Symfony\Component\Process\Exception\ProcessTimedOutException;
use Symfony\Component\Process\Process;

/**
 * Class ParallelExecTask
 *
 * ``` php
 * <?php
 * $this->taskParallelExec()
 *   ->process('php ~/demos/script.php hey')
 *   ->process('php ~/demos/script.php hoy')
 *   ->process('php ~/demos/script.php gou')
 *   ->run();
 * ?>
 * ```
 */
class ParallelExec extends BaseTask implements CommandInterface, PrintedInterface
{
    use \Robo\Common\CommandReceiver;

    /**
     * @var Process[]
     */
    protected $processes = [];

    /**
     * @var null|int
     */
    protected $timeout = null;

    /**
     * @var null|int
     */
    protected $idleTimeout = null;

    /**
     * @var null|int
     */
    protected $waitInterval = 0;

    /**
     * @var bool
     */
    protected $isPrinted = false;

    /**
     * {@inheritdoc}
     */
    public function getPrinted()
    {
        return $this->isPrinted;
    }

    /**
     * @param bool $isPrinted
     *
     * @return $this
     */
    public function printed($isPrinted = true)
    {
        $this->isPrinted = $isPrinted;
        return $this;
    }

    /**
     * @param string|\Robo\Contract\CommandInterface $command
     *
     * @return $this
     */
    public function process($command)
    {
        // TODO: Symfony 4 requires that we supply the working directory.
        $this->processes[] = Process::fromShellCommandline($this->receiveCommand($command), getcwd());
        return $this;
    }

    /**
     * Stops process if it runs longer then `$timeout` (seconds).
     *
     * @param int $timeout
     *
     * @return $this
     */
    public function timeout($timeout)
    {
        $this->timeout = $timeout;
        return $this;
    }

    /**
     * Stops process if it does not output for time longer then `$timeout` (seconds).
     *
     * @param int $idleTimeout
     *
     * @return $this
     */
    public function idleTimeout($idleTimeout)
    {
        $this->idleTimeout = $idleTimeout;
        return $this;
    }

    /**
     * Parallel processing will wait `$waitInterval` seconds after launching each process and before
     * the next one.
     *
     * @param int $waitInterval
     *
     * @return $this
     */
    public function waitInterval($waitInterval)
    {
        $this->waitInterval = $waitInterval;
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getCommand()
    {
        return implode(' && ', $this->processes);
    }

    /**
     * @return int
     */
    public function progressIndicatorSteps()
    {
        return count($this->processes);
    }

    /**
     * {@inheritdoc}
     */
    public function run()
    {
        $this->startProgressIndicator();
        $running = [];
        $queue = $this->processes;
        $nextTime = time();
        while (true) {
            if (($nextTime <= time()) && !empty($queue)) {
                $process = array_shift($queue);
                $process->setIdleTimeout($this->idleTimeout);
                $process->setTimeout($this->timeout);
                $process->start();
                $this->printTaskInfo($process->getCommandLine());
                $running[] = $process;
                $nextTime = time() + $this->waitInterval;
            }
            foreach ($running as $k => $process) {
                try {
                    $process->checkTimeout();
                } catch (ProcessTimedOutException $e) {
                    $this->printTaskWarning("Process timed out for {command}", ['command' => $process->getCommandLine(), '_style' => ['command' => 'fg=white;bg=magenta']]);
                }
                if (!$process->isRunning()) {
                    $this->advanceProgressIndicator();
                    if ($this->isPrinted) {
                        $this->printTaskInfo("Output for {command}:\n\n{output}", ['command' => $process->getCommandLine(), 'output' => $process->getOutput(), '_style' => ['command' => 'fg=white;bg=magenta']]);
                        $errorOutput = $process->getErrorOutput();
                        if ($errorOutput) {
                            $this->printTaskError(rtrim($errorOutput));
                        }
                    }
                    unset($running[$k]);
                }
            }
            if (empty($running) && empty($queue)) {
                break;
            }
            usleep(1000);
        }
        $this->stopProgressIndicator();

        $errorMessage = '';
        $exitCode = 0;
        foreach ($this->processes as $p) {
            if ($p->getExitCode() === 0) {
                continue;
            }
            $errorMessage .= "'" . $p->getCommandLine() . "' exited with code " . $p->getExitCode() . " \n";
            $exitCode = max($exitCode, $p->getExitCode());
        }
        if (!$errorMessage) {
            $this->printTaskSuccess('{process-count} processes finished running', ['process-count' => count($this->processes)]);
        }

        return new Result($this, $exitCode, $errorMessage, ['time' => $this->getExecutionTime()]);
    }
}


1			<?php
2
3			namespace Robo\Task\Base;
4
5			use Robo\Contract\CommandInterface;
6			use Robo\Contract\PrintedInterface;
7			use Robo\Result;
8			use Robo\Task\BaseTask;
9			use Symfony\Component\Process\Exception\ProcessTimedOutException;
10			use Symfony\Component\Process\Process;
11
12			/**
13			* Class ParallelExecTask
14			*
15			* ``` php
16			* <?php
17			* $this->taskParallelExec()
18			* ->process('php ~/demos/script.php hey')
19			* ->process('php ~/demos/script.php hoy')
20			* ->process('php ~/demos/script.php gou')
21			* ->run();
22			* ?>
23			* ```
24			*/
25			class ParallelExec extends BaseTask implements CommandInterface, PrintedInterface
26			{
27			use \Robo\Common\CommandReceiver;
28
29			/**
30			* @var Process[]
31			*/
32			protected $processes = [];
33
34			/**
35			* @var null\|int
36			*/
37			protected $timeout = null;
38
39			/**
40			* @var null\|int
41			*/
42			protected $idleTimeout = null;
43
44			/**
45			* @var null\|int
46			*/
47			protected $waitInterval = 0;
48
49			/**
50			* @var bool
51			*/
52			protected $isPrinted = false;
53
54			/**
55			* {@inheritdoc}
56			*/
57			public function getPrinted()
58			{
59			return $this->isPrinted;
60			}
61
62			/**
63			* @param bool $isPrinted
64			*
65			* @return $this
66			*/
67			public function printed($isPrinted = true)
68			{
69			$this->isPrinted = $isPrinted;
70			return $this;
71			}
72
73			/**
74			* @param string\|\Robo\Contract\CommandInterface $command
75			*
76			* @return $this
77			*/
78			public function process($command)
79			{
80			// TODO: Symfony 4 requires that we supply the working directory.
81			$this->processes[] = Process::fromShellCommandline($this->receiveCommand($command), getcwd());
82			return $this;
83			}
84
85			/**
86			* Stops process if it runs longer then `$timeout` (seconds).
87			*
88			* @param int $timeout
89			*
90			* @return $this
91			*/
92			public function timeout($timeout)
93			{
94			$this->timeout = $timeout;
95			return $this;
96			}
97
98			/**
99			* Stops process if it does not output for time longer then `$timeout` (seconds).
100			*
101			* @param int $idleTimeout
102			*
103			* @return $this
104			*/
105			public function idleTimeout($idleTimeout)
106			{
107			$this->idleTimeout = $idleTimeout;
108			return $this;
109			}
110
111			/**
112			* Parallel processing will wait `$waitInterval` seconds after launching each process and before
113			* the next one.
114			*
115			* @param int $waitInterval
116			*
117			* @return $this
118			*/
119			public function waitInterval($waitInterval)
120			{
121			$this->waitInterval = $waitInterval;
122			return $this;
123			}
124
125			/**
126			* {@inheritdoc}
127			*/
128			public function getCommand()
129			{
130			return implode(' && ', $this->processes);
131			}
132
133			/**
134			* @return int
135			*/
136			public function progressIndicatorSteps()
137			{
138			return count($this->processes);
139			}
140
141			/**
142			* {@inheritdoc}
143			*/
144			public function run()
145			{
146			$this->startProgressIndicator();
147			$running = [];
148			$queue = $this->processes;
149			$nextTime = time();
150			while (true) {
151			if (($nextTime <= time()) && !empty($queue)) {
152			$process = array_shift($queue);
153			$process->setIdleTimeout($this->idleTimeout);
154			$process->setTimeout($this->timeout);
155			$process->start();
156			$this->printTaskInfo($process->getCommandLine());
157			$running[] = $process;
158			$nextTime = time() + $this->waitInterval;
159			}
160			foreach ($running as $k => $process) {
161			try {
162			$process->checkTimeout();
163			} catch (ProcessTimedOutException $e) {
164			$this->printTaskWarning("Process timed out for {command}", ['command' => $process->getCommandLine(), '_style' => ['command' => 'fg=white;bg=magenta']]);
165			}
166			if (!$process->isRunning()) {
167			$this->advanceProgressIndicator();
168			if ($this->isPrinted) {
169			$this->printTaskInfo("Output for {command}:\n\n{output}", ['command' => $process->getCommandLine(), 'output' => $process->getOutput(), '_style' => ['command' => 'fg=white;bg=magenta']]);
170			$errorOutput = $process->getErrorOutput();
171			if ($errorOutput) {
172			$this->printTaskError(rtrim($errorOutput));
173			}
174			}
175			unset($running[$k]);
176			}
177			}
178			if (empty($running) && empty($queue)) {
179			break;
180			}
181			usleep(1000);
182			}
183			$this->stopProgressIndicator();
184
185			$errorMessage = '';
186			$exitCode = 0;
187			foreach ($this->processes as $p) {
188			if ($p->getExitCode() === 0) {
189			continue;
190			}
191			$errorMessage .= "'" . $p->getCommandLine() . "' exited with code " . $p->getExitCode() . " \n";
192			$exitCode = max($exitCode, $p->getExitCode());
193			}
194			if (!$errorMessage) {
195			$this->printTaskSuccess('{process-count} processes finished running', ['process-count' => count($this->processes)]);
196			}
197
198			return new Result($this, $exitCode, $errorMessage, ['time' => $this->getExecutionTime()]);
199			}
200			}
201

consolidation / robo

ParallelExec::run() C last analyzed 2020-08-27 17:44 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

ParallelExec::run() C
last analyzed 2020-08-27 17:44 UTC