Server::createMessageHandler() - Code Metrics - Inspection of "improve" - slince/spike - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 390e4e...b0ec12 )

by Taosikai

created 2017-06-22 13:52 UTC

Server::createMessageHandler() B

↳ Parent: Server

Complexity

Conditions	5
Paths	5

Size

Total Lines	22
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	22
rs	8.6737
cc	5
eloc	18
nc	5
nop	2

<?php
/**
 * Spike library
 * @author Tao <[email protected]>
 */
namespace Spike\Server;

use React\EventLoop\LoopInterface;
use React\EventLoop\Factory as LoopFactory;
use React\Socket\ConnectionInterface;
use React\Socket\Server as Socket;
use Slince\Event\Dispatcher;
use Slince\Event\Event;
use Spike\Authentication\AuthenticationInterface;
use Spike\Exception\InvalidArgumentException;
use Spike\Exception\RuntimeException;
use Spike\Logger\Logger;
use Spike\Parser\SpikeParser;
use Spike\Protocol\Spike;
use Spike\Protocol\SpikeInterface;
use Spike\Server\Handler\HandlerInterface;
use Spike\Server\Timer\ReviewClient;
use Spike\Server\Timer\SummaryWatcher;
use Spike\Timer\MemoryWatcher;
use Spike\Timer\TimerInterface;
use Spike\Timer\UseTimerTrait;
use Spike\Tunnel\HttpTunnel;
use Spike\Tunnel\TunnelInterface;
use Spike\Server\TunnelServer\TunnelServerInterface;
use Spike\Utility;

class Server
{
    use UseTimerTrait;

    /**
     * The server host
     * @var string
     */
    protected $host;

    /**
     * The server port
     * @var int
     */
    protected $port;

    /**
     * The auth information
     * @var AuthenticationInterface
     */
    protected $authentication;

    /**
     * @var LoopInterface
     */
    protected $loop;

    /**
     * @var Dispatcher
     */
    protected $dispatcher;

    /**
     * @var Socket
     */
    protected $socket;

    /**
     * @var TunnelServerInterface[]
     */
    protected $tunnelServers = [];

    /**
     * @var ClientCollection
     */
    protected $clients;

    /**
     * @var Logger
     */
    protected $logger;

    public function __construct(
        $address,
        AuthenticationInterface $authentication,
        LoopInterface $loop = null,
        Dispatcher $dispatcher = null
    ) {
        list($this->host, $this->port) = Utility::parseAddress($address);
        $this->authentication = $authentication;
        $this->loop = $loop ?: LoopFactory::create();
        $this->socket = new Socket($address, $this->loop);
        $this->dispatcher = $dispatcher ?: new Dispatcher();
        $this->clients = new ClientCollection();
        $this->tunnelServers = new TunnelServerCollection();

    }

    /**
     * Run the server
     */
    public function run()
    {
        $this->socket->on('connection', function(ConnectionInterface $connection){
            //Emit the event
            $this->dispatcher->dispatch(new Event(EventStore::ACCEPT_CONNECTION, $this, [
                'connection' => $connection
            ]));
            $this->handleControlConnection($connection);
        });
        $this->socket->on('error', function($exception){
            $this->dispatcher->dispatch(new Event(EventStore::SOCKET_ERROR, $this, [
                'exception' => $exception
            ]));
        });
        //Emit the event
        $this->dispatcher->dispatch(EventStore::SERVER_RUN);
        foreach ($this->getDefaultTimers() as $timer) {
            $this->addTimer($timer);
        }
        $this->loop->run();
    }

    /**
     * Handles control connection
     * @param ConnectionInterface $connection
     */
    protected function handleControlConnection(ConnectionInterface $connection)
    {
        $parser = new SpikeParser();
        $connection->on('data', function($data) use($parser, $connection){
            $parser->pushIncoming($data);
            try {
                $messages = $parser->parse();
                foreach ($messages as $message) {
                    $message = Spike::fromString($message);
                    $this->dispatcher->dispatch(new Event(EventStore::RECEIVE_MESSAGE, $this, [
                        'message' => $message,
                        'connection' => $connection
                    ]));
                    $this->createMessageHandler($message, $connection)->handle($message);
                }
            } catch (RuntimeException $exception) {
                $this->dispatcher->dispatch(new Event(EventStore::CONNECTION_ERROR, $this, [
                    'connection' => $connection,
                    'exception' => $exception
                ]));
                $connection->end('Bad message');
            }
        });
        //When client be closed
        $connection->on('end', function() use ($connection){
            $client = $this->clients->findByConnection($connection);
            $this->closeClient($client);
        });
    }

