MessageProcessor::processControlFrame() - Code Metrics - Inspection of "Start little refactoring to delete addData inside..." - Nekland/Woketo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#81)

by Charlotte

created 2016-11-19 14:02 UTC

MessageProcessor::processControlFrame() A

↳ Parent: MessageProcessor

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	8
ccs	5
cts	5
cp	1
rs	9.4285
cc	1
eloc	5
nc	1
nop	2
crap	1

<?php
/**
 * This file is a part of Woketo package.
 *
 * (c) Nekland <[email protected]>
 *
 * For the full license, take a look to the LICENSE file
 * on the root directory of this project
 */

namespace Nekland\Woketo\Rfc6455;

use Nekland\Woketo\Exception\Frame\IncoherentDataException;
use Nekland\Woketo\Exception\Frame\IncompleteFrameException;
use Nekland\Woketo\Exception\Frame\ProtocolErrorException;
use Nekland\Woketo\Exception\LimitationException;
use Nekland\Woketo\Rfc6455\MessageHandler\Rfc6455MessageHandlerInterface;
use React\Socket\ConnectionInterface;

/**
 * Class MessageProcessor
 *
 * This class is only a helper for Connection to avoid having so much instances of classes in memory.
 * Using it like that allow us to have only one instance of MessageProcessor.
 */
class MessageProcessor
{
    /**
     * @var FrameFactory
     */
    private $frameFactory;

    /**
     * @var Rfc6455MessageHandlerInterface[]
     */
    private $handlers;

    public function __construct(FrameFactory $factory = null)
    {
        $this->frameFactory = $factory ?: new FrameFactory();
        $this->handlers = [];
    }

    /**
     * This methods process data received from the socket to generate a `Message` entity and/or process handler
     * which may answer to some special frames.
     *
     * (binary data entry string in {}, frames in || and messages (of potentially many frames) in [])
     * This method buffer in many ways:
     *
     * - { [|frame1 (not final) |, |frame2 (final)|] }
     *   => buffer 2 frames from 1 binary to generate 1 message
     *
     * - { [|frame1 (not final, not finished } { frame 1 (final, finished)| } { |frame 2 (final, finished)|] }
     *   => buffer 2 frames from 3 binary data to generate 1 message
     *
     * - { [|frame1 (not final, not finished } { frame control 1 (final, finished)| } { |frame 2 (final, finished)|] }
     *   => buffer 2 frames from 3 binary data to generate 1 ping and 1 message
     *
     * @param string              $data
     * @param ConnectionInterface $socket
     * @param Message|null        $message
     * @return \Generator
     */
    public function onData(string $data, ConnectionInterface $socket, Message $message = null)
    {
        do {
            if (null === $message) {
                $message = new Message();
            }

            try {
                $message->addBuffer($data);

                // Loop that build message if the message is in many frames in the same data binary frame received.
                do {
                    try {
                        $frame = new Frame($message->getBuffer());

                        if ($frame->isControlFrame()) {
                            $controlFrameMessage = $this->processControlFrame($frame, $socket);

                            yield $controlFrameMessage; // Because every message should be returned !
                        } else {
                            $message->addFrame($frame);
                        }

                        // If the frame is a success maybe we still need to create messages
                        // And the buffer must be updated
                        $data = $message->removeFromBuffer($frame);
                    } catch (IncompleteFrameException $e) {
                        // Data is now stored in the message, let's clean the variable to stop both loops.
                        $data = null;
                    }
                } while(!$message->isComplete() && !empty($data));

                if ($message->isComplete()) {
                    $this->processHelper($message, $socket);

                    yield $message;
                    $message = null;
                } else {
                    yield $message;
                }
            } catch (IncoherentDataException $e) {
                $this->write($this->frameFactory->createCloseFrame(Frame::CLOSE_INCOHERENT_DATA), $socket);
                $socket->end();
                $data = '';
            } catch (ProtocolErrorException $e) {
                $this->write($this->frameFactory->createCloseFrame(Frame::CLOSE_PROTOCOL_ERROR), $socket);
                $socket->end();
                $data = '';
            } catch (LimitationException $e) {
                $this->write($this->frameFactory->createCloseFrame(Frame::CLOSE_TOO_BIG_TO_PROCESS), $socket);
                $socket->end();
                $data = '';
            }
        } while(!empty($data));
    }

