PHPDaemon\IPCManager\IPCManager

Complexity

Total Complexity

29

Size/Duplication

Total Lines	195
Duplicated Lines	8.21 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getConfigDefaults()	0	7	1
A	init()	0	10	2
A	getSocketUrl()	0	4	1
C	updatedWorkers()	0	38	13
A	onShutdown()	0	7	2
A	importFile()	0	9	2
A	ensureConnection()	0	4	1
A	sendPacket()	0	16	4
A	sendBroadcastCall()	8	9	1
A	sendSingleCall()	8	9	1
A	sendDirectCall()	0	10	1

<?php
namespace PHPDaemon\IPCManager;

use PHPDaemon\Config;
use PHPDaemon\Core\AppInstance;
use PHPDaemon\Core\Daemon;
use PHPDaemon\Thread;

class IPCManager extends AppInstance
{
    /** @var */
    public $pool;
    /** @var */
    public $conn;
    /** @var */
    public $socketurl;

    /**
     * Setting default config options
     * Overriden from AppInstance::getConfigDefaults
     * @return array|bool
     */
    protected function getConfigDefaults()
    {
        return [
            // listen to
            'mastersocket' => 'unix:///tmp/phpDaemon-ipc-%x.sock',
        ];
    }

    /**
     * Constructor.
     * @return void
     */
    public function init()
    {
        $this->socketurl = sprintf($this->config->mastersocket->value,
            crc32(Daemon::$config->pidfile->value . "\x00" . Daemon::$config->user->value . "\x00" . Daemon::$config->group->value));
        if (Daemon::$process instanceof Thread\IPC) {
            $this->pool = MasterPool::getInstance(['listen' => $this->socketurl]);

array('listen' => $this->socketurl) is of type array<string,string,{"listen":"string"}>, but the function expects a string.

            $this->pool->appInstance = $this;
            $this->pool->onReady();
        }
    }

    public function getSocketUrl()
    {
        return $this->socketurl;
    }

    /**
     * @TODO DESCR
     */
    public function updatedWorkers()
    {
        $perWorker = 1;
        $instancesCount = [];
        foreach (Daemon::$config as $name => $section) {

The expression \PHPDaemon\Core\Daemon::$config of type object<PHPDaemon\Config\_Object> is not traversable.

            if ((!$section instanceof Config\Section) || !isset($section->limitinstances)) {
                continue;
            }
            $instancesCount[$name] = 0;
        }
        foreach ($this->pool->workers as $worker) {
            foreach ($worker->instancesCount as $k => $v) {
                if (!isset($instancesCount[$k])) {
                    unset($worker->instancesCount[$k]);
                    continue;
                }
                $instancesCount[$k] += $v;
            }
        }
        foreach ($instancesCount as $name => $num) {
            $v = Daemon::$config->{$name}->limitinstances->value - $num;
            foreach ($this->pool->workers as $worker) {
                if ($v <= 0) {
                    break;
                }
                if ((isset($worker->instancesCount[$name])) && ($worker->instancesCount[$name] < $perWorker)) {
                    continue;
                }
                if (!isset($worker->instancesCount[$name])) {
                    $worker->instancesCount[$name] = 1;
                } else {
                    ++$worker->instancesCount[$name];
                }
                $worker->sendPacket(['op' => 'spawnInstance', 'appfullname' => $name]);
                --$v;
            }
        }
    }

    /**
     * Called when application instance is going to shutdown.
     * @param bool $graceful
     * @return boolean Ready to shutdown?
     */
    public function onShutdown($graceful = false)
    {
        if ($this->pool) {
            return $this->pool->onShutdown();
        }
        return true;
    }

    /**
     * @TODO DESCR
     * @param $workerId
     * @param $path
     * @return bool
     */
    public function importFile($workerId, $path)
    {
        if (!isset($this->pool->workers[$workerId])) {
            return false;
        }
        $worker = $this->pool->workers[$workerId];
        $worker->sendPacket(['op' => 'importFile', 'path' => $path]);
        return true;
    }

    /**
     * @TODO DESCR
     */
    public function ensureConnection()
    {
        $this->sendPacket('');
    }

    /**
     * @TODO DESCR
     * @param $packet
     */
    public function sendPacket($packet = null)
    {
        if ($this->conn && $this->conn->isConnected()) {
            $this->conn->sendPacket($packet);
            return;
        }

        $cb = function ($conn) use ($packet) {
            $conn->sendPacket($packet);
        };
        if (!$this->conn) {
            $this->conn = new WorkerConnection(null, null, null);

The call to WorkerConnection::__construct() has too many arguments starting with null.

            $this->conn->connect($this->socketurl);
        }
        $this->conn->onConnected($cb);
    }

    /**
     * @TODO DESCR
     * @param $appInstance
     * @param $method
     * @param array $args
     * @param callable $cb

Should the type for parameter $cb not be callable|null?

     */
    public function sendBroadcastCall($appInstance, $method, $args = [], $cb = null)

The parameter $cb is not used and could be removed.

This method seems to be duplicated in your project.

    {
        $this->sendPacket([
            'op' => 'broadcastCall',
            'appfullname' => $appInstance,
            'method' => $method,
            'args' => $args,
        ]);
    }

    /**
     * @TODO DESCR
     * @param $appInstance
     * @param $method
     * @param array $args
     * @param callable $cb

Should the type for parameter $cb not be callable|null?

     */
    public function sendSingleCall($appInstance, $method, $args = [], $cb = null)

The parameter $cb is not used and could be removed.

This method seems to be duplicated in your project.

    {
        $this->sendPacket([
            'op' => 'singleCall',
            'appfullname' => $appInstance,
            'method' => $method,
            'args' => $args,
        ]);
    }

    /**
     * @TODO DESCR
     * @param $workerId
     * @param $appInstance
     * @param $method
     * @param array $args
     * @param callable $cb

Should the type for parameter $cb not be callable|null?

     */
    public function sendDirectCall($workerId, $appInstance, $method, $args = [], $cb = null)

The parameter $cb is not used and could be removed.

    {
        $this->sendPacket([
            'op' => 'directCall',
            'appfullname' => $appInstance,
            'method' => $method,
            'args' => $args,
            'workerId' => $workerId,
        ]);
    }
}