Carno\HTTP\Powered\Swoole\Chips\Socket::socket()

Size

Total Lines	106
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	Socket.php$0 ➔ __construct()	0	3	1
A	Socket.php$0 ➔ push()	0	3	1
A	Socket.php$0 ➔ close()	0	3	1
A	Socket.php$0 ➔ valid()	0	3	1
A	Socket.php$0 ➔ status()	0	3	1

<?php
/**
 * SW client socket
 * User: moyo
 * Date: 2018/7/2
 * Time: 3:25 PM
 */

namespace Carno\HTTP\Powered\Swoole\Chips;

use Carno\HTTP\Client\Frame;
use Carno\HTTP\Client\Framing;
use Carno\HTTP\Contracts\WSocket;
use Carno\HTTP\Contracts\WSOpcode;
use Carno\HTTP\Exception\ErrorResponseException;
use Carno\HTTP\Standard\Utils\CodePhrases;
use Psr\Http\Message\RequestInterface as Request;
use Swoole\Http\Client as SWHClient;

The type Swoole\Http\Client was not found. Maybe you did not declare it correctly or list all dependencies?

use Swoole\WebSocket\Frame as SWSFrame;

The type Swoole\WebSocket\Frame was not found. Maybe you did not declare it correctly or list all dependencies?

trait Socket
{
    /**
     * @param Request $request
     * @return array
     */
    private function socket(Request $request) : array
    {
        /**
         * @var SWHClient $http
         */

        $http = $this->http;

        // -- frame handler

        $framing = new Framing($socket = new class($http) implements WSocket {
            /**
             * @var SWHClient
             */
            private $c = null;

            /**
             * @var bool
             */
            private $v = false;

            /**
             * anonymous constructor.
             * @param SWHClient $c
             */
            public function __construct(SWHClient $c)
            {
                $this->c = $c;
            }

            /**
             * @param bool $valid
             */
            public function status(bool $valid) : void
            {
                $this->v = $valid;
            }

            /**
             * @return bool
             */
            public function valid() : bool
            {
                return $this->v;
            }

            /**
             * @param Frame $frame
             */
            public function push(Frame $frame) : void
            {
                $this->c->push($frame->data(), $frame->code());
            }

            /**
             */
            public function close() : void
            {
                $this->push(new Frame(pack('n', 1000), WSOpcode::CLOSING));
            }
        });

        // -- message event

        $http->on('message', static function (SWHClient $c, SWSFrame $f) use ($framing, $socket) {
            switch ($f->opcode) {
                case WSOpcode::CLOSING:
                    $socket->status(false);
                    $framing->message()->close();
                    return;
                default:
                    $framing->message()->send(new Frame($f->data, $f->opcode));
            }
        });

        $http->on('close', static function (SWHClient $c) use ($framing, $socket) {

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

            $socket->status(false);
            $framing->message()->close();
        });

        // -- socket dial

        $connector = function ($fn) use ($http, $request) {
            $http->upgrade($this->getUriPath($request->getUri()), $fn);

It seems like getUriPath() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        };

        // -- socket resp

        $response = function (SWHClient $c) use ($request, $framing, $socket) {
            $code = $c->statusCode;

            if ($code === 101) {
                $socket->status(true);
                return $framing;
            }

            if ($code > 0) {
                throw new ErrorResponseException(CodePhrases::resolve($code), $code);
            }

            $this->throwing($request, $c);

It seems like throwing() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        };

        // -- packing

        return [$connector, $response];
    }
}