Worker::setExitCode() - Code Metrics - Inspection of "Change unit test assertion depending on the versio..." - brianium/paratest - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#204)

unknown

created 2016-05-08 17:11 UTC

Worker::setExitCode() A

↳ Parent: Worker

Complexity

Conditions	3
Paths	3

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	3

Metric	Value
dl	0
loc	8
ccs	7
cts	7
cp	1
rs	9.4285
cc	3
eloc	4
nc	3
nop	1
crap	3

<?php
namespace ParaTest\Runners\PHPUnit;

use Exception;

class Worker
{
    private static $descriptorspec = array(
       0 => array("pipe", "r"),
       1 => array("pipe", "w"),
       2 => array("pipe", "w")
    );
    private $proc;
    private $pipes;
    private $inExecution = 0;
    private $isRunning = false;
    private $exitCode = null;
    private $commands = array();
    private $chunks = '';
    private $alreadyReadOutput = '';
    /**
     * @var ExecutableTest
     */
    private $currentlyExecuting;

    public function start($wrapperBinary, $token = 1, $uniqueToken = null)
    {
        $bin = 'PARATEST=1 ';
        if (is_numeric($token)) {
            $bin .= "TEST_TOKEN=$token ";
        }
        if ($uniqueToken) {
            $bin .= "UNIQUE_TEST_TOKEN=$uniqueToken ";
        }
        $bin .= "exec \"$wrapperBinary\"";
        $pipes = array();
        $this->proc = proc_open($bin, self::$descriptorspec, $pipes);
        $this->pipes = $pipes;
        $this->isRunning = true;
    }

    public function stdout()
    {
        return $this->pipes[1];
    }

    public function execute($testCmd)
    {
        $this->checkStarted();
        $this->commands[] = $testCmd;
        fwrite($this->pipes[0], $testCmd . "\n");
        $this->inExecution++;
    }

    public function assign(ExecutableTest $test, $phpunit, $phpunitOptions)
    {
        if ($this->currentlyExecuting !== null) {
            throw new Exception("Worker already has a test assigned - did you forget to call reset()?");
        }
        $this->currentlyExecuting = $test;
        $this->execute($test->command($phpunit, $phpunitOptions));
    }

    public function printFeedback($printer)
    {
        if ($this->currentlyExecuting !== null) {
            $printer->printFeedback($this->currentlyExecuting);
        }
    }

    public function reset()
    {
        $this->currentlyExecuting = null;
    }

    public function isStarted()
    {
        return $this->proc !== null && $this->pipes !== null;
    }

    private function checkStarted()
    {
        if (!$this->isStarted()) {
            throw new \RuntimeException("You have to start the Worker first!");
        }
    }

    public function stop()
    {
        fwrite($this->pipes[0], "EXIT\n");
        fclose($this->pipes[0]);
    }

    /**
     * This is an utility function for tests.
     * Refactor or write it only in the test case.
     */
    public function waitForFinishedJob()
    {
        if ($this->inExecution == 0) {
            return;
        }
        $tellsUsItHasFinished = false;
        stream_set_blocking($this->pipes[1], 1);
        while ($line = fgets($this->pipes[1])) {
            if (strstr($line, "FINISHED\n")) {
                $tellsUsItHasFinished = true;
                $this->inExecution--;
                break;
            }
        }
        if (!$tellsUsItHasFinished) {
            throw new \RuntimeException("The Worker terminated without finishing the job.");
        }
    }

    public function isFree()
    {
        $this->checkNotCrashed();
        $this->updateStateFromAvailableOutput();
        return $this->inExecution == 0;
    }

    /**
     * @deprecated
     * This function consumes a lot of CPU while waiting for
     * the worker to finish. Use it only in testing paratest
     * itself.
     */
    public function waitForStop()
    {
        $status = proc_get_status($this->proc);
        while ($status['running']) {
            $status = proc_get_status($this->proc);
            $this->setExitCode($status);
        }
    }

    public function getCoverageFileName()
    {
        if ($this->currentlyExecuting !== null) {
            return $this->currentlyExecuting->getCoverageFileName();
        } else {
            return null;
        }
    }

    private function setExitCode($status)
    {
        if (!$status['running']) {
            if ($this->exitCode === null) {
                $this->exitCode = $status['exitcode'];
            }
        }
    }

    public function isRunning()
    {
        $this->checkNotCrashed();
        $this->updateStateFromAvailableOutput();
        return $this->isRunning;
    }

