WyriHaximus\React\ChildProcess\Messenger\Factory

Complexity

Total Complexity

8

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	9

Test Coverage

Coverage

83.05%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	parent()	0	16	1
B	child()	0	32	2
B	parentFromClass()	0	39	4
A	startParent()	0	22	1

<?php

namespace WyriHaximus\React\ChildProcess\Messenger;

use React\ChildProcess\Process;

This use statement conflicts with another class in this namespace, WyriHaximus\React\ChildProcess\Messenger\Process.

use React\EventLoop\LoopInterface;
use React\Promise;
use React\Socket\ConnectionInterface;
use React\Socket\Connector;
use React\Socket\Server;
use WyriHaximus\React\ChildProcess\Messenger\Messages\Factory as MessengesFactory;
use WyriHaximus\React\ChildProcess\Messenger\Messages\Payload;

final class Factory
{
    const INTERVAL = 0.1;
    const TIMEOUT = 13;
    const TERMINATE_TIMEOUT = 1;
    const PROCESS_REGISTER = 'wyrihaximus.react.child-process.messenger.child.register';

    public static function parent(
        Process $process,
        LoopInterface $loop,
        array $options = []
    ) {
        return new Promise\Promise(function ($resolve, $reject) use ($process, $loop, $options) {
            $server = new Server('127.0.0.1:0', $loop);
            $argvString = \escapeshellarg(ArgvEncoder::encode([
                'address' => $server->getAddress(),
            ]));

            $process = new Process($process->getCommand() . ' ' . $argvString);

Consider using a different name than the imported variable $process, or did you forget to import by reference?

            self::startParent($process, $server, $loop, $options)->done($resolve, $reject);
        });
    }

    /**
     * @param  string                              $process

There is no parameter named $process. Was it maybe removed?

     * @param  LoopInterface                       $loop
     * @param  array                               $options
     * @param  mixed                               $class
     * @return Promise\PromiseInterface<Messenger>

The doc-type Promise\PromiseInterface<Messenger> could not be parsed: Expected "|" or "end of type", but got "<" at position 24. (view supported doc-types)

     */
    public static function parentFromClass(
        $class,
        LoopInterface $loop,
        array $options = []
    ) {
        if (!is_subclass_of($class, 'WyriHaximus\React\ChildProcess\Messenger\ChildInterface')) {
            throw new \Exception('Given class doesn\'t implement ChildInterface');
        }

        return new Promise\Promise(function ($resolve, $reject) use ($class, $loop, $options) {
            $server = new Server('127.0.0.1:0', $loop);
            $options['address'] = $server->getAddress();

            $template = '%s';
            if (isset($options['cmdTemplate'])) {
                $template = $options['cmdTemplate'];
                unset($options['cmdTemplate']);
            }

            $phpBinary = \escapeshellarg(PHP_BINARY . (PHP_SAPI === 'phpdbg' ? ' -qrr --' : ''));
            $childProcessPath = \escapeshellarg(__DIR__ . DIRECTORY_SEPARATOR . 'child-process.php');
            $argvString = \escapeshellarg(ArgvEncoder::encode($options));
            $command = $phpBinary . ' ' . $childProcessPath;
            $process = new Process(
                sprintf(
                    $template,
                    $command . ' ' . $argvString
                )
            );

            self::startParent($process, $server, $loop, $options)->then(function (Messenger $messenger) use ($class) {
                return $messenger->rpc(MessengesFactory::rpc(Factory::PROCESS_REGISTER, [
                    'className' => $class,
                ]))->then(function () use ($messenger) {
                    return Promise\resolve($messenger);
                });
            })->done($resolve, $reject);
        });
    }

    /**
     * @param  LoopInterface                       $loop
     * @param  array                               $options
     * @param  callable                            $termiteCallable
     * @return Promise\PromiseInterface<Messenger>

The doc-type Promise\PromiseInterface<Messenger> could not be parsed: Expected "|" or "end of type", but got "<" at position 24. (view supported doc-types)

     */
    public static function child(LoopInterface $loop, array $options = [], callable $termiteCallable = null)
    {
        return (new Connector($loop))->connect($options['address'])->then(function (ConnectionInterface $connection) use ($options) {
            return new Messenger($connection, $options);
        })->then(function (Messenger $messenger) use ($loop, $termiteCallable) {
            if ($termiteCallable === null) {
                $termiteCallable = function () use ($loop) {

Consider using a different name than the imported variable $termiteCallable, or did you forget to import by reference?

                    $loop->addTimer(
                        self::TERMINATE_TIMEOUT,
                        [
                            $loop,
                            'stop',
                        ]
                    );
                };
            }

            $messenger->registerRpc(
                Messenger::TERMINATE_RPC,
                function (Payload $payload, Messenger $messenger) use ($termiteCallable) {
                    $messenger->emit('terminate', [
                        $messenger,
                    ]);
                    $termiteCallable($payload, $messenger);

                    return Promise\resolve([]);
                }
            );

            return $messenger;
        });
    }

    private static function startParent(
        Process $process,
        Server $server,
        LoopInterface $loop,
        array $options
    ) {
        return new Promise\Promise(function ($resolve, $reject) use ($process, $server, $loop, $options) {
            $server->on(
                'connection',
                function (ConnectionInterface $connection) use ($server, $resolve, $reject, $options) {
                    $server->close();
                    $messenger = new Messenger($connection, $options);
                    $resolve($messenger);
                }
            );
            $server->on('error', function ($et) use ($reject) {
                $reject($et);
            });

            $process->start($loop);
        });
    }
}