Laravoole\Wrapper\SwooleWebSocketWrapper

Complexity

Total Complexity

32

Size/Duplication

Total Lines	213
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

78.42%

Importance

Changes	10
Bugs	1	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getParams()	0	7	1
A	start()	0	16	1
A	onFinish()	0	4	1
A	registerCodec()	0	10	3
A	onTask()	0	8	3
C	onHandShake()	0	41	8
B	onMessage()	0	37	6
B	dispatch()	0	28	3
A	endResponse()	0	20	3
A	onClose()	0	12	2

<?php
namespace Laravoole\Wrapper;

use swoole_websocket_server;
use swoole_http_request;
use swoole_http_response;
use swoole_process;

use Laravoole\Request;
use Laravoole\Response;
use Laravoole\WebsocketCodec\Json;
use Laravoole\WebsocketCodec\JsonRpc;

use Symfony\Component\HttpFoundation\BinaryFileResponse;

class SwooleWebSocketWrapper extends SwooleHttpWrapper implements ServerInterface
{
    protected $defaultProtocol;

    protected $pushProcess;

    protected $connections = [];

    protected $unfinished = [];

    protected static $protocolCodecs = [
        'json' => Json::class,
        'jsonrpc' => JsonRpc::class,
    ];

    public function __construct($host, $port)
    {
        $this->server = new swoole_websocket_server($host, $port);
    }

    public static function getParams()
    {
        $params = parent::getParams();
        unset($params[array_search('task_worker_num', $params)]);
        $params['task_worker_num'] = 1;
        return $params;
    }

    public static function registerCodec($protocol, $class = null)
    {
        if (is_string($protocol)) {
            if (!class_exists($class)) {
                throw new Exception("class $class not found", 1);
            }
            $protocol = [$protocol => $class];
        }
        static::$protocolCodecs = array_merge(static::$protocolCodecs, $protocol);
    }

    public function start()
    {
        $this->defaultProtocol = $this->wrapper_config['websocket_default_protocol'];

        static::registerCodec($this->wrapper_config['websocket_protocols']);

        $this->callbacks = array_merge([
            'HandShake' => [$this, 'onHandShake'],
            'Message' => [$this, 'onMessage'],
            'Close' => [$this, 'onClose'],
            'Task' => [static::class, 'onTask'],
            'Finish' => [static::class, 'onFinish'],
        ], $this->callbacks);
        parent::start();

    }

    public static function onTask($server, $task_id, $from_id, $data)

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

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

    {
        foreach ($data['fds'] as $fd) {
            try {
                $server->push($fd, $data['params']);
            } catch (\ErrorException $e) {}

Consider adding a comment why this CATCH block is empty.

        }
    }

    public static function onFinish($server, $task_id, $data)

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

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

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

    {

    }

    public function onHandShake(swoole_http_request $request, swoole_http_response $response)
    {
        $protocol = false;
        if (isset($request->header['sec-websocket-protocol'])) {
            $protocols = preg_split('~,\s*~', $request->header['sec-websocket-protocol']);
            foreach ($protocols as $protocol) {
                if (isset(static::$protocolCodecs[$protocol])) {
                    break;
                }
            }
            if ($protocol) {
                $response->header('Sec-WebSocket-Protocol', $protocol);
            }
        }

        if (!$protocol) {
            $protocol = $this->defaultProtocol;
        }

        $secKey = $request->header['sec-websocket-key'];
        $secAccept = base64_encode(pack('H*', sha1($secKey . '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')));

        foreach ([
            "Upgrade" => "websocket",
            "Connection" => "Upgrade",
            "Sec-WebSocket-Version" => "13",
            "Sec-WebSocket-Accept" => $secAccept,
        ] as $k => $v) {
            $response->header($k, $v);
        }
        $response->status(101);

        $laravooleRequest = new Request($request->fd);
        foreach ($request as $k => $v) {
            $laravooleRequest->$k = $v;
        }
        $this->connections[$request->fd] = ['request' => $laravooleRequest, 'protocol' => static::$protocolCodecs[$protocol]];
        $this->unfinished[$request->fd] = '';
        return true;

    }

    public function onMessage(swoole_websocket_server $server, $frame)
    {
        if (!isset($this->unfinished[$frame->fd])) {
            return false;
        }
        if (isset($this->connections[$frame->fd]['request']->laravooleInfo->nextMessageRoute)) {
            $request = $this->connections[$frame->fd]['request'];
            $route = $request->laravooleInfo->nextMessageRoute;
            $data['method'] = $route['method'];

$data was never initialized. Although not strictly required by PHP, it is generally a good practice to add $data = array(); before regardless.

            $data['params'] = $route['params'];
            $data['params']['_laravoole_raw'] = $frame->data;
            $data['params']['_laravoole_previous'] = $route['previous'];

            $data['echo'] = $request->echo;
            if ($frame->finish) {
                unset($request->laravooleInfo->nextMessageRoute);
            }
            return $this->dispatch($server, $frame->fd, $data);

        } else {
            $this->unfinished[$frame->fd] .= $frame->data;
        }

        if (!$frame->finish) {
            return;
        }
        $protocol = $this->connections[$frame->fd]['protocol'];
        $data = $protocol::decode($this->unfinished[$frame->fd]);
        if (is_null($data)) {
            return;
        }

        $this->unfinished[$frame->fd] = '';

        return $this->dispatch($server, $frame->fd, $data);

    }

    protected function dispatch($server, $fd, $data)
    {
        $request = $this->connections[$fd]['request'];

        $request->method = $request->server['request_uri'] = $data['method'];
        $request->get = (array) ($data['params']);
        $request->echo = isset($data['echo']) ? $data['echo'] : null;
        $request = $this->ucHeaders($request);

        $response = new Response($this, $request);
        $illuminateRequest = $this->convertRequest($request);

        if (isset($request->laravooleInfo)) {
            $illuminateRequest->setLaravooleInfo($request->laravooleInfo);
        } else {
            $illuminateRequest->setLaravooleInfo((object) [
                'fd' => $fd,
                'server' => $server,
                'codec' => $this->connections[$response->request->fd]['protocol'],
            ]);
        }
        $illuminateRequest->headers->set('X-Requested-With', 'XMLHttpRequest');
        $illuminateRequest->headers->set('Accept', 'Accept: text/html,application/xhtml+xml,application/xml,application/json');
        $illuminateResponse = parent::handleRequest($illuminateRequest);

It seems like you call parent on a different method (handleRequest() instead of dispatch()). Are you sure this is correct? If so, you might want to change this to $this->handleRequest().

        $this->handleResponse($response, $illuminateResponse, '');

        $request->laravooleInfo = $illuminateRequest->getLaravooleInfo();
    }

    public function endResponse($response, $content)
    {
        if (isset($response->request)) {
            if (!is_string($content)) {
                $content = file_get_contents($content());
            }
            // This is a websocket request
            $protocol = $this->connections[$response->request->fd]['protocol'];
            $data = $protocol::encode(
                $response->http_status,
                $response->request->method,
                $content,
                $response->request->echo
            );
            $this->server->push($response->request->fd, $data);

The method push() does not seem to exist on object<Laravoole\Workerman\Worker>.

        } else {
            // This is a http request
            parent::endResponse($response, $content);
        }
    }

    public function onClose($server, $fd)
    {
        if (!isset($this->connections[$fd])) {
            return;
        }
        $request = $this->connections[$fd]['request'];
        $this->events->fire('laravoole.swoole.websocket.closing', [$request, $fd]);

The property events does not exist. Did you maybe forget to declare it?

        unset($this->unfinished[$fd]);
        unset($this->connections[$fd]);

    }
}