WebSocketHandler::limitConcurrentConnections() - Code Metrics - Inspection of "Implement event dispatching for client messages" - beyondcode/laravel-websockets - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#181)

unknown

created 2019-05-23 14:47 UTC

WebSocketHandler::limitConcurrentConnections() A

↳ Parent: WebSocketHandler

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
rs	9.9
c	0
b	0
f	0
cc	3
nc	3
nop	1

<?php

namespace BeyondCode\LaravelWebSockets\WebSockets;

use Exception;
use Ratchet\ConnectionInterface;
use BeyondCode\LaravelWebSockets\Apps\App;
use Ratchet\RFC6455\Messaging\MessageInterface;
use Ratchet\WebSocket\MessageComponentInterface;
use BeyondCode\LaravelWebSockets\QueryParameters;
use BeyondCode\LaravelWebSockets\Facades\StatisticsLogger;
use BeyondCode\LaravelWebSockets\Dashboard\DashboardLogger;
use BeyondCode\LaravelWebSockets\WebSockets\Channels\ChannelManager;
use BeyondCode\LaravelWebSockets\WebSockets\Exceptions\UnknownAppKey;
use BeyondCode\LaravelWebSockets\WebSockets\Exceptions\WebSocketException;
use BeyondCode\LaravelWebSockets\WebSockets\Messages\PusherMessageFactory;
use BeyondCode\LaravelWebSockets\WebSockets\Exceptions\ConnectionsOverCapacity;

class WebSocketHandler implements MessageComponentInterface
{
    /** @var \BeyondCode\LaravelWebSockets\WebSockets\Channels\ChannelManager */
    protected $channelManager;

    public function __construct(ChannelManager $channelManager)
    {
        $this->channelManager = $channelManager;
    }

    public function onOpen(ConnectionInterface $connection)
    {
        $this
            ->verifyAppKey($connection)
            ->limitConcurrentConnections($connection)
            ->generateSocketId($connection)
            ->establishConnection($connection);
    }

    public function onMessage(ConnectionInterface $connection, MessageInterface $message)
    {
        $pusherMessage = PusherMessageFactory::createForMessage($message, $connection, $this->channelManager);

        $pusherMessage->respond();

        StatisticsLogger::webSocketMessage($connection);

        if ($connection->app->clientMessagesEnabled) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $payload = json_decode($message->getPayload());
            if (isset($payload->event)
                && in_array($payload->event, $connection->app->dispatchEventsForClientMessages)
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ) {
                $this->dispatchClientMessageEvent($payload->event, $payload);
            }
        }
    }

    public function onClose(ConnectionInterface $connection)
    {
        $this->channelManager->removeFromAllChannels($connection);

        DashboardLogger::disconnection($connection);

        StatisticsLogger::disconnection($connection);
    }

    public function onError(ConnectionInterface $connection, Exception $exception)
    {
        if ($exception instanceof WebSocketException) {
            $connection->send(json_encode(
                $exception->getPayload()
            ));
        }
    }

    protected function verifyAppKey(ConnectionInterface $connection)
    {
        $appKey = QueryParameters::create($connection->httpRequest)->get('appKey');
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        if (! $app = App::findByKey($appKey)) {
            throw new UnknownAppKey($appKey);
        }

        $connection->app = $app;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        return $this;
    }

    protected function limitConcurrentConnections(ConnectionInterface $connection)
    {
        if (! is_null($capacity = $connection->app->capacity)) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $connectionsCount = $this->channelManager->getConnectionCount($connection->app->id);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            if ($connectionsCount >= $capacity) {
                throw new ConnectionsOverCapacity();
            }
        }

        return $this;
    }

    protected function generateSocketId(ConnectionInterface $connection)
    {
        $socketId = sprintf('%d.%d', random_int(1, 1000000000), random_int(1, 1000000000));

        $connection->socketId = $socketId;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        return $this;
    }

    protected function establishConnection(ConnectionInterface $connection)
    {
        $connection->send(json_encode([
            'event' => 'pusher:connection_established',
            'data' => json_encode([
                'socket_id' => $connection->socketId,
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                'activity_timeout' => 30,
            ]),
        ]));

        DashboardLogger::connection($connection);

        StatisticsLogger::connection($connection);

        return $this;
    }

    protected function dispatchClientMessageEvent(string $event, $payload)
    {
        app('events')->dispatch('websockets.'.$event, [$payload]);
    }
}


