Issues in Process.php - Fixed Issues - Inspection of "improve" - slince/process - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bbdfdc...3f4834 )

by Taosikai

created 2017-04-28 04:04 UTC

Process.php (1 issue)

Labels

Severity

Major 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
/**
 * Process Library
 * @author Tao <[email protected]>
 */
namespace Slince\Process;

use Slince\Process\Exception\InvalidArgumentException;
use Slince\Process\Exception\RuntimeException;

class Process implements ProcessInterface
{
    /**
     * process status,running
     * @var string
     */
    const STATUS_RUNNING = 'running';

    /**
     * process status,terminated
     * @var string
     */
    const STATUS_TERMINATED = 'terminated';

    /**
     * callback
     * @var callable
     */
    protected $callback;

    /**
     * pid
     * @var int
     */
    protected $pid;

    /**
     * Whether the process is running
     * @var bool
     */
    protected $isRunning = false;

    /**
     * signal handler
     * @var SignalHandler
     */
    protected $signalHandler;

    /**
     * current status
     * @var Status
     */
    protected $status;

    public function __construct($callback)
    {
        if (!static::isSupported()) {
            throw new RuntimeException("Process need ext-pcntl");
        }
        if (!is_callable($callback)) {
            throw new InvalidArgumentException("Process expects a callable callback");
        }
        $this->callback = $callback;
        $this->signalHandler = SignalHandler::create();
    }

    /**
     * Checks whether the current environment supports this
     * @return bool
     */
    public static function isSupported()
    {
        return function_exists('pcntl_fork');
    }

    /**
     * {@inheritdoc}
     */
    public function start()
    {
        if ($this->isRunning()) {
            throw new RuntimeException("The process is already running");
        }
        $pid = pcntl_fork();
        if ($pid == -1) {
            throw new RuntimeException("Could not fork");
        } elseif ($pid) { //Records the pid of the child process
            $this->pid = $pid;
            $this->isRunning = true;
        } else {
            $this->pid = posix_getpid();
            try {
                $exitCode = call_user_func($this->callback);
            } catch (\Exception $e) {
                $exitCode  = 255;
            }
            exit(intval($exitCode));
        }
    }

    /**
     * {@inheritdoc}
     */
    public function wait()
    {
        if ($this->isRunning()) {
            $this->updateStatus(true);
        }
    }

    /**
     * Start and wait for the process to complete
     */
    public function run()
    {
        $this->start();
        $this->wait();
    }

    /**
     * {@inheritdoc}
     */
    public function stop($signal = SIGKILL)
    {
        $this->signal($signal);
        $this->updateStatus(true);
    }