    /**
     * @param Message $message
     * @param ConnectionInterface $socket
     */
    protected function processHelper(Message $message, ConnectionInterface $socket)
    {
        foreach ($this->handlers as $handler) {
            if ($handler->supports($message)) {
                $handler->process($message, $this, $socket);
            }
        }
    }

    /**
     * @param Frame $frame
     * @param ConnectionInterface $socket
     *
     * @return Message
     */
    protected function processControlFrame(Frame $frame, ConnectionInterface $socket) : Message
    {
        $controlFrameMessage = new Message();
        $controlFrameMessage->addFrame($frame);
        $this->processHelper($controlFrameMessage, $socket);

        return $controlFrameMessage;
    }

    /**
     * @param Rfc6455MessageHandlerInterface $handler
     * @return self
     */
    public function addHandler(Rfc6455MessageHandlerInterface $handler)
    {
        $this->handlers[] = $handler;

        return $this;
    }

    /**
     * @param Frame|string        $frame
     * @param ConnectionInterface $socket
     * @param int                 $opCode An int representing binary or text data (const of Frame class)
     */
    public function write($frame, ConnectionInterface $socket, int $opCode = Frame::OP_TEXT)
    {
        if (!$frame instanceof Frame) {
            $data = $frame;
            $frame = new Frame();
            $frame->setPayload($data);
            $frame->setOpcode($opCode);
        }

        $socket->write($frame->getRawData());
    }

    /**
     * @return FrameFactory
     */
    public function getFrameFactory(): FrameFactory
    {
        return $this->frameFactory;
    }

    /**
     * @param ConnectionInterface $socket
     */
    public function timeout(ConnectionInterface $socket)
    {
        $this->write($this->frameFactory->createCloseFrame(Frame::CLOSE_PROTOCOL_ERROR), $socket);
        $socket->close();
    }

    /**
     * @param ConnectionInterface $socket
     */
    public function close(ConnectionInterface $socket)
    {
        $this->write($this->frameFactory->createCloseFrame(), $socket);
    }
}


