Run::isUpdateOnPoll() - Code Metrics - Inspection of "Write all the output from each process to the scre..." - graze/parallel-process - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#12)

by Harry

created 2017-10-06 12:11 UTC

Run::isUpdateOnPoll() A

↳ Parent: Run

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

namespace Graze\ParallelProcess;

use Symfony\Component\Process\Process;

class Run implements RunInterface
{
    const ON_SUCCESS  = 1;
    const ON_FAILURE  = 2;
    const ON_PROGRESS = 3;

    /** @var Process */
    private $process;
    /** @var callable|null */
    private $onSuccess;
    /** @var callable|null */
    private $onFailure;
    /** @var callable|null */
    private $onProgress;
    /** @var callable|null */
    private $onStart;
    /** @var float */
    private $started;
    /** @var bool */
    private $successful = false;
    /** @var bool */
    private $completed = false;
    /** @var string */
    private $last = '';
    /** @var string */
    private $lastType = 'std';
    /** @var bool */
    private $updateOnPoll = true;
    /** @var bool */
    private $updateOnProcessOutput = true;

    /**
     * Run constructor.
     *
     * @param Process       $process
     * @param callable|null $onSuccess  When the process finishes and is successful
     *                                  function (Process $process, float $duration, string $last, string $lastType) :
     *                                  void
     * @param callable|null $onFailure  When the process finishes and failed
     *                                  function (Process $process, float $duration, string $last, string $lastType) :
     *                                  void
     * @param callable|null $onProgress Called every check period or a message is returned from the process
     *                                  function (Process $process, float $duration, string $last, string $lastType) :
     *                                  void
     * @param callable|null $onStart    When the process starts
     *                                  function (Process $process, float $duration, string $last, string $lastType) :
     *                                  void
     */
    public function __construct(

        Process $process,
        callable $onSuccess = null,
        callable $onFailure = null,
        callable $onProgress = null,
        callable $onStart = null
    ) {
        $this->process = $process;
        $this->onSuccess = $onSuccess;
        $this->onFailure = $onFailure;
        $this->onProgress = $onProgress;
        $this->onStart = $onStart;
    }

    /**
     * Start the process
     *
     * @return $this
     */
    public function start()
    {
        if (!$this->process->isRunning()) {
            $this->started = microtime(true);
            $this->update($this->onStart);
            $this->process->start(
                function ($type, $data) {
                    $this->lastType = $type;
                    $this->last = rtrim($data);
                    if ($this->updateOnProcessOutput) {
                        $this->update($this->onProgress);
                    }
                }
            );
            $this->completed = false;
        }

        return $this;
    }

    /**
     * Poll the process to see if it is still running, and trigger events
     *
     * @return bool true if the process is currently running (started and not terminated)
     */
    public function poll()
    {
        if ($this->completed || !$this->hasStarted()) {
            return false;
        }

        if ($this->process->isRunning()) {
            if ($this->updateOnPoll) {
                $this->update($this->onProgress);
            }
            return true;
        }

        $this->completed = true;

        if ($this->process->isSuccessful()) {
            $this->successful = true;
            $this->update($this->onSuccess);
        } else {
            $this->update($this->onFailure);
        }
        return false;
    }

    /**
     * Return if the underlying process is running
     *
     * @return bool
     */
    public function isRunning()
    {
        return $this->process->isRunning();
    }

    /**
     * Call an event callback
     *
     * @param callable|null $func
     */
    protected function update($func)
    {
        if (!is_null($func)) {
            call_user_func(
                $func,
                $this->process,
                microtime(true) - $this->started,
                $this->last,
                $this->lastType
            );
        }
    }

    /**
     * @return bool
     */
    public function isSuccessful()
    {
        return $this->successful;
    }

    /**
     * @return bool
     */
    public function hasStarted()
    {
        return $this->process->isStarted();
    }

    /**
     * @return Process
     */
    public function getProcess()
    {
        return $this->process;
    }

    /**
     * @param bool $updateOnPoll
     *
     * @return $this
     */
    public function setUpdateOnPoll($updateOnPoll)
    {
        $this->updateOnPoll = $updateOnPoll;
        return $this;
    }

    /**
     * @return bool
     */
    public function isUpdateOnPoll()
    {
        return $this->updateOnPoll;
    }

    /**
     * @param bool $updateOnProcessOutput
     *
     * @return $this
     */
    public function setUpdateOnProcessOutput($updateOnProcessOutput)

    {
        $this->updateOnProcessOutput = $updateOnProcessOutput;
        return $this;
    }

    /**
     * @return bool
     */
    public function isUpdateOnProcessOutput()
    {
        return $this->updateOnProcessOutput;
    }
}


