Add path functionality to SocketListener instead of making UnixSocketListener

Author: CoolCat467

newsfragments/3187.feature.rst newsfragments/279.feature.rstnewsfragments/3187.feature.rst renamed to newsfragments/279.feature.rst

@@ -72,7 +72,6 @@
 from ._highlevel_socket import (
     SocketListener as SocketListener,
     SocketStream as SocketStream,
-    UnixSocketListener as UnixSocketListener,
 )
 from ._highlevel_ssl_helpers import (
     open_ssl_over_tcp_listeners as open_ssl_over_tcp_listeners,

src/trio/__init__.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 import os
-import sys
 from typing import TYPE_CHECKING
 
 import trio
 import trio.socket as tsocket
 from trio import TaskStatus
 
+from ._highlevel_open_tcp_listeners import _compute_backlog
+
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable
 
@@ -20,50 +21,12 @@
     HAS_UNIX = False
 
 
-# Default backlog size:
-#
-# Having the backlog too low can cause practical problems (a perfectly healthy
-# service that starts failing to accept connections if they arrive in a
-# burst).
-#
-# Having it too high doesn't really cause any problems. Like any buffer, you
-# want backlog queue to be zero usually, and it won't save you if you're
-# getting connection attempts faster than you can call accept() on an ongoing
-# basis. But unlike other buffers, this one doesn't really provide any
-# backpressure. If a connection gets stuck waiting in the backlog queue, then
-# from the peer's point of view the connection succeeded but then their
-# send/recv will stall until we get to it, possibly for a long time. OTOH if
-# there isn't room in the backlog queue, then their connect stalls, possibly
-# for a long time, which is pretty much the same thing.
-#
-# A large backlog can also use a bit more kernel memory, but this seems fairly
-# negligible these days.
-#
-# So this suggests we should make the backlog as large as possible. This also
-# matches what Golang does. However, they do it in a weird way, where they
-# have a bunch of code to sniff out the configured upper limit for backlog on
-# different operating systems. But on every system, passing in a too-large
-# backlog just causes it to be silently truncated to the configured maximum,
-# so this is unnecessary -- we can just pass in "infinity" and get the maximum
-# that way. (Verified on Windows, Linux, macOS using
-# https://github.com/python-trio/trio/wiki/notes-to-self#measure-listen-backlogpy
-def _compute_backlog(backlog: int | None) -> int:
-    # Many systems (Linux, BSDs, ...) store the backlog in a uint16 and are
-    # missing overflow protection, so we apply our own overflow protection.
-    # https://github.com/golang/go/issues/5030
-    if not isinstance(backlog, int) and backlog is not None:
-        raise TypeError(f"backlog must be an int or None, not {backlog!r}")
-    if backlog is None:
-        return 0xFFFF
-    return min(backlog, 0xFFFF)
-
-
 async def open_unix_listener(
     path: str | bytes | os.PathLike[str] | os.PathLike[bytes],
     *,
-    mode: int | None = None,  # 0o666,
+    mode: int | None = None,
     backlog: int | None = None,
-) -> trio.UnixSocketListener:
+) -> trio.SocketListener:
     """Create :class:`SocketListener` objects to listen for  connections.
     Opens a connection to the specified
     `Unix domain socket <https://en.wikipedia.org/wiki/Unix_domain_socket>`__.
@@ -76,20 +39,21 @@ async def open_unix_listener(
           Absolute or relative paths may be used.
 
       mode (int or None): The socket file permissions.
-          UNIX permissions are usually specified in octal numbers.
-          If you leave this as ``None``, Trio will not change the mode from
+          UNIX permissions are usually specified in octal numbers. If
+          you leave this as ``None``, Trio will not change the mode from
           the operating system's default.
 
       backlog (int or None): The listen backlog to use. If you leave this as
-          ``None`` then Trio will pick a good default. (Currently: whatever
-          your system has configured as the maximum backlog.)
+          ``None`` then Trio will pick a good default. (Currently:
+          whatever your system has configured as the maximum backlog.)
 
     Returns:
       :class:`UnixSocketListener`
 
     Raises:
-      :class:`TypeError` if invalid arguments.
+      :class:`ValueError` If invalid arguments.
       :class:`RuntimeError`: If AF_UNIX sockets are not supported.
+      :class:`FileNotFoundError`: If folder socket file is to be created in does not exist.
     """
     if not HAS_UNIX:
         raise RuntimeError("Unix sockets are not supported on this platform")
