Encore\LumenSwoole\Server

Complexity

Total Complexity

36

Size/Duplication

Total Lines	380
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	10
Bugs	2	Features	2

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	initHttpServer()	0	14	2
A	setApplication()	0	6	1
A	resolveApplication()	0	8	2
A	snapshotApplication()	0	6	2
A	basePath()	0	4	2
A	run()	0	18	3
A	isRunning()	0	10	2
A	options()	0	6	1
A	onRequest()	0	23	2
C	buildGlobals()	0	28	8
A	appendObContents()	0	4	1
A	handleLumenException()	0	4	1
A	handleLumenShutdown()	0	12	2
B	handleResponse()	0	28	4
A	onStart()	0	4	1
A	onShutdown()	0	4	1

<?php

namespace Encore\LumenSwoole;

use Illuminate\Container\Container;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Laravel\Lumen\Application;
use Laravel\Lumen\Exceptions\Handler;
use swoole_http_server as HttpServer;
use Symfony\Component\Debug\Exception\FatalErrorException;

class Server
{
    const VERSION = 'lumen-swoole 0.1.0';

    /**
     * @var \Laravel\Lumen\Application
     */
    protected $app;

    /**
     * @var string
     */
    protected $host = '127.0.0.1';

    /**
     * @var int
     */
    protected $port = 8083;

    /**
     * @var string
     */
    protected $pidFile = '';

    /**
     * @var HttpServer
     */
    protected $httpServer;

    /**
     * Http server options.
     *
     * @var array
     */
    protected $options = [];

    protected $appSnapshot = null;

    /**
     * @var array
     */
    public static $validServerOptions = [
        'reactor_num',
        'worker_num',
        'max_request',
        'max_conn',
        'task_worker_num',
        'task_ipc_mode',
        'task_max_request',
        'task_tmpdir',
        'dispatch_mode',
        'message_queue_key',
        'daemonize',
        'backlog',
        'log_file',
        'log_level',
        'heartbeat_check_interval',
        'heartbeat_idle_time',
        'open_eof_check',
        'open_eof_split',
        'package_eof',
        'open_length_check',
        'package_length_type',
        'package_max_length',
        'open_cpu_affinity',
        'cpu_affinity_ignore',
        'open_tcp_nodelay',
        'tcp_defer_accept',
        'ssl_cert_file',
        'ssl_method',
        'user',
        'group',
        'chroot',
        'pipe_buffer_size',
        'buffer_output_size',
        'socket_buffer_size',
        'enable_unsafe_event',
        'discard_timeout_request',
        'enable_reuse_port',
        'ssl_ciphers',
        'enable_delay_receive',
    ];

    /**
     * Create a new Server instance.
     *
     * @param string $host
     * @param int    $port
     */
    public function __construct($host = '127.0.0.1', $port = 8083)
    {
        $this->host = $host;
        $this->port = $port;
    }

    /**
     * Initialize the server.
     *
     * @return $this
     */
    public function initHttpServer()
    {
        if ($this->httpServer) {
            return $this;
        }

        $this->httpServer = new HttpServer($this->host, $this->port);

        $this->httpServer->on('Request', [$this, 'onRequest']);
        $this->httpServer->on('Start', [$this, 'onStart']);
        $this->httpServer->on('Shutdown', [$this, 'onShutdown']);

        return $this;
    }
    
    /**
     * Set application.
     *
     * @param \Laravel\Lumen\Application $app
     *
     * @return $this
     */
    public function setApplication($app)
    {
        $this->app = $app;

        return $this;
    }

    /**
     * Resolve application.
     *
     * @return void
     */
    protected function resolveApplication()
    {
        if (! $this->app) {
            require $this->basePath('bootstrap/app.php');
        }

        $this->snapshotApplication();
    }

    protected function snapshotApplication()
    {
        if (! $this->appSnapshot) {
            $this->appSnapshot = clone Application::getInstance();
        }
    }

    /**
     * Get the base path for the application.
     *
     * @param string|null $path
     *
     * @return string
     */
    public function basePath($path = null)
    {
        return getcwd().($path ? '/'.$path : $path);
    }

    /**
     * Start the server.
     *
     * @return void
     */
    public function run()
    {
        $this->initHttpServer();

        $this->resolveApplication();

        $this->pidFile = app()->storagePath('lumen-swoole.pid');

        if ($this->isRunning()) {
            throw new \Exception('The server is already running.');
        }

        if (!empty($this->options)) {
            $this->httpServer->set($this->options);
        }

        $this->httpServer->start();
    }

