From 47dd29c15065358c10bafab63a735958eef8dbc7 Mon Sep 17 00:00:00 2001 From: goodboy Date: Fri, 14 Aug 2026 09:52:42 -0400 Subject: [PATCH] Register `tipc` in the tpt tables + test harness MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Wire the backend through every registration site (contract §2) so `--tpt-proto tipc` is a first-class suite mode, - `_state.TransportProtocolKey` gains the key - `_addr._address_types` + `._default_lo_addrs` - `_addr.wrap_address()` gets a `case ('tipc', *_)`; being a 4-elem seq it can't collide w/ `tcp`s or `uds`s 2-tuple cases, so NO ordering hazard (and a bare seq-pattern matches the `list` form `msgpack` decodes to). - `_types`: the `Address` union, `_msg_transports`, `_key_to_transport`, `_addr_to_transport` and the `transport_from_stream()` family match. That last one keys off `._tipc.AF_TIPC` (which carries the uapi fallback) NOT `socket.AF_TIPC` which is linux-only. Test-harness side, - `get_rando_addr()` gains a `tipc` branch; `.get_random()` already salts w/ `uuid4`+pid so both within- and cross-proc isolation come for free. - the `tpt_protos` fixture calls an addr-type's optional `.is_available()` and `pytest.fail()`s w/ its reason. Keeps a module-less box from turning `--tpt-proto tipc` into a few hundred confusing connect-timeouts. Generic on purpose — plans 02/03 need the same hook. - the discovery `daemon` fixture's readiness probe learns to dial a TIPC service name (it previously assumed tcp-or-uds and blew up on the 4-tuple). (this patch was generated in some part by `claude-code` using `claude-opus-5` (`anthropic`)) --- tractor/_testing/addr.py | 14 ++++++++++++++ tractor/_testing/pytest.py | 31 ++++++++++++++++++++++++++----- tractor/discovery/_addr.py | 19 ++++++++++++++++--- tractor/ipc/_types.py | 25 ++++++++++++++++++------- tractor/runtime/_state.py | 1 + 5 files changed, 75 insertions(+), 15 deletions(-) diff --git a/tractor/_testing/addr.py b/tractor/_testing/addr.py index 58acfd1a..cc583d87 100644 --- a/tractor/_testing/addr.py +++ b/tractor/_testing/addr.py @@ -99,6 +99,20 @@ def get_rando_addr( assert addr.sockpath.resolve() testrun_reg_addr = addr.unwrap() + # NOTE, `.get_random()` already derives the service + # *instance* from a `uuid4`+pid-salted seed, so both the + # within- and cross-proc isolation the other 2 protos + # hand-roll above comes for free. + # + # XXX matters MORE here than for tcp/uds: a TIPC name + # clash doesn't raise `EADDRINUSE`, it silently + # round-robins connects between both publishers. + case 'tipc': + from tractor.ipc._tipc import TIPCAddress + addr: TIPCAddress = addr_type.get_random() + assert addr.is_valid + testrun_reg_addr = addr.unwrap() + # XXX, as sanity it should never the same as the default for the # host-singleton registry actor. assert def_reg_addr != testrun_reg_addr diff --git a/tractor/_testing/pytest.py b/tractor/_testing/pytest.py index b8938fb1..88941463 100644 --- a/tractor/_testing/pytest.py +++ b/tractor/_testing/pytest.py @@ -498,14 +498,14 @@ def pytest_configure( ) config.addinivalue_line( 'markers', - 'tipc: test targets the `AF_TIPC` tpt backend; the kernel- ' - 'touching cases self-skip unless the `tipc` module is loaded ' - '(`sudo modprobe tipc`).' + 'trio: legacy mark for tests meant to run under the `trio` ' + 'spawn backend (e.g. `test_local.py`).' ) config.addinivalue_line( 'markers', - 'trio: legacy mark for tests meant to run under the `trio` ' - 'spawn backend (e.g. `test_local.py`).' + 'tipc: test targets the `AF_TIPC` tpt backend; the kernel- ' + 'touching cases self-skip unless the `tipc` module is loaded ' + '(`sudo modprobe tipc`).' ) # `--enable-stackscope`: install SIGUSR1 → trio task-tree @@ -803,6 +803,27 @@ def tpt_protos( addr_type = _addr._address_types[proto_key] assert addr_type.proto_key == proto_key + # XXX, generic capability gate: an env-dependent tpt + # whose backing kernel-mod/lib/netns isn't present here + # must fail LOUDLY and EARLY rather than as a few hundred + # confusing connect-timeouts downstream. + # + # Any `Address` type MAY expose `.is_available()` + # returning `(ok, why_not)`; absence means "always + # available" (i.e. tcp/uds). + is_avail = getattr( + addr_type, + 'is_available', + None, + ) + if is_avail: + avail, why_not = is_avail() + if not avail: + pytest.fail( + f'--tpt-proto={proto_key!r} is NOT usable here!\n' + f'{why_not}\n' + ) + yield proto_keys diff --git a/tractor/discovery/_addr.py b/tractor/discovery/_addr.py index 7ef8b719..23346c6a 100644 --- a/tractor/discovery/_addr.py +++ b/tractor/discovery/_addr.py @@ -36,6 +36,7 @@ from ..ipc._uds import ( UDSAddress, HAS_UDS, ) +from ..ipc._tipc import TIPCAddress if TYPE_CHECKING: # ONLY type-annots, the eager import costs ~4.5ms @@ -200,12 +201,14 @@ class Address(Protocol): ... -# the address types available on this host: TCP always, UDS only -# where usable (`HAS_UDS`). Both registries derive from this single -# list via each type's `proto_key`. +# the address types supported by this build: TCP and TIPC are +# importable everywhere, while UDS is registered only where usable +# (`HAS_UDS`). Runtime TIPC availability is checked separately. +# Both registries derive from this list via each type's `proto_key`. _address_protos: list[Type[Address]] = [TCPAddress] if HAS_UDS: _address_protos.append(UDSAddress) +_address_protos.append(TIPCAddress) _address_types: dict[str, Type[Address]] = { cls.proto_key: cls @@ -270,6 +273,16 @@ def wrap_address( # import pdbp; pdbp.set_trace() match addr: + # XXX, the explicitly proto-keyed form (spelled with the + # `multiaddr` proto name) which is where ALL backends + # should eventually land per the `UnwrappedAddress` + # migration note above. + # + # NOTE, a bare seq-pattern matches `list` too, which is + # what `msgpack` decodes our tuples back to. + case ('tipc', *_): + cls = TIPCAddress + # classic network socket-address as tuple/list case ( (str(), int()) diff --git a/tractor/ipc/_types.py b/tractor/ipc/_types.py index 244da48b..5ff2088f 100644 --- a/tractor/ipc/_types.py +++ b/tractor/ipc/_types.py @@ -35,20 +35,25 @@ from tractor.ipc._uds import ( MsgpackUDSStream, HAS_UDS, ) +from tractor.ipc._tipc import ( + AF_TIPC, + TIPCAddress, + MsgpackTIPCStream, +) -# the UDS backend is importable everywhere but only *usable* when -# `HAS_UDS` is `True`; otherwise the runtime registers TCP only. -Address = TCPAddress|UDSAddress +Address = TCPAddress|UDSAddress|TIPCAddress -# the available msg-transport backends on this host: TCP always, -# UDS only where usable (`HAS_UDS`). The lookup maps below derive -# from this single list via each backend's `codec_key` and -# `address_type`: register a backend here and every map picks it up. +# the msg-transport backends supported by this build: TCP and TIPC +# are importable everywhere, while UDS is registered only where +# usable (`HAS_UDS`). Runtime TIPC availability is checked separately. +# The lookup maps derive from this list via each backend's `codec_key` +# and `address_type`. _msg_transports: list[Type[MsgTransport]] = [ MsgpackTCPStream, ] if HAS_UDS: _msg_transports.append(MsgpackUDSStream) +_msg_transports.append(MsgpackTIPCStream) # map a `MsgTransportKey` -> `MsgTransport` type _key_to_transport: dict[MsgTransportKey, Type[MsgTransport]] = { @@ -109,6 +114,12 @@ def transport_from_stream( ): transport = 'uds' + # NOTE, `AF_TIPC` is linux-only in CPython so we + # match the `._tipc` constant (which carries a uapi + # fallback) rather than `socket.AF_TIPC`. + case fam if fam == AF_TIPC: + transport = 'tipc' + case fam: raise NotImplementedError( f'Unsupported socket family: {fam}' diff --git a/tractor/runtime/_state.py b/tractor/runtime/_state.py index 5caa92e3..8c8357b0 100644 --- a/tractor/runtime/_state.py +++ b/tractor/runtime/_state.py @@ -52,6 +52,7 @@ _DARWIN_TMPDIR: Path = Path('/tmp') TransportProtocolKey = Literal[ 'tcp', 'uds', + 'tipc', ] _def_tpt_proto: TransportProtocolKey = 'tcp'