Jenner\SimpleFork\Process

Complexity

Total Complexity

55

Size/Duplication

Total Lines	405
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

69.33%

Importance

Changes	27
Bugs	10	Features	7

19 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	18	7
A	getPid()	0	4	1
A	name()	0	8	2
A	isRunning()	0	5	1
A	errno()	0	4	1
A	errmsg()	0	4	1
A	ifSignal()	0	4	1
D	start()	0	38	9
A	shutdown()	0	15	4
A	wait()	0	12	4
A	on()	0	8	2
A	registerSignalHandler()	0	4	1
A	run()	0	3	1
D	updateStatus()	0	40	9
A	signal()	0	13	3
A	getCallable()	0	13	4
A	initStatus()	0	9	1
A	isStopped()	0	8	2
A	hasStarted()	0	4	1

<?php
/**
 * Created by PhpStorm.
 * User: Jenner
 * Date: 2015/8/12
 * Time: 15:25
 */

namespace Jenner\SimpleFork;

class Process
{
    /**
     * @var Runnable|callable
     */
    protected $runnable;

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

    /**
     * @var string custom process name
     */
    protected $name = null;

    /**
     * @var bool if the process is started
     */
    protected $started = false;

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

    /**
     * @var int the signal which made the process terminate
     */
    protected $term_signal = null;

    /**
     * @var int the signal which made the process stop
     */
    protected $stop_signal = null;

    /**
     * @var int error code
     */
    protected $errno = null;

    /**
     * @var string error message
     */
    protected $errmsg = null;

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

    /**
     * @var array
     */
    protected $callbacks = array();

    /**
     * @var array signal handlers
     */
    protected $signal_handlers = array();

    /**
     * event name of before process start
     */
    const BEFORE_START = 'beforeStart';

    /**
     * event name of before process exit
     */
    const BEFORE_EXIT = 'beforeExit';

    /**
     * event name of after process exit
     */
    const AFTER_FINISHED = 'afterFinished';


    /**
     * @param string $execution it can be a Runnable object, callback function or null
     * @param null $name process name,you can manager the process by it's name.
     */
    public function __construct($execution = null, $name = null)
    {
        if (!is_null($execution) && $execution instanceof Runnable) {

As per coding-style, please use === null instead of is_null.

            $this->runnable = $execution;
        } elseif (!is_null($execution) && is_callable($execution)) {

As per coding-style, please use === null instead of is_null.

            $this->runnable = $execution;
        } elseif (!is_null($execution)) {

As per coding-style, please use === null instead of is_null.

            $message = "param execution is not a object of Runnable or callable";
            throw new \InvalidArgumentException($message);
        } else {
            Utils::checkOverwriteRunMethod(get_class($this));
        }
        if (!is_null($name)) {

As per coding-style, please use === null instead of is_null.

            $this->name = $name;
        }

        $this->initStatus();
    }

    /**
     * get pid
     *
     * @return int
     */
    public function getPid()
    {
        return $this->pid;
    }

    /**
     * get or set name
     *
     * @param string|null $name
     * @return mixed
     */
    public function name($name = null)
    {
        if (!is_null($name)) {

As per coding-style, please use === null instead of is_null.

            $this->name = $name;
        } else {
            return $this->name;
        }
    }

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

    /**
     * if the process is stopped
     *
     * @return bool
     */
    public function isStopped()
    {
        if (is_null($this->errno)) {

As per coding-style, please use === null instead of is_null.

            return false;
        }

        return true;
    }

    /**
     * if the process is started
     *
     * @return bool
     */
    public function hasStarted()
    {
        return $this->started;
    }

    /**
     * get pcntl errno
     *
     * @return int
     */
    public function errno()
    {
        return $this->errno;
    }

    /**
     * get pcntl errmsg
     *
     * @return string
     */
    public function errmsg()
    {
        return $this->errmsg;
    }

    public function ifSignal()
    {
        return $this->if_signal;
    }

    /**
     * start the sub process
     * and run the callback
     *
     * @return string pid
     */
    public function start()
    {
        if (!empty($this->pid) && $this->isRunning()) {
            throw new \LogicException("the process is already running");
        }

        $callback = $this->getCallable();

        $pid = pcntl_fork();
        if ($pid < 0) {
            throw new \RuntimeException("fork error");
        } elseif ($pid > 0) {
            $this->pid = $pid;
            $this->running = true;
            $this->started = true;
        } else {
            $this->pid = getmypid();
            $this->signal();
            foreach ($this->signal_handlers as $signal => $handler) {
                pcntl_signal($signal, $handler);
            }

            if (array_key_exists(self::BEFORE_START, $this->callbacks)) {
                $result = call_user_func($this->callbacks[self::BEFORE_START]);
                if ($result !== true) {
                    exit(0);

The method start() contains an exit expression.

                }
            }

            $result = call_user_func($callback);

            if (array_key_exists(self::AFTER_FINISHED, $this->callbacks)) {
                call_user_func($this->callbacks[self::AFTER_FINISHED], $result);
            }

            exit(0);

The method start() contains an exit expression.

        }
    }

