Dazzle\Http\Http\HttpServer

Complexity

Total Complexity

18

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

90%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	__destruct()	0	5	1
A	getDriver()	0	4	1
A	setComponent()	0	4	2
A	getComponent()	0	4	1
A	handleConnect()	0	6	1
A	handleDisconnect()	0	7	2
B	handleMessage()	0	31	5
A	handleError()	0	11	2
A	close()	0	7	1

<?php

namespace Dazzle\Http\Http;

use Dazzle\Http\NetworkComponentAwareInterface;
use Dazzle\Http\Http\Driver\HttpDriver;
use Dazzle\Http\Http\Driver\HttpDriverInterface;
use Dazzle\Http\Null\NullServer;
use Dazzle\Http\NetworkMessageInterface;
use Dazzle\Http\NetworkComponentInterface;
use Dazzle\Http\NetworkConnectionInterface;
use Dazzle\Util\Buffer\Buffer;
use Error;
use Exception;

class HttpServer implements HttpServerInterface, NetworkComponentAwareInterface
{
    /**
     * @var NetworkComponentInterface
     */
    protected $httpServer;

    /**
     * @var HttpDriverInterface
     */
    protected $httpDriver;

    /**
     * @param NetworkComponentAwareInterface|null $aware
     * @param NetworkComponentInterface|null $component
     */
    public function __construct(NetworkComponentAwareInterface $aware = null, NetworkComponentInterface $component = null)
    {
        $this->httpServer = $component;
        $this->httpDriver = new HttpDriver();

        if ($aware !== null)
        {
            $aware->setComponent($this);
        }
    }

    /**
     *
     */
    public function __destruct()
    {
        unset($this->httpServer);
        unset($this->httpDriver);
    }

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

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

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

    /**
     * @override
     * @inheritDoc
     */
    public function handleConnect(NetworkConnectionInterface $conn)
    {
        $conn->httpBuffer = new Buffer();

Accessing httpBuffer on the interface Dazzle\Http\NetworkConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        $conn->httpHeadersReceived = false;

Accessing httpHeadersReceived on the interface Dazzle\Http\NetworkConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        $conn->httpRequest = null;

Accessing httpRequest on the interface Dazzle\Http\NetworkConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * @override
     * @inheritDoc
     */
    public function handleDisconnect(NetworkConnectionInterface $conn)
    {
        if ($conn->httpHeadersReceived)

Accessing httpHeadersReceived on the interface Dazzle\Http\NetworkConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        {
            $this->httpServer->handleDisconnect($conn);
        }
    }

    /**
     * @override
     * @inheritDoc
     */
    public function handleMessage(NetworkConnectionInterface $conn, NetworkMessageInterface $message)
    {
        if ($conn->httpHeadersReceived !== true)

Accessing httpHeadersReceived on the interface Dazzle\Http\NetworkConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        {
            try
            {
                if (($request = $this->httpDriver->readRequest($conn->httpBuffer, $message->read())) === null)

Accessing httpBuffer on the interface Dazzle\Http\NetworkConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                {
                    return;
                }
            }
            catch (Error $ex)
            {
                return $this->close($conn, 413);
            }
            catch (Exception $ex)
            {
                return $this->close($conn, 413);
            }

            $conn->httpHeadersReceived = true;

Accessing httpHeadersReceived on the interface Dazzle\Http\NetworkConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $conn->httpRequest = $request;

Accessing httpRequest on the interface Dazzle\Http\NetworkConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $this->httpServer->handleConnect($conn);
            $this->httpServer->handleMessage($conn, $request);

$request is of type object<Dazzle\Http\Http\HttpRequestInterface>, but the function expects a object<Dazzle\Http\NetworkMessageInterface>.

        }
        else
        {
            $this->httpServer->handleMessage($conn, $message);
        }
    }

    /**
     * @override
     * @inheritDoc
     */
    public function handleError(NetworkConnectionInterface $conn, $ex)
    {
        if ($conn->httpHeadersReceived)

Accessing httpHeadersReceived on the interface Dazzle\Http\NetworkConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        {
            $this->httpServer->handleError($conn, $ex);
        }
        else
        {
            $this->close($conn, 500);
        }
    }

    /**
     * Close a connection with an HTTP response.
     *
     * @param NetworkConnectionInterface $conn
     * @param int $code
     * @return null
     */
    protected function close(NetworkConnectionInterface $conn, $code = 400)
    {
        $response = new HttpResponse($code);

        $conn->send($response);
        $conn->close();
    }
}