flux-networking-shared 0.2.2__tar.gz

flux_networking_shared-0.2.2/.gitignore

@@ -0,0 +1,47 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Ruff
+.ruff_cache/
+
+# Testing
+.coverage
+.pytest_cache/
+htmlcov/
+
+# OS
+.DS_Store

flux_networking_shared-0.2.2/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: flux-networking-shared
+Version: 0.2.2
+Summary: Shared networking utilities for Flux daemon and TUI
+Author-email: David White <david@runonflux.io>
+Requires-Python: >=3.12
+Requires-Dist: aiofiles<26,>=25.1.0
+Requires-Dist: pyyaml<7,>=6.0.3
+Requires-Dist: textual<7,>=6.11.0
+Requires-Dist: yarl<2,>=1.22.0
+Provides-Extra: backend
+Requires-Dist: aiohttp<4,>=3.13.2; extra == 'backend'
+Requires-Dist: miniupnpc<3,>=2.3.3; extra == 'backend'
+Requires-Dist: probert>=0.0.18; extra == 'backend'
+Requires-Dist: pyroute2<1,>=0.9.2; extra == 'backend'
+Description-Content-Type: text/markdown
+
+# flux-networking-shared
+
+Shared networking utilities for Flux daemon and TUI.
+
+This package contains platform-independent networking code that can be used by both the flux-configd daemon and the flux_iso_networking TUI package.
+
+## Components
+
+- `UpnpQuerier` - UPnP port mapping discovery
+- `NetworkObserver` - Network interface change observation (via probert)
+- `IcmpPacketSender` - Raw ICMP ping utilities
+- `SystemdConfigParser` - Parse systemd network configurations
+- Network models (Route, NetworkInterface, FluxShapingPolicy, etc.)
+
+## Platform Support
+
+- **Linux**: Full functionality with real probert dependency
+- **macOS**: Development support with stub probert implementation

flux_networking_shared-0.2.2/README.md

@@ -0,0 +1,18 @@
+# flux-networking-shared
+
+Shared networking utilities for Flux daemon and TUI.
+
+This package contains platform-independent networking code that can be used by both the flux-configd daemon and the flux_iso_networking TUI package.
+
+## Components
+
+- `UpnpQuerier` - UPnP port mapping discovery
+- `NetworkObserver` - Network interface change observation (via probert)
+- `IcmpPacketSender` - Raw ICMP ping utilities
+- `SystemdConfigParser` - Parse systemd network configurations
+- Network models (Route, NetworkInterface, FluxShapingPolicy, etc.)
+
+## Platform Support
+
+- **Linux**: Full functionality with real probert dependency
+- **macOS**: Development support with stub probert implementation

flux_networking_shared-0.2.2/dummy_packages/probert/probert/__init__.py

@@ -0,0 +1,3 @@
+# Dummy probert module for macOS development
+# This allows flux_networking_shared to be installed on macOS
+# without the actual probert dependency which is Linux-only

flux_networking_shared-0.2.2/dummy_packages/probert/probert/network.py

@@ -0,0 +1,43 @@
+# Dummy probert.network module for macOS development
+# Provides stub classes that network_observer.py imports
+
+
+class Link:
+    """Stub for probert Link class."""
+
+    def __init__(self):
+        self.type = ""
+        self.name = ""
+        self.flags = 0
+
+    def serialize(self) -> dict:
+        return {}
+
+
+class NetworkEventReceiver:
+    """Stub for probert NetworkEventReceiver class."""
+
+    def new_link(self, ifindex: int, link: Link):
+        pass
+
+    def update_link(self, ifindex: int):
+        pass
+
+    def del_link(self, ifindex: int):
+        pass
+
+    def route_change(self, action: str, data):
+        pass
+
+
+class UdevObserver:
+    """Stub for probert UdevObserver class."""
+
+    def __init__(self, receiver: NetworkEventReceiver):
+        self.receiver = receiver
+
+    def start(self) -> list[int]:
+        return []
+
+    def data_ready(self, fd: int):
+        pass

flux_networking_shared-0.2.2/dummy_packages/probert/setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="probert",
+    version="0.0.18",
+    description="Dummy probert package for macOS development",
+    packages=find_packages(),
+    py_modules=["probert"],
+)