    /**
     * kill self
     *
     * @param bool|true $block
     * @param int $signal
     */
    public function shutdown($block = true, $signal = SIGTERM)
    {
        if (empty($this->pid)) {
            $message = "the process pid is null, so maybe the process is not started";
            throw new \LogicException($message);
        }
        if (!$this->isRunning()) {
            throw new \LogicException("the process is not running");
        }
        if (!posix_kill($this->pid, $signal)) {
            throw new \RuntimeException("kill son process failed");
        }

        $this->updateStatus($block);
    }

    /**
     * waiting for the sub process exit
     *
     * @param bool|true $block if block the process
     * @param int $sleep default 0.1s check sub process status
     * every $sleep milliseconds.
     */
    public function wait($block = true, $sleep = 100000)
    {
        while (true) {
            if ($this->isRunning() === false) {
                return;
            }
            if (!$block) {
                break;
            }
            usleep($sleep);
        }
    }

    /**
     * register callback functions
     *
     * @param $event
     * @param $function
     */
    public function on($event, $function)
    {
        if (!is_callable($function)) {
            throw new \LogicException("the callback function is not callable");
        }

        $this->callbacks[$event] = $function;
    }

    /**
     * register sub process signal handler,
     * when the sub process start, the handlers will be registered
     *
     * @param $signal
     * @param callable $handler
     */
    public function registerSignalHandler($signal, callable $handler)
    {
        $this->signal_handlers[$signal] = $handler;
    }

    /**
     * you should overwrite this function
     * if you do not use the Runnable or callback.
     */
    public function run()
    {
    }

    /**
     * update the process status
     *
     * @param bool $block
     */
    protected function updateStatus($block = false)
    {
        if ($this->running !== true) {
            return;
        }

        if ($block) {
            $res = pcntl_waitpid($this->pid, $status);

The variable $status does not exist. Did you forget to declare it?

        } else {
            $res = pcntl_waitpid($this->pid, $status, WNOHANG | WUNTRACED);
        }

        if ($res === -1) {
            $message = "pcntl_waitpid failed. the process maybe available";
            throw new \RuntimeException($message);
        } elseif ($res === 0) {
            $this->running = true;
        } else {
            if (pcntl_wifsignaled($status)) {
                $this->term_signal = pcntl_wtermsig($status);
            }
            if (pcntl_wifstopped($status)) {
                $this->stop_signal = pcntl_wstopsig($status);
            }
            if (pcntl_wifexited($status)) {
                $this->errno = pcntl_wexitstatus($status);
                $this->errmsg = pcntl_strerror($this->errno);
            } else {
                $this->errno = pcntl_get_last_error();
                $this->errmsg = pcntl_strerror($this->errno);
            }
            if (pcntl_wifsignaled($status)) {
                $this->if_signal = true;
            } else {
                $this->if_signal = false;
            }

            $this->running = false;
        }
    }

    /**
     * register signal SIGTERM handler,
     * when the parent process call shutdown and use the default signal,
     * this handler will be triggered
     */
    protected function signal()
    {
        pcntl_signal(SIGTERM, function () {
            if (!array_key_exists(self::BEFORE_EXIT, $this->callbacks)) {
                exit(0);

The method signal() contains an exit expression.

            }

            $result = call_user_func($this->callbacks[self::BEFORE_EXIT]);
            if ($result === true) {
                exit(0);

The method signal() contains an exit expression.

            }
        });
    }

    /**
     * get sub process callback
     *
     * @return array|callable|null
     */
    protected function getCallable()
    {
        $callback = null;

$callback is not used, you could remove the assignment.

        if (is_object($this->runnable) && $this->runnable instanceof Runnable) {
            $callback = array($this->runnable, 'run');
        } elseif (is_callable($this->runnable)) {
            $callback = $this->runnable;
        } else {
            $callback = array($this, 'run');
        }

        return $callback;
    }

    /**
     * init process status
     */
    protected function initStatus()
    {
        $this->pid = null;
        $this->running = null;
        $this->term_signal = null;
        $this->stop_signal = null;
        $this->errno = null;
        $this->errmsg = null;
    }
}