Server::getServerStats() - Code Metrics - Inspection of "Merge pull request #17 from igniphp/gzip-support" - igniphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 5d9a17...2628ea )

by Dawid
created 2018-06-17 22:24 UTC
Server::getServerStats() A

↳ Parent: Server
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0
ccs	2
cts	2
cp	1
crap	1
<?php declare(strict_types=1);

namespace Igni\Http;

use Igni\Exception\RuntimeException;
use Igni\Http\Server\ClientStats;
use Igni\Http\Server\OnConnect;
use Igni\Http\Server\OnShutdown;
use Igni\Http\Server\OnStart;
use Igni\Http\Server\ServerStats;
use Igni\Http\Server\HttpConfiguration;
use Igni\Http\Server\Listener;
use Igni\Http\Server\OnClose;
use Igni\Http\Server\OnRequest;
use Swoole;
filter:
    dependency_paths: ["lib/*"]

/**
 * Http server implementation based on swoole extension.
 *
 * @package Igni\Http
 */
class Server
{
    private const SWOOLE_EXT_NAME = 'swoole';

    /**
     * @var Swoole\Server|null
filter:
    dependency_paths: ["lib/*"]
     */
    private $handler;

    /**
     * @var HttpConfiguration
     */
    private $settings;

    /**
     * @var Listener[]
     */
    private $listeners = [];

    public function __construct(HttpConfiguration $settings = null)
    {
        if (!extension_loaded(self::SWOOLE_EXT_NAME)) {
            throw new RuntimeException('Could not run server without swoole extension.');
        }

        if ($settings === null) {
            $settings = new HttpConfiguration();
        }

        $this->settings = $settings;
    }

    /**
     * Return server configuration.
     *
     * @return HttpConfiguration
     */
    public function getSettings(): HttpConfiguration
    {
        return $this->settings;
    }

    /**
     * Adds listener that is attached to server once it is run.
     *
     * @param Listener $listener
     */
    public function addListener(Listener $listener): void
    {
        $this->listeners[] = $listener;
        if ($this->handler !== null) {
            $this->attachListener($listener);
        }
    }

    /**
     * Checks if listener exists.
     *
     * @param Listener $listener
     * @return bool
     */
    public function hasListener(Listener $listener): bool
    {
        return in_array($listener, $this->listeners);
    }

    /**
     * Returns information about client.
     *
     * @param int $clientId
     * @return ClientStats
     */
    public function getClientStats(int $clientId): ClientStats
    {
        return new ClientStats($this->handler->getClientInfo($clientId));
        return new ClientStats($this->handler->/** @scrutinizer ignore-call */ getClientInfo($clientId));
    }

    /**
     * Returns information about server.
     *
     * @return ServerStats
     */
    public function getServerStats(): ServerStats
    {
        return new ServerStats($this->handler->stats());
    }

    /**
     * Starts the server.
     */
    public function start(): void
    {
        $flags = SWOOLE_SOCK_TCP;

        if ($this->settings->isSslEnabled()) {
            $flags |= SWOOLE_SSL;
        }

        $settings = $this->settings->getSettings();

        if (!defined('IS_TEST') || IS_TEST !== true) {
            $this->handler = new Swoole\Http\Server($settings['address'], $settings['port'], SWOOLE_PROCESS, $flags);
filter:
    dependency_paths: ["lib/*"]
        }
        $this->handler->set($settings);

        // Attach listeners.
        foreach ($this->listeners as $listener) {
            $this->attachListener($listener);
        }

        // Start the server.
        $this->handler->start();
    }

    /**
     * Stops the server.
     */
    public function stop(): void
    {
        if ($this->handler !== null) {
            $this->handler->shutdown();
            $this->handler = null;
        }
    }

    private function attachListener(Listener $listener): void
    {
        if ($listener instanceof OnRequest) {
            $this->attachOnRequestListener($listener);
        }

        if ($listener instanceof OnConnect) {
            $this->attachOnConnectListener($listener);
        }

        if ($listener instanceof OnClose) {
            $this->attachOnCloseListener($listener);
        }

        if ($listener instanceof OnShutdown) {
            $this->attachOnShutdownListener($listener);
        }

        if ($listener instanceof OnStart) {
            $this->attachOnStartListener($listener);
        }
    }

    private function attachOnRequestListener(OnRequest $listener): void
    {
        $this->handler->on('Request', function($request, $response) use ($listener) {
            $this->normalizeOnRequestListener($request, $response, $listener);
        });
    }

    private function attachOnConnectListener(OnConnect $listener): void
    {
        $this->handler->on('Connect', function($handler, $clientId) use ($listener) {
            $listener->onConnect($this, $clientId);
        });
    }

    private function attachOnCloseListener(OnClose $listener): void
    {
        $this->handler->on('Close', function($handler, $clientId) use ($listener) {
            $listener->onClose($this, $clientId);
        });
    }

    private function attachOnShutdownListener(OnShutdown $listener): void
    {
        $this->handler->on('Shutdown', function() use ($listener) {
            $listener->onShutdown($this);
        });
    }

    private function attachOnStartListener(OnStart $listener): void
    {
        $this->handler->on('Start', function() use ($listener) {
            $listener->onStart($this);
        });
    }

    private function normalizeOnRequestListener(
        Swoole\Http\Request $request,
filter:
    dependency_paths: ["lib/*"]
        Swoole\Http\Response $response,
filter:
    dependency_paths: ["lib/*"]
        OnRequest $listener
    ): void {
        $psrRequest = ServerRequest::fromSwooleRequest($request);
        $psrResponse = $listener->onRequest($psrRequest);

        // Set headers
        foreach ($psrResponse->getHeaders() as $name => $values) {
            foreach ($values as $value) {
                $response->header($name, $value);
            }
        }

        // Response body.
        $body = $psrResponse->getBody()->getContents();

        // Status code
        $response->status($psrResponse->getStatusCode());

        // Protect server software header.
        $response->header('software-server', '');
        $response->header('server', '');

        // Support gzip/deflate encoding.
        if ($psrRequest->hasHeader('accept-encoding')) {
            $encoding = explode(',', strtolower(implode(',', $psrRequest->getHeader('accept-encoding'))));

            if (in_array('gzip', $encoding, true)) {
                $response->gzip(1);
            } elseif (in_array('deflate', $encoding, true)) {
                $response->header('content-encoding', 'deflate');
                $body = gzdeflate($body);
            }
        }

        $response->end($body);
    }
}

igniphp / framework

Push — master ( 5d9a17...2628ea )

Server::getServerStats() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
