8346487915

Committed 19 Mar 2024 04:15PM UTC coverage: 22.584% (-77.4%) from 100.0%

Build # 8346487915

Build Type

push

github

Committed by

sirn-se

Commit Message

Temp test verification

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

742 existing lines in 32 files now uncovered.

222 of 983 relevant lines covered (22.58%)

0.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

25.0

/src/Middleware/MiddlewareHandler.php

<?php

/**
 * Copyright (C) 2014-2024 Textalk and contributors.
 * This file is part of Websocket PHP and is free software under the ISC License.
 */

namespace WebSocket\Middleware;

use Closure;
use Psr\Log\{
    LoggerInterface,
    LoggerAwareInterface,
    NullLogger
};
use Stringable;
use WebSocket\Connection;
use WebSocket\Http\{
    HttpHandler,
    Message as HttpMessage
};
use WebSocket\Message\{
    Message,
    MessageHandler
};
use WebSocket\Trait\StringableTrait;

/**
 * WebSocket\Middleware\MiddlewareHandler class.
 * Middleware handling.
 */
class MiddlewareHandler implements LoggerAwareInterface, Stringable
{
    use StringableTrait;

    // Processor collections
    private $incoming = [];
    private $outgoing = [];
    private $httpIncoming = [];
    private $httpOutgoing = [];
    private $tick = [];

    // Handlers
    private $httpHandler;
    private $messageHandler;
    private $logger;

    /**
     * Create MiddlewareHandler.
     * @param MessageHandler $messageHandler
     * @param HttpHandler $httpHandler
     */
    public function __construct(MessageHandler $messageHandler, HttpHandler $httpHandler)
    {
        $this->messageHandler = $messageHandler;
        $this->httpHandler = $httpHandler;
        $this->setLogger(new NullLogger());
    }

    /**
     * Set logger on MiddlewareHandler and all LoggerAware middlewares.
     * @param LoggerInterface $logger
     * @return $this
     */
    public function setLogger(LoggerInterface $logger): self
    {
        $this->logger = $logger;
        foreach ($this->incoming as $middleware) {
            if ($middleware instanceof LoggerAwareInterface) {
                $middleware->setLogger($this->logger);
            }
        }
        foreach ($this->outgoing as $middleware) {
            if ($middleware instanceof LoggerAwareInterface) {
                $middleware->setLogger($this->logger);
            }
        }
        return $this;
    }

    /**
     * Add a middleware.
     * @param MiddlewareInterface $middleware
     * @return $this
     */
    public function add(MiddlewareInterface $middleware): self
    {
        if ($middleware instanceof ProcessIncomingInterface) {
            $this->logger->info("[middleware-handler] Added incoming: {$middleware}");
            if ($middleware instanceof LoggerAwareInterface) {
                $middleware->setLogger($this->logger);
            }
            $this->incoming[] = $middleware;
        }
        if ($middleware instanceof ProcessOutgoingInterface) {
            $this->logger->info("[middleware-handler] Added outgoing: {$middleware}");
            if ($middleware instanceof LoggerAwareInterface) {
                $middleware->setLogger($this->logger);
            }
            $this->outgoing[] = $middleware;
        }
        if ($middleware instanceof ProcessHttpIncomingInterface) {
            $this->logger->info("[middleware-handler] Added http incoming: {$middleware}");
            if ($middleware instanceof LoggerAwareInterface) {
                $middleware->setLogger($this->logger);
            }
            $this->httpIncoming[] = $middleware;
        }
        if ($middleware instanceof ProcessHttpOutgoingInterface) {
            $this->logger->info("[middleware-handler] Added http outgoing: {$middleware}");
            if ($middleware instanceof LoggerAwareInterface) {
                $middleware->setLogger($this->logger);
            }
            $this->httpOutgoing[] = $middleware;
        }
        if ($middleware instanceof ProcessTickInterface) {
            $this->logger->info("[middleware-handler] Added tick: {$middleware}");
            if ($middleware instanceof LoggerAwareInterface) {
                $middleware->setLogger($this->logger);
            }
            $this->tick[] = $middleware;
        }
        return $this;
    }

    /**
     * Process middlewares for incoming messages.
     * @param Connection $connection
     * @return Message
     */
    public function processIncoming(Connection $connection): Message
    {
        $this->logger->info("[middleware-handler] Processing incoming");
        $stack = new ProcessStack($connection, $this->messageHandler, $this->incoming);
        return $stack->handleIncoming();
    }

