remoteRF-server 1.1.1__tar.gz → 1.1.2__tar.gz

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.1.1
+Version: 1.1.2
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "1.1.1"
+version = "1.1.2"
 description = "RemoteRF server-side control package"
 license = { text = "GPL-3.0-or-later" }
 requires-python = ">=3.10"

{remoterf_server-1.1.1/src/remoteRF_server/drivers/adalm_pluto → remoterf_server-1.1.2/src/remoteRF_server/common/idl}/pluto_schema.py

@@ -202,6 +202,9 @@ class PlutoSchema(DeviceSchema):
 
     @idl_expose(kind="set")
     def set_rx_buffer_size(self, value):
+        # pyadi reads rx_buffer_size only when it (re)creates the RX buffer.
+        if value != self.device.rx_buffer_size:
+            self.device.rx_destroy_buffer()
         self.device.rx_buffer_size = value
 
     @idl_expose(kind="call")

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/src/remoteRF_server/common/utils/api_token.py

@@ -15,6 +15,7 @@
 
 import os
 import hashlib
+import hmac
 import base64
 import secrets
 from dotenv import load_dotenv, find_dotenv
@@ -33,4 +34,21 @@ def validate_token(salt, hash, token) -> bool:
 def hash_token(token: str) -> tuple[str, str]:
     salt = os.urandom(16).hex()
     hashed = hashlib.sha256(bytes.fromhex(salt) + token.encode()).hexdigest()
-    return salt, hashed
+    return salt, hashed
+
+# Passwords get a real KDF; tokens stay on hash_token (random, high entropy).
+PASSWORD_HASH_PREFIX = "pbkdf2$"
+_PBKDF2_ROUNDS = 210_000
+
+def hash_password(password: str) -> tuple[str, str]:
+    salt = os.urandom(16).hex()
+    digest = hashlib.pbkdf2_hmac('sha256', password.encode(), bytes.fromhex(salt), _PBKDF2_ROUNDS)
+    return salt, f"{PASSWORD_HASH_PREFIX}{_PBKDF2_ROUNDS}${digest.hex()}"
+
+def verify_password(salt, hash, password) -> tuple[bool, bool]:
+    """Returns (matches, needs_rehash). Accepts legacy hash_token() hashes."""
+    if not hash.startswith(PASSWORD_HASH_PREFIX):
+        return validate_token(salt, hash, password), True
+    _, rounds, digest = hash.split('$', 2)
+    computed = hashlib.pbkdf2_hmac('sha256', password.encode(), bytes.fromhex(salt), int(rounds))
+    return hmac.compare_digest(computed.hex(), digest), False

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/src/remoteRF_server/drivers/adalm_pluto/pluto_remote_server.py

@@ -90,8 +90,7 @@ class PlutoServer:
         if result is not None:
             return {function_name: map_arg(result)}
         else:
-            # If there's no return value, return some placeholder
-            return {function_name: map_arg('None')}
+            return {function_name: map_arg(None)}
             
     @staticmethod
     def get(*, function_name, token):

{remoterf_server-1.1.1/src/remoteRF_server/common/idl → remoterf_server-1.1.2/src/remoteRF_server/drivers/adalm_pluto}/pluto_schema.py

@@ -202,6 +202,9 @@ class PlutoSchema(DeviceSchema):
 
     @idl_expose(kind="set")
     def set_rx_buffer_size(self, value):
+        # pyadi reads rx_buffer_size only when it (re)creates the RX buffer.
+        if value != self.device.rx_buffer_size:
+            self.device.rx_destroy_buffer()
         self.device.rx_buffer_size = value
 
     @idl_expose(kind="call")

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/src/remoteRF_server/drivers/adalm_pluto/poe.py

@@ -26,9 +26,11 @@ import threading
 import time
 
 from remoteRF_server.common.utils import get_remoterf_root
+from remoteRF_server.common.utils.ansi_codes import Sty, printf
 
 IIOD_PORT = 30431