1			<?php
2
3			namespace BeyondCode\LaravelWebSockets\WebSockets;
4
5			use Exception;
6			use Ratchet\ConnectionInterface;
7			use BeyondCode\LaravelWebSockets\Apps\App;
8			use Ratchet\RFC6455\Messaging\MessageInterface;
9			use Ratchet\WebSocket\MessageComponentInterface;
10			use BeyondCode\LaravelWebSockets\QueryParameters;
11			use BeyondCode\LaravelWebSockets\Facades\StatisticsLogger;
12			use BeyondCode\LaravelWebSockets\Dashboard\DashboardLogger;
13			use BeyondCode\LaravelWebSockets\WebSockets\Channels\ChannelManager;
14			use BeyondCode\LaravelWebSockets\WebSockets\Exceptions\UnknownAppKey;
15			use BeyondCode\LaravelWebSockets\WebSockets\Exceptions\WebSocketException;
16			use BeyondCode\LaravelWebSockets\WebSockets\Messages\PusherMessageFactory;
17			use BeyondCode\LaravelWebSockets\WebSockets\Exceptions\ConnectionsOverCapacity;
18
19			class WebSocketHandler implements MessageComponentInterface
20			{
21			/** @var \BeyondCode\LaravelWebSockets\WebSockets\Channels\ChannelManager */
22			protected $channelManager;
23
24			public function __construct(ChannelManager $channelManager)
25			{
26			$this->channelManager = $channelManager;
27			}
28
29			public function onOpen(ConnectionInterface $connection)
30			{
31			$this
32			->verifyAppKey($connection)
33			->limitConcurrentConnections($connection)
34			->generateSocketId($connection)
35			->establishConnection($connection);
36			}
37
38			public function onMessage(ConnectionInterface $connection, MessageInterface $message)
39			{
40			$pusherMessage = PusherMessageFactory::createForMessage($message, $connection, $this->channelManager);
41
42			$pusherMessage->respond();
43
44			StatisticsLogger::webSocketMessage($connection);
45
46			if ($connection->app->clientMessagesEnabled) {
			0 ignored issues – show Bug introduced 2019-05-23 14:44 UTC by Report Bug Copy Issue Report Accessing `app` on the interface `Ratchet\ConnectionInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
47			$payload = json_decode($message->getPayload());
48			if (isset($payload->event)
49			&& in_array($payload->event, $connection->app->dispatchEventsForClientMessages)
			0 ignored issues – show Bug introduced 2019-05-23 14:44 UTC by Report Bug Copy Issue Report Accessing `app` on the interface `Ratchet\ConnectionInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
50			) {
51			$this->dispatchClientMessageEvent($payload->event, $payload);
52			}
53			}
54			}
55
56			public function onClose(ConnectionInterface $connection)
57			{
58			$this->channelManager->removeFromAllChannels($connection);
59
60			DashboardLogger::disconnection($connection);
61
62			StatisticsLogger::disconnection($connection);
63			}
64
65			public function onError(ConnectionInterface $connection, Exception $exception)
66			{
67			if ($exception instanceof WebSocketException) {
68			$connection->send(json_encode(
69			$exception->getPayload()
70			));
71			}
72			}
73
74			protected function verifyAppKey(ConnectionInterface $connection)
75			{
76			$appKey = QueryParameters::create($connection->httpRequest)->get('appKey');
			0 ignored issues – show Bug introduced 2018-12-04 21:28 UTC by Report Bug Copy Issue Report Accessing `httpRequest` on the interface `Ratchet\ConnectionInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
77
78			if (! $app = App::findByKey($appKey)) {
79			throw new UnknownAppKey($appKey);
80			}
81
82			$connection->app = $app;
			0 ignored issues – show Bug introduced 2018-12-04 21:28 UTC by Report Bug Copy Issue Report Accessing `app` on the interface `Ratchet\ConnectionInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
83
84			return $this;
85			}
86
87			protected function limitConcurrentConnections(ConnectionInterface $connection)
88			{
89			if (! is_null($capacity = $connection->app->capacity)) {
			0 ignored issues – show Bug introduced 2019-03-30 23:52 UTC by Report Bug Copy Issue Report Accessing `app` on the interface `Ratchet\ConnectionInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
90			$connectionsCount = $this->channelManager->getConnectionCount($connection->app->id);
			0 ignored issues – show Bug introduced 2019-03-30 23:52 UTC by Report Bug Copy Issue Report Accessing `app` on the interface `Ratchet\ConnectionInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
91			if ($connectionsCount >= $capacity) {
92			throw new ConnectionsOverCapacity();
93			}
94			}
95
96			return $this;
97			}
98
99			protected function generateSocketId(ConnectionInterface $connection)
100			{
101			$socketId = sprintf('%d.%d', random_int(1, 1000000000), random_int(1, 1000000000));
102
103			$connection->socketId = $socketId;
			0 ignored issues – show Bug introduced 2018-12-04 21:28 UTC by Report Bug Copy Issue Report Accessing `socketId` on the interface `Ratchet\ConnectionInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
104
105			return $this;
106			}
107
108			protected function establishConnection(ConnectionInterface $connection)
109			{
110			$connection->send(json_encode([
111			'event' => 'pusher:connection_established',
112			'data' => json_encode([
113			'socket_id' => $connection->socketId,
			0 ignored issues – show Bug introduced 2018-12-04 21:28 UTC by Report Bug Copy Issue Report Accessing `socketId` on the interface `Ratchet\ConnectionInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
114			'activity_timeout' => 30,
115			]),
116			]));
117
118			DashboardLogger::connection($connection);
119
120			StatisticsLogger::connection($connection);
121
122			return $this;
123			}
124
125			protected function dispatchClientMessageEvent(string $event, $payload)
126			{
127			app('events')->dispatch('websockets.'.$event, [$payload]);
128			}
129			}
130

beyondcode / laravel-websockets

Pull Request — master (#181)

WebSocketHandler::limitConcurrentConnections() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like