Connection::__construct() - Code Metrics - Inspection of "Merge pull request #100 from Nekland/feature/webso..." - Nekland/Woketo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e26ab3...1dd3f4 )

by Maxime

created 2017-07-25 21:38 UTC

Connection::__construct() A

↳ Parent: Connection

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?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\Client;


use Nekland\Woketo\Core\AbstractConnection;
use Nekland\Woketo\Exception\Http\IncompleteHttpMessageException;
use Nekland\Woketo\Exception\RuntimeException;
use Nekland\Woketo\Exception\WebsocketException;
use Nekland\Woketo\Http\Response;
use Nekland\Woketo\Http\Url;
use Nekland\Woketo\Message\MessageHandlerInterface;
use Nekland\Woketo\Rfc6455\Frame;
use Nekland\Woketo\Rfc6455\Handshake\ClientHandshake;
use Nekland\Woketo\Rfc6455\MessageProcessor;
use React\EventLoop\LoopInterface;
use React\Promise\PromiseInterface;
use React\Stream\Stream;

class Connection extends AbstractConnection
{
    /**
     * @var string|null
     */
    private $handshakeKey;

    /**
     * @var string
     */
    private $buffer;

    /**
     * @var Url
     */
    private $url;

    public function __construct(Url $url, PromiseInterface $clientPromise, MessageProcessor $messageProcessor, MessageHandlerInterface $handler, LoopInterface $loop)
    {
        parent::__construct($messageProcessor, $loop, new ClientHandshake());

        $this->url = $url;
        $this->uri = $this->url->getUri();
        $this->buffer = '';
        $this->handler = $handler;

        $clientPromise->then(function (Stream $stream) {
            $this->stream = $stream;
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
            $this->onConnection($stream);
        }, function (\Exception $error){
            $this->onError($error);
        });
    }

    private function onConnection(Stream $stream)
    {
        $stream->on('data', function (string $data) {
            $this->onMessage($data);
        });

        // This is done because the handshake should come from the client.
        $this->processHandshake('');
    }

