@ajksunkang-aios/kgraph-linux-x64 0.1.2 → 0.1.3

package/lib/site-packages/trio/_tests/test_highlevel_open_unix_stream.py

@@ -0,0 +1,86 @@
+import os
+import socket
+import sys
+import tempfile
+from typing import TYPE_CHECKING
+
+import pytest
+
+from trio import Path, open_unix_socket
+from trio._highlevel_open_unix_stream import close_on_error
+
+assert not TYPE_CHECKING or sys.platform != "win32"
+
+skip_if_not_unix = pytest.mark.skipif(
+    not hasattr(socket, "AF_UNIX"),
+    reason="Needs unix socket support",
+)
+
+
+@skip_if_not_unix
+def test_close_on_error() -> None:
+    class CloseMe:
+        closed = False
+
+        def close(self) -> None:
+            self.closed = True
+
+    with close_on_error(CloseMe()) as c:
+        pass
+    assert not c.closed
+
+    with pytest.raises(RuntimeError):
+        with close_on_error(CloseMe()) as c:
+            raise RuntimeError
+    assert c.closed
+
+
+@skip_if_not_unix
+@pytest.mark.parametrize("filename", [4, 4.5])
+async def test_open_with_bad_filename_type(filename: float) -> None:
+    with pytest.raises(TypeError):
+        await open_unix_socket(filename)  # type: ignore[arg-type]
+
+
+@skip_if_not_unix
+async def test_open_bad_socket() -> None:
+    # mktemp is marked as insecure, but that's okay, we don't want the file to
+    # exist
+    name = tempfile.mktemp()
+    with pytest.raises(FileNotFoundError):
+        await open_unix_socket(name)
+
+
+@skip_if_not_unix
+async def test_open_unix_socket() -> None:
+    for name_type in [Path, str]:
+        name = tempfile.mktemp()
+        serv_sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        with serv_sock:
+            serv_sock.bind(name)
+            try:
+                serv_sock.listen(1)
+
+                # The actual function we're testing
+                unix_socket = await open_unix_socket(name_type(name))
+
+                async with unix_socket:
+                    client, _ = serv_sock.accept()
+                    with client:
+                        await unix_socket.send_all(b"test")
+                        assert client.recv(2048) == b"test"
+
+                        client.sendall(b"response")
+                        received = await unix_socket.receive_some(2048)
+                        assert received == b"response"
+            finally:
+                os.unlink(name)
+
+
+@pytest.mark.skipif(hasattr(socket, "AF_UNIX"), reason="Test for non-unix platforms")
+async def test_error_on_no_unix() -> None:
+    with pytest.raises(
+        RuntimeError,
+        match=r"^Unix sockets are not supported on this platform$",
+    ):
+        await open_unix_socket("")