    /**
     * Determine if server is running.
     *
     * @return bool
     */
    public function isRunning()
    {
        if (!file_exists($this->pidFile)) {
            return false;
        }

        $pid = file_get_contents($this->pidFile);

        return (bool) posix_getpgid($pid);
    }

    /**
     * Set http server options.
     *
     * @param array $options
     *
     * @return $this
     */
    public function options($options = [])
    {
        $this->options = array_only($options, static::$validServerOptions);

        return $this;
    }

    /**
     * On request callback.
     *
     * @param \swoole_http_request  $request
     * @param \swoole_http_response $response
     */
    public function onRequest($request, $response)
    {
        $this->buildGlobals($request);

        $obContents = '';

        $request = Request::capture();

        register_shutdown_function([$this, 'handleLumenShutdown'], $request, $response);

        ob_start();
        try {
            $lumenResponse = Application::getInstance()->dispatch($request);
            $obContents = ob_get_contents();
        } catch (\Exception $e) {
            $lumenResponse = $this->handleLumenException($request, $e);
        }
        ob_end_clean();

        $lumenResponse = $this->appendObContents($lumenResponse, $obContents);

        $this->handleResponse($response, $lumenResponse);
    }

    /**
     * Build global variables.
     *
     * @param \swoole_http_request  $request
     * @return void
     */
    protected function buildGlobals($request)

buildGlobals uses the super-global variable $_SERVER which is generally not recommended.

buildGlobals uses the super-global variable $_GET which is generally not recommended.

buildGlobals uses the super-global variable $_POST which is generally not recommended.

buildGlobals uses the super-global variable $_COOKIE which is generally not recommended.

buildGlobals uses the super-global variable $_FILES which is generally not recommended.

    {
        foreach ($request->server as $key => $value) {
            $_SERVER[strtoupper($key)] = $value;
        }

        if (property_exists($request, 'get')) {
            $_GET = $request->get;
        }

        if (property_exists($request, 'post')) {
            $_POST = $request->post;
        }

        if (property_exists($request, 'cookie')) {
            $_COOKIE = $request->cookie;
        }

        if (property_exists($request, 'files')) {
            $_FILES = $request->files;
        }

        if (property_exists($request, 'header')) {
            foreach ($request->header as $key => $value) {
                $_SERVER['HTTP_'.strtoupper($key)] = $value;
            }
        }
    }

    /**
     * Append ob contents to response.
     *
     * @param Response $lumenResponse
     * @param string   $obContents
     * @return $this
     */
    protected function appendObContents(Response $lumenResponse, $obContents)
    {
        return $lumenResponse->setContent($obContents.$lumenResponse->getContent());
    }

    /**
     * Handle uncaught exception.
     *
     * @param Request    $request
     * @param \Exception $e
     * @return Response
     */
    public function handleLumenException($request, $e)
    {
        return (new Handler())->render($request, $e);
    }

    /**
     * Handle lumen shutdown.
     *
     * @param Request               $request
     * @param \swoole_http_response $response
     * @return void
     */
    public function handleLumenShutdown($request, $response)
    {
        if ($error = error_get_last()) {
            $lumenResponse = $this->handleLumenException($request, new FatalErrorException(
                $error['message'], $error['type'], 0, $error['file'], $error['line']
            ));

            $this->handleResponse($response, $lumenResponse);
        } else {
            $this->handleResponse($response, new Response(ob_get_contents()));
        }
    }

    /**
     * Response handler.
     *
     * @param \swoole_http_response $swooleResponse
     * @param Response              $response
     *
     * @return void
     */
    protected function handleResponse($swooleResponse, Response $response)
    {
        $swooleResponse->status($response->getStatusCode());

        foreach ($response->headers->allPreserveCase() as $name => $values) {
            foreach ($values as $value) {
                $swooleResponse->header($name, $value);
            }
        }

        // set cookies
        foreach ($response->headers->getCookies() as $cookie) {
            $swooleResponse->rawcookie(
                $cookie->getName(),
                $cookie->getValue(),
                $cookie->getExpiresTime(),
                $cookie->getPath(),
                $cookie->getDomain(),
                $cookie->isSecure(),
                $cookie->isHttpOnly()
            );
        }

        Application::setInstance(clone $this->appSnapshot);

        // send content & close
        $swooleResponse->end($response->getContent());
    }

    /**
     * Server start event callback.
     *
     * @param $server
     */
    public function onStart($server)
    {
        file_put_contents($this->pidFile, $server->master_pid);
    }

    /**
     * Server shutdown event callback.
     */
    public function onShutdown()
    {
        unlink($this->pidFile);
    }
}