-BOOT_TIMEOUT_S = 120
+BOOT_TIMEOUT_S = 45
+LINK_CHECK_S = 30  # no IIOD by then: ask the switch whether the port even has a link
 OFF_S = 3  # long enough for the Pluto to lose power before it is switched back on
 
 
@@ -90,6 +92,19 @@ def set_poe(*, switch, user, password, port, on):
         ros.close()
 
 
+def port_running(*, switch, user, password, port):
+    """Whether the switch port has an Ethernet link (RouterOS 'running')."""
+    ros = RouterOS(switch, user, password)
+    try:
+        replies = ros.cmd("/interface/ethernet/print", f"?name={port}", "=.proplist=name,running")
+    finally:
+        ros.close()
+    for sentence in replies:
+        if sentence[0] == "!re":
+            return "=running=true" in sentence
+    raise RuntimeError(f"switch has no interface {port}")
+
+
 def _iiod_up(ip):
     try:
         socket.create_connection((ip, IIOD_PORT), timeout=1).close()
@@ -110,6 +125,7 @@ class PoePluto:
             _serial=str(serial or "").strip(),
             _switch={"switch": switch, "user": user, "password": password},
             _pluto=None,
+            fault=None,  # message of the last failed boot; None once a boot succeeds
             _lock=threading.RLock(),
         )
 
@@ -119,28 +135,58 @@ class PoePluto:
     def _poe(self, on):
         set_poe(port=self._port, on=on, **self._switch)
 
+    @property
+    def power_state(self):
+        if self.fault:
+            return "fault"
+        return "on" if self._pluto is not None else "standby"
+
     def power_up(self):
         with self._lock:
             if self._pluto is not None:
                 return
-            self._poe(True)
-            deadline = time.monotonic() + BOOT_TIMEOUT_S
-            while not _iiod_up(self._ip):
-                if time.monotonic() > deadline:
-                    self._poe(False)
-                    raise RuntimeError(f"PoE Pluto {self.uri} did not boot within {BOOT_TIMEOUT_S} s on {self._port}")
-                time.sleep(1)
-            import adi
-
-            pluto = adi.Pluto(self.uri)
-            found = str(pluto._ctx.attrs.get("hw_serial", "")).strip()
-            if self._serial and found.lower() != self._serial.lower():
-                del pluto
+            try:
+                self._boot()
+            except Exception as e:
+                vars(self)["fault"] = str(e)
+                printf(f"{time.strftime('%H:%M:%S')} {e}", Sty.GRAY)
+                raise
+            vars(self)["fault"] = None
+
+    def _boot(self):
+        self._poe(True)
+        started = time.monotonic()
+        link_checked = False
+        while not _iiod_up(self._ip):
+            waited = time.monotonic() - started
+            if waited > BOOT_TIMEOUT_S:
                 self._poe(False)
-                raise RuntimeError(f"{self.uri} on {self._port} is Pluto {found}, expected {self._serial}")
-            vars(self)["_pluto"] = pluto
+                raise RuntimeError(f"PoE Pluto {self.uri} did not boot within {BOOT_TIMEOUT_S} s on {self._port}")
+            if waited > LINK_CHECK_S and not link_checked:
+                link_checked = True
+                try:
+                    running = port_running(port=self._port, **self._switch)
+                except Exception:
+                    running = True  # switch unreachable: keep waiting for IIOD
+                if not running:
+                    self._poe(False)
+                    raise RuntimeError(
+                        f"Pluto {self.uri}: PoE on {self._port} but no Ethernet link after {LINK_CHECK_S} s (cable/port/board fault)"
+                    )
+            time.sleep(1)
+        import adi
+
+        pluto = adi.Pluto(self.uri)
+        found = str(pluto._ctx.attrs.get("hw_serial", "")).strip()
+        if self._serial and found.lower() != self._serial.lower():
+            del pluto
+            self._poe(False)
+            raise RuntimeError(f"{self.uri} on {self._port} is Pluto {found}, expected {self._serial}")
+        vars(self)["_pluto"] = pluto
 
     def power_down(self):