1			<?php
2
3			namespace Graze\ParallelProcess;
4
5			use Symfony\Component\Process\Process;
6
7			class Run implements RunInterface
8			{
9			const ON_SUCCESS = 1;
10			const ON_FAILURE = 2;
11			const ON_PROGRESS = 3;
12
13			/** @var Process */
14			private $process;
15			/** @var callable\|null */
16			private $onSuccess;
17			/** @var callable\|null */
18			private $onFailure;
19			/** @var callable\|null */
20			private $onProgress;
21			/** @var callable\|null */
22			private $onStart;
23			/** @var float */
24			private $started;
25			/** @var bool */
26			private $successful = false;
27			/** @var bool */
28			private $completed = false;
29			/** @var string */
30			private $last = '';
31			/** @var string */
32			private $lastType = 'std';
33			/** @var bool */
34			private $updateOnPoll = true;
35			/** @var bool */
36			private $updateOnProcessOutput = true;
37
38			/**
39			* Run constructor.
40			*
41			* @param Process $process
42			* @param callable\|null $onSuccess When the process finishes and is successful
43			* function (Process $process, float $duration, string $last, string $lastType) :
44			* void
45			* @param callable\|null $onFailure When the process finishes and failed
46			* function (Process $process, float $duration, string $last, string $lastType) :
47			* void
48			* @param callable\|null $onProgress Called every check period or a message is returned from the process
49			* function (Process $process, float $duration, string $last, string $lastType) :
50			* void
51			* @param callable\|null $onStart When the process starts
52			* function (Process $process, float $duration, string $last, string $lastType) :
53			* void
54			*/
55	43	View Code Duplication	public function __construct(
			0 ignored issues – show Duplication introduced 2017-10-06 11:26 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
56			Process $process,
57			callable $onSuccess = null,
58			callable $onFailure = null,
59			callable $onProgress = null,
60			callable $onStart = null
61			) {
62	43		$this->process = $process;
63	43		$this->onSuccess = $onSuccess;
64	43		$this->onFailure = $onFailure;
65	43		$this->onProgress = $onProgress;
66	43		$this->onStart = $onStart;
67	43		}
68
69			/**
70			* Start the process
71			*
72			* @return $this
73			*/
74	36		public function start()
75			{
76	36		if (!$this->process->isRunning()) {
77	35		$this->started = microtime(true);
78	35		$this->update($this->onStart);
79	35		$this->process->start(
80	18		function ($type, $data) {
81	18		$this->lastType = $type;
82	18		$this->last = rtrim($data);
83	18		if ($this->updateOnProcessOutput) {
84	7		$this->update($this->onProgress);
85	7		}
86	18		}
87	35		);
88	35		$this->completed = false;
89	35		}
90
91	36		return $this;
92			}
93
94			/**
95			* Poll the process to see if it is still running, and trigger events
96			*
97			* @return bool true if the process is currently running (started and not terminated)
98			*/
99	33		public function poll()
100			{
101	33		if ($this->completed \|\| !$this->hasStarted()) {
102	1		return false;
103			}
104
105	32		if ($this->process->isRunning()) {
106	24		if ($this->updateOnPoll) {
107	17		$this->update($this->onProgress);
108	17		}
109	24		return true;
110			}
111
112	32		$this->completed = true;
113
114	32		if ($this->process->isSuccessful()) {
115	23		$this->successful = true;
116	23		$this->update($this->onSuccess);
117	23		} else {
118	10		$this->update($this->onFailure);
119			}
120	32		return false;
121			}
122
123			/**
124			* Return if the underlying process is running
125			*
126			* @return bool
127			*/
128	32		public function isRunning()
129			{
130	32		return $this->process->isRunning();
131			}
132
133			/**
134			* Call an event callback
135			*
136			* @param callable\|null $func
137			*/
138	35		protected function update($func)
139			{
140	35		if (!is_null($func)) {
141	29		call_user_func(
142	29		$func,
143	29		$this->process,
144	29		microtime(true) - $this->started,
145	29		$this->last,
146	29		$this->lastType
147	29		);
148	29		}
149	35		}
150
151			/**
152			* @return bool
153			*/
154	28		public function isSuccessful()
155			{
156	28		return $this->successful;
157			}
158
159			/**
160			* @return bool
161			*/
162	36		public function hasStarted()
163			{
164	36		return $this->process->isStarted();
165			}
166
167			/**
168			* @return Process
169			*/
170	3		public function getProcess()
171			{
172	3		return $this->process;
173			}
174
175			/**
176			* @param bool $updateOnPoll
177			*
178			* @return $this
179			*/
180	8		public function setUpdateOnPoll($updateOnPoll)
181			{
182	8		$this->updateOnPoll = $updateOnPoll;
183	8		return $this;
184			}
185
186			/**
187			* @return bool
188			*/
189	2		public function isUpdateOnPoll()
190			{
191	2		return $this->updateOnPoll;
192			}
193
194			/**
195			* @param bool $updateOnProcessOutput
196			*
197			* @return $this
198			*/
199	14		public function setUpdateOnProcessOutput($updateOnProcessOutput)
			0 ignored issues – show Comprehensibility Naming introduced 2017-10-06 11:26 UTC by Report Bug Copy Issue Report The variable name `$updateOnProcessOutput` exceeds the maximum configured length of `20`. Very long variable names usually make code harder to read. It is therefore recommended not to make variable names too verbose. Loading history...
200			{
201	14		$this->updateOnProcessOutput = $updateOnProcessOutput;
202	14		return $this;
203			}
204
205			/**
206			* @return bool
207			*/
208	2		public function isUpdateOnProcessOutput()
209			{
210	2		return $this->updateOnProcessOutput;
211			}
212			}
213

graze / parallel-process

Pull Request — master (#12)

Run::isUpdateOnPoll() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like