kakserpom / phpdaemon

PHPDaemon/Network/Server.php

<?php
namespace PHPDaemon\Network;

use PHPDaemon\Core\Daemon;

/**
 * Network server pattern
 * @package PHPDaemon\Network
 * @author  Vasily Zorin <maintainer@daemon.io>
 */
abstract class Server extends Pool
{

    /**
     * @var array|null Allowed clients
     */
    public $allowedClients = null;
    /**
     * @var \PHPDaemon\Structures\ObjectStorage Bound sockets
     */
    protected $bound;

    /**
     * Constructor
     * @param array $config Config variables
     * @param boolean $init
     */
    public function __construct($config = [], $init = true)
    {
        parent::__construct($config, false);
        $this->bound = new \PHPDaemon\Structures\ObjectStorage;
        if (isset($this->config->listen)) {
            $this->bindSockets($this->config->listen->value);

The property listen does not seem to exist in PHPDaemon\Config\Section.

        }
        if ($init) {
            $this->init();
        }
    }

    /**
     * Bind given sockets
     * @param  mixed $addrs Addresses to bind
     * @param  integer $max Maximum
     * @return integer        Number of bound
     */
    public function bindSockets($addrs = [], $max = 0)
    {
        if (is_string($addrs)) {
            $addrs = array_map('trim', explode(',', $addrs));
        }
        $n = 0;
        foreach ($addrs as $addr) {

The expression $addrs of type object|integer|double|null|array|boolean is not guaranteed to be traversable. How about adding an additional type check?

            if ($this->bindSocket($addr)) {
                ++$n;
            }
            if ($max > 0 && ($n >= $max)) {
                return $n;
            }
        }
        return $n;
    }

    /**
     * Bind given socket
     * @param  string $uri Address to bind
     * @return boolean      Success
     */
    public function bindSocket($uri)
    {
        $u = \PHPDaemon\Config\_Object::parseCfgUri($uri);
        $scheme = $u['scheme'];
        if ($scheme === 'unix') {
            $socket = new \PHPDaemon\BoundSocket\UNIX($u);
        } elseif ($scheme === 'udp') {
            $socket = new \PHPDaemon\BoundSocket\UDP($u);
            if (isset($this->config->port->value)) {
                $socket->setDefaultPort($this->config->port->value);

The property port does not seem to exist in PHPDaemon\Config\Section.

            }
        } elseif ($scheme === 'tcp') {
            $socket = new \PHPDaemon\BoundSocket\TCP($u);
            if (isset($this->config->port->value)) {
                $socket->setDefaultPort($this->config->port->value);
            }
        } else {
            Daemon::log(get_class($this) . ': enable to bind \'' . $uri . '\': scheme \'' . $scheme . '\' is not supported');
            return false;
        }
        $socket->attachTo($this);
        if ($socket->bindSocket()) {
            if ($this->enabled) {
                $socket->enable();
            }
            return true;
        }
        return false;
    }

    /**
     * Attach Generic
     * @param  \PHPDaemon\BoundSocket\Generic $bound Generic
     * @param  mixed $inf Info
     * @return void
     */
    public function attachBound(\PHPDaemon\BoundSocket\Generic $bound, $inf = null)
    {
        $this->bound->attach($bound, $inf);
        if ($this->eventLoop !== null) {
            $bound->setEventLoop($this->eventLoop);
        }
    }

    /**
     * Detach Generic
     * @param  \PHPDaemon\BoundSocket\Generic $bound Generic
     * @return void
     */
    public function detachBound(\PHPDaemon\BoundSocket\Generic $bound)
    {
        $this->bound->detach($bound);
    }

    /**
     * Called when a request to HTTP-server looks like another connection
     * @param  object $req Request
     * @param  object $oldConn Connection
     * @return boolean Success
     */
    public function inheritFromRequest($req, $oldConn)
    {
        if (!$oldConn || !$req) {
            return false;
        }
        $class = $this->connectionClass;
        $conn = new $class(null, $this);
        $this->attach($conn);
        $conn->setFd($oldConn->getFd(), $oldConn->getBev());
        $oldConn->unsetFd();
        $oldConn->pool->detach($oldConn);
        $conn->onInheritanceFromRequest($req);
        if ($req instanceof \PHPDaemon\Request\Generic) {
            $req->free();
        }
        return true;
    }

    /**
     * Called when ConnectionPool is finished
     * @return void
     */
    protected function onFinish()
    {
        $this->closeBound();
        parent::onFinish();
    }

    /**
     * Close each of binded sockets
     * @return void
     */
    public function closeBound()
    {
        $this->bound->each('close');
    }

    /**
     * Applies config
     * @return void
     */
    protected function applyConfig()
    {
        parent::applyConfig();
        foreach ($this->config as $k => $v) {

The expression $this->config of type object<PHPDaemon\Config\Section> is not traversable.

            if (is_object($v) && $v instanceof \PHPDaemon\Config\Entry\Generic) {
                $v = $v->getValue();
            }
            $k = strtolower($k);
            if ($k === 'allowedclients') {
                $this->allowedClients = $v;
            }
        }
    }

    /**
     * Called when ConnectionPool is now enabled
     * @return void
     */
    protected function onEnable()
    {
        if ($this->bound) {
            $this->bound->each('enable');
        }
    }

    /**
     * Called when ConnectionPool is now disabled
     * @return void
     */
    protected function onDisable()
    {
        if ($this->bound) {
            $this->bound->each('disable');
        }
    }
}