    /**
     * Close the given client
     * @param Client $client
     */
    public function closeClient(Client $client)
    {
        $tunnelServers = $this->tunnelServers->filterByControlConnection($client->getControlConnection());

        $this->dispatcher->dispatch(new Event(EventStore::CLIENT_CLOSE, $this, [
            'client' => $client,
            'tunnelServers' => $tunnelServers
        ]));
        foreach ($tunnelServers as $tunnelServer) {
            //Close the tunnel server and removes it
            $tunnelServer->close();
            $this->tunnelServers->removeElement($tunnelServer);

        }
        $client->close();
        $this->clients->removeElement($client); //Removes the client
    }

    /**
     * Creates a tunnel server for the tunnel
     * @param TunnelInterface $tunnel
     * @param ConnectionInterface $controlConnection
     */
    public function createTunnelServer(TunnelInterface $tunnel, ConnectionInterface $controlConnection)
    {
        if ($tunnel instanceof HttpTunnel) {
            $tunnelServer = new TunnelServer\HttpTunnelServer($this, $controlConnection, $tunnel, $this->loop);
        } else {
            $tunnelServer = new TunnelServer\TcpTunnelServer($this, $controlConnection, $tunnel, $this->loop);
        }
        $tunnelServer->run();
        $this->tunnelServers->add($tunnelServer);

    }

    /**
     * Gets the dispatcher
     * @return Dispatcher
     */
    public function getDispatcher()
    {
        return $this->dispatcher;
    }

    /**
     * Gets all clients
     * @return ClientCollection
     */
    public function getClients()
    {
        return $this->clients;
    }

    /**
     * Gets all tunnel server
     * @return TunnelServerCollection
     */
    public function getTunnelServers()
    {
        return $this->tunnelServers;
    }

    /**
     * Gets the server host
     * @return string
     */
    public function getHost()
    {
        return $this->host;
    }

    /**
     * Gets the loop instance
     * @return LoopInterface
     */
    public function getLoop()
    {
        return $this->loop;
    }

    /**
     * Sets a logger
     * @param Logger $logger
     */
    public function setLogger($logger)
    {
        $this->logger = $logger;
    }

    /**
     * Gets the logger
     * @return Logger
     */
    public function getLogger()
    {
        return $this->logger;
    }

    /**
     * Gets the server port
     * @return int
     */
    public function getPort()
    {
        return $this->port;
    }

    /**
     * Gets the authentication
     * @return AuthenticationInterface
     */
    public function getAuthentication()
    {
        return $this->authentication;
    }

    /**
     * Creates the handler for the received message
     * @param SpikeInterface $message
     * @param ConnectionInterface $connection
     * @return HandlerInterface
     */
    protected function createMessageHandler($message, $connection)
    {
        switch ($message->getAction()) {
            case 'auth':
                $handler = new Handler\AuthHandler($this, $connection);
                break;
            case 'ping':
                $handler = new Handler\PingHandler($this, $connection);
                break;
            case 'register_tunnel':
                $handler = new Handler\RegisterTunnelHandler($this, $connection);
                break;
            case 'register_proxy':
                $handler = new Handler\RegisterProxyHandler($this, $connection);
                break;
            default:
                throw new InvalidArgumentException(sprintf('Cannot find handler for message type: "%s"',
                    get_class($message)
                ));
        }
        return $handler;
    }

    /**
     * Creates default timers
     * @return TimerInterface[]
     */
    protected function getDefaultTimers()
    {
        return [
            new ReviewClient($this),
            new MemoryWatcher($this->logger),
            new SummaryWatcher($this)
        ];
    }
}

1			<?php
2			/**
3			* Spike library
4			* @author Tao <[email protected]>
5			*/
6			namespace Spike\Server;
7
8			use React\EventLoop\LoopInterface;
9			use React\EventLoop\Factory as LoopFactory;
10			use React\Socket\ConnectionInterface;
11			use React\Socket\Server as Socket;
12			use Slince\Event\Dispatcher;
13			use Slince\Event\Event;
14			use Spike\Authentication\AuthenticationInterface;
15			use Spike\Exception\InvalidArgumentException;
16			use Spike\Exception\RuntimeException;
17			use Spike\Logger\Logger;
18			use Spike\Parser\SpikeParser;
19			use Spike\Protocol\Spike;
20			use Spike\Protocol\SpikeInterface;
21			use Spike\Server\Handler\HandlerInterface;
22			use Spike\Server\Timer\ReviewClient;
23			use Spike\Server\Timer\SummaryWatcher;
24			use Spike\Timer\MemoryWatcher;
25			use Spike\Timer\TimerInterface;
26			use Spike\Timer\UseTimerTrait;
27			use Spike\Tunnel\HttpTunnel;
28			use Spike\Tunnel\TunnelInterface;
29			use Spike\Server\TunnelServer\TunnelServerInterface;
30			use Spike\Utility;
31
32			class Server
33			{
34			use UseTimerTrait;
35
36			/**
37			* The server host
38			* @var string
39			*/
40			protected $host;
41
42			/**
43			* The server port
44			* @var int
45			*/
46			protected $port;
47
48			/**
49			* The auth information
50			* @var AuthenticationInterface
51			*/
52			protected $authentication;
53
54			/**
55			* @var LoopInterface
56			*/
57			protected $loop;
58
59			/**
60			* @var Dispatcher
61			*/
62			protected $dispatcher;
63
64			/**
65			* @var Socket
66			*/
67			protected $socket;
68
69			/**
70			* @var TunnelServerInterface[]
71			*/
72			protected $tunnelServers = [];
73
74			/**
75			* @var ClientCollection
76			*/
77			protected $clients;
78
79			/**
80			* @var Logger
81			*/
82			protected $logger;
83
84			public function __construct(
85			$address,
86			AuthenticationInterface $authentication,
87			LoopInterface $loop = null,
88			Dispatcher $dispatcher = null
89			) {
90			list($this->host, $this->port) = Utility::parseAddress($address);
91			$this->authentication = $authentication;
92			$this->loop = $loop ?: LoopFactory::create();
93			$this->socket = new Socket($address, $this->loop);
94			$this->dispatcher = $dispatcher ?: new Dispatcher();
95			$this->clients = new ClientCollection();
96			$this->tunnelServers = new TunnelServerCollection();
			0 ignored issues – show Documentation Bug introduced 2017-06-21 05:24 UTC by Report Bug Copy Issue Report It seems like `new \Spike\Server\TunnelServerCollection()` of type `object<Spike\Server\TunnelServerCollection>` is incompatible with the declared type `array<integer,object<Spi...TunnelServerInterface>>` of property `$tunnelServers`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
97			}
98
99			/**
100			* Run the server
101			*/
102			public function run()
103			{
104			$this->socket->on('connection', function(ConnectionInterface $connection){
105			//Emit the event
106			$this->dispatcher->dispatch(new Event(EventStore::ACCEPT_CONNECTION, $this, [
107			'connection' => $connection
108			]));
109			$this->handleControlConnection($connection);
110			});
111			$this->socket->on('error', function($exception){
112			$this->dispatcher->dispatch(new Event(EventStore::SOCKET_ERROR, $this, [
113			'exception' => $exception
114			]));
115			});
116			//Emit the event
117			$this->dispatcher->dispatch(EventStore::SERVER_RUN);
118			foreach ($this->getDefaultTimers() as $timer) {
119			$this->addTimer($timer);
120			}
121			$this->loop->run();
122			}
123
124			/**
125			* Handles control connection
126			* @param ConnectionInterface $connection
127			*/
128			protected function handleControlConnection(ConnectionInterface $connection)
129			{
130			$parser = new SpikeParser();
131			$connection->on('data', function($data) use($parser, $connection){
132			$parser->pushIncoming($data);
133			try {
134			$messages = $parser->parse();
135			foreach ($messages as $message) {
136			$message = Spike::fromString($message);
137			$this->dispatcher->dispatch(new Event(EventStore::RECEIVE_MESSAGE, $this, [
138			'message' => $message,
139			'connection' => $connection
140			]));
141			$this->createMessageHandler($message, $connection)->handle($message);
142			}
143			} catch (RuntimeException $exception) {
144			$this->dispatcher->dispatch(new Event(EventStore::CONNECTION_ERROR, $this, [
145			'connection' => $connection,
146			'exception' => $exception
147			]));
148			$connection->end('Bad message');
149			}
150			});
151			//When client be closed
152			$connection->on('end', function() use ($connection){
153			$client = $this->clients->findByConnection($connection);
154			$this->closeClient($client);
155			});
156			}
157
158			/**
159			* Close the given client
160			* @param Client $client
161			*/
162			public function closeClient(Client $client)
163			{
164			$tunnelServers = $this->tunnelServers->filterByControlConnection($client->getControlConnection());
			0 ignored issues – show Bug introduced 2017-06-21 05:24 UTC by Report Bug Copy Issue Report The method `filterByControlConnection` cannot be called on `$this->tunnelServers` (of type `array<integer,object<Spi...TunnelServerInterface>>`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
165			$this->dispatcher->dispatch(new Event(EventStore::CLIENT_CLOSE, $this, [
166			'client' => $client,
167			'tunnelServers' => $tunnelServers
168			]));
169			foreach ($tunnelServers as $tunnelServer) {
170			//Close the tunnel server and removes it
171			$tunnelServer->close();
172			$this->tunnelServers->removeElement($tunnelServer);
			0 ignored issues – show Bug introduced 2017-06-21 05:24 UTC by Report Bug Copy Issue Report The method `removeElement` cannot be called on `$this->tunnelServers` (of type `array<integer,object<Spi...TunnelServerInterface>>`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
173			}
174			$client->close();
175			$this->clients->removeElement($client); //Removes the client
176			}
177
178			/**
179			* Creates a tunnel server for the tunnel
180			* @param TunnelInterface $tunnel
181			* @param ConnectionInterface $controlConnection
182			*/
183			public function createTunnelServer(TunnelInterface $tunnel, ConnectionInterface $controlConnection)
184			{
185			if ($tunnel instanceof HttpTunnel) {
186			$tunnelServer = new TunnelServer\HttpTunnelServer($this, $controlConnection, $tunnel, $this->loop);
187			} else {
188			$tunnelServer = new TunnelServer\TcpTunnelServer($this, $controlConnection, $tunnel, $this->loop);
189			}
190			$tunnelServer->run();
191			$this->tunnelServers->add($tunnelServer);
			0 ignored issues – show Bug introduced 2017-06-21 05:24 UTC by Report Bug Copy Issue Report The method `add` cannot be called on `$this->tunnelServers` (of type `array<integer,object<Spi...TunnelServerInterface>>`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
192			}
193
194			/**
195			* Gets the dispatcher
196			* @return Dispatcher
197			*/
198			public function getDispatcher()
199			{
200			return $this->dispatcher;
201			}
202
203			/**
204			* Gets all clients
205			* @return ClientCollection
206			*/
207			public function getClients()
208			{
209			return $this->clients;
210			}
211
212			/**
213			* Gets all tunnel server
214			* @return TunnelServerCollection
215			*/
216			public function getTunnelServers()
217			{
218			return $this->tunnelServers;
219			}
220
221			/**
222			* Gets the server host
223			* @return string
224			*/
225			public function getHost()
226			{
227			return $this->host;
228			}
229
230			/**
231			* Gets the loop instance
232			* @return LoopInterface
233			*/
234			public function getLoop()
235			{
236			return $this->loop;
237			}
238
239			/**
240			* Sets a logger
241			* @param Logger $logger
242			*/
243			public function setLogger($logger)
244			{
245			$this->logger = $logger;
246			}
247
248			/**
249			* Gets the logger
250			* @return Logger
251			*/
252			public function getLogger()
253			{
254			return $this->logger;
255			}
256
257			/**
258			* Gets the server port
259			* @return int
260			*/
261			public function getPort()
262			{
263			return $this->port;
264			}
265
266			/**
267			* Gets the authentication
268			* @return AuthenticationInterface
269			*/
270			public function getAuthentication()
271			{
272			return $this->authentication;
273			}
274
275			/**
276			* Creates the handler for the received message
277			* @param SpikeInterface $message
278			* @param ConnectionInterface $connection
279			* @return HandlerInterface
280			*/
281			protected function createMessageHandler($message, $connection)
282			{
283			switch ($message->getAction()) {
284			case 'auth':
285			$handler = new Handler\AuthHandler($this, $connection);
286			break;
287			case 'ping':
288			$handler = new Handler\PingHandler($this, $connection);
289			break;
290			case 'register_tunnel':
291			$handler = new Handler\RegisterTunnelHandler($this, $connection);
292			break;
293			case 'register_proxy':
294			$handler = new Handler\RegisterProxyHandler($this, $connection);
295			break;
296			default:
297			throw new InvalidArgumentException(sprintf('Cannot find handler for message type: "%s"',
298			get_class($message)
299			));
300			}
301			return $handler;
302			}
303
304			/**
305			* Creates default timers
306			* @return TimerInterface[]
307			*/
308			protected function getDefaultTimers()
309			{
310			return [
311			new ReviewClient($this),
312			new MemoryWatcher($this->logger),
313			new SummaryWatcher($this)
314			];
315			}
316			}

slince / spike

Push — master ( 390e4e...b0ec12 )

Server::createMessageHandler() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like