socket-netty 0.3.0__py3-none-any.whl

pynetty/channel/__init__.py

@@ -0,0 +1,24 @@
+from pynetty.channel.channel import Channel
+from pynetty.channel.channel_pipeline import ChannelPipeline, DuplicateHandlerNameError
+from pynetty.channel.channel_future import ChannelFuture, ChannelPromise
+from pynetty.channel.event_loop import EventLoop, EventLoopGroup
+from pynetty.channel.channel_option import ChannelOption, apply_socket_options
+from pynetty.channel.flow_control import WriteBufferWaterMark, ChannelExecutor, FlowControlInboundHandler
+from pynetty.channel.datagram_channel import DatagramChannel, DatagramBootstrap
+
+__all__ = [
+    "Channel",
+    "ChannelPipeline",
+    "DuplicateHandlerNameError",
+    "ChannelFuture",
+    "ChannelPromise",
+    "EventLoop",
+    "EventLoopGroup",
+    "ChannelOption",
+    "apply_socket_options",
+    "WriteBufferWaterMark",
+    "ChannelExecutor",
+    "FlowControlInboundHandler",
+    "DatagramChannel",
+    "DatagramBootstrap",
+]

pynetty/channel/channel.py

@@ -0,0 +1,130 @@
+"""
+Channel: represents a network connection (socket) and its associated
+pipeline. Wraps an asyncio.Transport and exposes the Netty-style API
+(write, close, is_active, remote_address, attr).
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, Optional
+
+from pynetty.channel.channel_pipeline import ChannelPipeline
+from pynetty.channel.channel_future import ChannelFuture
+from pynetty.exceptions import ChannelException
+
+
+class Channel:
+    def __init__(self, transport: Optional[asyncio.BaseTransport] = None) -> None:
+        self.transport = transport
+        self.pipeline = ChannelPipeline(self)
+        self._active = False
+        self._attrs: Dict[str, Any] = {}
+        self._close_event = asyncio.Event()
+        self._writable = True
+
+    # ------------------------------------------------------------------
+    # Lifecycle — invoked by asyncio's Protocol
+    # ------------------------------------------------------------------
+    def _attach_transport(self, transport: asyncio.BaseTransport) -> None:
+        self.transport = transport
+
+    async def _mark_active(self) -> None:
+        self._active = True
+        await self.pipeline.fire_channel_registered()
+        await self.pipeline.fire_channel_active()
+
+    async def _mark_inactive(self) -> None:
+        if not self._active:
+            return
+        self._active = False
+        await self.pipeline.fire_channel_inactive()
+        self._close_event.set()
+
+    async def _fire_read(self, data: Any) -> None:
+        await self.pipeline.fire_channel_read(data)
+        await self.pipeline.fire_channel_read_complete()
+
+    async def _fire_exception(self, exc: Exception) -> None:
+        await self.pipeline.fire_exception_caught(exc)
+
+    # ------------------------------------------------------------------
+    # Public Netty-style API
+    # ------------------------------------------------------------------
+    def is_active(self) -> bool:
+        return self._active and self.transport is not None and not self.transport.is_closing()
+
+    def is_writable(self) -> bool:
+        """
+        Reflects the backpressure state of the underlying transport
+        (equivalent to Netty's Channel.isWritable()). Updated via
+        asyncio's Protocol pause_writing()/resume_writing().
+        """
+        return self._writable
+
+    def _set_writable(self, value: bool) -> None:
+        self._writable = value
+
+    def new_future(self) -> ChannelFuture:
+        """Creates a new ChannelFuture associated with this channel (equivalent to a new ChannelPromise)."""
+        return ChannelFuture(self)
+
+    async def write(self, msg: Any) -> None:
+        """Writes a message through the pipeline (passes through the outbound handlers)."""
+        await self.pipeline.write(msg)
+
+    async def close(self) -> None:
+        await self.pipeline.close()
+        # Wait for the transport's connection_lost() to fire
+        # _mark_inactive() and finish propagating channel_inactive, so
+        # `await channel.close()` is a real guarantee that the
+        # channel's lifecycle has fully closed.
+        if self.transport is not None:
+            try:
+                await asyncio.wait_for(self.wait_closed(), timeout=5)
+            except asyncio.TimeoutError:
+                pass
+
+    async def wait_closed(self) -> None:
+        await self._close_event.wait()
+
+    def remote_address(self) -> Optional[tuple]:
+        if self.transport is None:
+            return None
+        return self.transport.get_extra_info("peername")
+
+    def local_address(self) -> Optional[tuple]:
+        if self.transport is None:
+            return None
+        return self.transport.get_extra_info("sockname")
+
+    def attr(self, key: str, default: Any = None) -> Any:
+        return self._attrs.get(key, default)
+
+    def set_attr(self, key: str, value: Any) -> None:
+        self._attrs[key] = value
+
+    # ------------------------------------------------------------------
+    # Actual I/O implementation, invoked only once a message reaches the
+    # end of the outbound chain (or the head, in close()'s case)
+    # ------------------------------------------------------------------
+    async def _do_write(self, msg: Any) -> None:
+        if self.transport is None:
+            raise ChannelException("Channel has no associated transport; cannot write")
+        if isinstance(msg, (bytes, bytearray)):
+            self.transport.write(bytes(msg))
+        elif hasattr(msg, "to_bytes"):
+            # Supports ByteBuf and similar objects
+            self.transport.write(msg.to_bytes())
+        else:
+            raise TypeError(
+                f"Cannot write a message of type {type(msg).__name__}; "
+                "add an encoder to the pipeline that converts it to bytes"
+            )
+
+    async def _do_close(self) -> None:
+        if self.transport is not None and not self.transport.is_closing():
+            self.transport.close()
+
+    def __repr__(self) -> str:
+        return f"Channel(remote={self.remote_address()}, active={self.is_active()})"

pynetty/channel/channel_future.py

@@ -0,0 +1,143 @@
+"""
+ChannelFuture / ChannelPromise: equivalent to io.netty.channel.ChannelFuture.
+
+In Netty, nearly every async operation (connect, write, close, bind)
+returns a ChannelFuture you can add listeners to instead of blocking.
+Here it's modeled as a thin wrapper over asyncio.Future that:
+  - Is directly awaitable (`await future`), for Python-style usage.
+  - Supports add_listener()/remove_listener(), for Netty-style usage.
+  - Exposes is_done(), is_success(), cause(), get_now(), sync(), await_().
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Callable, List, Optional, TypeVar
+
+T = TypeVar("T")
+
+Listener = Callable[["ChannelFuture"], None]
+
+
+class ChannelFuture:
+    def __init__(self, channel: Any, aio_future: Optional[asyncio.Future] = None) -> None:
+        self.channel = channel
+        self._future: asyncio.Future = aio_future if aio_future is not None else asyncio.get_event_loop().create_future()
+        self._listeners: List[Listener] = []
+        self._notified = False
+        self._future.add_done_callback(self._on_future_done)
+
+    # ------------------------------------------------------------------
+    # Construction / resolution
+    # ------------------------------------------------------------------
+    @classmethod
+    def succeeded(cls, channel: Any, result: Any = None) -> "ChannelFuture":
+        fut = cls(channel)
+        fut.set_result(result)
+        return fut
+
+    @classmethod
+    def failed(cls, channel: Any, exc: Exception) -> "ChannelFuture":
+        fut = cls(channel)
+        fut.set_exception(exc)
+        return fut
+
+    def set_result(self, result: Any = None) -> "ChannelFuture":
+        if not self._future.done():
+            self._future.set_result(result)
+            self._on_done(self._future)
+        return self
+
+    def set_exception(self, exc: Exception) -> "ChannelFuture":
+        if not self._future.done():
+            self._future.set_exception(exc)
+            self._on_done(self._future)
+        return self
+
+    def _on_future_done(self, _fut: asyncio.Future) -> None:
+        # Fallback callback for external futures (passed via
+        # aio_future) that complete through another path (e.g. cancel()).
+        # If set_result/set_exception already fired _on_done
+        # synchronously, this callback arrives later and must not repeat listeners.
+        self._on_done(_fut)
+
+    def _on_done(self, _fut: asyncio.Future) -> None:
+        if self._notified:
+            return
+        self._notified = True
+        for listener in self._listeners:
+            try:
+                listener(self)
+            except Exception:
+                # A listener that blows up must not take down the rest.
+                pass
+
+    # ------------------------------------------------------------------
+    # Netty-style API
+    # ------------------------------------------------------------------
+    def add_listener(self, listener: Listener) -> "ChannelFuture":
+        """
+        Registers a callback that receives this ChannelFuture once it
+        completes. If it's already complete, it's invoked immediately
+        (same behavior as Netty).
+        """
+        self._listeners.append(listener)
+        if self._future.done():
+            listener(self)
+        return self
+
+    def remove_listener(self, listener: Listener) -> "ChannelFuture":
+        if listener in self._listeners:
+            self._listeners.remove(listener)
+        return self
+
+    def is_done(self) -> bool:
+        return self._future.done()
+
+    def is_success(self) -> bool:
+        return self._future.done() and self._future.exception() is None
+
+    def is_cancelled(self) -> bool:
+        return self._future.cancelled()
+
+    def cause(self) -> Optional[BaseException]:
+        if not self._future.done() or self._future.cancelled():
+            return None
+        return self._future.exception()
+
+    def get_now(self) -> Any:
+        """Returns the result if it's already ready, otherwise None (does not block)."""
+        if self._future.done() and not self._future.cancelled() and self._future.exception() is None:
+            return self._future.result()
+        return None
+
+    async def sync(self) -> "ChannelFuture":
+        """Waits for the operation to finish and re-raises the exception if it failed (equivalent to Netty's sync())."""
+        await self._future
+        return self
+
+    def __await__(self):
+        return self._future.__await__()
+
+    def __repr__(self) -> str:
+        state = "pending" if not self.is_done() else ("success" if self.is_success() else "failed")
+        return f"ChannelFuture({state})"
+
+
+class ChannelPromise(ChannelFuture):
+    """
+    Equivalent to io.netty.channel.ChannelPromise: a ChannelFuture that
+    can also be completed manually from the outside (writer side).
+    """
+
+    def try_success(self, result: Any = None) -> bool:
+        if self._future.done():
+            return False
+        self.set_result(result)
+        return True
+
+    def try_failure(self, exc: Exception) -> bool:
+        if self._future.done():
+            return False
+        self.set_exception(exc)
+        return True

pynetty/channel/channel_option.py

@@ -0,0 +1,59 @@
+"""
+ChannelOption: equivalent to io.netty.channel.ChannelOption.
+
+In Netty you configure socket options via
+`.option(ChannelOption.SO_BACKLOG, 128)` before bind()/connect().
+Here we replicate that declarative API and apply it to the real Python
+socket (via setsockopt) when the Channel is created.
+"""
+
+from __future__ import annotations
+
+import socket
+from typing import Any, Dict
+
+
+class ChannelOption:
+    """Namespace of option constants, like Netty's ChannelOption class."""
+
+    SO_BACKLOG = "SO_BACKLOG"          # size of the pending-connections queue (server only)
+    SO_REUSEADDR = "SO_REUSEADDR"      # reuse the address/port immediately after closing
+    SO_KEEPALIVE = "SO_KEEPALIVE"      # kernel-level TCP keepalive
+    SO_RCVBUF = "SO_RCVBUF"            # kernel receive-buffer size
+    SO_SNDBUF = "SO_SNDBUF"            # kernel send-buffer size
+    TCP_NODELAY = "TCP_NODELAY"        # disables Nagle's algorithm (low latency, useful for games)
+    SO_LINGER = "SO_LINGER"            # seconds to wait on close with pending data
+
+
+def apply_socket_options(sock: socket.socket, options: Dict[str, Any]) -> None:
+    """Applies a dict of ChannelOption -> value onto a real socket."""
+    for name, value in options.items():
+        if name == ChannelOption.SO_REUSEADDR:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1 if value else 0)
+        elif name == ChannelOption.SO_KEEPALIVE:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1 if value else 0)
+        elif name == ChannelOption.SO_RCVBUF:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, int(value))
+        elif name == ChannelOption.SO_SNDBUF:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, int(value))
+        elif name == ChannelOption.TCP_NODELAY:
+            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1 if value else 0)
+        elif name == ChannelOption.SO_LINGER:
+            # value: seconds (int) or None to disable
+            if value is None:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct_linger(0, 0))
+            else:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct_linger(1, int(value)))
+        elif name == ChannelOption.SO_BACKLOG:
+            # SO_BACKLOG is applied when creating the listener
+            # (loop.create_server(backlog=...)), not via setsockopt;
+            # the bootstrap handles it directly.
+            continue
+        else:
+            raise ValueError(f"Unknown ChannelOption: {name}")
+
+
+def struct_linger(onoff: int, linger: int) -> bytes:
+    import struct
+
+    return struct.pack("ii", onoff, linger)

