WebSocketManager::handleMessage() - Code Metrics - Inspection of "implement a basic token-based authentication syste..." - Jalle19/tvheadend-status-manager - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3c24ea...404feb )

by Sam

created 2016-04-15 19:44 UTC

WebSocketManager::handleMessage() A

↳ Parent: WebSocketManager

Complexity

Conditions	3
Paths	3

Size

Total Lines	21
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	21
ccs	0
cts	15
cp	0
rs	9.3142
cc	3
eloc	11
nc	3
nop	2
crap	12

<?php

namespace Jalle19\StatusManager\Manager;

use Jalle19\StatusManager\Configuration\Configuration;
use Jalle19\StatusManager\Event\Events;
use Jalle19\StatusManager\Event\InstanceStatusUpdatesEvent;
use Jalle19\StatusManager\Exception\MalformedRequestException;
use Jalle19\StatusManager\Exception\UnhandledMessageException;
use Jalle19\StatusManager\Exception\UnknownRequestException;
use Jalle19\StatusManager\Message\AbstractMessage;
use Jalle19\StatusManager\Message\Factory as MessageFactory;
use Jalle19\StatusManager\Message\Handler\DelegatesMessagesTrait;
use Jalle19\StatusManager\Message\Handler\HandlerInterface;
use Jalle19\StatusManager\Message\Request\AuthenticationRequest;
use Jalle19\StatusManager\Message\Response\AuthenticationResponse;
use Jalle19\StatusManager\Message\StatusUpdatesMessage;
use Jalle19\tvheadend\exception\RequestFailedException;
use Psr\Log\LoggerInterface;
use Ratchet\ConnectionInterface;
use Ratchet\Http\HttpServer;
use Ratchet\MessageComponentInterface;
use Ratchet\Server\IoServer;
use Ratchet\WebSocket\WsServer;
use React\EventLoop\LoopInterface;
use React\Socket\Server as ServerSocket;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

/**
 * Handles events related to the WebSocket. Events are either triggered from Ratchet (onOpen etc.)
 * or, the event dispatcher or client requests.
 *
 * @package   Jalle19\StatusManager
 * @copyright Copyright &copy; Sam Stenvall 2016-
 * @license   https://www.gnu.org/licenses/gpl.html The GNU General Public License v2.0
 */
class WebSocketManager extends AbstractManager implements
	MessageComponentInterface,

	EventSubscriberInterface,

	HandlerInterface

