Slince\Process\Process

Complexity

Total Complexity

27

Size/Duplication

Total Lines	202
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	isSupported()	0	4	1
B	start()	0	21	5
A	wait()	0	6	2
A	run()	0	5	1
A	stop()	0	5	1
A	getPid()	0	4	1
A	signal()	0	7	2
A	isRunning()	0	10	2
A	getSignalHandler()	0	4	1
A	getExitCode()	0	4	2
B	updateStatus()	0	18	5
A	getStatus()	0	4	1

<?php
/**
 * Process Library
 * @author Tao <taosikai@yeah.net>
 */
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::getInstance();
    }

    /**
     * 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));

The method start() contains an exit expression.

        }
    }

    /**
     * {@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;
    }

    /**
     * {@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;
    }
}