ONE PIECE HACKING

Ngiler SH3LL 360
: / home / tbf / membrubackend / vendor / react / socket / src /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	89.40.16.97
System	Linux server.atelieruldeit.ro 3.10.0-1160.el7.x86_64 #1 SMP Mon Oct 19 16:18:59 UTC 2020 x86_64
User	tbf
PHP Version	7.3.33
Software	Apache
Doc root	Writable

Edit File : LimitingServer.php \| Size : 6.47 KB
<?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)); } } Back

Edit File : LimitingServer.php | Size : 6.47 KB

<?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));
    }
}

Back