{

	use DelegatesMessagesTrait;

	/**
	 * @var IoServer the Websocket server
	 */
	private $_websocket;

	/**
	 * @var \SplObjectStorage the connected clients
	 */
	private $_connectedClients;

	/**
	 * @var \SplObjectStorage the authenticated clients
	 */
	private $_authenticatedClients;


	/**
	 * WebSocketManager constructor.
	 *
	 * @param Configuration   $configuration
	 * @param LoggerInterface $logger
	 * @param EventDispatcher $eventDispatcher
	 * @param LoopInterface   $loop
	 */
	public function __construct(
		Configuration $configuration,
		LoggerInterface $logger,
		EventDispatcher $eventDispatcher,
		LoopInterface $loop
	) {
		parent::__construct($configuration, $logger, $eventDispatcher);

		// Keep track of clients
		$this->_connectedClients     = new \SplObjectStorage();
		$this->_authenticatedClients = new \SplObjectStorage();

		// Create the socket to listen on
		$socket = new ServerSocket($loop);
		$socket->listen($configuration->getListenPort(), $configuration->getListenAddress());

		// Create the WebSocket server
		$this->_websocket = new IoServer(new HttpServer(new WsServer($this)), $socket, $loop);
	}


	/**
	 * @inheritdoc
	 */
	public static function getSubscribedEvents()
	{
		return [
			Events::MAIN_LOOP_STARTING      => 'onMainLoopStarted',
			Events::INSTANCE_STATUS_UPDATES => 'onInstanceStatusUpdates',
		];
	}


	/**
	 * Called right before the main loop is started
	 */
	public function onMainLoopStarted()
	{
		$this->logger->info('Starting the Websocket server on {address}:{port}', [
			'address' => $this->configuration->getListenAddress(),
			'port'    => $this->configuration->getListenPort(),
		]);
	}


	/**
	 * @param InstanceStatusUpdatesEvent $event
	 */
	public function onInstanceStatusUpdates(InstanceStatusUpdatesEvent $event)
	{
		$this->logger->debug('Broadcasting statuses to all clients');
		$message = new StatusUpdatesMessage($event->getInstanceStatusCollection());

		foreach ($this->_authenticatedClients as $client)
		{
			/* @var ConnectionInterface $client */
			$this->sendMessage($message, $client);
		}
	}


	/**
	 * @inheritdoc
	 */
	public function onOpen(ConnectionInterface $conn)
	{
		$this->logger->debug('Got client connection');
		$this->_connectedClients->attach($conn);
	}


	/**
	 * @inheritdoc
	 */
	public function onClose(ConnectionInterface $conn)
	{
		$this->logger->debug('Got client disconnect');

		$this->_connectedClients->detach($conn);
		$this->_authenticatedClients->detach($conn);
	}


	/**
	 * @inheritdoc
	 */
	public function onError(ConnectionInterface $conn, \Exception $e)
	{
		// TODO: Implement onError() method.
	}


	/**
	 * @inheritdoc
	 */
	public function handleMessage(AbstractMessage $message, ConnectionInterface $sender)
	{
		if ($message->getType() !== AbstractMessage::TYPE_AUTHENTICATION_REQUEST)
			return false;

		/* @var AuthenticationRequest $message */
		$status = AuthenticationResponse::STATUS_FAILURE;

		// Add the sender to the list of authenticated clients
		if ($message->getAccessToken() === $this->configuration->getAccessToken())
		{
			$status = AuthenticationResponse::STATUS_SUCCESS;
			$this->_authenticatedClients->attach($sender);

			$this->logger->info('Client authenticated successfully');
		}
		else
			$this->logger->warning('Got invalid authentication request from client');

		return new AuthenticationResponse($status);
	}


	/**
	 * Dispatches incoming client messages to the appropriate handlers
	 *
	 * @param ConnectionInterface $from
	 * @param string              $msg
	 */
	public function onMessage(ConnectionInterface $from, $msg)
	{
		try
		{
			$message = MessageFactory::factory($msg);

			$this->logger->debug('Got message from client (type: {messageType})', [
				'messageType' => $message->getType(),
			]);

			// Attempt to delegate the message
			try
			{
				$response = $this->tryDelegateMessage($message, $from);
				$this->sendMessage($response, $from);
			}
			catch (RequestFailedException $e)
			{
				$this->logger->critical('The request failed: ' . $e->getMessage());
			}
			catch (UnhandledMessageException $e)
			{
				$this->logger->error('Unhandled message (type: {messageType})', [
					'messageType' => $message->getType(),
				]);
			}
		}
		catch (MalformedRequestException $e)
		{
			$this->logger->error('Got malformed message from client (reason: {reason})', [
				'reason' => $e->getMessage(),
			]);
		}
		catch (UnknownRequestException $e)
		{
			// The server itself sometimes sends out messages that are received here, hence debug
			$this->logger->debug('Got unknown message from client (type: {messageType})', [
				'messageType' => $e->getType(),
			]);
		}
	}


	/**
	 * @param AbstractMessage     $message
	 * @param ConnectionInterface $target
	 */
	private function sendMessage(AbstractMessage $message, ConnectionInterface $target)
	{
		$target->send(json_encode($message));
	}

}