1		<?php
2		/**
3		* This file is a part of Woketo package.
4		*
5		* (c) Nekland <[email protected]>
6		*
7		* For the full license, take a look to the LICENSE file
8		* on the root directory of this project
9		*/
10
11		namespace Nekland\Woketo\Rfc6455;
12
13		use Nekland\Woketo\Exception\Frame\IncoherentDataException;
14		use Nekland\Woketo\Exception\Frame\IncompleteFrameException;
15		use Nekland\Woketo\Exception\Frame\ProtocolErrorException;
16		use Nekland\Woketo\Exception\LimitationException;
17		use Nekland\Woketo\Rfc6455\MessageHandler\Rfc6455MessageHandlerInterface;
18		use React\Socket\ConnectionInterface;
19
20		/**
21		* Class MessageProcessor
22		*
23		* This class is only a helper for Connection to avoid having so much instances of classes in memory.
24		* Using it like that allow us to have only one instance of MessageProcessor.
25		*/
26		class MessageProcessor
27		{
28		/**
29		* @var FrameFactory
30		*/
31		private $frameFactory;
32
33		/**
34		* @var Rfc6455MessageHandlerInterface[]
35		*/
36		private $handlers;
37
38	11	public function __construct(FrameFactory $factory = null)
39		{
40	11	$this->frameFactory = $factory ?: new FrameFactory();
41	11	$this->handlers = [];
42	11	}
43
44		/**
45		* This methods process data received from the socket to generate a `Message` entity and/or process handler
46		* which may answer to some special frames.
47		*
48		* (binary data entry string in {}, frames in \|\| and messages (of potentially many frames) in [])
49		* This method buffer in many ways:
50		*
51		* - { [\|frame1 (not final) \|, \|frame2 (final)\|] }
52		* => buffer 2 frames from 1 binary to generate 1 message
53		*
54		* - { [\|frame1 (not final, not finished } { frame 1 (final, finished)\| } { \|frame 2 (final, finished)\|] }
55		* => buffer 2 frames from 3 binary data to generate 1 message
56		*
57		* - { [\|frame1 (not final, not finished } { frame control 1 (final, finished)\| } { \|frame 2 (final, finished)\|] }
58		* => buffer 2 frames from 3 binary data to generate 1 ping and 1 message
59		*
60		* @param string $data
61		* @param ConnectionInterface $socket
62		* @param Message\|null $message
63		* @return \Generator
64		*/
65	9	public function onData(string $data, ConnectionInterface $socket, Message $message = null)
66		{
67		do {
68	9	if (null === $message) {
69	9	$message = new Message();
70		}
71
72		try {
73	9	$message->addBuffer($data);
74
75		// Loop that build message if the message is in many frames in the same data binary frame received.
76		do {
77		try {
78	9	$frame = new Frame($message->getBuffer());
79
80	6	if ($frame->isControlFrame()) {
81	2	$controlFrameMessage = $this->processControlFrame($frame, $socket);
82
83	2	yield $controlFrameMessage; // Because every message should be returned !
84		} else {
85	5	$message->addFrame($frame);
86		}
87
88		// If the frame is a success maybe we still need to create messages
89		// And the buffer must be updated
90	6	$data = $message->removeFromBuffer($frame);
91	3	} catch (IncompleteFrameException $e) {
92		// Data is now stored in the message, let's clean the variable to stop both loops.
93		$data = null;
94		}
95	6	} while(!$message->isComplete() && !empty($data));
96
97	6	if ($message->isComplete()) {
98	5	$this->processHelper($message, $socket);
99
100	5	yield $message;
101	5	$message = null;
102		} else {
103	6	yield $message;
104		}
105	3	} catch (IncoherentDataException $e) {
106	1	$this->write($this->frameFactory->createCloseFrame(Frame::CLOSE_INCOHERENT_DATA), $socket);
107	1	$socket->end();
108	1	$data = '';
109	2	} catch (ProtocolErrorException $e) {
110	1	$this->write($this->frameFactory->createCloseFrame(Frame::CLOSE_PROTOCOL_ERROR), $socket);
111	1	$socket->end();
112	1	$data = '';
113	1	} catch (LimitationException $e) {
114	1	$this->write($this->frameFactory->createCloseFrame(Frame::CLOSE_TOO_BIG_TO_PROCESS), $socket);
115	1	$socket->end();
116	1	$data = '';
117		}
118	9	} while(!empty($data));
119	9	}
120
121		/**
122		* @param Message $message
123		* @param ConnectionInterface $socket
124		*/
125	6	protected function processHelper(Message $message, ConnectionInterface $socket)
126		{
127	6	foreach ($this->handlers as $handler) {
128	2	if ($handler->supports($message)) {
129	2	$handler->process($message, $this, $socket);
130		}
131		}
132	6	}
133
134		/**
135		* @param Frame $frame
136		* @param ConnectionInterface $socket
137		*
138		* @return Message
139		*/
140	2	protected function processControlFrame(Frame $frame, ConnectionInterface $socket) : Message
141		{
142	2	$controlFrameMessage = new Message();
143	2	$controlFrameMessage->addFrame($frame);
144	2	$this->processHelper($controlFrameMessage, $socket);
145
146	2	return $controlFrameMessage;
147		}
148
149		/**
150		* @param Rfc6455MessageHandlerInterface $handler
151		* @return self
152		*/
153	2	public function addHandler(Rfc6455MessageHandlerInterface $handler)
154		{
155	2	$this->handlers[] = $handler;
156
157	2	return $this;
158		}
159
160		/**
161		* @param Frame\|string $frame
162		* @param ConnectionInterface $socket
163		* @param int $opCode An int representing binary or text data (const of Frame class)
164		*/
165	6	public function write($frame, ConnectionInterface $socket, int $opCode = Frame::OP_TEXT)
166		{
167	6	if (!$frame instanceof Frame) {
168	1	$data = $frame;
169	1	$frame = new Frame();
170	1	$frame->setPayload($data);
171	1	$frame->setOpcode($opCode);
172		}
173
174	6	$socket->write($frame->getRawData());
175	6	}
176
177		/**
178		* @return FrameFactory
179		*/
180	2	public function getFrameFactory(): FrameFactory
181		{
182	2	return $this->frameFactory;
183		}
184
185		/**
186		* @param ConnectionInterface $socket
187		*/
188		public function timeout(ConnectionInterface $socket)
189		{
190		$this->write($this->frameFactory->createCloseFrame(Frame::CLOSE_PROTOCOL_ERROR), $socket);
191		$socket->close();
192		}
193
194		/**
195		* @param ConnectionInterface $socket
196		*/
197		public function close(ConnectionInterface $socket)
198		{
199		$this->write($this->frameFactory->createCloseFrame(), $socket);
200		}
201		}
202

Nekland / Woketo

Pull Request — master (#81)

MessageProcessor::processControlFrame() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like