FrameHandler::onBinary() - Code Metrics - Inspection of "more overhauling" - hfw/socket - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( a91d54...875978 )

by y
created 2020-03-09 13:11 UTC
FrameHandler::onBinary() A

↳ Parent: FrameHandler
Complexity

Conditions	4
Paths	4
Size

Total Lines	14
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	4
eloc	11
nc	4
nop	1
dl	0
loc	14
rs	9.9
c	1
b	0
f	0
<?php

namespace Helix\Socket\WebSocket;

/**
 * Handles received frames from the peer, and packs and sends frames.
 */
class FrameHandler {

    /**
     * The binary message buffer when streaming is disabled.
     *
     * @var string
     */
    protected $binary = '';

    /**
     * @var WebSocketClient
     */
    protected $client;

    /**
     * Opcode for the `CONTINUE` handler.
     *
     * @var int|null
     */
    protected $continue;

    /**
     * The text message buffer when streaming is disabled.
     *
     * @var string
     */
    protected $text = '';

    public function __construct (WebSocketClient $client) {
        $this->client = $client;
    }

    /**
     * When a `BINARY` frame is received.
     *
     * Throws by default.
     *
     * @param Frame $binary
     */
    protected function onBinary (Frame $binary): void {
        $handler = $this->client->getMessageHandler();
        if ($handler->isBinaryStream()) {
            $handler->onBinary($binary->getPayload());
        }
        else {
            if (strlen($this->binary) + $binary->getLength() > $handler->getMaxLength()) {
                throw new WebSocketError(Frame::CLOSE_TOO_LARGE, $handler->getMaxLength(), $binary);
            }
            $this->binary .= $binary->getPayload();
            if ($binary->isFinal()) {
                $message = $this->binary;
                $this->binary = '';
                $handler->onBinary($message);
            }
        }
    }

    /**
     * When a `CLOSE` frame is received.
     *
     * https://tools.ietf.org/html/rfc6455#section-5.5.1
     * > If an endpoint receives a Close frame and did not previously send a
     * > Close frame, the endpoint MUST send a Close frame in response.  (When
     * > sending a Close frame in response, the endpoint typically echos the
     * > status code it received.)
     *
     * @param Frame $close
     */
    protected function onClose (Frame $close): void {
        $this->client->close($close->getCloseCode());
    }

    /**
     * When a `CONTINUE` data fragment is received.
     *
     * @param Frame $frame
     */
    protected function onContinue (Frame $frame): void {
        switch ($this->continue) {
            case Frame::OP_TEXT:
                $this->onText($frame);
                break;
            case Frame::OP_BINARY:
                $this->onBinary($frame);
                break;
            default:
                throw new WebSocketError(
                    Frame::CLOSE_PROTOCOL_ERROR,
                    "Received CONTINUE without a prior fragment.",
                    $frame
                );
        }
    }

    /**
     * When a control frame is received.
     *
     * https://tools.ietf.org/html/rfc6455#section-5.4
     * > Control frames (see Section 5.5) MAY be injected in the middle of
     * > a fragmented message.
     *
     * @param Frame $control
     */
    protected function onControl (Frame $control): void {
        if ($control->isClose()) {
            $this->onClose($control);
        }
        elseif ($control->isPing()) {
            $this->onPing($control);
        }
        elseif ($control->isPong()) {
            $this->onPong($control);
        }
    }

    /**
     * When an initial data frame (not `CONTINUE`) is received.
     *
     * @param Frame $data
     */
    protected function onData (Frame $data): void {
        if ($data->isText()) {
            $this->onText($data);
        }
        elseif ($data->isBinary()) {
            $this->onBinary($data);
        }
    }

    /**
     * Invoked by the client when a complete frame has been received.
     *
     * Delegates to the other handler methods using the control flow outlined in the RFC.
     *
     * @param Frame $frame
     */
    public function onFrame (Frame $frame): void {
        $this->onFrame_CheckRsv($frame);
        $frame->validate();
        if ($frame->isControl()) {
            $this->onControl($frame);
        }
        elseif ($frame->isContinue()) {
            $this->onContinue($frame);
        }
        else {
            $this->onData($frame);
        }
    }

    /**
     * Throws if unknown RSV bits are received.
     *
     * @param Frame $frame
     */
    protected function onFrame_CheckRsv (Frame $frame): void {
        if ($badRsv = $frame->getRsv() & ~$this->client->getHandshake()->getRsv()) {
            $badRsv = str_pad(base_convert($badRsv, 10, 2), 3, 0, STR_PAD_LEFT);
            throw new WebSocketError(Frame::CLOSE_PROTOCOL_ERROR, "Received unknown RSV: 0b{$badRsv}");
        }
    }

    /**
     * When a `PING` frame is received.
     *
     * Automatically pongs the payload back by default.
     *
     * @param Frame $ping
     */
    protected function onPing (Frame $ping): void {
        $this->writePong($ping->getPayload());
    }

    /**
     * When a `PONG` frame is received.
     *
     * Does nothing by default.
     *
     * @param Frame $pong
     */
    protected function onPong (Frame $pong): void {
    protected function onPong (/** @scrutinizer ignore-unused */ Frame $pong): void {
        // stub
    }

    /**
     * When a `BINARY` frame is received.
     *
     * Throws by default.
     *
     * @param Frame $text
     */
    protected function onText (Frame $text): void {
        $handler = $this->client->getMessageHandler();
        if ($handler->isTextStream()) {
            $handler->onText($text->getPayload());
        }
        else {
            if (strlen($this->text) + $text->getLength() > $handler->getMaxLength()) {
                throw new WebSocketError(Frame::CLOSE_TOO_LARGE, $handler->getMaxLength(), $text);
            }
            $this->text .= $text->getPayload();
            if ($text->isFinal()) {
                $message = $this->text;
                $this->text = '';
                $handler->onText($message);
            }
        }
    }

    /**
     * Writes a frame to the peer.
     *
     * @param string $payload
     * @param int $opCode
     * @param bool $final
     */
    public function write (string $payload, int $opCode = Frame::OP_TEXT, bool $final = true): void {
        $head = chr(($final ? 0x80 : 0) | $opCode);
        $length = strlen($payload);
        if ($length > 65535) {
            $head .= chr(127);
            $head .= pack('J', $length);
        }
        elseif ($length >= 126) {
            $head .= chr(126);
            $head .= pack('n', $length);
        }
        else {
            $head .= chr($length);
        }
        $this->client->write($head . $payload);
    }

    public function writeBinary (string $payload, bool $final = true): void {
        $this->write($payload, Frame::OP_BINARY, $final);
    }

    public function writePing (string $payload = ''): void {
        $this->write($payload, Frame::OP_PING);
    }

    public function writePong (string $payload = ''): void {
        $this->write($payload, Frame::OP_PONG);
    }

    public function writeText (string $payload, bool $final = true): void {
        $this->write($payload, Frame::OP_TEXT, $final);
    }
}
hfw / socket

Push — master ( a91d54...875978 )

FrameHandler::onBinary() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