    /**
     * {@inheritdoc}
     */
    protected function processHandshake(string $data)
    {
        // Sending initialization request
        if (null === $this->handshakeKey) {
            $request = $this->handshake->getRequest($this->url);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $this->stream->write($request->getRequestAsString());
            $this->handshakeKey = $request->getKey();

            return;
        }

        $this->buffer .= $data;

        // Receiving the response
        try {
            $response = Response::create($this->buffer);
        } catch (IncompleteHttpMessageException $e) {
            return;
        }

        // Verifying response data
        $this->handshake->verify($response, $this->handshakeKey);

        // Signaling the handshake is done to jump in the message exchange process
        $this->handshakeDone = true;
        $this->getHandler()->onConnection($this);

        if (!empty($this->buffer)) {
            $buffer = $this->buffer;
            $this->buffer = '';
            $this->onMessage($buffer);
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function processMessage(string $data)
    {
        // It may be a timeout going (we were waiting for data), let's clear it.
        if ($this->timeout !== null) {
            $this->timeout->cancel();
            $this->timeout = null;
        }

        foreach ($this->messageProcessor->onData($data, $this->stream, $this->currentMessage) as $message) {
            $this->currentMessage = $message;

            if ($this->currentMessage->isComplete()) {
                // Sending the message through the woketo API.
                switch($this->currentMessage->getOpcode()) {
                    case Frame::OP_TEXT:
                        $this->getHandler()->onMessage($this->currentMessage->getContent(), $this);
                        break;
                    case Frame::OP_BINARY:
                        $this->getHandler()->onBinary($this->currentMessage->getContent(), $this);
                        break;
                }
                $this->currentMessage = null;

            } else {
                // We wait for more data so we start a timeout.
                $this->timeout = $this->loop->addTimer(Connection::DEFAULT_TIMEOUT, function () {
                    $this->getLogger()->notice('Connection to ' . $this->getIp() . ' timed out.');
                    $this->messageProcessor->timeout($this->stream);
                });
            }
        }
    }

    /**
     * @param string|Frame $frame
     * @param int          $opCode An int representing binary or text data (const of Frame class)
     * @throws \Nekland\Woketo\Exception\RuntimeException
     */
    public function write($frame, int $opCode = Frame::OP_TEXT)
    {
        try {
            $this->messageProcessor->write($frame, $this->stream, $opCode);
        } catch (WebsocketException $e) {
            throw new RuntimeException($e);
        }
    }

    /**
     * @param \Exception|string $error
     */
    private function onError($error)
    {
        $error = $error instanceof \Exception ? $error->getMessage() : $error;

        $this->getLogger()->error(sprintf('An error occured: %s', $error));
    }

    /**
     * {@inheritdoc}
     */
    public function getIp()
    {
        return $this->url->getHost();
    }
}


1			<?php
2
3			/**
4			* This file is a part of Woketo package.
5			*
6			* (c) Nekland <[email protected]>
7			*
8			* For the full license, take a look to the LICENSE file
9			* on the root directory of this project
10			*/
11
12			namespace Nekland\Woketo\Client;
13
14
15			use Nekland\Woketo\Core\AbstractConnection;
16			use Nekland\Woketo\Exception\Http\IncompleteHttpMessageException;
17			use Nekland\Woketo\Exception\RuntimeException;
18			use Nekland\Woketo\Exception\WebsocketException;
19			use Nekland\Woketo\Http\Response;
20			use Nekland\Woketo\Http\Url;
21			use Nekland\Woketo\Message\MessageHandlerInterface;
22			use Nekland\Woketo\Rfc6455\Frame;
23			use Nekland\Woketo\Rfc6455\Handshake\ClientHandshake;
24			use Nekland\Woketo\Rfc6455\MessageProcessor;
25			use React\EventLoop\LoopInterface;
26			use React\Promise\PromiseInterface;
27			use React\Stream\Stream;
28
29			class Connection extends AbstractConnection
30			{
31			/**
32			* @var string\|null
33			*/
34			private $handshakeKey;
35
36			/**
37			* @var string
38			*/
39			private $buffer;
40
41			/**
42			* @var Url
43			*/
44			private $url;
45
46			public function __construct(Url $url, PromiseInterface $clientPromise, MessageProcessor $messageProcessor, MessageHandlerInterface $handler, LoopInterface $loop)
47			{
48			parent::__construct($messageProcessor, $loop, new ClientHandshake());
49
50			$this->url = $url;
51			$this->uri = $this->url->getUri();
52			$this->buffer = '';
53			$this->handler = $handler;
54
55			$clientPromise->then(function (Stream $stream) {
56			$this->stream = $stream;
			0 ignored issues – show Documentation Bug introduced 2017-03-03 00:33 UTC by Report Bug Copy Issue Report `$stream` is of type `object<React\Stream\Stream>`, but the property `$stream` was declared to be of type `object<React\Socket\Connection>`. Are you sure that you always receive this specific sub-class here, or does it make sense to add an `instanceof` check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a given class or a super-class is assigned to a property that is type hinted more strictly. Either this assignment is in error or an instanceof check should be added for that assignment. class Alien {} class Dalek extends Alien {} class Plot { /** @var Dalek */ public $villain; } $alien = new Alien(); $plot = new Plot(); if ($alien instanceof Dalek) { $plot->villain = $alien; } Loading history...
57			$this->onConnection($stream);
58			}, function (\Exception $error){
59			$this->onError($error);
60			});
61			}
62
63			private function onConnection(Stream $stream)
64			{
65			$stream->on('data', function (string $data) {
66			$this->onMessage($data);
67			});
68
69			// This is done because the handshake should come from the client.
70			$this->processHandshake('');
71			}
72
73			/**
74			* {@inheritdoc}
75			*/
76			protected function processHandshake(string $data)
77			{
78			// Sending initialization request
79			if (null === $this->handshakeKey) {
80			$request = $this->handshake->getRequest($this->url);
			0 ignored issues – show Bug introduced 2017-07-04 06:19 UTC by Report Bug Copy Issue Report The method `getRequest` does only exist in `Nekland\Woketo\Rfc6455\Handshake\ClientHandshake`, but not in `Nekland\Woketo\Rfc6455\Handshake\ServerHandshake`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
81			$this->stream->write($request->getRequestAsString());
82			$this->handshakeKey = $request->getKey();
83
84			return;
85			}
86
87			$this->buffer .= $data;
88
89			// Receiving the response
90			try {
91			$response = Response::create($this->buffer);
92			} catch (IncompleteHttpMessageException $e) {
93			return;
94			}
95
96			// Verifying response data
97			$this->handshake->verify($response, $this->handshakeKey);
98
99			// Signaling the handshake is done to jump in the message exchange process
100			$this->handshakeDone = true;
101			$this->getHandler()->onConnection($this);
102
103			if (!empty($this->buffer)) {
104			$buffer = $this->buffer;
105			$this->buffer = '';
106			$this->onMessage($buffer);
107			}
108			}
109
110			/**
111			* {@inheritdoc}
112			*/
113			protected function processMessage(string $data)
114			{
115			// It may be a timeout going (we were waiting for data), let's clear it.
116			if ($this->timeout !== null) {
117			$this->timeout->cancel();
118			$this->timeout = null;
119			}
120
121			foreach ($this->messageProcessor->onData($data, $this->stream, $this->currentMessage) as $message) {
122			$this->currentMessage = $message;
123
124			if ($this->currentMessage->isComplete()) {
125			// Sending the message through the woketo API.
126			switch($this->currentMessage->getOpcode()) {
127			case Frame::OP_TEXT:
128			$this->getHandler()->onMessage($this->currentMessage->getContent(), $this);
129			break;
130			case Frame::OP_BINARY:
131			$this->getHandler()->onBinary($this->currentMessage->getContent(), $this);
132			break;
133			}
134			$this->currentMessage = null;
135
136			} else {
137			// We wait for more data so we start a timeout.
138			$this->timeout = $this->loop->addTimer(Connection::DEFAULT_TIMEOUT, function () {
139			$this->getLogger()->notice('Connection to ' . $this->getIp() . ' timed out.');
140			$this->messageProcessor->timeout($this->stream);
141			});
142			}
143			}
144			}
145
146			/**
147			* @param string\|Frame $frame
148			* @param int $opCode An int representing binary or text data (const of Frame class)
149			* @throws \Nekland\Woketo\Exception\RuntimeException
150			*/
151			public function write($frame, int $opCode = Frame::OP_TEXT)
152			{
153			try {
154			$this->messageProcessor->write($frame, $this->stream, $opCode);
155			} catch (WebsocketException $e) {
156			throw new RuntimeException($e);
157			}
158			}
159
160			/**
161			* @param \Exception\|string $error
162			*/
163			private function onError($error)
164			{
165			$error = $error instanceof \Exception ? $error->getMessage() : $error;
166
167			$this->getLogger()->error(sprintf('An error occured: %s', $error));
168			}
169
170			/**
171			* {@inheritdoc}
172			*/
173			public function getIp()
174			{
175			return $this->url->getHost();
176			}
177			}
178

Nekland / Woketo

Push — master ( e26ab3...1dd3f4 )

Connection::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like