    public function isCrashed()
    {
        if (!$this->isStarted()) {
            return false;
        }
        $status = proc_get_status($this->proc);

        $this->updateStateFromAvailableOutput();
        if (!$this->isRunning) {
            return false;
        }

        $this->setExitCode($status);
        if ($this->exitCode === null) {
            return false;
        }
        return $this->exitCode != 0;
    }

    private function checkNotCrashed()
    {
        if ($this->isCrashed()) {
            throw new \RuntimeException(
                "This worker has crashed. Last executed command: " . end($this->commands) . PHP_EOL
                . "Output:" . PHP_EOL
                . "----------------------" . PHP_EOL
                . $this->alreadyReadOutput . PHP_EOL
                . "----------------------" . PHP_EOL
                . $this->readAllStderr()
            );
        }
    }

    private function readAllStderr()
    {
        return stream_get_contents($this->pipes[2]);
    }

    /**
     * Have to read even incomplete lines to play nice with stream_select()
     * Otherwise it would continue to non-block because there are bytes to be read,
     * but fgets() won't pick them up.
     */
    private function updateStateFromAvailableOutput()
    {
        if (isset($this->pipes[1])) {
            stream_set_blocking($this->pipes[1], 0);
            while ($chunk = fread($this->pipes[1], 4096)) {
                $this->chunks .= $chunk;
                $this->alreadyReadOutput .= $chunk;
            }
            $lines = explode("\n", $this->chunks);
            // last element is not a complete line,
            // becomes part of a line completed later
            $this->chunks = $lines[count($lines) - 1];
            unset($lines[count($lines) - 1]);
            // delivering complete lines to this Worker
            foreach ($lines as $line) {
                $line .= "\n";
                if (strstr($line, "FINISHED\n")) {
                    $this->inExecution--;
                }
                if (strstr($line, "EXITED\n")) {
                    $this->isRunning = false;
                }
            }
            stream_set_blocking($this->pipes[1], 1);
        }
    }
}


