AbstractClientManager::onMessage() - Code Metrics - Inspection of "add initial installation instructions for end user..." - Jalle19/tvheadend-status-manager - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( eeb5e0...9f7a88 )

by Sam

created 2016-10-28 20:12 UTC

AbstractClientManager::onMessage() B

↳ Parent: AbstractClientManager

Complexity

Conditions	5
Paths	21

Size

Total Lines	41
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	9.9614

Importance

Changes

Metric	Value
dl	0
loc	41
ccs	10
cts	24
cp	0.4167
rs	8.439
c	0
b	0
f	0
cc	5
eloc	19
nc	21
nop	2
crap	9.9614

<?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\MessageComponentInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

/**
 * Keeps track of connected clients and handles events related to them.
 *
 * @package   Jalle19\StatusManager
 * @copyright Copyright &copy; Sam Stenvall 2016-
 * @license   https://www.gnu.org/licenses/gpl.html The GNU General Public License v2.0
 */
abstract class AbstractClientManager extends AbstractManager implements
	MessageComponentInterface,
	EventSubscriberInterface,
	HandlerInterface
{

	use DelegatesMessagesTrait;

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

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


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

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


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


	/**
	 * @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->info('Got client connection');
		$this->_connectedClients->attach($conn);
	}


	/**
	 * @inheritdoc
	 */
	public function onClose(ConnectionInterface $conn)
	{
		$this->logger->info('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->notice('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->error('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\MessageComponentInterface;
22		use Symfony\Component\EventDispatcher\EventDispatcher;
23		use Symfony\Component\EventDispatcher\EventSubscriberInterface;
24
25		/**
26		* Keeps track of connected clients and handles events related to them.
27		*
28		* @package Jalle19\StatusManager
29		* @copyright Copyright © Sam Stenvall 2016-
30		* @license https://www.gnu.org/licenses/gpl.html The GNU General Public License v2.0
31		*/
32		abstract class AbstractClientManager extends AbstractManager implements
33		MessageComponentInterface,
34		EventSubscriberInterface,
35		HandlerInterface
36		{
37
38		use DelegatesMessagesTrait;
39
40		/**
41		* @var \SplObjectStorage the connected clients
42		*/
43		protected $_connectedClients;
44
45		/**
46		* @var \SplObjectStorage the authenticated clients
47		*/
48		protected $_authenticatedClients;
49
50
51		/**
52		* WebSocketManager constructor.
53		*
54		* @param Configuration $configuration
55		* @param LoggerInterface $logger
56		* @param EventDispatcher $eventDispatcher
57		*/
58	4	public function __construct(
59		Configuration $configuration,
60		LoggerInterface $logger,
61		EventDispatcher $eventDispatcher
62		) {
63	4	parent::__construct($configuration, $logger, $eventDispatcher);
64
65		// Keep track of clients
66	4	$this->_connectedClients = new \SplObjectStorage();
67	4	$this->_authenticatedClients = new \SplObjectStorage();
68	4	}
69
70
71		/**
72		* @inheritdoc
73		*/
74	4	public static function getSubscribedEvents()
75		{
76		return [
77	4	Events::INSTANCE_STATUS_UPDATES => 'onInstanceStatusUpdates',
78	4	];
79		}
80
81
82		/**
83		* @param InstanceStatusUpdatesEvent $event
84		*/
85	1	public function onInstanceStatusUpdates(InstanceStatusUpdatesEvent $event)
86		{
87	1	$this->logger->debug('Broadcasting statuses to all clients');
88	1	$message = new StatusUpdatesMessage($event->getInstanceStatusCollection());
89
90	1	foreach ($this->_authenticatedClients as $client)
91		{
92		/* @var ConnectionInterface $client */
93	1	$this->sendMessage($message, $client);
94	1	}
95	1	}
96
97
98		/**
99		* @inheritdoc
100		*/
101	4	public function onOpen(ConnectionInterface $conn)
102		{
103	4	$this->logger->info('Got client connection');
104	4	$this->_connectedClients->attach($conn);
105	4	}
106
107
108		/**
109		* @inheritdoc
110		*/
111		public function onClose(ConnectionInterface $conn)
112		{
113		$this->logger->info('Got client disconnect');
114
115		$this->_connectedClients->detach($conn);
116		$this->_authenticatedClients->detach($conn);
117		}
118
119
120		/**
121		* @inheritdoc
122		*/
123		public function onError(ConnectionInterface $conn, \Exception $e)
124		{
125		// TODO: Implement onError() method.
126		}
127
128
129		/**
130		* @inheritdoc
131		*/
132	3	public function handleMessage(AbstractMessage $message, ConnectionInterface $sender)
133		{
134	3	if ($message->getType() !== AbstractMessage::TYPE_AUTHENTICATION_REQUEST)
135	3	return false;
136
137		/* @var AuthenticationRequest $message */
138	3	$status = AuthenticationResponse::STATUS_FAILURE;
139
140		// Add the sender to the list of authenticated clients
141	3	if ($message->getAccessToken() === $this->configuration->getAccessToken())
142	3	{
143	3	$status = AuthenticationResponse::STATUS_SUCCESS;
144	3	$this->_authenticatedClients->attach($sender);
145
146	3	$this->logger->notice('Client authenticated successfully');
147	3	}
148		else
149	1	$this->logger->warning('Got invalid authentication request from client');
150
151	3	return new AuthenticationResponse($status);
152		}
153
154
155		/**
156		* Dispatches incoming client messages to the appropriate handlers
157		*
158		* @param ConnectionInterface $from
159		* @param string $msg
160		*/
161	1	public function onMessage(ConnectionInterface $from, $msg)
162		{
163		try
164		{
165	1	$message = MessageFactory::factory($msg);
166
167	1	$this->logger->debug('Got message from client (type: {messageType})', [
168	1	'messageType' => $message->getType(),
169	1	]);
170
171		// Attempt to delegate the message
172		try
173		{
174	1	$response = $this->tryDelegateMessage($message, $from);
175	1	$this->sendMessage($response, $from);
176		}
177	1	catch (RequestFailedException $e)
178		{
179		$this->logger->error('The request failed: ' . $e->getMessage());
180		}
181		catch (UnhandledMessageException $e)
182		{
183		$this->logger->error('Unhandled message (type: {messageType})', [
184		'messageType' => $message->getType(),
185		]);
186		}
187		}
188	1	catch (MalformedRequestException $e)
189		{
190		$this->logger->error('Got malformed message from client (reason: {reason})', [
191		'reason' => $e->getMessage(),
192		]);
193		}
194		catch (UnknownRequestException $e)
195		{
196		// The server itself sometimes sends out messages that are received here, hence debug
197		$this->logger->debug('Got unknown message from client (type: {messageType})', [
198		'messageType' => $e->getType(),
199		]);
200		}
201	1	}
202
203
204		/**
205		* @param AbstractMessage $message
206		* @param ConnectionInterface $target
207		*/
208	2	private function sendMessage(AbstractMessage $message, ConnectionInterface $target)
209		{
210	2	$target->send(json_encode($message));
211	2	}
212
213		}
214

Jalle19 / tvheadend-status-manager

Push — master ( eeb5e0...9f7a88 )

AbstractClientManager::onMessage() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like