flux_networking_shared-0.2.2/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "flux-networking-shared"
+version = "0.2.2"
+description = "Shared networking utilities for Flux daemon and TUI"
+readme = "README.md"
+authors = [
+    { name = "David White", email = "david@runonflux.io" }
+]
+requires-python = ">=3.12"
+
+dependencies = [
+    "aiofiles>=25.1.0,<26",
+    "pyyaml>=6.0.3,<7",
+    "textual>=6.11.0,<7",
+    "yarl>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+backend = [
+    "aiohttp>=3.13.2,<4",
+    "miniupnpc>=2.3.3,<3",
+    "probert>=0.0.18",
+    "pyroute2>=0.9.2,<1",
+]
+
+[tool.uv]
+# This is to override probert. python 3.12 moved the Container endpoint
+override-dependencies = ["pyudev==0.24.3"]
+
+# Limit resolution to supported platforms to avoid probert resolution failures
+environments = [
+    "sys_platform == 'darwin'",
+    "sys_platform == 'linux'"
+]
+
+[tool.uv.sources]
+# Platform-specific probert: dummy on macOS, real on Linux
+probert = [
+    { path = "dummy_packages/probert", marker = "sys_platform == 'darwin'" },
+    { git = "https://github.com/canonical/probert.git", branch = "server/jammy", marker = "sys_platform == 'linux'" }
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.11.6",
+]

flux_networking_shared-0.2.2/src/flux_networking_shared/__init__.py

@@ -0,0 +1,54 @@
+"""Shared networking utilities for Flux daemon and TUI."""
+
+import asyncio
+
+from flux_networking_shared.upnp_querier import UpnpQuerier, UpnpLease, FluxPortMap
+from flux_networking_shared.helpers import do_http, exec_binary, ExecBinaryError
+from flux_networking_shared.async_ping import IcmpPacketSender, IcmpPingResponse
+from flux_networking_shared.systemd_parser import SystemdConfigParser
+from flux_networking_shared.models import (
+    Route,
+    SourceAddress,
+    NetworkInterface,
+    NetworkInterfaceGroup,
+    InterfaceState,
+    InterfaceShapingPolicy,
+    FluxShapingPolicy,
+    ResolvedDnsServer,
+    ResolvedHostname,
+)
+
+
+def clean_upnp() -> list[int]:
+    """Remove all UPnP port mappings created by this machine.
+
+    Returns:
+        List of removed port numbers
+    """
+    async def main() -> list[int]:
+        querier = UpnpQuerier()
+        return await querier.remove_all_mappings()
+
+    return asyncio.run(main())
+
+__all__ = [
+    "UpnpQuerier",
+    "UpnpLease",
+    "FluxPortMap",
+    "do_http",
+    "exec_binary",
+    "ExecBinaryError",
+    "IcmpPacketSender",
+    "IcmpPingResponse",
+    "SystemdConfigParser",
+    "Route",
+    "SourceAddress",
+    "NetworkInterface",
+    "NetworkInterfaceGroup",
+    "InterfaceState",
+    "InterfaceShapingPolicy",
+    "FluxShapingPolicy",
+    "ResolvedDnsServer",
+    "ResolvedHostname",
+    "clean_upnp",
+]

flux_networking_shared-0.2.2/src/flux_networking_shared/async_ping.py