+        """Cut power. The Pluto boots with default settings: sample rate, LOs,
+        gains and rx_buffer_size are all reset by the next power_up()."""
         with self._lock:
             # Drop the handle while the Pluto can still answer its buffer teardown.
             vars(self)["_pluto"] = None

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/src/remoteRF_server/server/commands.py

@@ -106,7 +106,7 @@ def _table() -> list[Command]:
         # ---- devices ----
         Command(("devices list",), "Configured devices", _shell("cmd_devices_list"), "Devices"),
         Command(("devices status",), "Live device online/last_seen/route", _daemon("cmd_devices_status"), "Devices", where=D),
-        Command(("devices add",), "Add a device (asks type, name, serial)", _shell("cmd_devices_add"), "Devices", after="reload_devices"),
+        Command(("devices add",), "Add a device (asks type, name, serial)", _shell("cmd_devices_add"), "Devices", after="reload_devices", hidden=True),
         Command(("devices remove",), "Remove a device by id", _shell("cmd_devices_remove"), "Devices", after="reload_devices"),
         Command(("devices rename",), "Rename a device: devices rename <id> <name>", _shell("cmd_devices_rename"), "Devices", after="reload_devices"),
         Command(("devices wipe",), "Remove ALL devices [-y]", _shell("cmd_devices_wipe"), "Devices", after="reload_devices"),
@@ -264,10 +264,6 @@ def cmd_help(argv: list[str]) -> int:
             return 2
         rows = [c for c in _visible(_IN_DAEMON) if c.section == section]
         lines = [_SECTION_BLURB.get(section, ""), ""] + _columns([(prefix + c.names[0], c.help) for c in rows])
-        if section == "Devices":
-            lines += ["", "Types for `devices add`:",
-                      "  pluto, pluto-mimo, rtl-sdr, hackrf, ti-mmwave,",
-                      "  usrp-2901, usrp-b205-mini, usrp-n210, usrp-profile"]
         print_panel(section, lines, literal=True)
         return 0
     lines: list[str] = []

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/src/remoteRF_server/server/device_manager.py

@@ -77,6 +77,10 @@ def _is_connected(st: _DeviceState) -> bool:
     # host
     return bool(st.online)
 
+def _poe_fault(st: _DeviceState):
+    """Last boot failure of a local PoE Pluto (None otherwise; see drivers/adalm_pluto/poe.py)."""
+    return getattr(getattr(st.dev, "device", None), "fault", None)
+
 # Host device pulling/grabbing
 
 def _get_host_registry():
@@ -187,6 +191,12 @@ def _local_devices_str_snapshot() -> Dict[int, str]:
             name = (st.name or f"device-{gid}").strip()
 
             status = "online" if _is_connected(st) else "offline"
+            fault = _poe_fault(st)
+            power = getattr(getattr(st.dev, "device", None), "power_state", None)
+            if fault:
+                status = f"offline: {fault}"
+            elif power:
+                status = f"{status}, {power}"
             if st.salt or st.hsh:
                 status = f"{status}, reserved"
 
@@ -728,7 +738,7 @@ def describe_devices(ids) -> list[dict]:
             if st is None:
                 continue
             out.append({"id": int(gid), "name": (st.name or f"device-{gid}").strip(),
-                        "type": st.dtype or "", "online": _is_connected(st)})
+                        "type": st.dtype or "", "online": _is_connected(st) and not _poe_fault(st)})
     return out
 
 
@@ -1187,7 +1197,7 @@ def device_inventory_snapshot() -> Dict[int, Dict[str, object]]:
             gid: {
                 "name": st.name or f"device {gid}",
                 "device_type": st.dtype or None,
-                "online": _is_connected(st),
+                "online": _is_connected(st) and not _poe_fault(st),
                 "origin": st.origin,
             }
             for gid, st in _devices.items()

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/src/remoteRF_server/server/direct_path.py

