ByJG\PHPThread\Handler\ForkHandler

Complexity

Total Complexity

23

Size/Duplication

Total Lines	161
Duplicated Lines	1.86 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	9
Bugs	0	Features	2

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	setCallable()	0	4	1
C	execute()	0	38	7
A	saveResult()	0	5	1
B	getResult()	3	19	5
A	stop()	0	11	3
A	isAlive()	0	5	1
A	signalHandler()	0	7	2
A	waitFinish()	0	4	1

<?php

namespace ByJG\PHPThread\Handler;

use ByJG\Cache\CacheContext;
use InvalidArgumentException;
use RuntimeException;

/**
 * Native Implementation of Threads in PHP.
 *
 * A class to spawn a thread. Only works in *nix environments,
 * as Windows platform is missing libpcntl.
 *
 * Forks the process.
 */
class ForkHandler implements ThreadInterface
{
    protected $threadKey;
    private $callable;
    private $pid;

    /**
     * constructor method
     *
     * @throws RuntimeException
     * @throws InvalidArgumentException
     */
    public function __construct()
    {
        if (!function_exists('pcntl_fork')) {
            throw new RuntimeException('PHP was compiled without --enable-pcntl or you are running on Windows.');
        }

        /** Check if is configured */
        CacheContext::factory('phpthread');
    }

    /**
     * Private function for set the method will be forked;
     *
     * @param callable $callable string with the function name or a array with the instance and the method name
     * @return mixed|void
     */
    public function setCallable(callable $callable)
    {
        $this->callable = $callable;
    }

    /**
     * Start the thread
     *
     * @throws RuntimeException
     */
    public function execute()
    {
        $this->threadKey = 'thread_' . rand(1000, 9999) . rand(1000, 9999) . rand(1000, 9999) . rand(1000, 9999);

        if (($this->pid = pcntl_fork()) == -1) {
            throw new RuntimeException('Couldn\'t fork the process');
        }

        if ($this->pid) {

This if statement is empty and can be removed.

            // Parent
            //pcntl_wait($status); //Protect against Zombie children

67% of this comment could be valid code. Did you maybe forget this after debugging?

        } else {
            // Child.
            pcntl_signal(SIGTERM, array($this, 'signalHandler'));
            $args = func_get_args();

            $callable = $this->callable;
            if (!is_string($callable)) {
                $callable = (array) $this->callable;
            }

            try {
                $return = call_user_func_array($callable, (array)$args);

                if (!is_null($return)) {
                    $this->saveResult($return);
                }
            // Executed only in PHP 7, will not match in PHP 5.x
            } catch (\Throwable $t) {

The class Throwable does not exist. Did you forget a USE statement, or did you not list all dependencies?

                $this->saveResult($t);
            // Executed only in PHP 5. Remove when PHP 5.x is no longer necessary.
            } catch (\Exception $ex) {
                $this->saveResult($ex);
            }

            exit(0);

The method execute() contains an exit expression.

        }
    }

    /**
     * Save the thread result in a shared memory block
     *
     * @param mixed $object Need to be serializable
     */
    protected function saveResult($object)
    {
        $cache = CacheContext::factory('phpthread');
        $cache->set($this->threadKey, $object);
    }

    /**
     * Get the thread result from the shared memory block and erase it
     *
     * @return mixed
     * @throws \Error
     * @throws object
     */
    public function getResult()
    {
        if (is_null($this->threadKey)) {
            return null;
        }

        $key = $this->threadKey;
        $this->threadKey = null;

        $cache = CacheContext::factory('phpthread');
        $result = $cache->get($key);
        $cache->release($key);

        if (is_object($result) && (is_subclass_of($result, '\\Error') || is_subclass_of($result, '\\Exception'))) {

This code seems to be duplicated across your project.

             throw $result;
        }

        return $result;
    }

    /**
     * Kill a thread
     *
     * @param int $signal
     * @param bool $wait
     */
    public function stop($signal = SIGKILL, $wait = false)
    {
        if ($this->isAlive()) {
            posix_kill($this->pid, $signal);

            $status = null;
            if ($wait) {
                pcntl_waitpid($this->pid, $status);
            }
        }
    }

    /**
     * Check if the forked process is alive
     * @return bool
     */
    public function isAlive()
    {
        $status = null;
        return (pcntl_waitpid($this->pid, $status, WNOHANG) === 0);
    }

    /**
     * Handle the signal to the thread
     *
     * @param int $signal
     */
    private function signalHandler($signal)
    {
        switch ($signal) {
            case SIGTERM:
                exit(0);

The method signalHandler() contains an exit expression.

        }
    }

    public function waitFinish()
    {
        pcntl_wait($status);

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

    }
}