1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
<?php
namespace React\Socket;
use Evenement\EventEmitter;
use Exception;
use OverflowException;
/**
* The `LimitingServer` decorator wraps a given `ServerInterface` and is responsible
* for limiting and keeping track of open connections to this server instance.
*
* Whenever the underlying server emits a `connection` event, it will check its
* limits and then either
* - keep track of this connection by adding it to the list of
* open connections and then forward the `connection` event
* - or reject (close) the connection when its limits are exceeded and will
* forward an `error` event instead.
*
* Whenever a connection closes, it will remove this connection from the list of
* open connections.
*
* ```php
* $server = new React\Socket\LimitingServer($server, 100);
* $server->on('connection', function (React\Socket\ConnectionInterface $connection) {
* $connection->write('hello there!' . PHP_EOL);
* …
* });
* ```
*
* See also the `ServerInterface` for more details.
*
* @see ServerInterface
* @see ConnectionInterface
*/
class LimitingServer extends EventEmitter implements ServerInterface
{
private $connections = array();
private $server;
private $limit;
private $pauseOnLimit = false;
private $autoPaused = false;
private $manuPaused = false;
/**
* Instantiates a new LimitingServer.
*
* You have to pass a maximum number of open connections to ensure
* the server will automatically reject (close) connections once this limit
* is exceeded. In this case, it will emit an `error` event to inform about
* this and no `connection` event will be emitted.
*
* ```php
* $server = new React\Socket\LimitingServer($server, 100);
* $server->on('connection', function (React\Socket\ConnectionInterface $connection) {
* $connection->write('hello there!' . PHP_EOL);
* …
* });
* ```
*
* You MAY pass a `null` limit in order to put no limit on the number of
* open connections and keep accepting new connection until you run out of
* operating system resources (such as open file handles). This may be
* useful if you do not want to take care of applying a limit but still want
* to use the `getConnections()` method.
*
* You can optionally configure the server to pause accepting new
* connections once the connection limit is reached. In this case, it will
* pause the underlying server and no longer process any new connections at
* all, thus also no longer closing any excessive connections.
* The underlying operating system is responsible for keeping a backlog of
* pending connections until its limit is reached, at which point it will
* start rejecting further connections.
* Once the server is below the connection limit, it will continue consuming
* connections from the backlog and will process any outstanding data on
* each connection.
* This mode may be useful for some protocols that are designed to wait for
* a response message (such as HTTP), but may be less useful for other
* protocols that demand immediate responses (such as a "welcome" message in
* an interactive chat).
*
* ```php
* $server = new React\Socket\LimitingServer($server, 100, true);
* $server->on('connection', function (React\Socket\ConnectionInterface $connection) {
* $connection->write('hello there!' . PHP_EOL);
* …
* });
* ```
*
* @param ServerInterface $server
* @param int|null $connectionLimit
* @param bool $pauseOnLimit
*/
public function __construct(ServerInterface $server, $connectionLimit, $pauseOnLimit = false)
{
$this->server = $server;
$this->limit = $connectionLimit;
if ($connectionLimit !== null) {
$this->pauseOnLimit = $pauseOnLimit;
}
$this->server->on('connection', array($this, 'handleConnection'));
$this->server->on('error', array($this, 'handleError'));
}
/**
* Returns an array with all currently active connections
*
* ```php
* foreach ($server->getConnection() as $connection) {
* $connection->write('Hi!');
* }
* ```
*
* @return ConnectionInterface[]
*/
public function getConnections()
{
return $this->connections;
}
public function getAddress()
{
return $this->server->getAddress();
}
public function pause()
{
if (!$this->manuPaused) {
$this->manuPaused = true;
if (!$this->autoPaused) {
$this->server->pause();
}
}
}
public function resume()
{
if ($this->manuPaused) {
$this->manuPaused = false;
if (!$this->autoPaused) {
$this->server->resume();
}
}
}
public function close()
{
$this->server->close();
}
/** @internal */
public function handleConnection(ConnectionInterface $connection)
{
// close connection if limit exceeded
if ($this->limit !== null && \count($this->connections) >= $this->limit) {
$this->handleError(new \OverflowException('Connection closed because server reached connection limit'));
$connection->close();
return;
}
$this->connections[] = $connection;
$that = $this;
$connection->on('close', function () use ($that, $connection) {
$that->handleDisconnection($connection);
});
// pause accepting new connections if limit exceeded
if ($this->pauseOnLimit && !$this->autoPaused && \count($this->connections) >= $this->limit) {
$this->autoPaused = true;
if (!$this->manuPaused) {
$this->server->pause();
}
}
$this->emit('connection', array($connection));
}
/** @internal */
public function handleDisconnection(ConnectionInterface $connection)
{
unset($this->connections[\array_search($connection, $this->connections)]);
// continue accepting new connection if below limit
if ($this->autoPaused && \count($this->connections) < $this->limit) {
$this->autoPaused = false;
if (!$this->manuPaused) {
$this->server->resume();
}
}
}
/** @internal */
public function handleError(\Exception $error)
{
$this->emit('error', array($error));
}
}
|