package/lib/site-packages/trio/_tests/test_highlevel_serve_listeners.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import errno
+from functools import partial
+from typing import TYPE_CHECKING, NoReturn, cast
+
+import attrs
+import pytest
+
+import trio
+from trio import Nursery, StapledStream, TaskStatus
+from trio.testing import (
+    MemoryReceiveStream,
+    MemorySendStream,
+    MockClock,
+    memory_stream_pair,
+    wait_all_tasks_blocked,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from trio._channel import MemoryReceiveChannel, MemorySendChannel
+    from trio.abc import Stream
+
+# types are somewhat tentative - I just bruteforced them until I got something that didn't
+# give errors
+StapledMemoryStream = StapledStream[MemorySendStream, MemoryReceiveStream]
+
+
+@attrs.define(eq=False, slots=False)
+class MemoryListener(trio.abc.Listener[StapledMemoryStream]):
+    closed: bool = False
+    accepted_streams: list[trio.abc.Stream] = attrs.Factory(list)
+    queued_streams: tuple[
+        MemorySendChannel[StapledMemoryStream],
+        MemoryReceiveChannel[StapledMemoryStream],
+    ] = attrs.Factory(lambda: trio.open_memory_channel[StapledMemoryStream](1))
+    accept_hook: Callable[[], Awaitable[object]] | None = None
+
+    async def connect(self) -> StapledMemoryStream:
+        assert not self.closed
+        client, server = memory_stream_pair()
+        await self.queued_streams[0].send(server)
+        return client
+
+    async def accept(self) -> StapledMemoryStream:
+        await trio.lowlevel.checkpoint()
+        assert not self.closed
+        if self.accept_hook is not None:
+            await self.accept_hook()
+        stream = await self.queued_streams[1].receive()
+        self.accepted_streams.append(stream)
+        return stream
+
+    async def aclose(self) -> None:
+        self.closed = True
+        await trio.lowlevel.checkpoint()
+
+
+async def test_serve_listeners_basic() -> None:
+    listeners = [MemoryListener(), MemoryListener()]
+
+    record = []
+
+    def close_hook() -> None:
+        # Make sure this is a forceful close
+        assert trio.current_effective_deadline() == float("-inf")
+        record.append("closed")
+
+    async def handler(stream: StapledMemoryStream) -> None:
+        await stream.send_all(b"123")
+        assert await stream.receive_some(10) == b"456"
+        stream.send_stream.close_hook = close_hook
+        stream.receive_stream.close_hook = close_hook
+
+    async def client(listener: MemoryListener) -> None:
+        s = await listener.connect()
+        assert await s.receive_some(10) == b"123"
+        await s.send_all(b"456")
+
+    async def do_tests(parent_nursery: Nursery) -> None:
+        async with trio.open_nursery() as nursery:
+            for listener in listeners:
+                for _ in range(3):
+                    nursery.start_soon(client, listener)
+
+        await wait_all_tasks_blocked()
+
+        # verifies that all 6 streams x 2 directions each were closed ok
+        assert len(record) == 12
+
+        parent_nursery.cancel_scope.cancel()
+
+    async with trio.open_nursery() as nursery:
+        value = await nursery.start(
+            trio.serve_listeners,
+            handler,
+            listeners,
+        )
+        assert isinstance(value, list)
+        l2 = cast("list[MemoryListener]", value)
+        assert l2 == listeners
+        # This is just split into another function because gh-136 isn't
+        # implemented yet
+        nursery.start_soon(do_tests, nursery)
+
+    for listener in listeners:
+        assert listener.closed
+
+
+async def test_serve_listeners_accept_unrecognized_error() -> None:
+    for error in [KeyError(), OSError(errno.ECONNABORTED, "ECONNABORTED")]:
+        listener = MemoryListener()
+
+        async def raise_error() -> NoReturn:
+            raise error  # noqa: B023  # Set from loop
+
+        def check_error(e: BaseException) -> bool:
+            return e is error  # noqa: B023
+
+        listener.accept_hook = raise_error
+
+        with pytest.RaisesGroup(pytest.RaisesExc(check=check_error)):
+            await trio.serve_listeners(None, [listener])  # type: ignore[arg-type]
+
+
+async def test_serve_listeners_accept_capacity_error(
+    autojump_clock: MockClock,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    listener = MemoryListener()
+
+    async def raise_EMFILE() -> NoReturn:
+        raise OSError(errno.EMFILE, "out of file descriptors")
+
+    listener.accept_hook = raise_EMFILE
+
+    # It retries every 100 ms, so in 950 ms it will retry at 0, 100, ..., 900
+    # = 10 times total
+    with trio.move_on_after(0.950):
+        await trio.serve_listeners(None, [listener])  # type: ignore[arg-type]
+
+    assert len(caplog.records) == 10
+    for record in caplog.records:
+        assert "retrying" in record.msg
+        assert record.exc_info is not None
+        assert isinstance(record.exc_info[1], OSError)
+        assert record.exc_info[1].errno == errno.EMFILE
+
+
+async def test_serve_listeners_connection_nursery(autojump_clock: MockClock) -> None:
+    listener = MemoryListener()
+
+    async def handler(stream: Stream) -> None:
+        await trio.sleep(1)
+
+    class Done(Exception):
+        pass
+
+    async def connection_watcher(
+        *,
+        task_status: TaskStatus[Nursery] = trio.TASK_STATUS_IGNORED,
+    ) -> NoReturn:
+        async with trio.open_nursery() as nursery:
+            task_status.started(nursery)
+            await wait_all_tasks_blocked()
+            assert len(nursery.child_tasks) == 10
+            raise Done
+
+    # the exception is wrapped twice because we open two nested nurseries
+    with pytest.RaisesGroup(pytest.RaisesGroup(Done)):
+        async with trio.open_nursery() as nursery:
+            value = await nursery.start(connection_watcher)
+            assert isinstance(value, trio.Nursery)
+            handler_nursery: trio.Nursery = value
+            await nursery.start(
+                partial(
+                    trio.serve_listeners,
+                    handler,
+                    [listener],
+                    handler_nursery=handler_nursery,
+                ),
+            )
+            for _ in range(10):
+                nursery.start_soon(listener.connect)

package/lib/site-packages/trio/_tests/test_highlevel_socket.py

@@ -0,0 +1,336 @@
+from __future__ import annotations
+
+import errno
+import socket as stdlib_socket
+import sys
+from typing import TYPE_CHECKING
+
+import pytest
+
+from .. import _core, socket as tsocket
+from .._highlevel_socket import *
+from ..testing import (
+    assert_checkpoints,
+    check_half_closeable_stream,
+    wait_all_tasks_blocked,
+)
+from .test_socket import setsockopt_tests
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+async def test_SocketStream_basics() -> None:
+    # stdlib socket bad (even if connected)
+    stdlib_a, stdlib_b = stdlib_socket.socketpair()
+    with stdlib_a, stdlib_b:
+        with pytest.raises(TypeError):
+            SocketStream(stdlib_a)  # type: ignore[arg-type]
+
+    # DGRAM socket bad
+    with tsocket.socket(type=tsocket.SOCK_DGRAM) as sock:
+        with pytest.raises(
+            ValueError,
+            match=r"^SocketStream requires a SOCK_STREAM socket$",
+        ):
+            # TODO: does not raise an error?
+            SocketStream(sock)
+
+    a, b = tsocket.socketpair()
+    with a, b:
+        s = SocketStream(a)
+        assert s.socket is a
+
+    # Use a real, connected socket to test socket options, because
+    # socketpair() might give us a unix socket that doesn't support any of
+    # these options
+    with tsocket.socket() as listen_sock:
+        await listen_sock.bind(("127.0.0.1", 0))
+        listen_sock.listen(1)
+        with tsocket.socket() as client_sock:
+            await client_sock.connect(listen_sock.getsockname())
+
+            s = SocketStream(client_sock)
+
+            # TCP_NODELAY enabled by default
+            assert s.getsockopt(tsocket.IPPROTO_TCP, tsocket.TCP_NODELAY)
+            # We can disable it though
+            s.setsockopt(tsocket.IPPROTO_TCP, tsocket.TCP_NODELAY, False)
+            assert not s.getsockopt(tsocket.IPPROTO_TCP, tsocket.TCP_NODELAY)
+
+            res = s.getsockopt(tsocket.IPPROTO_TCP, tsocket.TCP_NODELAY, 1)
+            assert isinstance(res, bytes)
+
+            setsockopt_tests(s)
+
+
+async def test_SocketStream_send_all() -> None:
+    BIG = 10000000
+
+    a_sock, b_sock = tsocket.socketpair()
+    with a_sock, b_sock:
+        a = SocketStream(a_sock)
+        b = SocketStream(b_sock)
+
+        # Check a send_all that has to be split into multiple parts (on most
+        # platforms... on Windows every send() either succeeds or fails as a
+        # whole)
+        async def sender() -> None:
+            data = bytearray(BIG)
+            await a.send_all(data)
+            # send_all uses memoryviews internally, which temporarily "lock"
+            # the object they view. If it doesn't clean them up properly, then
+            # some bytearray operations might raise an error afterwards, which
+            # would be a pretty weird and annoying side-effect to spring on
+            # users. So test that this doesn't happen, by forcing the
+            # bytearray's underlying buffer to be realloc'ed:
+            data += bytes(BIG)
+            # (Note: the above line of code doesn't do a very good job at
+            # testing anything, because:
+            # - on CPython, the refcount GC generally cleans up memoryviews
+            #   for us even if we're sloppy.
+            # - on PyPy3, at least as of 5.7.0, the memoryview code and the
+            #   bytearray code conspire so that resizing never fails – if
+            #   resizing forces the bytearray's internal buffer to move, then
+            #   all memoryview references are automagically updated (!!).
+            #   See:
+            #   https://gist.github.com/njsmith/0ffd38ec05ad8e34004f34a7dc492227
+            # But I'm leaving the test here in hopes that if this ever changes
+            # and we break our implementation of send_all, then we'll get some
+            # early warning...)
+
+        async def receiver() -> None:
+            # Make sure the sender fills up the kernel buffers and blocks
+            await wait_all_tasks_blocked()
+            nbytes = 0
+            while nbytes < BIG:
+                nbytes += len(await b.receive_some(BIG))
+            assert nbytes == BIG
+
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(sender)
+            nursery.start_soon(receiver)
+
+        # We know that we received BIG bytes of NULs so far. Make sure that
+        # was all the data in there.
+        await a.send_all(b"e")
+        assert await b.receive_some(10) == b"e"
+        await a.send_eof()
+        assert await b.receive_some(10) == b""
+
+
+async def fill_stream(s: SocketStream) -> None:
+    async def sender() -> None:
+        while True:
+            await s.send_all(b"x" * 10000)
+
+    async def waiter(nursery: _core.Nursery) -> None:
+        await wait_all_tasks_blocked()
+        nursery.cancel_scope.cancel()
+
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(sender)
+        nursery.start_soon(waiter, nursery)
+
+
+async def test_SocketStream_generic() -> None:
+    async def stream_maker() -> tuple[
+        SocketStream,
+        SocketStream,
+    ]:
+        left, right = tsocket.socketpair()
+        return SocketStream(left), SocketStream(right)
+
+    async def clogged_stream_maker() -> tuple[SocketStream, SocketStream]:
+        left, right = await stream_maker()
+        await fill_stream(left)
+        await fill_stream(right)
+        return left, right
+
+    await check_half_closeable_stream(stream_maker, clogged_stream_maker)
+
+
+async def test_SocketListener() -> None:
+    # Not a Trio socket
+    with stdlib_socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        s.listen(10)
+        with pytest.raises(TypeError):
+            SocketListener(s)  # type: ignore[arg-type]
+
+    # Not a SOCK_STREAM
+    with tsocket.socket(type=tsocket.SOCK_DGRAM) as s:
+        await s.bind(("127.0.0.1", 0))
+        with pytest.raises(
+            ValueError,
+            match=r"^SocketListener requires a SOCK_STREAM socket$",
+        ) as excinfo:
+            SocketListener(s)
+        excinfo.match(r".*SOCK_STREAM")
+
+    # Didn't call .listen()
+    # macOS has no way to check for this, so skip testing it there.
+    if sys.platform != "darwin":
+        with tsocket.socket() as s:
+            await s.bind(("127.0.0.1", 0))
+            with pytest.raises(
+                ValueError,
+                match=r"^SocketListener requires a listening socket$",
+            ) as excinfo:
+                SocketListener(s)
+            excinfo.match(r".*listen")
+
+    listen_sock = tsocket.socket()
+    await listen_sock.bind(("127.0.0.1", 0))
+    listen_sock.listen(10)
+    listener = SocketListener(listen_sock)
+
+    assert listener.socket is listen_sock
+
+    client_sock = tsocket.socket()
+    await client_sock.connect(listen_sock.getsockname())
+    with assert_checkpoints():
+        server_stream = await listener.accept()
+    assert isinstance(server_stream, SocketStream)
+    assert server_stream.socket.getsockname() == listen_sock.getsockname()
+    assert server_stream.socket.getpeername() == client_sock.getsockname()
+
+    with assert_checkpoints():
+        await listener.aclose()
+
+    with assert_checkpoints():
+        await listener.aclose()
+
+    with assert_checkpoints():
+        with pytest.raises(_core.ClosedResourceError):
+            await listener.accept()
+
+    client_sock.close()
+    await server_stream.aclose()
+
+
+async def test_SocketListener_socket_closed_underfoot() -> None:
+    listen_sock = tsocket.socket()
+    await listen_sock.bind(("127.0.0.1", 0))
+    listen_sock.listen(10)
+    listener = SocketListener(listen_sock)
+
+    # Close the socket, not the listener
+    listen_sock.close()
+
+    # SocketListener gives correct error
+    with assert_checkpoints():
+        with pytest.raises(_core.ClosedResourceError):
+            await listener.accept()
+
+
+async def test_SocketListener_accept_errors() -> None:
+    class FakeSocket(tsocket.SocketType):
+        def __init__(self, events: Sequence[SocketType | BaseException]) -> None:
+            self._events = iter(events)
+
+        type = tsocket.SOCK_STREAM
+
+        # Fool the check for SO_ACCEPTCONN in SocketListener.__init__
+        @overload
+        def getsockopt(self, /, level: int, optname: int) -> int: ...
+
+        @overload
+        def getsockopt(  # noqa: F811
+            self,
+            /,
+            level: int,
+            optname: int,
+            buflen: int,
+        ) -> bytes: ...
+
+        def getsockopt(  # noqa: F811
+            self,
+            /,
+            level: int,
+            optname: int,
+            buflen: int | None = None,
+        ) -> int | bytes:
+            return True
+
+        @overload
+        def setsockopt(
+            self,
+            /,
+            level: int,
+            optname: int,
+            value: int | Buffer,
+        ) -> None: ...
+
+        @overload
+        def setsockopt(  # noqa: F811
+            self,
+            /,
+            level: int,
+            optname: int,
+            value: None,
+            optlen: int,
+        ) -> None: ...
+
+        def setsockopt(  # noqa: F811
+            self,
+            /,
+            level: int,
+            optname: int,
+            value: int | Buffer | None,
+            optlen: int | None = None,
+        ) -> None:
+            pass
+
+        async def accept(self) -> tuple[SocketType, object]:
+            await _core.checkpoint()
+            event = next(self._events)
+            if isinstance(event, BaseException):
+                raise event
+            else:
+                return event, None
+
+    fake_server_sock = FakeSocket([])
+
+    fake_listen_sock = FakeSocket(
+        [
+            OSError(errno.ECONNABORTED, "Connection aborted"),
+            OSError(errno.EPERM, "Permission denied"),
+            OSError(errno.EPROTO, "Bad protocol"),
+            fake_server_sock,
+            OSError(errno.EMFILE, "Out of file descriptors"),
+            OSError(errno.EFAULT, "attempt to write to read-only memory"),
+            OSError(errno.ENOBUFS, "out of buffers"),
+            fake_server_sock,
+        ],
+    )
+
+    listener = SocketListener(fake_listen_sock)
+
+    with assert_checkpoints():
+        stream = await listener.accept()
+        assert stream.socket is fake_server_sock
+
+    for code, match in {
+        errno.EMFILE: r"\[\w+ \d+\] Out of file descriptors$",
+        errno.EFAULT: r"\[\w+ \d+\] attempt to write to read-only memory$",
+        errno.ENOBUFS: r"\[\w+ \d+\] out of buffers$",
+    }.items():
+        with assert_checkpoints():
+            with pytest.raises(OSError, match=match) as excinfo:
+                await listener.accept()
+            assert excinfo.value.errno == code
+
+    with assert_checkpoints():
+        stream = await listener.accept()
+        assert stream.socket is fake_server_sock
+
+
+async def test_socket_stream_works_when_peer_has_already_closed() -> None:
+    sock_a, sock_b = tsocket.socketpair()
+    with sock_a, sock_b:
+        await sock_b.send(b"x")
+        sock_b.close()
+        stream = SocketStream(sock_a)
+        assert await stream.receive_some(1) == b"x"
+        assert await stream.receive_some(1) == b""