Dazzle\Http\Socket\SocketServer

Complexity

Total Complexity

21

Size/Duplication

Total Lines	175
Duplicated Lines	18.29 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

92.86%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	__destruct()	0	5	1
A	setComponent()	0	4	2
A	getComponent()	0	4	1
A	handleConnect()	0	21	3
A	handleDisconnect()	17	17	3
A	handleData()	0	15	3
A	handleError()	15	15	3
A	close()	0	4	1
A	start()	0	4	1
A	stop()	0	4	1

<?php
namespace Dazzle\Http\Socket;

use Dazzle\Socket\SocketInterface;
use Dazzle\Socket\SocketListenerInterface;
use Dazzle\Http\Null\NullServer;
use Dazzle\Http\NetworkComponentAwareInterface;
use Dazzle\Http\NetworkConnection;
use Dazzle\Http\NetworkMessage;
use Dazzle\Http\NetworkComponentInterface;
use Error;
use Exception;

class SocketServer implements SocketServerInterface, NetworkComponentAwareInterface
{
    /**
     * @var SocketListenerInterface
     */
    protected $socket;

    /**
     * @var NetworkComponentInterface
     */
    protected $component;

    /**
     * @param NetworkComponentInterface $component
     * @param SocketListenerInterface $socket
     */
    public function __construct(SocketListenerInterface $socket, NetworkComponentInterface $component = null)
    {

        $this->socket = $socket;
        $this->component = $component === null ? new NullServer() : $component;

        $socket->on('connect', [ $this, 'handleConnect' ]);
    }

    /**
     *
     */
    public function __destruct()
    {
        unset($this->socket);
        unset($this->component);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function start()
    {
        $this->socket->start();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function stop()
    {
        $this->socket->close();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function setComponent(NetworkComponentInterface $component = null)
    {
        $this->component = $component === null ? new NullServer() : $component;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function getComponent()
    {
        return $this->component;
    }

    /**
     * Handler triggered when a new connection is received from SocketListener.
     *
     * @param SocketListenerInterface $server
     * @param SocketInterface $socket
     */
    public function handleConnect($server, $socket)
    {
        $socket->conn = new NetworkConnection($socket);

Accessing conn on the interface Dazzle\Socket\SocketInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        try
        {
            $this->component->handleConnect($socket->conn);

Accessing conn on the interface Dazzle\Socket\SocketInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $socket->on('data',  [ $this, 'handleData' ]);
            $socket->on('error', [ $this, 'handleError' ]);
            $socket->on('close', [ $this, 'handleDisconnect' ]);
        }
        catch (Error $ex)
        {
            $this->close($socket);
        }
        catch (Exception $ex)
        {
            $this->close($socket);
        }
    }

    /**
     * Handler triggered when an existing connection is being closed.
     *
     * @param SocketInterface $socket
     */
    public function handleDisconnect($socket)

This method seems to be duplicated in your project.

    {
        try
        {
            $this->component->handleDisconnect($socket->conn);

Accessing conn on the interface Dazzle\Socket\SocketInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
        catch (Error $ex)
        {
            $this->handleError($socket, $ex);
        }
        catch (Exception $ex)
        {
            $this->handleError($socket, $ex);
        }

        unset($socket->conn);
    }

    /**
     * Handler triggered when a new data is received from existing connection.
     *
     * @param SocketInterface $socket
     * @param mixed $data
     */
    public function handleData($socket, $data)
    {
        try
        {
            $this->component->handleMessage($socket->conn, new NetworkMessage($data));

Accessing conn on the interface Dazzle\Socket\SocketInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
        catch (Error $ex)
        {
            $this->handleError($socket, $ex);
        }
        catch (Exception $ex)
        {
            $this->handleError($socket, $ex);
        }
    }

    /**
     * Handler triggered when an error has occured during doing operation on existing connection.
     *
     * @param SocketInterface $socket
     * @param Error|Exception $ex
     */
    public function handleError($socket, $ex)

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

This method seems to be duplicated in your project.

    {
        try
        {
            $this->component->handleError($socket->conn, $ex);

Accessing conn on the interface Dazzle\Socket\SocketInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
        catch (Error $ex)
        {
            $this->close($socket);
        }
        catch (Exception $ex)
        {
            $this->close($socket);
        }
    }

    /**
     * Close socket.
     *
     * @param SocketInterface $socket
     */
    protected function close(SocketInterface $socket)
    {
        $socket->close();
    }
}