Jenner\SimpleFork\ParallelPool

Complexity

Total Complexity

14

Size/Duplication

Total Lines	91
Duplicated Lines	10.99 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
B	keep()	0	16	5
A	start()	5	13	3
A	reload()	5	15	3

<?php
/**
 * @author Jenner <hypxm@qq.com>
 * @blog http://www.huyanping.cn
 * @license https://opensource.org/licenses/MIT MIT
 * @datetime: 2015/11/19 20:49
 */

namespace Jenner\SimpleFork;

/**
 * parallel pool
 *
 * @package Jenner\SimpleFork
 */
class ParallelPool extends AbstractPool
{

    /**
     * @var callable|Runnable sub process callback
     */
    protected $runnable;

    /**
     * @var int max process count
     */
    protected $max;

    /**
     * @param callable|Runnable $callback
     * @param int $max
     */
    public function __construct($callback, $max = 4)
    {
        if (!is_callable($callback) && !($callback instanceof Runnable)) {
            throw new \InvalidArgumentException('callback must be a callback function or a object of Runnalbe');
        }

        $this->runnable = $callback;

It seems like $callback can also be of type object<Jenner\SimpleFork\Runnable>. However, the property $runnable is declared as type callable. Maybe add an additional type check?

        $this->max = $max;
    }

    /**
     * start the same number processes and kill the old sub process
     * just like nginx -s reload
     * this method will block until all the old process exit;
     *
     * @param bool $block
     */
    public function reload($block = true)
    {
        $old_processes = $this->processes;
        for ($i = 0; $i < $this->max; $i++) {

This code seems to be duplicated across your project.

            $process = new Process($this->runnable);

$this->runnable is of type callable, but the function expects a string|null.

            $process->start();
            $this->processes[$process->getPid()] = $process;
        }

        foreach ($old_processes as $process) {
            $process->shutdown();
            $process->wait($block);
            unset($this->processes[$process->getPid()]);
        }
    }

    /**
     * keep sub process count
     *
     * @param bool $block block the master process
     * to keep the sub process count all the time
     * @param int $interval check time interval
     */
    public function keep($block = false, $interval = 100)
    {
        do {
            $this->start();

            // recycle sub process and delete the processes
            // which are not running from process list
            foreach ($this->processes as $process) {
                if (!$process->isRunning()) {
                    unset($this->processes[$process->getPid()]);
                }
            }

            $block ? usleep($interval) : null;
        } while ($block);
    }

    /**
     * start the pool
     */
    public function start()
    {
        $alive_count = $this->aliveCount();
        // create sub process and run
        if ($alive_count < $this->max) {
            $need = $this->max - $alive_count;
            for ($i = 0; $i < $need; $i++) {

This code seems to be duplicated across your project.

                $process = new Process($this->runnable);

$this->runnable is of type callable, but the function expects a string|null.

                $process->start();
                $this->processes[$process->getPid()] = $process;
            }
        }
    }
}