1		<?php
2		namespace ParaTest\Runners\PHPUnit;
3
4		use Exception;
5
6		class Worker
7		{
8		private static $descriptorspec = array(
9		0 => array("pipe", "r"),
10		1 => array("pipe", "w"),
11		2 => array("pipe", "w")
12		);
13		private $proc;
14		private $pipes;
15		private $inExecution = 0;
16		private $isRunning = false;
17		private $exitCode = null;
18		private $commands = array();
19		private $chunks = '';
20		private $alreadyReadOutput = '';
21		/**
22		* @var ExecutableTest
23		*/
24		private $currentlyExecuting;
25
26	5	public function start($wrapperBinary, $token = 1, $uniqueToken = null)
27		{
28	5	$bin = 'PARATEST=1 ';
29	5	if (is_numeric($token)) {
30	5	$bin .= "TEST_TOKEN=$token ";
31	5	}
32	5	if ($uniqueToken) {
33		$bin .= "UNIQUE_TEST_TOKEN=$uniqueToken ";
34		}
35	5	$bin .= "exec \"$wrapperBinary\"";
36	5	$pipes = array();
37	5	$this->proc = proc_open($bin, self::$descriptorspec, $pipes);
38	5	$this->pipes = $pipes;
39	5	$this->isRunning = true;
40	5	}
41
42		public function stdout()
43		{
44		return $this->pipes[1];
45		}
46
47	4	public function execute($testCmd)
48		{
49	4	$this->checkStarted();
50	4	$this->commands[] = $testCmd;
51	4	fwrite($this->pipes[0], $testCmd . "\n");
52	4	$this->inExecution++;
53	4	}
54
55		public function assign(ExecutableTest $test, $phpunit, $phpunitOptions)
56		{
57		if ($this->currentlyExecuting !== null) {
58		throw new Exception("Worker already has a test assigned - did you forget to call reset()?");
59		}
60		$this->currentlyExecuting = $test;
61		$this->execute($test->command($phpunit, $phpunitOptions));
62		}
63
64		public function printFeedback($printer)
65		{
66		if ($this->currentlyExecuting !== null) {
67		$printer->printFeedback($this->currentlyExecuting);
68		}
69		}
70
71		public function reset()
72		{
73		$this->currentlyExecuting = null;
74		}
75
76	6	public function isStarted()
77		{
78	6	return $this->proc !== null && $this->pipes !== null;
79		}
80
81	4	private function checkStarted()
82		{
83	4	if (!$this->isStarted()) {
84		throw new \RuntimeException("You have to start the Worker first!");
85		}
86	4	}
87
88	3	public function stop()
89		{
90	3	fwrite($this->pipes[0], "EXIT\n");
91	3	fclose($this->pipes[0]);
92	3	}
93
94		/**
95		* This is an utility function for tests.
96		* Refactor or write it only in the test case.
97		*/
98	2	public function waitForFinishedJob()
99		{
100	2	if ($this->inExecution == 0) {
101		return;
102		}
103	2	$tellsUsItHasFinished = false;
104	2	stream_set_blocking($this->pipes[1], 1);
105	2	while ($line = fgets($this->pipes[1])) {
106	2	if (strstr($line, "FINISHED\n")) {
107	2	$tellsUsItHasFinished = true;
108	2	$this->inExecution--;
109	2	break;
110		}
111	2	}
112	2	if (!$tellsUsItHasFinished) {
113		throw new \RuntimeException("The Worker terminated without finishing the job.");
114		}
115	2	}
116
117	1	public function isFree()
118		{
119	1	$this->checkNotCrashed();
120	1	$this->updateStateFromAvailableOutput();
121	1	return $this->inExecution == 0;
122		}
123
124		/**
125		* @deprecated
126		* This function consumes a lot of CPU while waiting for
127		* the worker to finish. Use it only in testing paratest
128		* itself.
129		*/
130	3	public function waitForStop()
131		{
132	3	$status = proc_get_status($this->proc);
133	3	while ($status['running']) {
134	3	$status = proc_get_status($this->proc);
135	3	$this->setExitCode($status);
136	3	}
137	3	}
138
139		public function getCoverageFileName()
140		{
141		if ($this->currentlyExecuting !== null) {
142		return $this->currentlyExecuting->getCoverageFileName();
143		} else {
144		return null;
145		}
146		}
147
148	4	private function setExitCode($status)
149		{
150	4	if (!$status['running']) {
151	3	if ($this->exitCode === null) {
152	3	$this->exitCode = $status['exitcode'];
153	3	}
154	3	}
155	4	}
156
157	1	public function isRunning()
158		{
159	1	$this->checkNotCrashed();
160	1	$this->updateStateFromAvailableOutput();
161	1	return $this->isRunning;
162		}
163
164	3	public function isCrashed()
165		{
166	3	if (!$this->isStarted()) {
167	1	return false;
168		}
169	3	$status = proc_get_status($this->proc);
170
171	3	$this->updateStateFromAvailableOutput();
172	3	if (!$this->isRunning) {
173	2	return false;
174		}
175
176	2	$this->setExitCode($status);
177	2	if ($this->exitCode === null) {
178	2	return false;
179		}
180		return $this->exitCode != 0;
181		}
182
183	2	private function checkNotCrashed()
184		{
185	2	if ($this->isCrashed()) {
186		throw new \RuntimeException(
187		"This worker has crashed. Last executed command: " . end($this->commands) . PHP_EOL
188		. "Output:" . PHP_EOL
189		. "----------------------" . PHP_EOL
190		. $this->alreadyReadOutput . PHP_EOL
191		. "----------------------" . PHP_EOL
192		. $this->readAllStderr()
193		);
194		}
195	2	}
196
197		private function readAllStderr()
198		{
199		return stream_get_contents($this->pipes[2]);
200		}
201
202		/**
203		* Have to read even incomplete lines to play nice with stream_select()
204		* Otherwise it would continue to non-block because there are bytes to be read,
205		* but fgets() won't pick them up.
206		*/
207	3	private function updateStateFromAvailableOutput()
208		{
209	3	if (isset($this->pipes[1])) {
210	2	stream_set_blocking($this->pipes[1], 0);
211	2	while ($chunk = fread($this->pipes[1], 4096)) {
212	1	$this->chunks .= $chunk;
213	1	$this->alreadyReadOutput .= $chunk;
214	1	}
215	2	$lines = explode("\n", $this->chunks);
216		// last element is not a complete line,
217		// becomes part of a line completed later
218	2	$this->chunks = $lines[count($lines) - 1];
219	2	unset($lines[count($lines) - 1]);
220		// delivering complete lines to this Worker
221	2	foreach ($lines as $line) {
222	1	$line .= "\n";
223	1	if (strstr($line, "FINISHED\n")) {
224		$this->inExecution--;
225		}
226	1	if (strstr($line, "EXITED\n")) {
227	1	$this->isRunning = false;
228	1	}
229	2	}
230	2	stream_set_blocking($this->pipes[1], 1);
231	2	}
232	3	}
233		}
234

brianium / paratest

Pull Request — master (#204)

Worker::setExitCode() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like