1			<?php
2
3			namespace Jalle19\StatusManager\Manager;
4
5			use Jalle19\StatusManager\Configuration\Configuration;
6			use Jalle19\StatusManager\Event\Events;
7			use Jalle19\StatusManager\Event\InstanceStatusUpdatesEvent;
8			use Jalle19\StatusManager\Exception\MalformedRequestException;
9			use Jalle19\StatusManager\Exception\UnhandledMessageException;
10			use Jalle19\StatusManager\Exception\UnknownRequestException;
11			use Jalle19\StatusManager\Message\AbstractMessage;
12			use Jalle19\StatusManager\Message\Factory as MessageFactory;
13			use Jalle19\StatusManager\Message\Handler\DelegatesMessagesTrait;
14			use Jalle19\StatusManager\Message\Handler\HandlerInterface;
15			use Jalle19\StatusManager\Message\Request\AuthenticationRequest;
16			use Jalle19\StatusManager\Message\Response\AuthenticationResponse;
17			use Jalle19\StatusManager\Message\StatusUpdatesMessage;
18			use Jalle19\tvheadend\exception\RequestFailedException;
19			use Psr\Log\LoggerInterface;
20			use Ratchet\ConnectionInterface;
21			use Ratchet\Http\HttpServer;
22			use Ratchet\MessageComponentInterface;
23			use Ratchet\Server\IoServer;
24			use Ratchet\WebSocket\WsServer;
25			use React\EventLoop\LoopInterface;
26			use React\Socket\Server as ServerSocket;
27			use Symfony\Component\EventDispatcher\EventDispatcher;
28			use Symfony\Component\EventDispatcher\EventSubscriberInterface;
29
30			/**
31			* Handles events related to the WebSocket. Events are either triggered from Ratchet (onOpen etc.)
32			* or, the event dispatcher or client requests.
33			*
34			* @package Jalle19\StatusManager
35			* @copyright Copyright © Sam Stenvall 2016-
36			* @license https://www.gnu.org/licenses/gpl.html The GNU General Public License v2.0
37			*/
38			class WebSocketManager extends AbstractManager implements
39			MessageComponentInterface,
			1 ignored issue – show Coding Style introduced 2016-04-15 19:47 UTC by Report Bug Copy Issue Report Expected 4 spaces before interface name; 1 found Loading history...
40			EventSubscriberInterface,
			1 ignored issue – show Coding Style introduced 2016-04-15 19:47 UTC by Report Bug Copy Issue Report Expected 4 spaces before interface name; 1 found Loading history...
41			HandlerInterface
			1 ignored issue – show Coding Style introduced 2016-04-15 19:47 UTC by Report Bug Copy Issue Report Expected 4 spaces before interface name; 1 found Loading history...
