simple-socket-server 2.0__tar.gz → 2.1__tar.gz

{simple_socket_server-2.0 → simple_socket_server-2.1}/CHANGELOG.md

@@ -5,6 +5,59 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1] - 2026-11-15
+
+### Added
+
+- `disconnect(sock)`: a graceful way to drop a client from a handler or from
+  another thread. The socket stops being read, the replies already queued for it
+  are delivered, and only then it is closed and `disconnect` is emitted.
+- `max_clients` argument of `run()` (500 by default): a connection above the limit
+  is accepted, closed at once and reported through the `error` event.
+- Tests for the new behaviour: a client half-close, a queued reply delivered before
+  the close, a socket closed inside a handler, a failing `disconnect` handler
+  during `stop()`, the client limit and a port that is already taken.
+
+### Fixed
+
+- `select()` could kill the server with `ValueError`. A socket closed behind the
+  server's back left the poll set with a dead descriptor (`file descriptor cannot
+  be a negative integer`), and an oversized client set failed the same way
+  (`filedescriptor out of range`). Dead sockets are dropped before the poll,
+  failures of `select()` are reported through `error` and stop the server instead
+  of escaping `run()`, and the number of clients is capped below `FD_SETSIZE`.
+- The reply to a client that half-closed the connection (`sendall()` followed by
+  `shutdown(SHUT_WR)`, the way `nc -N` behaves) was thrown away. A connection that
+  ended its input keeps being written to until its queue is drained.
+- `stop()` could leave clients open and the port listening when a `disconnect`
+  handler raised. The listening socket is closed first, every client is closed in
+  its own `try`, and `stop` is emitted in any case; the first handler failure is
+  re-raised afterwards.
+- `send()` called from another thread mutated the poll state without a lock. The
+  queues and the poll sets are guarded by a lock now, and handlers are never called
+  under it.
+- Urgent (out of band) data disconnected the client without an `error` event. Only
+  the listening socket is passed to the exceptional set of `select()`.
+- A `BlockingIOError` of `accept()` was reported as an `error` event. It is ignored
+  now, any other `accept()` failure pauses before the next attempt, so a descriptor
+  shortage does not spin the loop.
+
+### Changed
+
+- A `disconnect` handler that raises no longer aborts the cleanup: `run()` closes
+  every socket and emits `stop` before the exception surfaces.
+- `error` for a failed `select()` or a broken listening socket reports the listening
+  socket and `peer=None`; for a rejected connection it reports the client socket
+  and its address.
+- Concurrent clients are limited to 500 by default. A larger `max_clients` can
+  exceed the descriptor limit of `select()` (512 on Windows), which stops the server
+  with an `error` event.
+- The version test reads the package metadata instead of a hard-coded version.
+- Documentation: `max_conn` is described as the `listen()` backlog and `max_clients`
+  as the limit of concurrent clients; the thread safety of `send()` and
+  `disconnect()`, the unbounded outbound queue, the `select()` descriptor limit and
+  the rule that a handler must not raise are spelled out.
+
 ## [2.0] - 2026-11-15
 
 ### Added

{simple_socket_server-2.0/simple_socket_server.egg-info → simple_socket_server-2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple-socket-server
-Version: 2.0
+Version: 2.1
 Summary: Simple TCP socket server with select
 Author-email: webtoucher <webtoucher@ya.ru>
 License-Expression: BSD-3-Clause
@@ -59,7 +59,7 @@ $ pip install simple-socket-server
 Or you can add it as dependency in requirements.txt file of your python application:
 
 ```