    /**
     * {@inheritdoc}
     */
    public function getPid()
    {
        return $this->pid;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * {@inheritdoc}
     */
    public function signal($signal)
    {
        if (!$this->isRunning()) {
            throw new RuntimeException("The process is not currently running");
        }
        posix_kill($this->getPid(), $signal);
    }

    /**
     * {@inheritdoc}
     */
    public function isRunning()
    {
        //if process is not running, return false
        if (!$this->isRunning) {
            return false;
        }
        //if the process is running, update process status again
        $this->updateStatus(false);
        return $this->isRunning;
    }

    /**
     * Gets the signal handler
     * @return SignalHandler
     */
    public function getSignalHandler()
    {
        return $this->signalHandler;
    }

    /**
     * Gets the exit code of the process
     * @return int
     */
    public function getExitCode()
    {
        return $this->status ? $this->status->getExitCode() : null;
    }

    /**
     * Updates the status of the process
     * @param bool $blocking
     * @throws RuntimeException
     */
    protected function updateStatus($blocking = false)
    {
        if (!$this->isRunning) {
            return;
        }
        $options = $blocking ? 0 : WNOHANG | WUNTRACED;
        $result = pcntl_waitpid($this->getPid(), $status, $options);
        if ($result == -1) {
            throw new RuntimeException("Error waits on or returns the status of the process");
        } elseif ($result) {
            //The process is terminated
            $this->isRunning = false;
            //checks if the process is exited normally
            $this->status = new Status($status);
        } else {
            $this->isRunning = true;
        }
    }

    /**
     * Gets the status of the process
     * @return Status
     */
    public function getStatus()
    {
        return $this->status;
    }
}

1			<?php
2			/**
3			* Process Library
4			* @author Tao <[email protected]>
5			*/
6			namespace Slince\Process;
7
8			use Slince\Process\Exception\InvalidArgumentException;
9			use Slince\Process\Exception\RuntimeException;
10
11			class Process implements ProcessInterface
12			{
13			/**
14			* process status,running
15			* @var string
16			*/
17			const STATUS_RUNNING = 'running';
18
19			/**
20			* process status,terminated
21			* @var string
22			*/
23			const STATUS_TERMINATED = 'terminated';
24
25			/**
26			* callback
27			* @var callable
28			*/
29			protected $callback;
30
31			/**
32			* pid
33			* @var int
34			*/
35			protected $pid;
36
37			/**
38			* Whether the process is running
39			* @var bool
40			*/
41			protected $isRunning = false;
42
43			/**
44			* signal handler
45			* @var SignalHandler
46			*/
47			protected $signalHandler;
48
49			/**
50			* current status
51			* @var Status
52			*/
53			protected $status;
54
55			public function __construct($callback)
56			{
57			if (!static::isSupported()) {
58			throw new RuntimeException("Process need ext-pcntl");
59			}
60			if (!is_callable($callback)) {
61			throw new InvalidArgumentException("Process expects a callable callback");
62			}
63			$this->callback = $callback;
64			$this->signalHandler = SignalHandler::create();
65			}
66
67			/**
68			* Checks whether the current environment supports this
69			* @return bool
70			*/
71			public static function isSupported()
72			{
73			return function_exists('pcntl_fork');
74			}
75
76			/**
77			* {@inheritdoc}
78			*/
79			public function start()
80			{
81			if ($this->isRunning()) {
82			throw new RuntimeException("The process is already running");
83			}
84			$pid = pcntl_fork();
85			if ($pid == -1) {
86			throw new RuntimeException("Could not fork");
87			} elseif ($pid) { //Records the pid of the child process
88			$this->pid = $pid;
89			$this->isRunning = true;
90			} else {
91			$this->pid = posix_getpid();
92			try {
93			$exitCode = call_user_func($this->callback);
94			} catch (\Exception $e) {
95			$exitCode = 255;
96			}
97			exit(intval($exitCode));
98			}
99			}
100
101			/**
102			* {@inheritdoc}
103			*/
104			public function wait()
105			{
106			if ($this->isRunning()) {
107			$this->updateStatus(true);
108			}
109			}
110
111			/**
112			* Start and wait for the process to complete
113			*/
114			public function run()
115			{
116			$this->start();
117			$this->wait();
118			}
119
120			/**
121			* {@inheritdoc}
122			*/
123			public function stop($signal = SIGKILL)
124			{
125			$this->signal($signal);
126			$this->updateStatus(true);
127			}
128
129			/**
130			* {@inheritdoc}
131			*/
132			public function getPid()
133			{
134			return $this->pid;
			0 ignored issues – show Bug Best Practice introduced 2017-04-28 03:30 UTC by Report Bug Copy Issue Report Show Similar Issues like this The return type of `return $this->pid;` (`integer`) is incompatible with the return type declared by the interface `Slince\Process\ProcessInterface::getPid` of type `resource`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
135			}
136
137			/**
138			* {@inheritdoc}
139			*/
140			public function signal($signal)
141			{
142			if (!$this->isRunning()) {
143			throw new RuntimeException("The process is not currently running");
144			}
145			posix_kill($this->getPid(), $signal);
146			}
147
148			/**
149			* {@inheritdoc}
150			*/
151			public function isRunning()
152			{
153			//if process is not running, return false
154			if (!$this->isRunning) {
155			return false;
156			}
157			//if the process is running, update process status again
158			$this->updateStatus(false);
159			return $this->isRunning;
160			}
161
162			/**
163			* Gets the signal handler
164			* @return SignalHandler
165			*/
166			public function getSignalHandler()
167			{
168			return $this->signalHandler;
169			}
170
171			/**
172			* Gets the exit code of the process
173			* @return int
174			*/
175			public function getExitCode()
176			{
177			return $this->status ? $this->status->getExitCode() : null;
178			}
179
180			/**
181			* Updates the status of the process
182			* @param bool $blocking
183			* @throws RuntimeException
184			*/
185			protected function updateStatus($blocking = false)
186			{
187			if (!$this->isRunning) {
188			return;
189			}
190			$options = $blocking ? 0 : WNOHANG \| WUNTRACED;
191			$result = pcntl_waitpid($this->getPid(), $status, $options);
192			if ($result == -1) {
193			throw new RuntimeException("Error waits on or returns the status of the process");
194			} elseif ($result) {
195			//The process is terminated
196			$this->isRunning = false;
197			//checks if the process is exited normally
198			$this->status = new Status($status);
199			} else {
200			$this->isRunning = true;
201			}
202			}
203
204			/**
205			* Gets the status of the process
206			* @return Status
207			*/
208			public function getStatus()
209			{
210			return $this->status;
211			}
212			}

slince / process

Push — master ( bbdfdc...3f4834 )

Process.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like