    /**
     * Process middlewares for outgoing messages.
     * @param Connection $connection
     * @param Message $message
     * @return Message
     */
    public function processOutgoing(Connection $connection, Message $message): Message
    {
        $this->logger->info("[middleware-handler] Processing outgoing");
        $stack = new ProcessStack($connection, $this->messageHandler, $this->outgoing);
        return $stack->handleOutgoing($message);
    }

    /**
     * Process middlewares for http requests.
     * @param Connection $connection
     * @return HttpMessage
     */
    public function processHttpIncoming(Connection $connection): HttpMessage
    {
        $this->logger->info("[middleware-handler] Processing http incoming");
        $stack = new ProcessHttpStack($connection, $this->httpHandler, $this->httpIncoming);
        return $stack->handleHttpIncoming();
    }

    /**
     * Process middlewares for http requests.
     * @param Connection $connection
     * @param HttpMessage $message
     * @return HttpMessage
     */
    public function processHttpOutgoing(Connection $connection, HttpMessage $message): HttpMessage
    {
        $this->logger->info("[middleware-handler] Processing http outgoing");
        $stack = new ProcessHttpStack($connection, $this->httpHandler, $this->httpOutgoing);
        return $stack->handleHttpOutgoing($message);
    }

    /**
     * Process middlewares for tick.
     * @param Connection $connection
     */
    public function processTick(Connection $connection): void
    {
        $this->logger->info("[middleware-handler] Processing tick");
        $stack = new ProcessTickStack($connection, $this->tick);
        $stack->handleTick();
    }
}