pynetty/channel/channel_pipeline.py

@@ -0,0 +1,173 @@
+"""
+ChannelPipeline: doubly-linked list of ChannelHandlerContext instances,
+each wrapping a ChannelHandler added to a Channel. It's the central
+entry point for firing inbound events and outbound operations.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, TYPE_CHECKING
+
+from pynetty.exceptions import DuplicateHandlerNameError
+from pynetty.handler.channel_handler import (
+    ChannelHandler,
+    ChannelInboundHandler,
+    ChannelOutboundHandler,
+)
+from pynetty.handler.channel_handler_context import ChannelHandlerContext
+
+if TYPE_CHECKING:
+    from pynetty.channel.channel import Channel
+
+
+class ChannelPipeline:
+    def __init__(self, channel: "Channel") -> None:
+        self.channel = channel
+        # Sentinel head and tail (no real handler), as in Netty
+        # (HeadContext / TailContext).
+        self._head = ChannelHandlerContext("__head__", _HeadHandler(), self)
+        self._tail = ChannelHandlerContext("__tail__", _TailHandler(), self)
+        self._head._next = self._tail
+        self._tail._prev = self._head
+        self._contexts: Dict[str, ChannelHandlerContext] = {}
+
+    # ------------------------------------------------------------------
+    # Handler registration
+    # ------------------------------------------------------------------
+    def add_last(self, name: str, handler: ChannelHandler) -> "ChannelPipeline":
+        if name in self._contexts:
+            raise DuplicateHandlerNameError(f"Duplicate handler name: {name!r}")
+        ctx = ChannelHandlerContext(name, handler, self)
+        prev = self._tail._prev
+        prev._next = ctx
+        ctx._prev = prev
+        ctx._next = self._tail
+        self._tail._prev = ctx
+        self._contexts[name] = ctx
+        return self
+
+    def add_first(self, name: str, handler: ChannelHandler) -> "ChannelPipeline":
+        if name in self._contexts:
+            raise DuplicateHandlerNameError(f"Duplicate handler name: {name!r}")
+        ctx = ChannelHandlerContext(name, handler, self)
+        nxt = self._head._next
+        self._head._next = ctx
+        ctx._prev = self._head
+        ctx._next = nxt
+        nxt._prev = ctx
+        self._contexts[name] = ctx
+        return self
+
+    def remove(self, name: str) -> "ChannelPipeline":
+        ctx = self._contexts.pop(name, None)
+        if ctx is None:
+            return self
+        ctx._prev._next = ctx._next
+        ctx._next._prev = ctx._prev
+        return self
+
+    def get(self, name: str) -> "ChannelHandler | None":
+        ctx = self._contexts.get(name)
+        return ctx.handler if ctx else None
+
+    def context(self, name: str) -> "ChannelHandlerContext | None":
+        return self._contexts.get(name)
+
+    def names(self) -> list[str]:
+        return list(self._contexts.keys())
+
+    # ------------------------------------------------------------------
+    # Firing inbound events (enter through the head)
+    # ------------------------------------------------------------------
+    async def fire_channel_registered(self) -> None:
+        await self._head.handler.channel_registered(self._head)
+
+    async def fire_channel_active(self) -> None:
+        await self._head.handler.channel_active(self._head)
+
+    async def fire_channel_inactive(self) -> None:
+        await self._head.handler.channel_inactive(self._head)
+
+    async def fire_channel_read(self, msg: Any) -> None:
+        await self._head.handler.channel_read(self._head, msg)
+
+    async def fire_channel_read_complete(self) -> None:
+        await self._head.handler.channel_read_complete(self._head)
+
+    async def fire_exception_caught(self, exc: Exception) -> None:
+        await self._head.handler.exception_caught(self._head, exc)
+
+    # ------------------------------------------------------------------
+    # Outbound operations (enter through the tail, travel toward the head)
+    # ------------------------------------------------------------------
+    async def write(self, msg: Any) -> None:
+        await self._tail.handler.write(self._tail, msg)
+
+    async def close(self) -> None:
+        await self._tail.handler.close(self._tail)
+
+
+class _HeadHandler(ChannelInboundHandler, ChannelOutboundHandler):
+    """Sentinel head handler: both inbound AND outbound (marks the start of the chain)."""
+
+    async def channel_registered(self, ctx: ChannelHandlerContext) -> None:
+        await ctx.fire_channel_registered()
+
+    async def channel_active(self, ctx: ChannelHandlerContext) -> None:
+        await ctx.fire_channel_active()
+
+    async def channel_inactive(self, ctx: ChannelHandlerContext) -> None:
+        await ctx.fire_channel_inactive()
+
+    async def channel_read(self, ctx: ChannelHandlerContext, msg: Any) -> None:
+        await ctx.fire_channel_read(msg)
+
+    async def channel_read_complete(self, ctx: ChannelHandlerContext) -> None:
+        await ctx.fire_channel_read_complete()
+
+    async def write(self, ctx: ChannelHandlerContext, msg: Any) -> None:
+        await ctx.channel._do_write(msg)
+
+    async def close(self, ctx: ChannelHandlerContext) -> None:
+        await ctx.channel._do_close()
+
+    async def exception_caught(self, ctx: ChannelHandlerContext, exc: Exception) -> None:
+        # See the note in _TailHandler.exception_caught: with no one
+        # else left in the chain, we don't re-raise so we don't kill the
+        # task that fired the event.
+        pass
+
+
+class _TailHandler(ChannelInboundHandler, ChannelOutboundHandler):
+    """Sentinel tail handler: end of the inbound chain, start of the outbound chain."""
+
+    async def channel_registered(self, ctx: ChannelHandlerContext) -> None:
+        pass
+
+    async def channel_active(self, ctx: ChannelHandlerContext) -> None:
+        pass
+
+    async def channel_inactive(self, ctx: ChannelHandlerContext) -> None:
+        pass
+
+    async def channel_read(self, ctx: ChannelHandlerContext, msg: Any) -> None:
+        # If a message reaches the tail without being consumed, Netty
+        # logs it as "unhandled". Here it's simply discarded.
+        pass
+
+    async def channel_read_complete(self, ctx: ChannelHandlerContext) -> None:
+        pass
+
+    async def write(self, ctx: ChannelHandlerContext, msg: Any) -> None:
+        await ctx.write(msg)
+
+    async def close(self, ctx: ChannelHandlerContext) -> None:
+        await ctx.close()
+
+    async def exception_caught(self, ctx: ChannelHandlerContext, exc: Exception) -> None:
+        # If the exception reaches the end of the pipeline without any
+        # handler having "consumed" it (stopped propagating it), there's
+        # no one else left to notify. Netty logs this as a warning; here
+        # we don't re-raise so we don't kill the task that fired the
+        # event (e.g. ReadTimeoutHandler's watcher).
+        pass

pynetty/channel/datagram_channel.py

@@ -0,0 +1,164 @@
+"""
+DatagramChannel: equivalent to io.netty.channel.socket.DatagramChannel.
+
+Unlike TCP, UDP has no "connection" or framing — each datagram arrives
+together with the sender's address. The pipeline receives
+(data: bytes, addr: (host, port)) tuples in channel_read, and expects
+the same from write() unless you use connect() to fix a default peer.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Optional, Tuple
+
+from pynetty.channel.channel_pipeline import ChannelPipeline
+from pynetty.exceptions import ChannelException
+
+Address = Tuple[str, int]
+
+
+class DatagramChannel:
+    def __init__(self) -> None:
+        self.transport: Optional[asyncio.DatagramTransport] = None
+        self.pipeline = ChannelPipeline(self)
+        self._active = False
+        self._remote_addr: Optional[Address] = None
+        self._close_event = asyncio.Event()
+
+    def _attach_transport(self, transport: asyncio.DatagramTransport) -> None:
+        self.transport = transport
+
+    async def _mark_active(self) -> None:
+        self._active = True
+        await self.pipeline.fire_channel_registered()
+        await self.pipeline.fire_channel_active()
+
+    async def _mark_inactive(self) -> None:
+        if not self._active:
+            return
+        self._active = False
+        await self.pipeline.fire_channel_inactive()
+        self._close_event.set()
+
+    async def _fire_read(self, data: bytes, addr: Address) -> None:
+        await self.pipeline.fire_channel_read((data, addr))
+        await self.pipeline.fire_channel_read_complete()
+
+    async def _fire_exception(self, exc: Exception) -> None:
+        await self.pipeline.fire_exception_caught(exc)
+
+    def is_active(self) -> bool:
+        return self._active and self.transport is not None and not self.transport.is_closing()
+
+    def connect(self, addr: Address) -> "DatagramChannel":
+        """Fixes a default remote peer (optional; UDP doesn't require a real connection)."""
+        self._remote_addr = addr
+        return self
+
+    async def write(self, msg: Any, addr: Optional[Address] = None) -> None:
+        """
+        Writes through the pipeline. `msg` can be raw bytes or
+        (bytes, addr) to specify an explicit destination per send.
+        """
+        if addr is not None:
+            await self.pipeline.write((msg, addr))
+        else:
+            await self.pipeline.write(msg)
+
+    async def close(self) -> None:
+        await self.pipeline.close()
+        if self.transport is not None:
+            try:
+                await asyncio.wait_for(self.wait_closed(), timeout=5)
+            except asyncio.TimeoutError:
+                pass
+
+    async def wait_closed(self) -> None:
+        await self._close_event.wait()
+
+    def local_address(self) -> Optional[Address]:
+        if self.transport is None:
+            return None
+        return self.transport.get_extra_info("sockname")
+
+    async def _do_write(self, msg: Any) -> None:
+        if self.transport is None:
+            raise ChannelException("DatagramChannel has no associated transport")
+
+        if isinstance(msg, tuple) and len(msg) == 2 and isinstance(msg[1], tuple):
+            data, addr = msg
+        else:
+            data = msg
+            addr = self._remote_addr
+
+        if addr is None:
+            raise ChannelException(
+                "No destination address: use connect(addr) or write(msg, addr=...)"
+            )
+
+        payload = data if isinstance(data, (bytes, bytearray)) else data.to_bytes()
+        self.transport.sendto(bytes(payload), addr)
+
+    async def _do_close(self) -> None:
+        if self.transport is not None and not self.transport.is_closing():
+            self.transport.close()
+
+    def __repr__(self) -> str:
+        return f"DatagramChannel(local={self.local_address()}, active={self.is_active()})"
+
+
+class _DatagramProtocolAdapter(asyncio.DatagramProtocol):
+    def __init__(self, channel: DatagramChannel) -> None:
+        self.channel = channel
+        self._loop = asyncio.get_event_loop()
+
+    def connection_made(self, transport: asyncio.DatagramTransport) -> None:
+        self.channel._attach_transport(transport)
+        self._loop.create_task(self._safe(self.channel._mark_active()))
+
+    def datagram_received(self, data: bytes, addr: Address) -> None:
+        self._loop.create_task(self._safe(self.channel._fire_read(data, addr)))
+
+    def error_received(self, exc: Exception) -> None:
+        self._loop.create_task(self._safe(self.channel._fire_exception(exc)))
+
+    def connection_lost(self, exc: Optional[Exception]) -> None:
+        if exc is not None:
+            self._loop.create_task(self._safe(self.channel._fire_exception(exc)))
+        self._loop.create_task(self._safe(self.channel._mark_inactive()))
+
+    async def _safe(self, coro) -> None:
+        try:
+            await coro
+        except Exception as exc:
+            try:
+                await self.channel._fire_exception(exc)
+            except Exception:
+                pass
+
+
+class DatagramBootstrap:
+    """Equivalent to a Bootstrap configured with NioDatagramChannel in Netty."""
+
+    def __init__(self) -> None:
+        self._initializer = None
+
+    def handler(self, initializer) -> "DatagramBootstrap":
+        self._initializer = initializer
+        return self
+
+    async def bind(self, host: str = "0.0.0.0", port: int = 0) -> DatagramChannel:
+        if self._initializer is None:
+            raise ChannelException("You must call handler(...) before bind()")
+
+        loop = asyncio.get_event_loop()
+        channel = DatagramChannel()
+        result = self._initializer(channel)
+        if asyncio.iscoroutine(result):
+            await result
+
+        await loop.create_datagram_endpoint(
+            lambda: _DatagramProtocolAdapter(channel), local_addr=(host, port)
+        )
+        return channel