@@ -102,28 +66,23 @@ async def open_unix_listener(
     if not await folder.exists():
         raise FileNotFoundError(f"Socket folder does not exist: {folder!r}")
 
-    # much more simplified logic vs tcp sockets - one socket type and only one
+    str_path = str(fspath)
+
+    # much more simplified logic vs tcp sockets - one socket family and only one
     # possible location to connect to
     sock = tsocket.socket(AF_UNIX, tsocket.SOCK_STREAM)
     try:
-        # See https://github.com/python-trio/trio/issues/39
-        if sys.platform != "win32":
-            sock.setsockopt(tsocket.SOL_SOCKET, tsocket.SO_REUSEADDR, 1)
-
-        await sock.bind(str(fspath))
-
-        sock.listen(computed_backlog)
+        await sock.bind(str_path)
 
         if mode is not None:
             await fspath.chmod(mode)
 
-        return trio.UnixSocketListener(sock)
-    except BaseException as exc:
+        sock.listen(computed_backlog)
+
+        return trio.SocketListener(sock, str_path)
+    except BaseException:
         sock.close()
-        try:
-            os.unlink(str(fspath))
-        except BaseException as exc_2:
-            raise exc_2 from exc
+        os.unlink(str_path)
         raise
 
 

src/trio/_highlevel_open_unix_listeners.py

@@ -3,7 +3,8 @@
 
 import errno
 from contextlib import contextmanager, suppress
-from os import unlink
+from os import PathLike, stat, unlink
+from stat import S_ISSOCK
 from typing import TYPE_CHECKING, Final, overload
 
 import trio
@@ -71,6 +72,8 @@ class SocketStream(HalfCloseableStream):
 
     """
 
+    __slots__ = ("_send_conflict_detector", "socket")
+
     def __init__(self, socket: SocketType) -> None:
         if not isinstance(socket, tsocket.SocketType):
             raise TypeError("SocketStream requires a Trio socket object")
@@ -355,90 +358,34 @@ class SocketListener(Listener[SocketStream]):
     incoming connections as :class:`SocketStream` objects.
 
     Args:
+
       socket: The Trio socket object to wrap. Must have type ``SOCK_STREAM``,
           and be listening.
 
+      path: Used for keeping track of which path a Unix socket is bound
+          to. If not ``None``, :meth:`aclose` will unlink this path.
+          File must have socket mode flag set.
+
     Note that the :class:`SocketListener` "takes ownership" of the given
     socket; closing the :class:`SocketListener` will also close the socket.
 
     .. attribute:: socket
 
        The Trio socket object that this stream wraps.
 
-    """
-
-    def __init__(self, socket: SocketType) -> None:
-        if not isinstance(socket, tsocket.SocketType):
-            raise TypeError("SocketListener requires a Trio socket object")
-        if socket.type != tsocket.SOCK_STREAM:
-            raise ValueError("SocketListener requires a SOCK_STREAM socket")
-        try:
-            listening = socket.getsockopt(tsocket.SOL_SOCKET, tsocket.SO_ACCEPTCONN)
-        except OSError:
-            # SO_ACCEPTCONN fails on macOS; we just have to trust the user.
-            pass
-        else:
-            if not listening:
-                raise ValueError("SocketListener requires a listening socket")
-
-        self.socket = socket
-
-    async def accept(self) -> SocketStream:
-        """Accept an incoming connection.
-
-        Returns:
-          :class:`SocketStream`
-
-        Raises:
-          OSError: if the underlying call to ``accept`` raises an unexpected
-              error.
-          ClosedResourceError: if you already closed the socket.
+    .. attribute:: path
 
-        This method handles routine errors like ``ECONNABORTED``, but passes
-        other errors on to its caller. In particular, it does *not* make any
-        special effort to handle resource exhaustion errors like ``EMFILE``,
-        ``ENFILE``, ``ENOBUFS``, ``ENOMEM``.
-
-        """
-        while True:
-            try:
-                sock, _ = await self.socket.accept()
-            except OSError as exc:
-                if exc.errno in _closed_stream_errnos:
-                    raise trio.ClosedResourceError from None
-                if exc.errno not in _ignorable_accept_errnos:
-                    raise
-            else:
-                return SocketStream(sock)
-
-    async def aclose(self) -> None:
-        """Close this listener and its underlying socket."""
-        self.socket.close()
-        await trio.lowlevel.checkpoint()
-
-
-@final
-class UnixSocketListener(Listener[SocketStream]):
-    """A :class:`~trio.abc.Listener` that uses a listening socket to accept
-    incoming connections as :class:`SocketStream` objects.
-
-    Args:
-      socket: The Trio socket object to wrap. Must have type ``SOCK_STREAM``,
-          and be listening.
-
-    Note that the :class:`UnixSocketListener` "takes ownership" of the given
-    socket; closing the :class:`UnixSocketListener` will also close the socket
-    and unlink its associated file.
-
-    .. attribute:: socket
-
-       The Trio socket object that this stream wraps.
+       The path to unlink in :meth:`aclose` that a Unix socket is bound to.
 
     """
 
-    def __init__(self, socket: SocketType) -> None:
-        if not HAS_UNIX:
-            raise RuntimeError("Unix sockets are not supported on this platform")
+    __slots__ = ("path", "socket")
+
+    def __init__(
+        self,
+        socket: SocketType,
+        path: str | bytes | PathLike[str] | PathLike[bytes] | None = None,
+    ) -> None:
         if not isinstance(socket, tsocket.SocketType):
             raise TypeError("SocketListener requires a Trio socket object")
         if socket.type != tsocket.SOCK_STREAM:
@@ -451,8 +398,11 @@ def __init__(self, socket: SocketType) -> None:
         else:
             if not listening:
                 raise ValueError("SocketListener requires a listening socket")
+        if path is not None and not S_ISSOCK(stat(path).st_mode):
+            raise ValueError("Specified path must be a Unix socket file")
 
         self.socket = socket
+        self.path = path
 
     async def accept(self) -> SocketStream:
         """Accept an incoming connection.
@@ -483,8 +433,8 @@ async def accept(self) -> SocketStream:
                 return SocketStream(sock)
 
     async def aclose(self) -> None:
-        """Close this listener, its underlying socket, and unlink its associated file."""
-        path = self.socket.getsockname()
+        """Close this listener and its underlying socket."""
         self.socket.close()
-        unlink(path)
+        if self.path is not None:
+            unlink(self.path)
         await trio.lowlevel.checkpoint()