1	<?php
2
3	/**
4	* Copyright (C) 2014-2024 Textalk and contributors.
5	* This file is part of Websocket PHP and is free software under the ISC License.
6	*/
7
8	namespace WebSocket\Middleware;
9
10	use Closure;
11	use Psr\Log\{
12	LoggerInterface,
13	LoggerAwareInterface,
14	NullLogger
15	};
16	use Stringable;
17	use WebSocket\Connection;
18	use WebSocket\Http\{
19	HttpHandler,
20	Message as HttpMessage
21	};
22	use WebSocket\Message\{
23	Message,
24	MessageHandler
25	};
26	use WebSocket\Trait\StringableTrait;
27
28	/**
29	* WebSocket\Middleware\MiddlewareHandler class.
30	* Middleware handling.
31	*/
32	class MiddlewareHandler implements LoggerAwareInterface, Stringable
33	{
34	use StringableTrait;
35
36	// Processor collections
37	private $incoming = [];
38	private $outgoing = [];
39	private $httpIncoming = [];
40	private $httpOutgoing = [];
41	private $tick = [];
42
43	// Handlers
44	private $httpHandler;
45	private $messageHandler;
46	private $logger;
47
48	/**
49	* Create MiddlewareHandler.
50	* @param MessageHandler $messageHandler
51	* @param HttpHandler $httpHandler
52	*/
53	public function __construct(MessageHandler $messageHandler, HttpHandler $httpHandler)
54	{
55	$this->messageHandler = $messageHandler;	1✔
56	$this->httpHandler = $httpHandler;	1✔
57	$this->setLogger(new NullLogger());	1✔
58	}
59
60	/**
61	* Set logger on MiddlewareHandler and all LoggerAware middlewares.
62	* @param LoggerInterface $logger
63	* @return $this
64	*/
65	public function setLogger(LoggerInterface $logger): self
66	{
67	$this->logger = $logger;	1✔
68	foreach ($this->incoming as $middleware) {	1✔
UNCOV 69	if ($middleware instanceof LoggerAwareInterface) {	×
UNCOV 70	$middleware->setLogger($this->logger);	×
71	}
72	}
73	foreach ($this->outgoing as $middleware) {	1✔
UNCOV 74	if ($middleware instanceof LoggerAwareInterface) {	×
UNCOV 75	$middleware->setLogger($this->logger);	×
76	}
77	}
78	return $this;	1✔
79	}
80
81	/**
82	* Add a middleware.
83	* @param MiddlewareInterface $middleware
84	* @return $this
85	*/
86	public function add(MiddlewareInterface $middleware): self
87	{
UNCOV 88	if ($middleware instanceof ProcessIncomingInterface) {	×
UNCOV 89	$this->logger->info("[middleware-handler] Added incoming: {$middleware}");	×
UNCOV 90	if ($middleware instanceof LoggerAwareInterface) {	×
UNCOV 91	$middleware->setLogger($this->logger);	×
92	}
UNCOV 93	$this->incoming[] = $middleware;	×
94	}
UNCOV 95	if ($middleware instanceof ProcessOutgoingInterface) {	×
UNCOV 96	$this->logger->info("[middleware-handler] Added outgoing: {$middleware}");	×
UNCOV 97	if ($middleware instanceof LoggerAwareInterface) {	×
UNCOV 98	$middleware->setLogger($this->logger);	×
99	}
UNCOV 100	$this->outgoing[] = $middleware;	×
101	}
UNCOV 102	if ($middleware instanceof ProcessHttpIncomingInterface) {	×
UNCOV 103	$this->logger->info("[middleware-handler] Added http incoming: {$middleware}");	×
UNCOV 104	if ($middleware instanceof LoggerAwareInterface) {	×
UNCOV 105	$middleware->setLogger($this->logger);	×
106	}
UNCOV 107	$this->httpIncoming[] = $middleware;	×
108	}
UNCOV 109	if ($middleware instanceof ProcessHttpOutgoingInterface) {	×
UNCOV 110	$this->logger->info("[middleware-handler] Added http outgoing: {$middleware}");	×
UNCOV 111	if ($middleware instanceof LoggerAwareInterface) {	×
UNCOV 112	$middleware->setLogger($this->logger);	×
113	}
UNCOV 114	$this->httpOutgoing[] = $middleware;	×
115	}
UNCOV 116	if ($middleware instanceof ProcessTickInterface) {	×
UNCOV 117	$this->logger->info("[middleware-handler] Added tick: {$middleware}");	×
UNCOV 118	if ($middleware instanceof LoggerAwareInterface) {	×
UNCOV 119	$middleware->setLogger($this->logger);	×
120	}
UNCOV 121	$this->tick[] = $middleware;	×
122	}
UNCOV 123	return $this;	×
124	}
125
126	/**
127	* Process middlewares for incoming messages.
128	* @param Connection $connection
129	* @return Message
130	*/
131	public function processIncoming(Connection $connection): Message
132	{
UNCOV 133	$this->logger->info("[middleware-handler] Processing incoming");	×
UNCOV 134	$stack = new ProcessStack($connection, $this->messageHandler, $this->incoming);	×
UNCOV 135	return $stack->handleIncoming();	×
136	}
137
138	/**
139	* Process middlewares for outgoing messages.
140	* @param Connection $connection
141	* @param Message $message
142	* @return Message
143	*/
144	public function processOutgoing(Connection $connection, Message $message): Message
145	{
UNCOV 146	$this->logger->info("[middleware-handler] Processing outgoing");	×
UNCOV 147	$stack = new ProcessStack($connection, $this->messageHandler, $this->outgoing);	×
UNCOV 148	return $stack->handleOutgoing($message);	×
149	}
150
151	/**
152	* Process middlewares for http requests.
153	* @param Connection $connection
154	* @return HttpMessage
155	*/
156	public function processHttpIncoming(Connection $connection): HttpMessage
157	{
158	$this->logger->info("[middleware-handler] Processing http incoming");	1✔
159	$stack = new ProcessHttpStack($connection, $this->httpHandler, $this->httpIncoming);	1✔
160	return $stack->handleHttpIncoming();	1✔
161	}
162
163	/**
164	* Process middlewares for http requests.
165	* @param Connection $connection
166	* @param HttpMessage $message
167	* @return HttpMessage
168	*/
169	public function processHttpOutgoing(Connection $connection, HttpMessage $message): HttpMessage
170	{
171	$this->logger->info("[middleware-handler] Processing http outgoing");	1✔
172	$stack = new ProcessHttpStack($connection, $this->httpHandler, $this->httpOutgoing);	1✔
173	return $stack->handleHttpOutgoing($message);	1✔
174	}
175
176	/**
177	* Process middlewares for tick.
178	* @param Connection $connection
179	*/
180	public function processTick(Connection $connection): void
181	{
UNCOV 182	$this->logger->info("[middleware-handler] Processing tick");	×
UNCOV 183	$stack = new ProcessTickStack($connection, $this->tick);	×
UNCOV 184	$stack->handleTick();	×
185	}
186	}

sirn-se / websocket-php / 8346487915

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous