mx-remote 5.1.0__tar.gz → 5.2.0__tar.gz

{mx_remote-5.1.0 → mx_remote-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mx_remote
-Version: 5.1.0
+Version: 5.2.0
 Summary: Python 3 library for interfacing with MX Remote compatible devices
 Project-URL: Homepage, https://github.com/opdenkamp/mx-remote/
 Project-URL: Documentation, https://github.com/opdenkamp/mx-remote/

{mx_remote-5.1.0 → mx_remote-5.2.0}/mx_remote/const.py

@@ -14,7 +14,7 @@ Default communication modes:
 """
 import os
 
-VERSION = '5.1.0'
+VERSION = '5.2.0'
 __version__ = VERSION
 
 MX_BCAST_UDP_PORT = 8811
@@ -26,6 +26,17 @@ MX_MCAST_UDP_IP = '224.8.8.8'
 MX_MCAST_UDP_PORT = 8812
 """UDP port used in multicast mode (default)."""
 
+MXR_HELLO_INTERVAL_MIN = 2.5
+"""Shortest gap between hello announcements, in seconds (firmware ``hello_timeout`` minimum)."""
+
+MXR_HELLO_INTERVAL_RAND = 2.5
+"""Random spread added to each hello interval, in seconds.
+
+Mirrors ``rand_timeout_init(&mxr_class->hello_timeout, 2500, 2500)``: the delay is
+re-drawn after every hello that is sent, so devices announcing on the same mesh do
+not converge into synchronised bursts.
+"""
+
 V2IP_UDP_PORT_VIDEO = 50020
 """Default destination UDP port for a V2IP video stream (firmware ``V2IP_UDP_PORT_VIDEO``)."""
 

{mx_remote-5.1.0 → mx_remote-5.2.0}/mx_remote/const.pyi

@@ -5,6 +5,8 @@ __version__ = VERSION
 MX_BCAST_UDP_PORT: int
 MX_MCAST_UDP_IP: str
 MX_MCAST_UDP_PORT: int
+MXR_HELLO_INTERVAL_MIN: float
+MXR_HELLO_INTERVAL_RAND: float
 V2IP_UDP_PORT_VIDEO: int
 V2IP_UDP_PORT_ANC: int
 V2IP_UDP_PORT_AUDIO: int

{mx_remote-5.1.0 → mx_remote-5.2.0}/mx_remote/proto/Constants.py

@@ -651,6 +651,10 @@ class EdidProfile(IntEnum):
 			return '4K HDR Dolby Atmos'
 		if (self.value >= EdidProfile.SINK_1.value) and (self.value <= EdidProfile.SINK_32.value):
 			return f'copy from sink #{self.value - EdidProfile.SINK_1.value + 1}'
+		if self.value == EdidProfile.UNKNOWN.value:
+			# decode_enum lands here for any value this build has no member for,
+			# so it is a profile we cannot name, not one somebody configured
+			return 'unknown'
 		return f"custom #{self.value}"
 
 	TEMPLATE_1080P_STEREO = 0

mx_remote-5.2.0/mx_remote/proto/FrameEDIDProfile.py

@@ -0,0 +1,53 @@
+######################################################
+##            MX Remote Python Interface            ##
+##                                                  ##
+## author: Lars Op den Kamp (lars@opdenkamp-it.nl)  ##
+## copyright (c) 2021-2026 Op den Kamp IT Solutions ##
+######################################################
+'''Protocol frame for EDID profile change commands.'''
+
+from .FrameBase import FrameBase
+from ..Interface import DeviceRegistry, DeviceBase, EdidProfile, MxrDeviceUid
+from .Constants import decode_enum
+
+class FrameEDIDProfile(FrameBase):
+    '''Change an EDID profile on a target device.'''
+    @staticmethod
+    def construct(mxr:DeviceRegistry, target:DeviceBase, profile:EdidProfile) -> FrameBase|None:
+        '''Build an EDID profile change frame for transmission.'''
+        payload = target.remote_id.byte_value + \
+            bytes([(profile.value >> 0) & 0xFF, (profile.value >> 8) & 0xFF]) + \
+            bytes([0 for _ in range(6)])
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x34, payload=payload)
+
+    @property
+    def target_uid(self) -> MxrDeviceUid|None:
+        '''Device whose EDID profile is being set.'''
+        return self.payload_uuid(0)
+
+    @property
+    def target_device(self) -> DeviceBase|None:
+        return self.mxr.get_by_uid(self.target_uid)
+
+    @property
+    def profile_raw(self) -> int|None:
+        '''Profile as carried on the wire, before mapping to a local one.'''
+        return self.payload_u16(16)
+
+    @property
+    def profile(self) -> EdidProfile|None:
+        '''Requested EDID profile.
+
+        A value this build has no member for reads as EdidProfile.UNKNOWN rather
+        than raising or being folded into a real profile. Read profile_raw when
+        the distinction matters.
+        '''
+        return decode_enum(EdidProfile, self.profile_raw)
+
+    def __str__(self) -> str:
+        # The frame names no bay because it never needs to: the receiver applies it
+        # to MBAY_ID_0, its own input bay, so a device is the whole address.
+        target = self.target_device if (self.target_device is not None) else self.target_uid
+        profile = f"{self.profile} ({self.profile_raw})" \
+            if (self.profile == EdidProfile.UNKNOWN) else str(self.profile)
+        return f"set edid profile: {target} input 0 -> {profile}"

mx_remote-5.2.0/mx_remote/proto/FrameEDIDProfile.pyi

@@ -0,0 +1,15 @@
+from ..Interface import DeviceBase as DeviceBase, DeviceRegistry as DeviceRegistry, EdidProfile as EdidProfile, MxrDeviceUid as MxrDeviceUid
+from .Constants import decode_enum as decode_enum
+from .FrameBase import FrameBase as FrameBase
+
+class FrameEDIDProfile(FrameBase):
+    @staticmethod
+    def construct(mxr: DeviceRegistry, target: DeviceBase, profile: EdidProfile) -> FrameBase | None: ...
+    @property
+    def target_uid(self) -> MxrDeviceUid | None: ...
+    @property
+    def target_device(self) -> DeviceBase | None: ...
+    @property
+    def profile_raw(self) -> int | None: ...
+    @property
+    def profile(self) -> EdidProfile | None: ...

mx_remote-5.2.0/mx_remote/proto/FrameSetName.py

@@ -0,0 +1,62 @@
+######################################################
+##            MX Remote Python Interface            ##
+##                                                  ##
+## author: Lars Op den Kamp (lars@opdenkamp-it.nl)  ##
+## copyright (c) 2021-2026 Op den Kamp IT Solutions ##
+######################################################
+'''Protocol frame for changing a bay name on a device.'''
+
+from .Constants import MXR_DEVICE_NAME_LEN
+from .FrameBase import FrameBase
+from ..Interface import DeviceRegistry, BayBase, DeviceBase, MxrDeviceUid
+
+class FrameSetName(FrameBase):
+    '''Change a bay name.'''
+    @staticmethod
+    def construct(mxr:DeviceRegistry, target:BayBase, name:str) -> FrameBase|None:
+        '''Build a bay name change frame for transmission.'''
+        # 15, not 16: the receiver copies MXR_DEVICE_NAME_LEN - 1 bytes and
+        # terminates, so a name filling the field is stored one short. Sending
+        # all 16 means the bay ends up named something other than what was
+        # asked for, with success reported either way.
+        name = name[:MXR_DEVICE_NAME_LEN - 1]
+        name_bytes = name.encode(encoding='ascii', errors='replace').ljust(MXR_DEVICE_NAME_LEN, b'\x00')
+        payload = target.device.remote_id.byte_value + \
+            bytes([(target.port >> 0) & 0xFF, (target.port >> 8) & 0xFF]) + \
+            name_bytes
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x22, protocol=0x11, payload=payload)
+
+    @property
+    def target_uid(self) -> MxrDeviceUid|None:
+        '''Device whose bay is being renamed.'''
+        return self.payload_uuid(0)
+
+    @property
+    def target_device(self) -> DeviceBase|None:
+        return self.mxr.get_by_uid(self.target_uid)
+
+    @property
+    def port(self) -> int|None:
+        '''Port id of the bay being renamed (mbay_port_id, a u16).'''
+        return self.payload_u16(16)
+
+    @property
+    def bay(self) -> BayBase|None:
+        return self.payload_bay(device=self.target_device, idx=16, u16=True)
+
+    @property
+    def name(self) -> str|None:
+        '''The new name, read from its fixed 16-byte field.
+
+        The field carries no terminator of its own, so a name that fills it has
+        none and must not be read as a C string: read it at its width. A sender
+        that fills all MXR_DEVICE_NAME_LEN bytes is readable here, even though a
+        receiver keeps only the first MXR_DEVICE_NAME_LEN - 1 of them.
+        '''
+        return self.payload_str(18, 16)
+
+    def __str__(self) -> str:
+        target = self.bay if (self.bay is not None) else self.target_device
+        if (target is None):
+            return f"set bay name: port {self.port} -> '{self.name}'"
+        return f"set bay name: {target} -> '{self.name}'"

mx_remote-5.2.0/mx_remote/proto/FrameSetName.pyi

@@ -0,0 +1,17 @@
+from ..Interface import BayBase as BayBase, DeviceBase as DeviceBase, DeviceRegistry as DeviceRegistry, MxrDeviceUid as MxrDeviceUid
+from .Constants import MXR_DEVICE_NAME_LEN as MXR_DEVICE_NAME_LEN
+from .FrameBase import FrameBase as FrameBase
+
+class FrameSetName(FrameBase):
+    @staticmethod
+    def construct(mxr: DeviceRegistry, target: BayBase, name: str) -> FrameBase | None: ...
+    @property
+    def target_uid(self) -> MxrDeviceUid | None: ...
+    @property
+    def target_device(self) -> DeviceBase | None: ...
+    @property
+    def port(self) -> int | None: ...
+    @property
+    def bay(self) -> BayBase | None: ...
+    @property
+    def name(self) -> str | None: ...

{mx_remote-5.1.0 → mx_remote-5.2.0}/mx_remote/remote/Remote.py

@@ -14,10 +14,11 @@ import aiofiles
 import aiohttp
 import os
 from pathlib import Path
+import random
 import time
 
 from .ConnectionAsync import ConnectionAsync
-from ..const import __version__
+from ..const import MXR_HELLO_INTERVAL_MIN, MXR_HELLO_INTERVAL_RAND, __version__
 from .Device import Device
 from ..Interface import ConnectionCallbacks, DeviceRegistry, MxrDeviceUid, BayLinks, BayBase, DeviceBase, MxrCallbacks, AudioEndpoint, mxr_broadcast_address
 from ..proto.Constants import MXR_PROTOCOL_VERSION
@@ -60,7 +61,8 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
         self._callbacks = State(callbacks, http_session)
         self.remotes:dict[MxrDeviceUid,Device] = {}
         self._links = BayLinks(self)
-        self._last_hello = 0
+        self._hello_due = 0.0
+        self._probe_failures = 0
         self._tasks:set[asyncio.Task[None]] = set()
         self._uid:bytes|None = None
         self._uid_path = uid_path
@@ -218,19 +220,56 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
                 return True
         return False
 
+    def _on_task_done(self, task:'asyncio.Task[None]') -> None:
+        '''Drop a finished background task, and report it if something killed it.
+
+        asyncio only surfaces an unretrieved task exception when the task object is
+        garbage collected, which is a different moment and may never come, so a task
+        that dies otherwise does so in silence. Retrieving it here is what makes any
+        future background task fail loudly, including one whose own guard misses.
+        '''
+        self._tasks.discard(task)
+        if task.cancelled():
+            return
+        exc = task.exception()
+        if (exc is not None):
+            _LOGGER.error(f"background task {task.get_name()} died: {exc!r}")
+
     async def _background_probe(self) -> None:
         while not self._closing:
             await asyncio.sleep(1)
-            tx_discover = False
-            if (not self.has_completed_devices()):
-                tx_discover = True
-            else:
-                for _, device in self.remotes.items():
-                    device.check_online()
-                    if not device.check_configuration_complete_timeout():
-                        tx_discover = True
-            if tx_discover and ((time.time() - self._discover_timeout) >= 5):
-                self.tx_discover()
+            try:
+                self._probe_once()
+                self._probe_failures = 0
+            except Exception as e:
+                # A send raises on a closed or unreachable socket. Letting that
+                # escape ends the task, and this loop is the only thing that
+                # announces this client and drives discovery, so one transient
+                # failure would silence it permanently.
+                #
+                # A disconnected interface fails every tick, so only the first
+                # carries a traceback: a full one per second buries everything
+                # else in the log, and the repeats say nothing the first did not.
+                self._probe_failures += 1
+                if (self._probe_failures == 1):
+                    _LOGGER.warning(f"probe failed: {traceback.format_exc()}")
+                else:
+                    _LOGGER.debug(f"probe still failing ({self._probe_failures}): {e!r}")
+
+    def _probe_once(self) -> None:
+        '''One pass of the probe loop: announce if due, then discover if needed.'''
+        if (time.time() >= self._hello_due):
+            self.tx_hello()
+        tx_discover = False
+        if (not self.has_completed_devices()):
+            tx_discover = True
+        else:
+            for _, device in self.remotes.items():
+                device.check_online()
+                if not device.check_configuration_complete_timeout():
+                    tx_discover = True
+        if tx_discover and ((time.time() - self._discover_timeout) >= 5):
+            self.tx_discover()
 
     async def start_async(self) -> None:
         '''Start the server that listens for mx_remote frames from other devices.'''
@@ -240,7 +279,7 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
         await self.conn.start_srv()
         checker = asyncio.create_task(self._background_probe())
         self._tasks.add(checker)
-        checker.add_done_callback(self._tasks.discard)
+        checker.add_done_callback(self._on_task_done)
 
     async def stop_async(self) -> None:
         '''Stop the server and close all connections.'''
@@ -335,14 +374,32 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
         _LOGGER.debug("discovering devices")
         return self.transmit(pkt.frame)
 
+    def _arm_hello(self) -> None:
+        '''Schedule the next announcement, mirroring the firmware's hello timer.
+
+        MatrixOS re-draws min 2.5s + random(0..2.5s) after each hello it sends,
+        so a mesh of devices does not synchronise into bursts. The interval is
+        re-drawn per send rather than fixed for the same reason.
+        '''
+        self._hello_due = time.time() + MXR_HELLO_INTERVAL_MIN \
+            + (random.random() * MXR_HELLO_INTERVAL_RAND)
+
     def tx_hello(self) -> int:
         '''Transmit a hello frame to announce this device on the network.'''
         pkt = constructFrameHello(self)
         if (pkt is None):
             return 0
         _LOGGER.debug("sending hello")
-        self._last_hello = time.time()
-        return self.transmit(pkt.frame)
+        sent = self.transmit(pkt.frame)
+        if (sent > 0):
+            # Only a hello that went out buys the next interval. A send that wrote
+            # nothing leaves _hello_due where it was, so the next probe tick tries
+            # again, which is what firmware does - it resets hello_timeout only in
+            # the success branch of mxr_transmit. Arming here on failure instead
+            # would silence a client for a full interval every time a write failed,
+            # and on an interface that never writes, permanently.
+            self._arm_hello()
+        return sent
 
     def on_connection_made(self) -> None:
         '''Callback invoked after ConnectionAsync has started the server.'''
@@ -374,10 +431,6 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
         timestamp = time.time()
         self.process_frame(timestamp=timestamp, data=data, addr=addr)
 
-        if (self.conn is not None):
-            if (timestamp - self._last_hello >= 30):
-                self.tx_hello()
-
     @override
     def on_mxr_update(self, data:Any) -> None:
         if isinstance(data, FrameHello):

{mx_remote-5.1.0 → mx_remote-5.2.0}/mx_remote/remote/Remote.pyi

@@ -1,7 +1,7 @@
 import aiohttp
 from ..Interface import AudioEndpoint as AudioEndpoint, BayBase as BayBase, BayLinks as BayLinks, ConnectionCallbacks as ConnectionCallbacks, DeviceBase as DeviceBase, DeviceRegistry as DeviceRegistry, MxrCallbacks as MxrCallbacks, mxr_broadcast_address as mxr_broadcast_address
 from ..Uid import MxrDeviceUid as MxrDeviceUid
-from ..const import MX_BCAST_UDP_PORT as MX_BCAST_UDP_PORT, MX_MCAST_UDP_IP as MX_MCAST_UDP_IP, MX_MCAST_UDP_PORT as MX_MCAST_UDP_PORT, __version__ as __version__
+from ..const import MXR_HELLO_INTERVAL_MIN as MXR_HELLO_INTERVAL_MIN, MXR_HELLO_INTERVAL_RAND as MXR_HELLO_INTERVAL_RAND, MX_BCAST_UDP_PORT as MX_BCAST_UDP_PORT, MX_MCAST_UDP_IP as MX_MCAST_UDP_IP, MX_MCAST_UDP_PORT as MX_MCAST_UDP_PORT, __version__ as __version__
 from ..proto.Constants import MXR_PROTOCOL_VERSION as MXR_PROTOCOL_VERSION
 from ..proto.Factory import process_mxr_frame as process_mxr_frame
 from ..proto.FrameDiscover import constructFrameDiscover as constructFrameDiscover

mx_remote-5.2.0/tests/entry.py

@@ -0,0 +1,59 @@
+"""Enter where the runtime enters.
+
+on_datagram_received is what ConnectionAsync calls. process_frame is one level
+below it and is what a test reaches for, because it takes the arguments a test
+already has - so a layer that only the runtime touches goes uncovered while the
+suite looks like it exercises the receive path.
+
+Here that layer re-announces this client's hello. It has one other caller, at
+startup, so if it stopped working the client would announce once and then go
+silent to every peer that started later.
+"""
+import os
+import struct
+import sys
+import time
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import logging
+logging.disable(logging.CRITICAL)
+
+import mx_remote
+from mx_remote.Uid import MxrDeviceUid
+from mx_remote.proto.Factory import create_mxr_frame
+
+UID = bytes(range(1, 17))
+ADDR = ('192.0.2.9', 8812)
+
+class RecordingConn:
+    """Stands in for ConnectionAsync so transmits can be counted."""
+    def __init__(self):
+        self.sent = []
+    def transmit(self, data):
+        self.sent.append(data)
+        return len(data)
+
+def nm(s, sz=16):
+    b = s.encode('ascii')[:sz]
+    return b + bytes(sz - len(b))
+
+HELLO = (struct.pack('<H', 0x28) + nm('MX-1') + nm('P8SN12345678') + nm('4.7.9')
+         + struct.pack('<I', 1 << 5))
+
+mx = mx_remote.Remote(open_connection=False)
+mx._uid = bytes(range(100, 116))
+conn = RecordingConn()
+mx.conn = conn
+
+# a datagram arriving must be decoded, not merely counted
+mx.on_datagram_received(create_mxr_frame(UID, 0x00, HELLO), ADDR)
+assert mx.get_by_uid(MxrDeviceUid(UID)) is not None, 'the datagram was not processed'
+print('entry : a datagram reaching on_datagram_received is decoded')
+
+# Hello timing is not asserted here. It belongs to whatever drives the
+# announcement, and pinning it to a datagram arriving would encode the trigger
+# rather than the behaviour - an assertion that no datagram sends a hello
+# passes trivially once nothing does.
+
+print()
+print('ALL OK')

mx_remote-5.2.0/tests/hello.py

@@ -0,0 +1,197 @@
+######################################################
+##            MX Remote Python Interface            ##
+##                                                  ##
+## author: Lars Op den Kamp (lars@opdenkamp-it.nl)  ##
+## copyright (c) 2021-2026 Op den Kamp IT Solutions ##
+######################################################
+'''A client announces itself on a clock, not when something arrives.
+
+MatrixOS sends SYS_HELLO from its probe loop every 2.5s + random(0..2.5s),
+re-drawn after each send and independent of received traffic. A client that
+announces only on receipt is invisible to a silent mesh: nothing arrives, so it
+never speaks, so nothing learns it is there.
+
+This drives the real periodic loop rather than the pieces under it. Asserting
+that "is it due" works and that tx_hello sends proves nothing about whether
+anything ever asks.
+'''
+
+import asyncio, os, sys, time, logging
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+logging.disable(logging.CRITICAL)
+import mx_remote
+from mx_remote.proto.Factory import create_mxr_frame
+from mx_remote.remote import Remote as RemoteModule
+
+# keep the wall-clock cost down without touching the loop being tested
+RemoteModule.MXR_HELLO_INTERVAL_MIN = 0.1
+RemoteModule.MXR_HELLO_INTERVAL_RAND = 0.1
+
+HELLO = 0x00
+
+def opcode(frame):
+    return int.from_bytes(frame[20:22], 'little')
+
+async def run(seconds, wire_ok=True):
+    mx = mx_remote.Remote(open_connection=False)
+    mx._uid = bytes(range(0x20, 0x30))
+    sent = []
+    mx.transmit = lambda data: (sent.append(data), len(data) if wire_ok else 0)[1]
+    task = asyncio.ensure_future(mx._background_probe())
+    await asyncio.sleep(seconds)
+    mx._closing = True
+    task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+    return mx, [f for f in sent if opcode(f) == HELLO]
+
+# ---- a silent network: nothing is fed in, and it must still announce, repeatedly
+mx, hellos = asyncio.run(run(3.5))
+print('silent network, 3.5s: %d hellos' % len(hellos))
+assert len(hellos) >= 2, 'a client must keep announcing with no traffic arriving'
+
+# ---- arriving datagrams must not announce, asserted by behaviour rather than by
+# name. Checking that "tx_hello" is absent from on_datagram_received passes the
+# moment the method is renamed, while the receipt-driven path is back in place.
+def announces_on_receipt():
+    mx = mx_remote.Remote(open_connection=False)
+    mx._uid = bytes(range(0x20, 0x30))
+    mx._hello_due = time.time() + 3600          # nothing is due on the clock
+    sent = []
+    mx.transmit = lambda data: (sent.append(data), len(data))[1]
+    peer = bytes(range(1, 17))
+    for _ in range(20):
+        mx.on_datagram_received(create_mxr_frame(peer, 0x01, b''), ('192.0.2.9', 8812))
+    return [f for f in sent if opcode(f) == HELLO]
+
+on_receipt = announces_on_receipt()
+print('20 datagrams, nothing due: %d hellos' % len(on_receipt))
+assert len(on_receipt) == 0, 'arriving traffic must not trigger an announcement'
+
+# ---- a hello that did not go out does not buy the next interval, as in firmware
+mx, hellos = asyncio.run(run(2.5, wire_ok=False))
+print('failing wire, 2.5s : %d attempts' % len(hellos))
+assert len(hellos) >= 2, 'a send that wrote nothing must be retried, not treated as done'
+
+# ---- the interval is re-drawn per send rather than fixed
+mx2 = mx_remote.Remote(open_connection=False)
+mx2._uid = bytes(range(0x20, 0x30))
+mx2.transmit = lambda data: len(data)
+# Measure the interval, not the due timestamp: _hello_due moves every call because
+# the clock advances, so counting distinct timestamps says nothing about whether
+# anything was drawn.
+deltas = []
+for _ in range(40):
+    before = time.time()
+    mx2._arm_hello()
+    deltas.append(mx2._hello_due - before)
+spread = max(deltas) - min(deltas)
+print('interval spread    : %.4fs over 40 draws (rand range %.2fs)'
+      % (spread, RemoteModule.MXR_HELLO_INTERVAL_RAND))
+assert spread > RemoteModule.MXR_HELLO_INTERVAL_RAND * 0.3, \
+    'the interval must be re-drawn per send, not fixed'
+assert min(deltas) >= RemoteModule.MXR_HELLO_INTERVAL_MIN, 'a draw must never be shorter than the minimum'
+
+# ---- a send that raises must not end the loop. This loop is now the only thing
+# that announces and the only thing that drives discovery, so a task that dies on
+# a transient socket error silences the client for good.
+async def survives_raising_transmit():
+    mx = mx_remote.Remote(open_connection=False)
+    mx._uid = bytes(range(0x20, 0x30))
+    sent = []
+    state = {'raise': True}
+    def wire(data):
+        if state['raise']:
+            raise OSError('network is unreachable')
+        sent.append(data)
+        return len(data)
+    mx.transmit = wire
+    task = asyncio.ensure_future(mx._background_probe())
+    await asyncio.sleep(2.2)
+    alive_while_failing = not task.done()
+    state['raise'] = False          # the socket comes back
+    await asyncio.sleep(2.2)
+    mx._closing = True
+    task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+    return alive_while_failing, [f for f in sent if opcode(f) == HELLO]
+
+alive, recovered = asyncio.run(survives_raising_transmit())
+print('raising wire       : loop alive=%s, hellos after recovery=%d' % (alive, len(recovered)))
+assert alive, 'a raising send must not end the probe loop'
+assert len(recovered) >= 1, 'the client must announce again once sending works'
+
+# ---- a task that dies must say so. asyncio only reports an unretrieved task
+# exception when the task object is collected, which is a different moment and may
+# never come, so without this a background task dies in silence. Driven through
+# start_async so the real registration is what is under test, not _on_task_done.
+class Boom(BaseException):
+    """Not an Exception, so the loop's own guard does not catch it."""
+
+class FakeConn:
+    async def start_srv(self):
+        return (None, None)
+    def close(self):
+        pass
+
+async def dying_task_is_reported():
+    records = []
+    class Catch(logging.Handler):
+        def emit(self, rec):
+            records.append(rec)
+    logging.disable(logging.NOTSET)
+    log = logging.getLogger('mx_remote.remote.Remote')
+    log.addHandler(Catch()); log.setLevel(logging.DEBUG)
+    try:
+        mx = mx_remote.Remote(open_connection=False)
+        mx._uid = bytes(range(0x20, 0x30))
+        mx.conn = FakeConn()
+        mx._probe_once = lambda: (_ for _ in ()).throw(Boom('probe exploded'))
+        await mx.start_async()
+        await asyncio.sleep(1.6)
+        task = next(iter(mx._tasks), None)
+        died = [r for r in records if r.levelno >= logging.ERROR and 'died' in r.getMessage()]
+        return died
+    finally:
+        log.removeHandler(Catch)
+        logging.disable(logging.CRITICAL)
+
+died = asyncio.run(dying_task_is_reported())
+print('task killed by a BaseException: %d error(s) logged' % len(died))
+assert len(died) >= 1, 'a background task that dies must be reported, not vanish'
+
+# ---- a disconnected interface must not bury the log in identical tracebacks
+async def one_traceback_then_quiet():
+    records = []
+    class Catch(logging.Handler):
+        def emit(self, rec):
+            records.append(rec)
+    logging.disable(logging.NOTSET)
+    log = logging.getLogger('mx_remote.remote.Remote')
+    log.addHandler(Catch()); log.setLevel(logging.DEBUG)
+    try:
+        mx = mx_remote.Remote(open_connection=False)
+        mx._uid = bytes(range(0x20, 0x30))
+        mx.transmit = lambda data: (_ for _ in ()).throw(OSError('network is unreachable'))
+        task = asyncio.ensure_future(mx._background_probe())
+        await asyncio.sleep(3.2)
+        mx._closing = True
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+        return [r for r in records if r.levelno >= logging.WARNING]
+    finally:
+        logging.disable(logging.CRITICAL)
+
+warns = asyncio.run(one_traceback_then_quiet())
+print('3 failing ticks    : %d warning(s)' % len(warns))
+assert len(warns) == 1, 'only the first failure carries a traceback; repeats must not flood'
+
+print('ALL OK')