@@ -45,6 +45,7 @@ import os
 import secrets
 import socket
 import threading
+import time
 from pathlib import Path
 from typing import Optional
 
@@ -125,6 +126,20 @@ ALPN = "remoterf-direct/1"
 MAX_FRAME = 100 * 1024 * 1024  # the gRPC message ceiling
 IDLE_SECONDS = 600
 CONNECT_SECONDS = 30  # ICE checks, then the QUIC handshake; a silent client is dropped
+# How long the punch waits for the client's first check when the answer also
+# offered the fixed port. A 2.1.0 client dials that port for 2 s before its
+# first check; a check of ours reaching its NAT before then leaves a stale
+# entry there that shadows the port its own checks are then mapped to (Linux
+# NAT picks another), and the punch can never complete. A check that arrives
+# sooner ends the wait; a client that never reaches us gets ours after it.
+# 3.0 = the 2 s dial plus ~1 s for the relay round trip that carries the
+# answer; a shorter hold reproduces the shadow on a slow relay.
+HOLD_SECONDS = 3.0
+# A client that punches at once ("race" in its offer) sends its first check
+# as soon as the answer reaches it, but that check is dropped at a border
+# that has not seen ours yet, so it cannot end the hold: ours must simply
+# leave after its first check has, and before its retransmit at 0.5 s.
+RACE_HOLD_SECONDS = 0.4
 MAX_PATHS_PER_SESSION = 8  # processes of one login; the oldest path makes room
 DEFAULT_STUN = "stun.l.google.com:19302"
 STUN_SECONDS = 1.5  # a STUN server answers in milliseconds or not at all
@@ -145,6 +160,23 @@ _listener = None
 _listener_port = 0
 
 
+def say(message: str) -> None:
+    """A console line about a path, stamped: paths fail minutes apart."""
+    printf(f"{time.strftime('%H:%M:%S')} {message}", Sty.GRAY)
+
+
+def describe_failure(exc: BaseException, stage: str) -> str:
+    """The exception class and a message that says what did not happen."""
+    if isinstance(exc, asyncio.TimeoutError):
+        return f"TimeoutError: {stage} did not complete within {CONNECT_SECONDS} s"
+    return f"{type(exc).__name__}: {exc}"
+
+
+def describe_remotes(ice: Connection) -> str:
+    """The candidates the client offered, host:port/type each."""
+    return " ".join(f"{c.host}:{c.port}/{c.type}" for c in ice.remote_candidates) or "none"
+
+
 def frame(payload: bytes) -> bytes:
     return len(payload).to_bytes(4, "big") + payload
 
@@ -187,8 +219,15 @@ class Ice(Connection):
     server, and aioice would hold gathering for its whole 5 s timeout on each
     one, on every offer. One interface and a short STUN wait instead; a
     machine without a default route gathers the way aioice does.
+
+    ``heard`` is set by the peer's first check, which may arrive before
+    connect() (aioice holds it as an early check until then).
     """
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.heard = asyncio.Event()
+
     async def gather_candidates(self) -> None:
         address = default_route_address()
         if address is None or self._local_candidates_start:
@@ -199,6 +238,10 @@ class Ice(Connection):
         )
         self._local_candidates_end = True
 
+    def request_received(self, *args) -> None:
+        super().request_received(*args)
+        self.heard.set()
+
 
 def peer_address(ice: Connection) -> tuple[str, int]:
     """The remote end of the nominated pair (aioice keeps it private)."""
@@ -299,11 +342,12 @@ class _Protocol(QuicConnectionProtocol):
 class _Path:
     """One client session's punched pair and the QUIC connection over it."""
 
-    def __init__(self, key: str, user: str, ice: Connection, bound: Optional[dict] = None):
+    def __init__(self, key: str, user: str, ice: Connection, bound: Optional[dict] = None, hold: float = 0.0):
         self.key = key
         self.user = user
         self.ice = ice
         self.bound = bound
