Spatie\Async\Pool

Complexity

Total Complexity

34

Size/Duplication

Total Lines	235
Duplicated Lines	8.51 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	create()	0	4	1
A	isSupported()	0	4	2
A	concurrency()	0	6	1
A	timeout()	0	6	1
A	autoload()	0	6	1
A	sleepTime()	0	6	1
A	notify()	0	14	3
A	add()	0	10	2
B	wait()	0	18	5
A	putInQueue()	0	6	1
A	putInProgress()	0	10	1
A	markAsFinished()	0	10	1
A	markAsTimedOut()	10	10	1
A	markAsFailed()	10	10	1
A	offsetExists()	0	6	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	getFinished()	0	4	1
A	getFailed()	0	4	1
B	registerListener()	0	28	5

<?php

namespace Spatie\Async;

use ArrayAccess;
use Spatie\Async\Runtime\ParentRuntime;

class Pool implements ArrayAccess
{
    protected $concurrency = 20;
    protected $tasksPerProcess = 1;
    protected $timeout = 300;
    protected $sleepTime = 50000;

    /** @var \Spatie\Async\ParallelProcess[] */
    protected $queue = [];

    /** @var \Spatie\Async\ParallelProcess[] */
    protected $inProgress = [];

    /** @var \Spatie\Async\ParallelProcess[] */
    protected $finished = [];

    /** @var \Spatie\Async\ParallelProcess[] */
    protected $failed = [];

    protected $results = [];

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

    /**
     * @return static
     */
    public static function create()
    {
        return new static();
    }

    public static function isSupported(): bool
    {
        return function_exists('pcntl_async_signals') && function_exists('posix_kill');
    }

    public function concurrency(int $concurrency): self
    {
        $this->concurrency = $concurrency;

        return $this;
    }

    public function timeout(int $timeout): self
    {
        $this->timeout = $timeout;

        return $this;
    }

    public function autoload(string $autoloader): self
    {
        ParentRuntime::init($autoloader);

        return $this;
    }

    public function sleepTime(int $sleepTime): self
    {
        $this->sleepTime = $sleepTime;

        return $this;
    }

    public function notify()
    {
        if (count($this->inProgress) >= $this->concurrency) {
            return;
        }

        $process = array_shift($this->queue);

        if (! $process) {
            return;
        }

        $this->putInProgress($process);
    }

    /**
     * @param \Spatie\Async\ParallelProcess|callable $process
     *
     * @return \Spatie\Async\ParallelProcess
     */
    public function add($process): ParallelProcess
    {
        if (! $process instanceof ParallelProcess) {
            $process = ParentRuntime::createChildProcess($process);
        }

        $this->putInQueue($process);

        return $process;
    }

    public function wait(): array
    {
        while ($this->inProgress) {

The expression $this->inProgress of type Spatie\Async\ParallelProcess[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($this->inProgress as $process) {
                if ($process->getCurrentExecutionTime() > $this->timeout) {
                    $this->markAsTimedOut($process);
                }
            }

            if (! $this->inProgress) {

The expression $this->inProgress of type Spatie\Async\ParallelProcess[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

                break;
            }

            usleep($this->sleepTime);
        }

        return $this->results;
    }

    public function putInQueue(ParallelProcess $process)
    {
        $this->queue[$process->getId()] = $process;

        $this->notify();
    }

    public function putInProgress(ParallelProcess $process)
    {
        $process->getProcess()->setTimeout($this->timeout);

        $process->start();

        unset($this->queue[$process->getId()]);

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

    public function markAsFinished(ParallelProcess $process)
    {
        $this->results[] = $process->triggerSuccess();

        unset($this->inProgress[$process->getPid()]);

        $this->finished[$process->getPid()] = $process;

        $this->notify();
    }

    public function markAsTimedOut(ParallelProcess $process)

This method seems to be duplicated in your project.

    {
        $process->triggerTimeout();

        unset($this->inProgress[$process->getPid()]);

        $this->failed[$process->getPid()] = $process;

        $this->notify();
    }

    public function markAsFailed(ParallelProcess $process)

This method seems to be duplicated in your project.

    {
        $process->triggerError();

        unset($this->inProgress[$process->getPid()]);

        $this->failed[$process->getPid()] = $process;

        $this->notify();
    }

    public function offsetExists($offset)
    {
        // TODO

        return false;
    }

    public function offsetGet($offset)
    {
        // TODO
    }

    public function offsetSet($offset, $value)
    {
        $this->add($value);

$value is of type *, but the function expects a callable.

    }

    public function offsetUnset($offset)
    {
        // TODO
    }

    /**
     * @return \Spatie\Async\ParallelProcess[]
     */
    public function getFinished(): array
    {
        return $this->finished;
    }

    /**
     * @return \Spatie\Async\ParallelProcess[]
     */
    public function getFailed(): array
    {
        return $this->failed;
    }

    protected function registerListener()
    {
        pcntl_async_signals(true);

        pcntl_signal(SIGCHLD, function ($signo, $status) {
            while (true) {
                $pid = pcntl_waitpid(-1, $processState, WNOHANG | WUNTRACED);

                if ($pid <= 0) {
                    break;
                }

                $process = $this->inProgress[$pid] ?? null;

                if (! $process) {
                    continue;
                }

                if ($status['status'] === 0) {
                    $this->markAsFinished($process);

                    continue;
                }

                $this->markAsFailed($process);
            }
        });
    }
}