42			{
43
44			use DelegatesMessagesTrait;
45
46			/**
47			* @var IoServer the Websocket server
48			*/
49			private $_websocket;
50
51			/**
52			* @var \SplObjectStorage the connected clients
53			*/
54			private $_connectedClients;
55
56			/**
57			* @var \SplObjectStorage the authenticated clients
58			*/
59			private $_authenticatedClients;
60
61
62			/**
63			* WebSocketManager constructor.
64			*
65			* @param Configuration $configuration
66			* @param LoggerInterface $logger
67			* @param EventDispatcher $eventDispatcher
68			* @param LoopInterface $loop
69			*/
70			public function __construct(
71			Configuration $configuration,
72			LoggerInterface $logger,
73			EventDispatcher $eventDispatcher,
74			LoopInterface $loop
75			) {
76			parent::__construct($configuration, $logger, $eventDispatcher);
77
78			// Keep track of clients
79			$this->_connectedClients = new \SplObjectStorage();
80			$this->_authenticatedClients = new \SplObjectStorage();
81
82			// Create the socket to listen on
83			$socket = new ServerSocket($loop);
84			$socket->listen($configuration->getListenPort(), $configuration->getListenAddress());
85
86			// Create the WebSocket server
87			$this->_websocket = new IoServer(new HttpServer(new WsServer($this)), $socket, $loop);
88			}
89
90
91			/**
92			* @inheritdoc
93			*/
94			public static function getSubscribedEvents()
95			{
96			return [
97			Events::MAIN_LOOP_STARTING => 'onMainLoopStarted',
98			Events::INSTANCE_STATUS_UPDATES => 'onInstanceStatusUpdates',
99			];
100			}
101
102
103			/**
104			* Called right before the main loop is started
105			*/
106			public function onMainLoopStarted()
107			{
108			$this->logger->info('Starting the Websocket server on {address}:{port}', [
109			'address' => $this->configuration->getListenAddress(),
110			'port' => $this->configuration->getListenPort(),
111			]);
112			}
113
114
115			/**
116			* @param InstanceStatusUpdatesEvent $event
117			*/
118			public function onInstanceStatusUpdates(InstanceStatusUpdatesEvent $event)
119			{
120			$this->logger->debug('Broadcasting statuses to all clients');
121			$message = new StatusUpdatesMessage($event->getInstanceStatusCollection());
122
123			foreach ($this->_authenticatedClients as $client)
124			{
125			/* @var ConnectionInterface $client */
126			$this->sendMessage($message, $client);
127			}
128			}
129
130
131			/**
132			* @inheritdoc
133			*/
134			public function onOpen(ConnectionInterface $conn)
135			{
136			$this->logger->debug('Got client connection');
137			$this->_connectedClients->attach($conn);
138			}
139
140
141			/**
142			* @inheritdoc
143			*/
144			public function onClose(ConnectionInterface $conn)
145			{
146			$this->logger->debug('Got client disconnect');
147
148			$this->_connectedClients->detach($conn);
149			$this->_authenticatedClients->detach($conn);
150			}
151
152
153			/**
154			* @inheritdoc
155			*/
156			public function onError(ConnectionInterface $conn, \Exception $e)
157			{
158			// TODO: Implement onError() method.
159			}
160
161
162			/**
163			* @inheritdoc
164			*/
165			public function handleMessage(AbstractMessage $message, ConnectionInterface $sender)
166			{
167			if ($message->getType() !== AbstractMessage::TYPE_AUTHENTICATION_REQUEST)
168			return false;
169
170			/* @var AuthenticationRequest $message */
171			$status = AuthenticationResponse::STATUS_FAILURE;
172
173			// Add the sender to the list of authenticated clients
174			if ($message->getAccessToken() === $this->configuration->getAccessToken())
175			{
176			$status = AuthenticationResponse::STATUS_SUCCESS;
177			$this->_authenticatedClients->attach($sender);
178
179			$this->logger->info('Client authenticated successfully');
180			}
181			else
182			$this->logger->warning('Got invalid authentication request from client');
183
184			return new AuthenticationResponse($status);
185			}
186
187
188			/**
189			* Dispatches incoming client messages to the appropriate handlers
190			*
191			* @param ConnectionInterface $from
192			* @param string $msg
193			*/
194			public function onMessage(ConnectionInterface $from, $msg)
195			{
196			try
197			{
198			$message = MessageFactory::factory($msg);
199
200			$this->logger->debug('Got message from client (type: {messageType})', [
201			'messageType' => $message->getType(),
202			]);
203
204			// Attempt to delegate the message
205			try
206			{
207			$response = $this->tryDelegateMessage($message, $from);
208			$this->sendMessage($response, $from);
209			}
210			catch (RequestFailedException $e)
211			{
212			$this->logger->critical('The request failed: ' . $e->getMessage());
213			}
214			catch (UnhandledMessageException $e)
215			{
216			$this->logger->error('Unhandled message (type: {messageType})', [
217			'messageType' => $message->getType(),
218			]);
219			}
220			}
221			catch (MalformedRequestException $e)
222			{
223			$this->logger->error('Got malformed message from client (reason: {reason})', [
224			'reason' => $e->getMessage(),
225			]);
226			}
227			catch (UnknownRequestException $e)
228			{
229			// The server itself sometimes sends out messages that are received here, hence debug
230			$this->logger->debug('Got unknown message from client (type: {messageType})', [
231			'messageType' => $e->getType(),
232			]);
233			}
234			}
235
236
237			/**
238			* @param AbstractMessage $message
239			* @param ConnectionInterface $target
240			*/
241			private function sendMessage(AbstractMessage $message, ConnectionInterface $target)
242			{
243			$target->send(json_encode($message));
244			}
245
246			}
247

Jalle19 / tvheadend-status-manager

Push — master ( 3c24ea...404feb )

WebSocketManager::handleMessage() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like