+        self.hold = hold  # seconds to wait for the client's first check (a fixed port was offered too)
         self.peer: Optional[tuple[str, int]] = None
         self.calls = 0
         self.task: Optional[asyncio.Task] = None
@@ -312,24 +356,31 @@ class _Path:
 
     async def run(self) -> None:
         protocol = None
+        stage = "ICE"
         try:
+            if self.hold:
+                with contextlib.suppress(asyncio.TimeoutError):
+                    await asyncio.wait_for(self.ice.heard.wait(), self.hold)
             await asyncio.wait_for(self.ice.connect(), CONNECT_SECONDS)
             self.peer = peer_address(self.ice)
+            stage = "the QUIC Initial"
             protocol = await asyncio.wait_for(self._accept(), CONNECT_SECONDS)
             pump = asyncio.ensure_future(self._pump(protocol))
             closed = asyncio.ensure_future(protocol.wait_closed())
             try:
+                stage = "the QUIC handshake"
                 try:
                     await asyncio.wait_for(protocol.wait_connected(), CONNECT_SECONDS)
                 except ConnectionError:
                     raise ConnectionError(f"QUIC handshake failed: {protocol.terminated}") from None
                 where = "offsite" if is_offsite(self.peer[0]) else "local"
-                printf(f"Direct path open: {self.user} from {self.peer[0]}:{self.peer[1]} ({where})", Sty.GRAY)
+                say(f"Direct path open: {self.user} from {self.peer[0]}:{self.peer[1]} ({where})")
                 await asyncio.wait({pump, closed}, return_when=asyncio.FIRST_COMPLETED)
             finally:
                 await cancel_tasks((pump, closed))
         except Exception as exc:  # noqa: BLE001 - a failed punch is expected on some networks
-            printf(f"Direct path failed: {self.user}: {type(exc).__name__}: {exc}", Sty.GRAY)
+            held = f"; held {self.hold:g} s" if self.hold else ""
+            say(f"Direct path failed: {self.user}: {describe_failure(exc, stage)}; offered {describe_remotes(self.ice)}{held}")
         finally:
             if protocol is not None:
                 protocol.close()
@@ -339,7 +390,7 @@ class _Path:
             await self.close()
             if self.peer is not None:
                 why = f" ({protocol.terminated})" if protocol is not None and protocol.terminated else ""
-                printf(f"Direct path closed: {self.user} from {self.peer[0]}:{self.peer[1]} after {self.calls} calls{why}", Sty.GRAY)
+                say(f"Direct path closed: {self.user} from {self.peer[0]}:{self.peer[1]} after {self.calls} calls{why}")
 
     async def _accept(self) -> QuicConnectionProtocol:
         """The client's Initial packet decides the connection, as aioquic's server does."""