@@ -0,0 +1,240 @@
+import asyncio
+from socket import (
+    socket,
+    IPPROTO_ICMP,
+    IPPROTO_IP,
+    SOCK_RAW,
+    AF_INET,
+    IP_TTL,
+    SOL_SOCKET,
+)
+import struct
+from functools import partial
+from random import randint
+from time import perf_counter
+from dataclasses import dataclass
+
+SO_BINDTODEVICE = 25
+
+# https://datatracker.ietf.org/doc/html/rfc792
+ICMP_ECHO_REPLY = 0
+ICMP_DEST_UNREACHABLE = 3
+ICMP_ECHO_REQUEST = 8
+ICMP_TTL_EXCEEDED = 11
+
+ICMP_RESPONSES = [ICMP_ECHO_REPLY, ICMP_DEST_UNREACHABLE, ICMP_TTL_EXCEEDED]
+
+
+@dataclass
+class IcmpPingResponse:
+    rtt: float | None = None
+    message: str | None = None
+
+    @property
+    def rtt_ms(self) -> str:
+        return f"{round(self.rtt, 3):.3f} ms" if self.rtt else ""
+
+    def __bool__(self) -> bool:
+        return bool(self.rtt and not self.message)
+
+
+class IcmpPacketSender:
+    def __init__(self) -> None:
+        self.loop = asyncio.get_running_loop()
+
+    @staticmethod
+    def calculate_checksum(data: bytes) -> int:
+        checksum = 0
+
+        if len(data) % 2:
+            data += b"\x00"
+
+        for i in range(0, len(data), 2):
+            checksum += (data[i] << 8) + data[i + 1]
+
+        checksum = (checksum >> 16) + (checksum & 0xFFFF)
+        checksum += checksum >> 16
+
+        return (~checksum) & 0xFFFF
+
+    @staticmethod
+    def generate_header(id: int, *, checksum: int | None = None) -> bytes:
+        icmp_type = ICMP_ECHO_REQUEST
+        icmp_code = 0
+        icmp_checksum = checksum or 0
+        icmp_sequence = 1
+
+        icmp_header = struct.pack(
+            "!BBHHH",
+            icmp_type,
+            icmp_code,
+            icmp_checksum,
+            id,
+            icmp_sequence,
+        )
+
+        return icmp_header
+
+    async def receive_ping(
+        self, raw_socket: socket, id: int, timeout: float
+    ) -> IcmpPingResponse:
+        try:
+            while True:
+                received = await asyncio.wait_for(
+                    self.loop.sock_recv(raw_socket, 1500), timeout
+                )
+
+                time_received = perf_counter()
+
+                offset = 20
+                icmp_header_size = 8
+
+                icmp_header = received[offset : offset + icmp_header_size]
+
+                # On ttl and dest unreachable, only the type, code, and checksum
+                # will be present. The packet_id and sequence are zero. Then
+                # follows the ip header, then the original header + data
+
+                try:
+                    type, code, checksum, packet_id, sequence = struct.unpack(
+                        "!BBHHH", icmp_header
+                    )
+                except (struct.error, TypeError):
+                    continue
+
+                msg = None
+                rtt = None
+
+                if type == ICMP_ECHO_REPLY:
+                    if packet_id != id:
+                        continue
+
+                    data = received[
+                        offset + 8 : offset + 8 + struct.calcsize("d")
+                    ]
+                    time_sent = struct.unpack("d", data)[0]
+
+                    rtt = (time_received - time_sent) * 1000
+                elif type == ICMP_TTL_EXCEEDED:
+                    msg = "TTL Exceeded"
+                elif type == ICMP_DEST_UNREACHABLE:
+                    msg = "Dest Unreachable"
+
+                return IcmpPingResponse(rtt, msg)
+
+        except asyncio.TimeoutError:
+            self.loop.remove_writer(raw_socket)
+            self.loop.remove_reader(raw_socket)
+            raw_socket.close()
+
+            raise TimeoutError("Ping timeout")
+
+    def send_packet(
+        self,
+        packet: bytes,
+        socket: socket,
+        future: asyncio.Future,
+        dest: tuple[str, int],
+    ) -> None:
+        try:
+            socket.sendto(packet, dest)
+        except (BlockingIOError, InterruptedError):
+            return  # The callback will be retried
+        except Exception as e:
+            self.loop.remove_writer(socket)
+            future.set_exception(e)
+        else:
+            self.loop.remove_writer(socket)
+            future.set_result(None)
+
+    async def send_ping(
+        self, raw_socket: socket, dest_addr: tuple[str, int], id: int
+    ) -> bool:
+        dummy_header = self.generate_header(id)
+
+        fmt = "d"
+        rtt_size = struct.calcsize(fmt)
+        data = (192 - rtt_size) * "0"
+
+        payload = struct.pack(fmt, perf_counter()) + data.encode("utf-8")
+        checksum = self.calculate_checksum(dummy_header + payload)
+
+        header = self.generate_header(id, checksum=checksum)
+
+        future: asyncio.Future[float] = asyncio.Future()
+
+        callback = partial(
+            self.send_packet,
+            packet=header + payload,
+            socket=raw_socket,
+            dest=dest_addr,
+            future=future,
+        )
+        self.loop.add_writer(raw_socket, callback)
+
+        try:
+            await future
+        except OSError:
+            return False
+
+        return True
+
+    async def ping(
+        self,
+        dest_addr: str,
+        *,
+        timeout: float = 5.0,
+        ttl: int = 64,
+        interface: str | None = None,
+    ) -> IcmpPingResponse:
+        addr = (dest_addr, 0)
+
+        # info = await self.loop.getaddrinfo(addr)
+
+        # let this raise
+        sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)
+
+        # if interface:
+        #     sock.bind((interface_ip, 0))
+
+        if interface:
+            # linux only
+            encoded = str(interface + "\0").encode("utf-8")
+            sock.setsockopt(SOL_SOCKET, SO_BINDTODEVICE, encoded)
+
+        sock.setblocking(False)
+        sock.setsockopt(IPPROTO_IP, IP_TTL, struct.pack("I", ttl))
+
+        icmp_id = randint(1, 65535)
+
+        ok = await self.send_ping(sock, addr, icmp_id)
+
+        if not ok:
+            return IcmpPingResponse(message="OSError")
+
+        try:
+            response = await self.receive_ping(sock, icmp_id, timeout)
+        except asyncio.TimeoutError:
+            response = IcmpPingResponse(message="Timeout exceeded")
+        finally:
+            sock.close()
+
+        return response
+
+
+if __name__ == "__main__":
+
+    async def main():
+        icmp = IcmpPacketSender()
+
+        while True:
+            res = await icmp.ping("8.8.8.8", ttl=14)
+
+            if res:
+                print(res.rtt_ms)
+            else:
+                print(res.message)
+
+            await asyncio.sleep(1)
+
+    asyncio.run(main())