-simple-socket-server~=2.0
+simple-socket-server~=2.1
 ```
 
 ## Usage
@@ -127,40 +127,57 @@ print(socket_server.host, socket_server.port)
 
 Handlers are called from the thread that runs `run()`, one at a time.
 
-| Event        | Arguments               | When it fires                                                    |
-|--------------|-------------------------|------------------------------------------------------------------|
-| `start`      | `host, port`            | the listening socket is ready                                    |
-| `connect`    | `sock, peer`            | a client has been accepted                                       |
-| `message`    | `sock, peer, data`      | a chunk of bytes has been received                               |
-| `disconnect` | `sock, peer`            | the connection is gone; the socket is closed right after         |
-| `error`      | `sock, peer, error`     | a socket error occurred; `disconnect` follows                    |
-| `stop`       | `host, port`            | `run()` has returned and every socket is closed                  |
+| Event        | Arguments               | When it fires                                                             |
+|--------------|-------------------------|---------------------------------------------------------------------------|
+| `start`      | `host, port`            | the listening socket is ready                                             |
+| `connect`    | `sock, peer`            | a client has been accepted                                                |
+| `message`    | `sock, peer, data`      | a chunk of bytes has been received                                        |
+| `disconnect` | `sock, peer`            | the connection is closed; the replies queued for it were delivered first   |
+| `error`      | `sock, peer, error`     | a socket error occurred; the connection is closed and `disconnect` follows |
+| `stop`       | `host, port`            | `run()` has returned and every socket is closed                            |
 
-`peer` is an `(host, port)` tuple, `data` is `bytes`, `error` is an `OSError`.
+`peer` is an `(host, port)` tuple, `data` is `bytes`, `error` is an `OSError`. When
+`error` reports a failure of the listening socket or of `select()` itself, `peer` is
+`None` and the server stops.
 
 ## API
 
-| Member                                | Description                                                          |
-|---------------------------------------|----------------------------------------------------------------------|
-| `run(host='0.0.0.0', port=6666, max_conn=5)` | serve connections until `stop()` is called                    |
-| `stop()`                              | ask `run()` to return; safe from a handler or another thread          |
-| `send(sock, message)`                 | queue `bytes` for a client; `ValueError` if it is not a client        |
-| `is_running`                          | `True` while `run()` is serving connections                           |
-| `host`, `port`                        | the address the listening socket is bound to                          |
-| `on(event)`, `emit(...)`              | inherited from `event_bus.EventBus`                                   |
+| Member                                   | Description                                                          |
+|------------------------------------------|----------------------------------------------------------------------|
+| `run(host='0.0.0.0', port=6666, max_conn=5, max_clients=500)` | serve connections until `stop()` is called      |
+| `stop()`                                 | ask `run()` to return; safe from a handler or another thread          |
+| `send(sock, message)`                    | queue `bytes` for a client; `ValueError` if it is not a client        |
+| `disconnect(sock)`                       | stop reading a client, deliver its queue, then close it               |
+| `is_running`                             | `True` while `run()` is serving connections                           |
+| `host`, `port`                           | the address the listening socket is bound to                          |
+| `on(event)`, `emit(...)`                 | inherited from `event_bus.EventBus`                                   |
 
 Notes:
 
 - The server is single-threaded and handlers are called synchronously, so a slow
   handler delays every other connection. Hand off long work to your own thread.
+- **A handler must not raise.** The exception propagates out of `run()` and stops
+  the server for every client; the sockets are still closed before the call returns.
+  If one connection misbehaves, handle it in the handler and call `disconnect()`.
 - `message` carries one raw `recv()` chunk of up to 1024 bytes. There is no
   framing: the protocol you put on top has to delimit its own messages.
 - `send()` never blocks and never truncates: because client sockets are
   non-blocking, the bytes are buffered and the unwritten tail is retried on the
   next poll, so a message larger than the socket buffer arrives in full.
-- Do not use the socket after `disconnect` or `error`: it is closed.
-- An exception raised by a handler propagates out of `run()`. The socket state is
-  still cleaned up before the call returns.
+- The outbound queue has no size limit: a client that stops reading grows the
+  buffer of the server until you disconnect it.
+- `send()` and `disconnect()` are safe to call from another thread. Delivery
+  happens during the next poll, so it can take up to the poll interval (0.1 s).
+- `max_conn` is the `listen()` backlog: how many connections the system queues
+  before `accept()`. It is not a limit of served clients. `max_clients` is that
+  limit: a connection above it is accepted, closed at once and reported through
+  `error`.
+- Do not call `sock.close()` yourself and do not use the socket after
+  `disconnect` or `error`. Use `disconnect(sock)` instead: it stops reading the
+  client and closes the socket after the queued replies are delivered. A socket
+  closed behind the server's back is dropped on the next poll, without delivery.
+- Urgent (out of band) data is not supported, and such data is not treated as an
+  error: the bytes stay in the stream and arrive through `message`.
 
 ## Compatibility
 
@@ -171,6 +188,10 @@ Notes:
   pyright see real signatures instead of `Any`.
 - Any server instance is independent: several servers may run in one process, each
   in its own thread.
+- The poll set of `select()` is limited by the platform: 512 descriptors on Windows
+  and 1024 elsewhere, the listening socket included. That is why concurrent clients
+  are capped by `max_clients`, 500 by default; a larger value makes `select()` fail,
+  and the server stops with an `error` event.
 
 ## Development
 
@@ -187,7 +208,16 @@ The test suite covers:
 - the message flow: `connect`, echo round trips, ordering and large payloads,
 - disconnects: graceful close by the peer, an abrupt reset and a send to a
   connection that is already gone,
-- error handling: an unknown socket for `send()` and a port that is already taken,
+- error handling: `send()` and `disconnect()` for an unknown socket, a client limit
+  that is reached, and a port that is already taken (POSIX only: on Windows
+  `SO_REUSEADDR` allows rebinding a listening port),
+- a half-close: the peer sends, shuts down its writing side and still receives the
+  whole reply, a 256 KiB one included,
+- server-driven disconnects: a queued reply reaches the client before the socket is
+  closed,
+- resilience: a handler that closes its socket does not stop the server, and
+  `stop()` closes every client and emits `stop` even if a `disconnect` handler
+  raises,
 - independence of two servers running in one process.
 
 Project layout:

{simple_socket_server-2.0 → simple_socket_server-2.1}/README.md

@@ -22,7 +22,7 @@ $ pip install simple-socket-server
 Or you can add it as dependency in requirements.txt file of your python application:
 
 ```