@@ -423,10 +474,10 @@ async def _serve_call(path, reader: asyncio.StreamReader, writer: asyncio.Stream
     if bad_frame is not None:
         # A client that cannot frame a request is not ours; its bytes are
         # still arriving and would only pile up in this stream's buffer.
-        printf(f"Direct path dropped: {path.user} sent a {bad_frame}", Sty.GRAY)
+        say(f"Direct path dropped: {path.user} sent a {bad_frame}")
         await path.drop()
     if refused is not None:
-        printf(f"Direct path refused: {path.user}: {refused}", Sty.GRAY)
+        say(f"Direct path refused: {path.user}: {refused}")
         await path.drop()
 
 
@@ -475,7 +526,7 @@ class _Conn(_Protocol):
             if self.key is not None and _paths.get(self.key) is self:
                 del _paths[self.key]
                 why = f" ({self.terminated})" if self.terminated else ""
-                printf(f"Direct path closed: {self.user} from {self.peer[0]}:{self.peer[1]} after {self.calls} calls{why}", Sty.GRAY)
+                say(f"Direct path closed: {self.user} from {self.peer[0]}:{self.peer[1]} after {self.calls} calls{why}")
 
     def _stream(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
         task = asyncio.ensure_future(self._hello(reader, writer) if self.key is None else _serve_call(self, reader, writer))
@@ -487,7 +538,7 @@ class _Conn(_Protocol):
             await self._claim(reader, writer)
         except Exception as exc:  # noqa: BLE001 - a hello that cannot be honoured closes the connection
             logger.warning("direct path fixed-port hello failed: %r", exc)
-            printf(f"Direct path fixed-port hello failed: {type(exc).__name__}: {exc}", Sty.GRAY)
+            say(f"Direct path fixed-port hello failed: {type(exc).__name__}: {exc}")
             self.close()
 
     async def _claim(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
@@ -509,7 +560,7 @@ class _Conn(_Protocol):
         writer.write(frame(json.dumps({"ok": True}).encode()))
         writer.write_eof()
         where = "offsite" if is_offsite(self.peer[0]) else "local"
-        printf(f"Direct path open: {self.user} from {self.peer[0]}:{self.peer[1]} ({where}, fixed port)", Sty.GRAY)
+        say(f"Direct path open: {self.user} from {self.peer[0]}:{self.peer[1]} ({where}, fixed port)")
 
     async def drop(self) -> None:
         if self.key is not None and _paths.get(self.key) is self:
@@ -569,13 +620,17 @@ async def _offer(key: str, user: str, remote: dict, bound: Optional[dict] = None
     except Exception:
         await close_ice(ice)
         raise
-    path = _paths[key] = _Path(key, user, ice, bound)
+    fixed = _fixed_port_offer(key, user, bound)
+    # A client that races the fixed port against the punch says so ("race")
+    # and needs only a short hold; a 2.1.0 offer has no such key.
+    hold = 0.0 if not fixed else RACE_HOLD_SECONDS if remote.get("race") else HOLD_SECONDS
+    path = _paths[key] = _Path(key, user, ice, bound, hold=hold)
     path.task = asyncio.ensure_future(path.run())
     return {
         "ufrag": ice.local_username,
         "pwd": ice.local_password,
         "candidates": [candidate.to_sdp() for candidate in ice.local_candidates],
-        **_fixed_port_offer(key, user, bound),
+        **fixed,
     }
 
 
@@ -612,8 +667,9 @@ def offer(session_key: str, user: str, ice: str) -> dict:
         answer = asyncio.run_coroutine_threadsafe(
             _offer(key, user, remote), _get_loop()
         ).result(20)
-    except Exception as exc:  # noqa: BLE001
-        return {"ace": map_arg(f"direct path unavailable: {exc}")}
+    except Exception as exc:  # noqa: BLE001 - the console gets the detail, the client a fixed line
+        say(f"Direct path offer failed: {user}: {type(exc).__name__}: {exc}")
+        return {"ace": map_arg("direct path unavailable")}
     return {"ice": map_arg(json.dumps(answer)), "server_name": map_arg(hostname() or "")}
 
 

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/src/remoteRF_server/server/global_onboarding.py

@@ -24,9 +24,8 @@ State lives in ``<config dir>/global.env``:
   GLOBAL_CONSENT    yes | no          answered once at first run
   GLOBAL_NAME       requested slug
   GLOBAL_EMAIL      contact address for a human admin
-  GLOBAL_SHARE_LAN  yes | no
   GLOBAL_STATE      unregistered | requested | active | rejected
-                    | suspended | left | expired
+                    | suspended | left | expired | unknown
 """
 
 from __future__ import annotations
@@ -316,15 +315,11 @@ def configure() -> bool:
         return False
     display_name = _prompt_display_name(name)
     email = _prompt_email()
-    share = _confirm("Share LAN address?")
-    if share is None:
-        return False
     update(
         GLOBAL_CONSENT="yes",
         GLOBAL_NAME=name,
         GLOBAL_DISPLAY_NAME=display_name,
         GLOBAL_EMAIL=email,
-        GLOBAL_SHARE_LAN="yes" if share else "no",
         GLOBAL_STATE="unregistered",
     )
     ensure_identity()
@@ -530,13 +525,6 @@ def lan_endpoint() -> Optional[str]:
     return f"{host}:{port}" if host else None
 
 
-def lan_address() -> Optional[str]:
-    """host:port a client on the LAN should dial, when the operator shares it."""
-    if load().get("GLOBAL_SHARE_LAN", "yes").lower() != "yes":
-        return None
-    return lan_endpoint()
-
-
 # -----------------------------
 # Where a call came from
 # -----------------------------
@@ -605,7 +593,7 @@ def submit_request() -> dict:
         "email": kv["GLOBAL_EMAIL"],
         "public_key": _public_key_b64(),
         "ssh_public_key": relay_public_key(),
-        "lan_address": lan_address(),
+        "lan_address": lan_endpoint(),
         "server_version": server_version(),
     }
     result = call("POST", REQUEST_PATH, payload)
@@ -621,7 +609,17 @@ def verify_contact(code: str) -> dict:
 
 
 def fetch_me() -> dict:
-    result = call("GET", ME_PATH)
+    try:
+        result = call("GET", ME_PATH)
+    except GlobalError as exc:
+        # Global lost (or never had) this deployment: polling again cannot
+        # fix it, only a re-join can. The identity is kept so the re-request
+        # is keyed by the same issuer UUID.
+        if exc.code == "unknown_deployment" and state() != "unknown":
+            update(GLOBAL_STATE="unknown")
+            _warn("  RemoteRF Global has no record of this deployment; "
+                  "the relay stops. Run `serverrf global join` to re-register.")
+        raise
     _apply_me(result)
     return result
 
@@ -783,7 +781,7 @@ def status_payload() -> dict:
             "SELECT COUNT(*) FROM Reservations WHERE start_time <= ? AND end_time > ?",
             (now, now),
         ),
-        "lan_address": lan_address(),
+        "lan_address": lan_endpoint(),
         "cert_sha256": cert_sha256(),
     }
     assert set(payload) == STATUS_FIELDS  # the consent text is the contract
@@ -791,7 +789,10 @@ def status_payload() -> dict:
 
 
 def send_liveness() -> None:
+    from datetime import datetime, timezone
+
     call("POST", REPORT_PATH, {"kind": "liveness"})
+    update(GLOBAL_LAST_SEEN_AT=datetime.now(timezone.utc).isoformat())
 
 
 def send_status() -> None:
@@ -943,10 +944,11 @@ POLL_ACTIVE_SECONDS = 3600
 LIVENESS_SECONDS = 300
 STATUS_SECONDS = 3600
 TICK_SECONDS = 60
+POLL_BACKOFF_MAX_SECONDS = 900
 
 # States the agent will never leave on its own: the operator or a Global admin
 # has to act first, so the loop stops instead of retrying forever.
-TERMINAL_STATES = {"left", "rejected", "expired"}
+TERMINAL_STATES = {"left", "rejected", "expired", "unknown"}
 
 
 def _tick(last: dict, tunnel=None) -> None:
@@ -961,7 +963,15 @@ def _tick(last: dict, tunnel=None) -> None:
         return
     interval = POLL_ACTIVE_SECONDS if current == "active" else POLL_PENDING_SECONDS
     if now - last.get("poll", -interval) >= interval:
-        fetch_me()
+        try:
+            fetch_me()
+        except Exception:
+            # Stamp the poll so the next attempt waits out the backoff.
+            backoff = min(2 * last.get("backoff", TICK_SECONDS), POLL_BACKOFF_MAX_SECONDS)
+            last["backoff"] = backoff
+            last["poll"] = now - interval + backoff
+            raise
+        last.pop("backoff", None)
         last["poll"] = now
     if tunnel is not None:
         tunnel.supervise(now)
@@ -972,7 +982,12 @@ def _tick(last: dict, tunnel=None) -> None:
         ("status", STATUS_SECONDS, send_status),
     ):
         if now - last.get(key, -interval) >= interval:
-            send()
+            try:
+                send()
+            except GlobalError as exc:
+                if exc.code == "unknown_deployment":
+                    last.pop("poll", None)  # confirm with /me next tick, not in an hour
+                raise
             last[key] = now
     _cluster_tick()
 
@@ -1016,7 +1031,10 @@ def run_agent(stop=None, tunnel=None) -> None:
                 return
             _tick(last, tunnel)
         except Exception as exc:  # noqa: BLE001 - never take the server down
-            logger.warning("global agent tick failed: %s", exc)
+            logger.warning(
+                "global agent tick failed: %s (%s)",
+                exc, getattr(exc, "code", type(exc).__name__),
+            )
         if stop is not None:
             if stop.wait(TICK_SECONDS):
                 tunnel.stop()
@@ -1088,6 +1106,7 @@ _STATE_SUMMARY = {
     "suspended": "suspended by a RemoteRF admin",
     "left": "left RemoteRF Global",
     "expired": "request expired",
+    "unknown": "RemoteRF Global has no record of this deployment -- run: serverrf global join",
 }
 
 
@@ -1118,10 +1137,12 @@ def cmd_status(refresh: bool = True) -> int:
 
     # Ask Global rather than reporting a stale local answer: the operator runs
     # this precisely because they are waiting to hear about their request.
-    unreachable = None
+    unreachable = refused = None
     if refresh and state() not in TERMINAL_STATES:
         try:
             fetch_me()
+        except GlobalError as exc:
+            refused = exc.code
         except Exception as exc:  # noqa: BLE001 - offline is not an error here
             unreachable = str(exc)
         kv = load()
@@ -1136,9 +1157,9 @@ def cmd_status(refresh: bool = True) -> int:
         ("display", kv.get("GLOBAL_DISPLAY_NAME", "-")),
         ("hostname", hostname() or "-"),
         ("email", kv.get("GLOBAL_EMAIL", "-")),
-        ("share LAN", kv.get("GLOBAL_SHARE_LAN", "no")),
         ("tunnel", tunnel_state()),
         ("last report", kv.get("GLOBAL_LAST_REPORT_AT", "-")),
+        ("last seen", kv.get("GLOBAL_LAST_SEEN_AT", "-")),
     ]
     if kv.get("GLOBAL_REASON"):
         fields.append(("reason", kv["GLOBAL_REASON"]))
@@ -1147,6 +1168,8 @@ def cmd_status(refresh: bool = True) -> int:
 
     if current == "unverified":
         rows += ["", "    serverrf global verify <code>"]
+    if refused:
+        rows += ["", f"(refused by RemoteRF Global ({refused}))"]
     if unreachable:
         rows += ["", f"(could not reach RemoteRF Global just now: {unreachable})"]
 

{remoterf_server-1.1.1 → remoterf_server-1.1.2}/src/remoteRF_server/server/grpc_server.py

@@ -1097,9 +1097,9 @@ def _cmd_status() -> None:
                 ("", ""),
                 ("global", f"{state} -- {g._STATE_SUMMARY.get(state, '')}".rstrip(" -")),
                 ("hostname", g.hostname() or "-"),
-                ("share LAN", kv.get("GLOBAL_SHARE_LAN", "no")),
                 ("tunnel", g.tunnel_state()),
                 ("last report", (kv.get("GLOBAL_LAST_REPORT_AT") or "-").split(".")[0]),
+                ("last seen", (kv.get("GLOBAL_LAST_SEEN_AT") or "-").split(".")[0]),
             ]
         else:
             fields += [("", ""), ("global", "not participating (serverrf global join)")]