-simple-socket-server~=2.0
+simple-socket-server~=2.1
 ```
 
 ## Usage
@@ -90,40 +90,57 @@ print(socket_server.host, socket_server.port)
 
 Handlers are called from the thread that runs `run()`, one at a time.
 
-| Event        | Arguments               | When it fires                                                    |
-|--------------|-------------------------|------------------------------------------------------------------|
-| `start`      | `host, port`            | the listening socket is ready                                    |
-| `connect`    | `sock, peer`            | a client has been accepted                                       |
-| `message`    | `sock, peer, data`      | a chunk of bytes has been received                               |
-| `disconnect` | `sock, peer`            | the connection is gone; the socket is closed right after         |
-| `error`      | `sock, peer, error`     | a socket error occurred; `disconnect` follows                    |
-| `stop`       | `host, port`            | `run()` has returned and every socket is closed                  |
+| Event        | Arguments               | When it fires                                                             |
+|--------------|-------------------------|---------------------------------------------------------------------------|
+| `start`      | `host, port`            | the listening socket is ready                                             |
+| `connect`    | `sock, peer`            | a client has been accepted                                                |
+| `message`    | `sock, peer, data`      | a chunk of bytes has been received                                        |
+| `disconnect` | `sock, peer`            | the connection is closed; the replies queued for it were delivered first   |
+| `error`      | `sock, peer, error`     | a socket error occurred; the connection is closed and `disconnect` follows |
+| `stop`       | `host, port`            | `run()` has returned and every socket is closed                            |
 
-`peer` is an `(host, port)` tuple, `data` is `bytes`, `error` is an `OSError`.
+`peer` is an `(host, port)` tuple, `data` is `bytes`, `error` is an `OSError`. When
+`error` reports a failure of the listening socket or of `select()` itself, `peer` is
+`None` and the server stops.
 
 ## API
 
-| Member                                | Description                                                          |
-|---------------------------------------|----------------------------------------------------------------------|
-| `run(host='0.0.0.0', port=6666, max_conn=5)` | serve connections until `stop()` is called                    |
-| `stop()`                              | ask `run()` to return; safe from a handler or another thread          |
-| `send(sock, message)`                 | queue `bytes` for a client; `ValueError` if it is not a client        |
-| `is_running`                          | `True` while `run()` is serving connections                           |
-| `host`, `port`                        | the address the listening socket is bound to                          |
-| `on(event)`, `emit(...)`              | inherited from `event_bus.EventBus`                                   |
+| Member                                   | Description                                                          |
+|------------------------------------------|----------------------------------------------------------------------|
+| `run(host='0.0.0.0', port=6666, max_conn=5, max_clients=500)` | serve connections until `stop()` is called      |
+| `stop()`                                 | ask `run()` to return; safe from a handler or another thread          |
+| `send(sock, message)`                    | queue `bytes` for a client; `ValueError` if it is not a client        |
+| `disconnect(sock)`                       | stop reading a client, deliver its queue, then close it               |
+| `is_running`                             | `True` while `run()` is serving connections                           |
+| `host`, `port`                           | the address the listening socket is bound to                          |
+| `on(event)`, `emit(...)`                 | inherited from `event_bus.EventBus`                                   |
 
 Notes:
 
 - The server is single-threaded and handlers are called synchronously, so a slow
   handler delays every other connection. Hand off long work to your own thread.
+- **A handler must not raise.** The exception propagates out of `run()` and stops
+  the server for every client; the sockets are still closed before the call returns.
+  If one connection misbehaves, handle it in the handler and call `disconnect()`.
 - `message` carries one raw `recv()` chunk of up to 1024 bytes. There is no
   framing: the protocol you put on top has to delimit its own messages.
 - `send()` never blocks and never truncates: because client sockets are
   non-blocking, the bytes are buffered and the unwritten tail is retried on the
   next poll, so a message larger than the socket buffer arrives in full.
-- Do not use the socket after `disconnect` or `error`: it is closed.
-- An exception raised by a handler propagates out of `run()`. The socket state is
-  still cleaned up before the call returns.
+- The outbound queue has no size limit: a client that stops reading grows the
+  buffer of the server until you disconnect it.
+- `send()` and `disconnect()` are safe to call from another thread. Delivery
+  happens during the next poll, so it can take up to the poll interval (0.1 s).
+- `max_conn` is the `listen()` backlog: how many connections the system queues
+  before `accept()`. It is not a limit of served clients. `max_clients` is that
+  limit: a connection above it is accepted, closed at once and reported through
+  `error`.
+- Do not call `sock.close()` yourself and do not use the socket after
+  `disconnect` or `error`. Use `disconnect(sock)` instead: it stops reading the
+  client and closes the socket after the queued replies are delivered. A socket
+  closed behind the server's back is dropped on the next poll, without delivery.
+- Urgent (out of band) data is not supported, and such data is not treated as an
+  error: the bytes stay in the stream and arrive through `message`.
 
 ## Compatibility
 
@@ -134,6 +151,10 @@ Notes:
   pyright see real signatures instead of `Any`.
 - Any server instance is independent: several servers may run in one process, each
   in its own thread.
+- The poll set of `select()` is limited by the platform: 512 descriptors on Windows
+  and 1024 elsewhere, the listening socket included. That is why concurrent clients
+  are capped by `max_clients`, 500 by default; a larger value makes `select()` fail,
+  and the server stops with an `error` event.
 
 ## Development
 
@@ -150,7 +171,16 @@ The test suite covers:
 - the message flow: `connect`, echo round trips, ordering and large payloads,
 - disconnects: graceful close by the peer, an abrupt reset and a send to a
   connection that is already gone,
-- error handling: an unknown socket for `send()` and a port that is already taken,
+- error handling: `send()` and `disconnect()` for an unknown socket, a client limit
+  that is reached, and a port that is already taken (POSIX only: on Windows
+  `SO_REUSEADDR` allows rebinding a listening port),
+- a half-close: the peer sends, shuts down its writing side and still receives the
+  whole reply, a 256 KiB one included,
+- server-driven disconnects: a queued reply reaches the client before the socket is
+  closed,
+- resilience: a handler that closes its socket does not stop the server, and
+  `stop()` closes every client and emits `stop` even if a `disconnect` handler
+  raises,
 - independence of two servers running in one process.
 
 Project layout:

simple_socket_server-2.1/simple_socket_server/__init__.py

@@ -0,0 +1,392 @@
+"""
+Simple TCP socket server built on select().
+
+The server is single-threaded: run() polls the sockets and calls the handlers
+registered for its events. No third-party networking code is involved, the only
+runtime dependency is the event bus used to dispatch those events.
+
+Copyright (c) 2023–2026 webtoucher
+Distributed under the BSD 3-Clause license. See LICENSE.md for more info.
+"""
+
+import select
+import socket
+import sys
+import threading
+import time
+
+from typing import Dict, List, Optional, Set, Tuple
+
+from event_bus import EventBus
+
+__all__ = ["SimpleSocketServer", "SimpleSocketServerException"]
+
+__version__ = "2.1"
+
+#: Peer address as returned by accept(): (host, port).
+Address = Tuple[str, int]
+
+#: Size of a single recv() chunk; a message event carries one such chunk.
+_RECV_SIZE = 1024
+
+#: How long select() waits for socket activity, in seconds.
+_POLL_INTERVAL = 0.1
+
+#: Default client limit. select() refuses a descriptor set larger than
+#: FD_SETSIZE by raising ValueError, and that limit is 512 on Windows and
+#: 1024 elsewhere, so the default stays below both.
+_DEFAULT_MAX_CLIENTS = 500
+
+
+class SimpleSocketServerException(socket.error):
+    """Raised when the listening socket cannot be created, bound or enabled."""
+
+
+class SimpleSocketServer(EventBus):
+    """Single-threaded TCP server dispatching events through an event bus.
+
+    Events, in the order they may arrive:
+
+    ``start(host, port)``
+        The listening socket is ready.
+    ``connect(sock, peer)``
+        A client has been accepted.
+    ``message(sock, peer, data)``
+        A chunk of bytes has been received.
+    ``disconnect(sock, peer)``
+        The connection is closed: the peer closed it, reset it, a send failed
+        or disconnect() was called. Queued replies are delivered before it.
+    ``error(sock, peer, error)``
+        A socket error occurred; the connection is closed right after, or the
+        server itself stops when the listening socket or select() fails.
+    ``stop(host, port)``
+        run() has returned and every socket is closed.
+
+    Handlers are called from the thread that runs run(), one at a time, so a
+    slow handler delays every other connection. **Handlers must not raise**: an
+    exception propagates out of run() and stops the server for every client.
+    The sockets are still closed before run() returns.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.__host = "0.0.0.0"
+        self.__port = 6666
+        self.__max_conn = 5
+        self.__max_clients = _DEFAULT_MAX_CLIENTS
+        self.__server_socket: Optional[socket.socket] = None
+        self.__inputs: List[socket.socket] = []
+        self.__outputs: List[socket.socket] = []
+        self.__pending: Dict[socket.socket, bytearray] = {}
+        self.__clients: Dict[socket.socket, Address] = {}
+        self.__closing: Set[socket.socket] = set()
+        self.__lock = threading.Lock()
+        self.__stop = threading.Event()
+
+    @property
+    def is_running(self) -> bool:
+        """True while run() is serving connections."""
+        return self.__server_socket is not None and not self.__stop.is_set()
+
+    @property
+    def host(self) -> str:
+        """Host the listening socket is bound to."""
+        return self.__host
+
+    @property
+    def port(self) -> int:
+        """Port the listening socket is bound to."""
+        return self.__port
+
+    def run(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 6666,
+        max_conn: int = 5,
+        max_clients: int = _DEFAULT_MAX_CLIENTS,
+    ) -> None:
+        """Serve connections until stop() is called.
+
+        The call blocks the calling thread. Once it returns, every client socket
+        and the listening socket are closed. A port of 0 makes the operating
+        system pick a free port; the actual address is reported by the start
+        event and by the host and port properties.
+
+        max_conn is the backlog of the listening socket: how many connections the
+        system may queue before accept(). max_clients is the number of clients
+        the server keeps at once; a connection above it is accepted and closed
+        immediately with an error event.
+        """
+        if self.is_running:
+            raise RuntimeError("the server is already running")
+        self.__host = host
+        self.__port = port
+        self.__max_conn = max_conn
+        self.__max_clients = max_clients
+        self.__stop.clear()
+        self.__initialize()
+        try:
+            while not self.__stop.is_set():
+                self.__select()
+        finally:
+            self.__shutdown()
+
+    def stop(self) -> None:
+        """Ask run() to return.
+
+        It only raises a flag, so it is safe to call from an event handler or
+        from another thread. run() finishes the current poll and then closes
+        every socket.
+        """
+        self.__stop.set()
+
+    def send(self, sock: socket.socket, message: bytes) -> None:
+        """Queue message for delivery to a client of this server.
+
+        The socket is non-blocking, so the bytes are buffered and the unwritten
+        tail is retried on the next poll; a message larger than the socket
+        buffer is delivered in full. Empty messages are ignored.
+
+        Safe to call from another thread: delivery happens during the next poll,
+        so it may take up to the poll interval. The queue has no size limit, so
+        a slow reader grows the buffer until it is disconnected.
+        """
+        if not message:
+            return
+        with self.__lock:
+            pending = self.__pending.get(sock)
+            if pending is None:
+                raise ValueError("the socket is not a client of this server")
+            pending.extend(message)
+            if sock not in self.__outputs:
+                self.__outputs.append(sock)
+
+    def disconnect(self, sock: socket.socket) -> None:
+        """Close a client connection gracefully.
+
+        The socket stops being read, the replies already queued for it are
+        delivered first, and only then it is closed and the disconnect event is
+        emitted. Safe to call from an event handler or from another thread.
+
+        Use it instead of sock.close(): closing a socket behind the server's
+        back leaves the select() set with a dead descriptor.
+        """
+        self.__start_closing(sock, strict=True)
+
+    def __initialize(self) -> None:
+        server_socket = socket.socket(
+            socket.AF_INET,
+            socket.SOCK_STREAM,
+            socket.IPPROTO_TCP,
+        )
+        try:
+            server_socket.setblocking(False)
+            server_socket.setsockopt(
+                socket.SOL_SOCKET,
+                socket.SO_REUSEADDR,
+                1,
+            )
+            server_socket.bind((self.__host, self.__port))
+            server_socket.listen(self.__max_conn)
+        except OSError as error:
+            server_socket.close()
+            raise SimpleSocketServerException(
+                "cannot listen on %s:%s" % (self.__host, self.__port)
+            ) from error
+        self.__server_socket = server_socket
+        self.__inputs.append(server_socket)
+        # A port of 0 is resolved by the system, so report the real address.
+        self.__host, self.__port = server_socket.getsockname()[:2]
+        self.emit("start", self.__host, self.__port)
+
+    def __select(self) -> None:
+        self.__prune()
+        # Handlers may call disconnect() and send() from another thread, so the
+        # sequences handed to select() are snapshots taken under the lock.
+        with self.__lock:
+            sock_to_read = list(self.__inputs)
+            sock_to_write = list(self.__outputs)
+        server_socket = self.__server_socket
+        sock_to_check = [server_socket] if server_socket is not None else []
+        try:
+            sock_to_read, sock_to_write, sock_errors = select.select(
+                sock_to_read,
+                sock_to_write,
+                sock_to_check,
+                _POLL_INTERVAL,
+            )
+        except (OSError, ValueError) as error:
+            # select() broke: an unusable listening socket, or a descriptor set
+            # larger than the platform allows. The poll set cannot be trusted.
+            self.emit("error", server_socket, None, error)
+            self.stop()
+            return
+        for sock in sock_errors:
+            # Only the listening socket is polled here: urgent (out of band)
+            # data on a client connection is not a connection error.
+            if sock is server_socket:
+                self.stop()
+        for sock in sock_to_read:
+            if sock is server_socket:
+                self.__accept()
+            else:
+                self.__receive(sock)
+        for sock in sock_to_write:
+            self.__flush(sock)
+
+    def __prune(self) -> None:
+        """Drop sockets that the application closed behind the server's back."""
+        for sock in list(self.__clients):
+            if sock.fileno() < 0:
+                self.__close(sock)
+
+    def __accept(self) -> None:
+        server_socket = self.__server_socket
+        if server_socket is None:
+            return
+        try:
+            client_socket, client_address = server_socket.accept()
+        except BlockingIOError:
+            # The connection died in the backlog before accept() reached it.
+            return
+        except OSError as error:
+            self.emit("error", server_socket, None, error)
+            # Out of descriptors (EMFILE) would spin the loop without a pause.
+            time.sleep(_POLL_INTERVAL)
+            return
+        client_socket.setblocking(False)
+        if len(self.__clients) >= self.__max_clients:
+            client_socket.close()
+            self.emit(
+                "error",
+                client_socket,
+                client_address,
+                ConnectionAbortedError("the client limit is reached"),
+            )
+            return
+        with self.__lock:
+            self.__clients[client_socket] = client_address
+            self.__pending[client_socket] = bytearray()
+            self.__inputs.append(client_socket)
+        self.emit("connect", client_socket, client_address)
+
+    def __receive(self, sock: socket.socket) -> None:
+        peer = self.__clients.get(sock)
+        if peer is None:
+            # The socket was already dropped during this poll.
+            return
+        try:
+            data = sock.recv(_RECV_SIZE)
+        except BlockingIOError:
+            # select() woke us up for nothing; try again on the next poll.
+            return
+        except (ConnectionResetError, ConnectionAbortedError, BrokenPipeError):
+            self.__close(sock)
+            return
+        except OSError as error:
+            self.emit("error", sock, peer, error)
+            self.__close(sock)
+            return
+        if not data:
+            # An empty chunk means the peer closed its end of the connection.
+            # Replies queued for it are still delivered before the socket goes.
+            self.__start_closing(sock)
+            return
+        self.emit("message", sock, peer, data)
+
+    def __start_closing(self, sock: socket.socket, strict: bool = False) -> None:
+        """Stop reading a connection and close it once its queue is drained."""
+        with self.__lock:
+            if sock not in self.__clients:
+                if strict:
+                    raise ValueError("the socket is not a client of this server")
+                return
+            self.__closing.add(sock)
+            if sock in self.__inputs:
+                self.__inputs.remove(sock)
+            drained = not self.__pending.get(sock)
+            if not drained and sock not in self.__outputs:
+                self.__outputs.append(sock)
+        if drained:
+            self.__close(sock)
+
+    def __flush(self, sock: socket.socket) -> None:
+        failure: Optional[OSError] = None
+        drained = False
+        closing = False
+        with self.__lock:
+            pending = self.__pending.get(sock)
+            if pending is None:
+                if sock in self.__outputs:
+                    self.__outputs.remove(sock)
+                return
+            try:
+                with memoryview(pending) as view:
+                    sent = sock.send(view)
+            except BlockingIOError:
+                # The kernel buffer is full again; the tail stays queued.
+                return
+            except OSError as error:
+                failure = error
+            else:
+                del pending[:sent]
+                drained = not pending
+                if drained and sock in self.__outputs:
+                    self.__outputs.remove(sock)
+            closing = drained and sock in self.__closing
+        if failure is not None:
+            self.emit("error", sock, self.__clients.get(sock), failure)
+            self.__close(sock)
+            return
+        if closing:
+            self.__close(sock)
+
+    def __close(self, sock: socket.socket) -> None:
+        """Drop a client connection and close it. Safe to call twice."""
+        with self.__lock:
+            peer = self.__clients.pop(sock, None)
+            if sock in self.__inputs:
+                self.__inputs.remove(sock)
+            if sock in self.__outputs:
+                self.__outputs.remove(sock)
+            self.__pending.pop(sock, None)
+            self.__closing.discard(sock)
+        if peer is None:
+            sock.close()
+            return
+        try:
+            self.emit("disconnect", sock, peer)
+        finally:
+            sock.close()
+
+    def __shutdown(self) -> None:
+        """Close everything, no matter what the handlers do.
+
+        The listening socket goes first, so the port stops accepting; then every
+        client is closed even if a disconnect handler raises, and stop is
+        emitted in any case. The first handler failure is re-raised afterwards
+        unless run() is already unwinding because of another error.
+        """
+        failure: Optional[BaseException] = None
+        server_socket, self.__server_socket = self.__server_socket, None
+        if server_socket is not None:
+            with self.__lock:
+                if server_socket in self.__inputs:
+                    self.__inputs.remove(server_socket)
+            server_socket.close()
+        for sock in list(self.__clients):
+            try:
+                self.__close(sock)
+            except Exception as error:  # noqa: BLE001 - cleanup must finish
+                if failure is None:
+                    failure = error
+        for sock in list(self.__outputs):
+            sock.close()
+        self.__outputs.clear()
+        try:
+            self.emit("stop", self.__host, self.__port)
+        except Exception as error:  # noqa: BLE001 - cleanup must finish
+            if failure is None:
+                failure = error
+        if failure is not None and sys.exc_info()[0] is None:
+            raise failure

{simple_socket_server-2.0 → simple_socket_server-2.1/simple_socket_server.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple-socket-server
-Version: 2.0
+Version: 2.1
 Summary: Simple TCP socket server with select
 Author-email: webtoucher <webtoucher@ya.ru>
 License-Expression: BSD-3-Clause
@@ -59,7 +59,7 @@ $ pip install simple-socket-server
 Or you can add it as dependency in requirements.txt file of your python application:
 
 ```
-simple-socket-server~=2.0
+simple-socket-server~=2.1
 ```
 
 ## Usage
@@ -127,40 +127,57 @@ print(socket_server.host, socket_server.port)
 
 Handlers are called from the thread that runs `run()`, one at a time.
 
-| Event        | Arguments               | When it fires                                                    |
-|--------------|-------------------------|------------------------------------------------------------------|
-| `start`      | `host, port`            | the listening socket is ready                                    |
-| `connect`    | `sock, peer`            | a client has been accepted                                       |
-| `message`    | `sock, peer, data`      | a chunk of bytes has been received                               |
-| `disconnect` | `sock, peer`            | the connection is gone; the socket is closed right after         |
-| `error`      | `sock, peer, error`     | a socket error occurred; `disconnect` follows                    |
-| `stop`       | `host, port`            | `run()` has returned and every socket is closed                  |
+| Event        | Arguments               | When it fires                                                             |
+|--------------|-------------------------|---------------------------------------------------------------------------|
+| `start`      | `host, port`            | the listening socket is ready                                             |
+| `connect`    | `sock, peer`            | a client has been accepted                                                |
+| `message`    | `sock, peer, data`      | a chunk of bytes has been received                                        |
+| `disconnect` | `sock, peer`            | the connection is closed; the replies queued for it were delivered first   |
+| `error`      | `sock, peer, error`     | a socket error occurred; the connection is closed and `disconnect` follows |
+| `stop`       | `host, port`            | `run()` has returned and every socket is closed                            |
 
-`peer` is an `(host, port)` tuple, `data` is `bytes`, `error` is an `OSError`.
+`peer` is an `(host, port)` tuple, `data` is `bytes`, `error` is an `OSError`. When
+`error` reports a failure of the listening socket or of `select()` itself, `peer` is
+`None` and the server stops.
 
 ## API
 
-| Member                                | Description                                                          |
-|---------------------------------------|----------------------------------------------------------------------|
-| `run(host='0.0.0.0', port=6666, max_conn=5)` | serve connections until `stop()` is called                    |
-| `stop()`                              | ask `run()` to return; safe from a handler or another thread          |
-| `send(sock, message)`                 | queue `bytes` for a client; `ValueError` if it is not a client        |
-| `is_running`                          | `True` while `run()` is serving connections                           |
-| `host`, `port`                        | the address the listening socket is bound to                          |
-| `on(event)`, `emit(...)`              | inherited from `event_bus.EventBus`                                   |
+| Member                                   | Description                                                          |
+|------------------------------------------|----------------------------------------------------------------------|
+| `run(host='0.0.0.0', port=6666, max_conn=5, max_clients=500)` | serve connections until `stop()` is called      |
+| `stop()`                                 | ask `run()` to return; safe from a handler or another thread          |
+| `send(sock, message)`                    | queue `bytes` for a client; `ValueError` if it is not a client        |
+| `disconnect(sock)`                       | stop reading a client, deliver its queue, then close it               |
+| `is_running`                             | `True` while `run()` is serving connections                           |
+| `host`, `port`                           | the address the listening socket is bound to                          |
+| `on(event)`, `emit(...)`                 | inherited from `event_bus.EventBus`                                   |
 
 Notes:
 
 - The server is single-threaded and handlers are called synchronously, so a slow
   handler delays every other connection. Hand off long work to your own thread.
+- **A handler must not raise.** The exception propagates out of `run()` and stops
+  the server for every client; the sockets are still closed before the call returns.
+  If one connection misbehaves, handle it in the handler and call `disconnect()`.
 - `message` carries one raw `recv()` chunk of up to 1024 bytes. There is no
   framing: the protocol you put on top has to delimit its own messages.
 - `send()` never blocks and never truncates: because client sockets are
   non-blocking, the bytes are buffered and the unwritten tail is retried on the
   next poll, so a message larger than the socket buffer arrives in full.
-- Do not use the socket after `disconnect` or `error`: it is closed.
-- An exception raised by a handler propagates out of `run()`. The socket state is
-  still cleaned up before the call returns.
+- The outbound queue has no size limit: a client that stops reading grows the
+  buffer of the server until you disconnect it.
+- `send()` and `disconnect()` are safe to call from another thread. Delivery
+  happens during the next poll, so it can take up to the poll interval (0.1 s).
+- `max_conn` is the `listen()` backlog: how many connections the system queues
+  before `accept()`. It is not a limit of served clients. `max_clients` is that
+  limit: a connection above it is accepted, closed at once and reported through
+  `error`.
+- Do not call `sock.close()` yourself and do not use the socket after
+  `disconnect` or `error`. Use `disconnect(sock)` instead: it stops reading the
+  client and closes the socket after the queued replies are delivered. A socket
+  closed behind the server's back is dropped on the next poll, without delivery.
+- Urgent (out of band) data is not supported, and such data is not treated as an
+  error: the bytes stay in the stream and arrive through `message`.
 
 ## Compatibility
 
@@ -171,6 +188,10 @@ Notes:
   pyright see real signatures instead of `Any`.
 - Any server instance is independent: several servers may run in one process, each
   in its own thread.
+- The poll set of `select()` is limited by the platform: 512 descriptors on Windows
+  and 1024 elsewhere, the listening socket included. That is why concurrent clients
+  are capped by `max_clients`, 500 by default; a larger value makes `select()` fail,
+  and the server stops with an `error` event.
 
 ## Development
 
@@ -187,7 +208,16 @@ The test suite covers:
 - the message flow: `connect`, echo round trips, ordering and large payloads,
 - disconnects: graceful close by the peer, an abrupt reset and a send to a
   connection that is already gone,
-- error handling: an unknown socket for `send()` and a port that is already taken,
+- error handling: `send()` and `disconnect()` for an unknown socket, a client limit
+  that is reached, and a port that is already taken (POSIX only: on Windows
+  `SO_REUSEADDR` allows rebinding a listening port),
+- a half-close: the peer sends, shuts down its writing side and still receives the
+  whole reply, a 256 KiB one included,
+- server-driven disconnects: a queued reply reaches the client before the socket is
+  closed,
+- resilience: a handler that closes its socket does not stop the server, and
+  `stop()` closes every client and emits `stop` even if a `disconnect` handler
+  raises,
 - independence of two servers running in one process.
 
 Project layout:

{simple_socket_server-2.0 → simple_socket_server-2.1}/tests/test_simple_socket_server.py

@@ -1,6 +1,8 @@
 """Tests for the simple_socket_server package."""
 
+import importlib.metadata
 import os
+import re
 import socket
 import struct
 import threading
@@ -39,6 +41,7 @@ class RunningServer:
         self.run_kwargs = {"host": LOCAL_HOST, "port": 0, "max_conn": 5}
         self.run_kwargs.update(run_kwargs)
         self.events = []
+        self.error = None
         self._lock = threading.Lock()
         self._started = threading.Event()
         self._finished = threading.Event()
@@ -56,6 +59,8 @@ class RunningServer:
     def _run(self):
         try:
             self.server.run(**self.run_kwargs)
+        except BaseException as error:  # noqa: BLE001 - kept for the assertions
+            self.error = error
         finally:
             self._finished.set()
 
@@ -341,5 +346,172 @@ def test_public_api_is_explicit():
     for name in simple_socket_server.__all__:
         assert not name.startswith("_"), "%s is not a public name" % name
         assert hasattr(simple_socket_server, name), "%s is in __all__ but missing" % name
-    assert simple_socket_server.__version__ == "2.0"
+    assert re.match(r"^\d+\.\d+(\.\d+)?$", simple_socket_server.__version__)
     assert issubclass(SimpleSocketServerException, OSError)
+
+
+def test_declared_version_matches_the_package_metadata():
+    try:
+        installed = importlib.metadata.version("simple-socket-server")
+    except importlib.metadata.PackageNotFoundError:
+        pytest.skip("the package is not installed, metadata is unavailable")
+    assert installed == simple_socket_server.__version__
+
+
+@pytest.mark.skipif(
+    os.name == "nt",
+    reason="SO_REUSEADDR lets Windows bind a port that is already listening",
+)
+def test_taken_port_raises_server_exception():
+    blocker = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    blocker.bind((LOCAL_HOST, 0))
+    blocker.listen(1)
+    try:
+        server = SimpleSocketServer()
+        with pytest.raises(SimpleSocketServerException):
+            server.run(host=LOCAL_HOST, port=blocker.getsockname()[1])
+        assert not server.is_running
+    finally:
+        blocker.close()
+
+
+def test_client_limit_is_reported_through_the_error_event():
+    server = RunningServer(max_clients=1).start()
+    try:
+        first = server.connect()
+        second = server.connect()
+        try:
+            (_sock, _peer, error), = server.wait_for("error")
+            assert isinstance(error, ConnectionAbortedError)
+            assert server.thread.is_alive(), "one excessive client does not stop the loop"
+            second.settimeout(10)
+            assert second.recv(1) == b"", "the excessive client is closed at once"
+            assert len(server.events_of("connect")) == 1
+        finally:
+            first.close()
+            second.close()
+    finally:
+        server.stop()
+
+
+def half_close_client(server, request, timeout=10.0):
+    """Send a request, close the write half and read the reply until EOF."""
+    client = server.connect()
+    try:
+        client.sendall(request)
+        client.shutdown(socket.SHUT_WR)
+        client.settimeout(timeout)
+        reply = b""
+        while True:
+            chunk = client.recv(65536)
+            if not chunk:
+                return reply
+            reply += chunk
+    finally:
+        client.close()
+
+
+def test_reply_survives_a_half_close_of_the_client():
+    def on_message(sock, _peer, data):
+        state["server"].send(sock, b"echo:" + data)
+
+    state = {}
+    server = RunningServer({"message": on_message})
+    state["server"] = server.server
+    server.start()
+    try:
+        # The reply used to be dropped whenever the EOF arrived before the flush.
+        for attempt in range(10):
+            reply = half_close_client(server, b"ping")
+            assert reply == b"echo:ping", "attempt %d lost the reply" % attempt
+    finally:
+        server.stop()
+
+
+def test_large_reply_survives_a_half_close_of_the_client():
+    payload = bytes(range(256)) * 1024  # 256 KiB, far above the socket buffer
+
+    def on_message(sock, _peer, _data):
+        state["server"].send(sock, payload)
+
+    state = {}
+    server = RunningServer({"message": on_message})
+    state["server"] = server.server
+    server.start()
+    try:
+        assert half_close_client(server, b"go", timeout=30) == payload
+    finally:
+        server.stop()
+
+
+def test_disconnect_delivers_the_queue_before_it_closes():
+    def on_message(sock, _peer, _data):
+        state["server"].send(sock, b"bye")
+        state["server"].disconnect(sock)
+
+    state = {}
+    server = RunningServer({"message": on_message})
+    state["server"] = server.server
+    server.start()
+    try:
+        assert half_close_client(server, b"go") == b"bye"
+        server.wait_for("disconnect")
+    finally:
+        server.stop()
+
+
+def test_disconnect_rejects_a_foreign_socket(running_server):
+    stranger = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        with pytest.raises(ValueError):
+            running_server.server.disconnect(stranger)
+    finally:
+        stranger.close()
+
+
+def test_closing_the_socket_inside_a_handler_keeps_the_server_alive():
+    def on_message(sock, _peer, _data):
+        sock.close()
+
+    server = RunningServer({"message": on_message}).start()
+    try:
+        victim = server.connect()
+        server.wait_for("connect")
+        victim.sendall(b"x")
+        server.wait_for("disconnect")
+
+        assert server.thread.is_alive(), "run() survived a socket closed by a handler"
+        assert server.error is None, server.error
+
+        second = server.connect()
+        try:
+            server.wait_for("connect", count=2)
+            assert server.thread.is_alive()
+        finally:
+            victim.close()
+            second.close()
+    finally:
+        server.stop()
+
+
+def test_stop_closes_everything_even_if_a_disconnect_handler_raises():
+    def bad_disconnect(_sock, _peer):
+        raise RuntimeError("boom on disconnect")
+
+    server = RunningServer({"disconnect": bad_disconnect}).start()
+    first = server.connect()
+    second = server.connect()
+    server.wait_for("connect", count=2)
+
+    server.stop()
+
+    assert server.events_of("stop"), "the stop event arrives despite the failure"
+    assert isinstance(server.error, RuntimeError), "the handler failure is not swallowed"
+    first.settimeout(10)
+    second.settimeout(10)
+    assert first.recv(1) == b"", "every client is closed"
+    assert second.recv(1) == b"", "every client is closed, not just the first one"
+    first.close()
+    second.close()
+    with pytest.raises(OSError):
+        socket.create_connection(server.address, timeout=2)

simple_socket_server-2.0/simple_socket_server/__init__.py

@@ -1,262 +0,0 @@
-"""
-Simple TCP socket server built on select().
-
-The server is single-threaded: run() polls the sockets and calls the handlers
-registered for its events. No third-party networking code is involved, the only
-runtime dependency is the event bus used to dispatch those events.
-
-Copyright (c) 2023–2026 webtoucher
-Distributed under the BSD 3-Clause license. See LICENSE.md for more info.
-"""
-
-import select
-import socket
-import threading
-
-from typing import Dict, List, Optional, Tuple
-
-from event_bus import EventBus
-
-__all__ = ["SimpleSocketServer", "SimpleSocketServerException"]
-
-__version__ = "2.0"
-
-#: Peer address as returned by accept(): (host, port).
-Address = Tuple[str, int]
-
-#: Size of a single recv() chunk; a message event carries one such chunk.
-_RECV_SIZE = 1024
-
-#: How long select() waits for socket activity, in seconds.
-_POLL_INTERVAL = 0.1
-
-
-class SimpleSocketServerException(socket.error):
-    """Raised when the listening socket cannot be created, bound or enabled."""
-
-
-class SimpleSocketServer(EventBus):
-    """Single-threaded TCP server dispatching events through an event bus.
-
-    Events, in the order they may arrive:
-
-    ``start(host, port)``
-        The listening socket is ready.
-    ``connect(sock, peer)``
-        A client has been accepted.
-    ``message(sock, peer, data)``
-        A chunk of bytes has been received.
-    ``disconnect(sock, peer)``
-        The connection is gone: the peer closed it, reset it or a send failed.
-    ``error(sock, peer, error)``
-        A socket error occurred; the connection is closed right after.
-    ``stop(host, port)``
-        run() has returned and every socket is closed.
-
-    Handlers are called from the thread that runs run(), one at a time, so a
-    slow handler delays every other connection.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.__host = "0.0.0.0"
-        self.__port = 6666
-        self.__max_conn = 5
-        self.__server_socket: Optional[socket.socket] = None
-        self.__inputs: List[socket.socket] = []
-        self.__outputs: List[socket.socket] = []
-        self.__pending: Dict[socket.socket, bytearray] = {}
-        self.__clients: Dict[socket.socket, Address] = {}
-        self.__stop = threading.Event()
-
-    @property
-    def is_running(self) -> bool:
-        """True while run() is serving connections."""
-        return self.__server_socket is not None and not self.__stop.is_set()
-
-    @property
-    def host(self) -> str:
-        """Host the listening socket is bound to."""
-        return self.__host
-
-    @property
-    def port(self) -> int:
-        """Port the listening socket is bound to."""
-        return self.__port
-
-    def run(self, host: str = "0.0.0.0", port: int = 6666, max_conn: int = 5) -> None:
-        """Serve connections until stop() is called.
-
-        The call blocks the calling thread. Once it returns, every client socket
-        and the listening socket are closed. A port of 0 makes the operating
-        system pick a free port; the actual address is reported by the start
-        event and by the host and port properties.
-        """
-        if self.is_running:
-            raise RuntimeError("the server is already running")
-        self.__host = host
-        self.__port = port
-        self.__max_conn = max_conn
-        self.__stop.clear()
-        self.__initialize()
-        try:
-            while not self.__stop.is_set():
-                self.__select()
-        finally:
-            self.__shutdown()
-
-    def stop(self) -> None:
-        """Ask run() to return.
-
-        It only raises a flag, so it is safe to call from an event handler or
-        from another thread. run() finishes the current poll and then closes
-        every socket.
-        """
-        self.__stop.set()
-
-    def send(self, sock: socket.socket, message: bytes) -> None:
-        """Queue message for delivery to a client of this server.
-
-        The socket is non-blocking, so the bytes are buffered and the unwritten
-        tail is retried on the next poll; a message larger than the socket
-        buffer is delivered in full. Empty messages are ignored.
-        """
-        if sock not in self.__pending:
-            raise ValueError("the socket is not a client of this server")
-        if not message:
-            return
-        self.__pending[sock].extend(message)
-        if sock not in self.__outputs:
-            self.__outputs.append(sock)
-
-    def __initialize(self) -> None:
-        server_socket = socket.socket(
-            socket.AF_INET,
-            socket.SOCK_STREAM,
-            socket.IPPROTO_TCP,
-        )
-        try:
-            server_socket.setblocking(False)
-            server_socket.setsockopt(
-                socket.SOL_SOCKET,
-                socket.SO_REUSEADDR,
-                1,
-            )
-            server_socket.bind((self.__host, self.__port))
-            server_socket.listen(self.__max_conn)
-        except OSError as error:
-            server_socket.close()
-            raise SimpleSocketServerException(
-                "cannot listen on %s:%s" % (self.__host, self.__port)
-            ) from error
-        self.__server_socket = server_socket
-        self.__inputs.append(server_socket)
-        # A port of 0 is resolved by the system, so report the real address.
-        self.__host, self.__port = server_socket.getsockname()[:2]
-        self.emit("start", self.__host, self.__port)
-
-    def __select(self) -> None:
-        try:
-            sock_to_read, sock_to_write, sock_errors = select.select(
-                self.__inputs,
-                self.__outputs,
-                self.__inputs,
-                _POLL_INTERVAL,
-            )
-        except OSError as error:
-            # select() itself failed, so the listening socket is unusable.
-            self.emit("error", None, None, error)
-            self.stop()
-            return
-        for sock in sock_errors:
-            if sock is self.__server_socket:
-                self.stop()
-            else:
-                self.__close(sock)
-        for sock in sock_to_read:
-            if sock is self.__server_socket:
-                self.__accept()
-            else:
-                self.__receive(sock)
-        for sock in sock_to_write:
-            self.__flush(sock)
-
-    def __accept(self) -> None:
-        try:
-            client_socket, client_address = self.__server_socket.accept()
-        except OSError as error:
-            self.emit("error", self.__server_socket, None, error)
-            return
-        client_socket.setblocking(False)
-        self.__clients[client_socket] = client_address
-        self.__pending[client_socket] = bytearray()
-        self.__inputs.append(client_socket)
-        self.emit("connect", client_socket, client_address)
-
-    def __receive(self, sock: socket.socket) -> None:
-        peer = self.__clients.get(sock)
-        if peer is None:
-            # The socket was already dropped during this poll.
-            return
-        try:
-            data = sock.recv(_RECV_SIZE)
-        except BlockingIOError:
-            # select() woke us up for nothing; try again on the next poll.
-            return
-        except (ConnectionResetError, ConnectionAbortedError, BrokenPipeError):
-            self.__close(sock)
-            return
-        except OSError as error:
-            self.emit("error", sock, peer, error)
-            self.__close(sock)
-            return
-        if not data:
-            # An empty chunk means the peer closed its end of the connection.
-            self.__close(sock)
-            return
-        self.emit("message", sock, peer, data)
-
-    def __flush(self, sock: socket.socket) -> None:
-        pending = self.__pending.get(sock)
-        if pending is None:
-            if sock in self.__outputs:
-                self.__outputs.remove(sock)
-            return
-        try:
-            sent = sock.send(pending)
-        except BlockingIOError:
-            # The kernel buffer is full again; the tail stays queued.
-            return
-        except OSError as error:
-            self.emit("error", sock, self.__clients.get(sock), error)
-            self.__close(sock)
-            return
-        del pending[:sent]
-        if not pending and sock in self.__outputs:
-            self.__outputs.remove(sock)
-
-    def __close(self, sock: socket.socket) -> None:
-        """Close a client connection and forget it. Safe to call twice."""
-        peer = self.__clients.pop(sock, None)
-        if sock in self.__inputs:
-            self.__inputs.remove(sock)
-        if sock in self.__outputs:
-            self.__outputs.remove(sock)
-        self.__pending.pop(sock, None)
-        if peer is None:
-            sock.close()
-            return
-        try:
-            self.emit("disconnect", sock, peer)
-        finally:
-            sock.close()
-
-    def __shutdown(self) -> None:
-        for sock in list(self.__clients):
-            self.__close(sock)
-        server_socket, self.__server_socket = self.__server_socket, None
-        if server_socket is not None:
-            if server_socket in self.__inputs:
-                self.__inputs.remove(server_socket)
-            server_socket.close()
-        self.emit("stop", self.__host, self.__port)