remoteRF-server 1.7.0__tar.gz → 1.7.4__tar.gz

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/PKG-INFO

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

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/pyproject.toml

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

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/src/remoteRF_server/server/device_manager.py

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import importlib
+import logging
 import os
 import re
 import secrets
@@ -37,6 +38,8 @@ from ..common.utils import validate_token, get_remoterf_root, get_drivers_dir, d
 from ..common.idl.schema import get_driver_class, load_drivers
 from ..host import host_tunnel_server as hts
 
+logger = logging.getLogger(__name__)
+
 _state_lock = threading.RLock()
 _reservation_end_callbacks: list = []
 # token -> (gid, salt, hsh): see reservation_bridge_token()
@@ -807,6 +810,7 @@ def set_device(device_id: int, salt: str, hash: str):
             return
 
     notify_end = False
+    host_start = None
     with _state_lock:
         st = _devices.get(int(device_id))
         if not st:
@@ -819,6 +823,8 @@ def set_device(device_id: int, salt: str, hash: str):
             all(held) and previous != held and st.origin == "local"
             and callable(getattr(st.dev, "prepare_for_holder", None))
         )
+        if all(held) and previous != held and st.origin == "host" and isinstance(st.dev, VirtualDevice):
+            host_start = st.dev
         # The holder changed: the reservation ended, or a back-to-back one
         # replaced it without the device ever being free.
         notify_end = any(previous) and previous != (st.salt, st.hsh)
@@ -836,10 +842,24 @@ def set_device(device_id: int, salt: str, hash: str):
         # Now, not at the next call: a transmitter left running must stop
         # even when nobody reserves the device next.
         threading.Thread(target=_reset_if_pending, args=(int(device_id),), daemon=True).start()
+    if host_start is not None:
+        _start_host_reservation(host_start)
     if prepare:
         threading.Thread(target=_prepare_for_holder, args=(int(device_id), held), daemon=True).start()
 
 
+def _start_host_reservation(device: VirtualDevice) -> None:
+    try:
+        registry = hts.get_tunnel_registry(create=False)
+        if registry is None or not registry.send_control(
+            device.host_id, kind="reservation_start", device_id=device.device_id,
+            payload={"at": time.time()},
+        ):
+            logger.warning("host reservation start unavailable for %s", device.host_id)
+    except Exception as exc:
+        logger.warning("host reservation start unavailable for %s: %s", device.host_id, exc)
+
+
 def _prepare_for_holder(device_id: int, held: Tuple[str, str]) -> None:
     """A reservation started: ready the device (a PoE Pluto boots) before the
     holder's first call, which waits on io_lock for this same boot meanwhile."""

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/src/remoteRF_server/server/federation/cluster.py

@@ -1080,7 +1080,16 @@ def _sync_contract(party: dict, peer: str, directory: list[dict]) -> str:
     for item in directory:
         if item["contract_id"] == party["contract_id"] and item.get("terms"):
             _import(store, item["terms"], item["events"])
-    return store.show(party["contract_id"], 1)["state"]
+    try:
+        return store.show(party["contract_id"], 1)["state"]
+    except ContractError as exc:
+        if exc.code != "unknown_contract":
+            raise
+    # Neither this store nor Global has it: the lab's database was reset while its
+    # federation state survived. Forget it; a member adopts afresh, a proposer proposes again.
+    party.pop("contract_id")
+    party.update(state="created", published=[])
+    return _sync_contract(party, peer, directory)
 
 
 def _event_order(signed_event: str) -> tuple:
@@ -1112,6 +1121,9 @@ def _advance(party: dict, peer: str, directory: list[dict], *, label: str, notif
     if before in ("pending", "revoked"):
         return
     state = _sync_contract(party, peer, directory)
+    if not party.get("contract_id") and not is_member and (other := _identity_of(peer)) is not None:
+        _contract_with(party, other)  # the stale contract was dropped: propose a new one
+        state = "proposed"
     store = _contracts()
     if state == "proposed" and is_member:
         store.accept(party["contract_id"], 1, actor_admin_ref="cluster")
@@ -1291,13 +1303,22 @@ def _walk_in(pools: list[dict], notify) -> None:
     active. Any other open door (an older lab's own) is ignored."""
     from . import global_home
 
-    if GLOBAL in load():
-        return
     state = global_home.load()
     home = (state.get("identity") or {}).get("deployment_id")
     party = state.get("party") or {}
+    clusters = load()
+    if GLOBAL in clusters and (clusters[GLOBAL].get("peer") == home or not home):
+        return
     if not home or party.get("state") != "active":
         return
+    if GLOBAL in clusters:
+        # Joined under an earlier Global home (this lab's state outlived a Global
+        # reset): drop it and rejoin the current one, keeping what it shared.
+        stale = clusters.pop(GLOBAL)
+        queued = state.setdefault("public_groups", [])
+        queued += [group_id for group_id in stale.get("groups", []) if group_id not in queued]
+        save(clusters)
+        global_home.save(state)
     for pool in pools:
         owner = (pool.get("owner") or {}).get("identity") or {}
         if pool.get("cluster_name") != GLOBAL or owner.get("deployment_id") != home:

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/src/remoteRF_server/server/global_onboarding.py

@@ -65,8 +65,9 @@ time reserved so far (a single number), and your LAN address. Nothing else leave
 server -- no credentials, no user or reservation details -- and the
 connection only goes outward.
 
-A RemoteRF admin reviews each new deployment by hand, so there is a short wait
-before your address goes live. You can join or leave whenever you like:
+A RemoteRF admin will review your new deployment before its address goes live.
+If you opt out, you cannot opt back in without a full data reset. You may leave
+at any time:
 
     serverrf global join
     serverrf global leave"""

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/src/remoteRF_server/server/rpc_manager.py

@@ -252,14 +252,23 @@ class RpcManager:
             fwd_args = dict(args)
             fwd_args.pop('a', None)
             fwd_args['g'] = map_arg(int(gid))
-            return hts.handle_host_device(
+            results = hts.handle_host_device(
                 hts.get_tunnel_registry(create=False),
                 host_id=dev.host_id,
                 device_id=dev.device_id,
                 function_name=function_name,
                 args=fwd_args,
-                timeout_sec=10.0,
+                timeout_sec=25.0,
             )
+            failed = "Error" in results
+            if "Ok" in results:
+                failed = failed or not bool(unmap_arg(results["Ok"]))
+            if failed:
+                error = str(unmap_arg(results["Error"]) or "") if "Error" in results else ""
+                return {"a": map_arg(
+                    error or "The device did not answer in time; it may still be powering on. Try again."
+                )}
+            return results
 
         return self._dispatch_local_schema(function_name=function_name, args=args, gid=gid, dev=dev)
 

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/src/remoteRF_server.egg-info/PKG-INFO

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

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/src/remoteRF_server.egg-info/SOURCES.txt

@@ -177,6 +177,7 @@ tests/test_reservation_policy_b.py
 tests/test_reservation_timestamps.py
 tests/test_rpc_manager_batch.py
 tests/test_rpc_manager_calln.py
+tests/test_rpc_manager_host_legacy.py
 tests/test_rpc_manager_rx_n.py
 tests/test_rtl_sdr_schema.py
 tests/test_schema_registry.py

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/tests/test_global_home.py

@@ -67,6 +67,35 @@ class GlobalHomeContractTests(unittest.TestCase):
             self.assertEqual(global_home.contract_id(), party["contract_id"])
         self.assertIn("[cluster] RemoteRF Global is active", self.notes)
 
+    def test_a_contract_neither_the_lab_nor_global_has_is_dropped_and_proposed_again(self):
+        with self.server(H):
+            home_identity = cluster._identity()
+        with self.server(A), mock.patch.object(global_home, "fetch_identity", return_value=home_identity):
+            # The lab's database was reset; its federation state still names the old contract.
+            global_home.save({"party": {"state": "proposed", "display_name": global_home.LABEL,
+                                        "contract_id": "8a2e3f10-0000-4000-8000-0000000000ff", "published": []}})
+            global_home.tick(self.notes.append)
+            party = global_home.load()["party"]
+            self.assertEqual(party["state"], "proposed")
+            self.assertNotEqual(party["contract_id"], "8a2e3f10-0000-4000-8000-0000000000ff")
+        self.assertEqual([c["contract_id"] for c in self.broker.call("GET", "/v2/broker/contracts")["contracts"]],
+                         [party["contract_id"]])
+
+    def test_a_global_cluster_joined_under_an_earlier_home_is_rejoined_with_its_groups(self):
+        with self.server(H):
+            home_identity = cluster._identity()
+            cluster._public_note(cluster.GLOBAL, "open")
+        self._standing(B, home_identity)
+        with self.server(B):
+            # State from before a Global reset: the cluster names a home that is gone.
+            cluster.save({cluster.GLOBAL: {"role": "member", "state": "active", "public": True, "peer": C,
+                                           "contract_id": "8a2e3f10-0000-4000-8000-0000000000ff",
+                                           "published": [], "groups": [7]}})
+            cluster.tick(self.notes.append)
+            item = cluster.load()[cluster.GLOBAL]
+            self.assertEqual((item["peer"], item["contract_id"], item["groups"]), (H, global_home.contract_id(), [7]))
+            self.assertNotIn("public_groups", global_home.load())
+
     def _standing(self, lab, home_identity):
         """The lab proposes its standing contract; the home accepts; the lab sees it active."""
         with self.server(lab), mock.patch.object(global_home, "fetch_identity", return_value=home_identity):

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/tests/test_remote_admin.py

@@ -536,9 +536,14 @@ def test_a_real_openssh_session_through_the_tunnel(lab, tmp_path):
         out = _expect(ssh_argv("jdoe"), [("Password for remote admin jdoe:", "a long password!"),
                                           ("jdoe@lab>", "exit")])
         assert "jdoe@lab>" in out, out
-        time.sleep(1.5)
-        with contextlib.closing(ra.connect()) as conn:
-            seen = [r[0] for r in conn.execute("SELECT event FROM remote_admin_audit ORDER BY id")]
+        # session_end is written after the server closes the channel, so ssh can exit first.
+        deadline = time.monotonic() + 20
+        while True:
+            with contextlib.closing(ra.connect()) as conn:
+                seen = [r[0] for r in conn.execute("SELECT event FROM remote_admin_audit ORDER BY id")]
+            if seen.count("session_end") >= 2 or time.monotonic() > deadline:
+                break
+            time.sleep(0.1)
         assert seen.count("session_start") == 2 and seen.count("session_end") == 2, seen
         assert "device_approved" in seen and "refused" in seen
     finally:

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/tests/test_reservation_handoff.py

@@ -122,6 +122,31 @@ class HandoffTests(unittest.TestCase):
             self.assertEqual(self._wait_log(2), ["reset"])
 
 
+class HostReservationStartTests(unittest.TestCase):
+    def test_start_is_sent_once_for_a_new_holder_only(self):
+        sent = []
+
+        class Registry:
+            def send_control(self, host_id, *, kind, device_id, payload):
+                sent.append((host_id, kind, device_id, payload))
+                return True
+
+        device_manager._devices[GID] = device_manager._DeviceState(
+            dev=device_manager.VirtualDevice(GID, "host-1", "d1"), origin="host", online=True,
+            salt="", hsh="", name="dev", ident="X", dtype="adalm_pluto",
+        )
+        self.addCleanup(device_manager._devices.pop, GID, None)
+        with patch.object(device_manager, "_sync_host_devices"), patch.object(
+            device_manager, "_reservation_end_callbacks", []
+        ), patch.object(device_manager.hts, "get_tunnel_registry", return_value=Registry()):
+            device_manager.set_device(GID, "s1", "h1")
+            device_manager.set_device(GID, "s1", "h1")
+            device_manager.set_device(GID, "", "")
+
+        self.assertEqual(len(sent), 1)
+        self.assertEqual(sent[0][:3], ("host-1", "reservation_start", "d1"))
+        self.assertEqual(set(sent[0][3]), {"at"})
+
 
 if __name__ == "__main__":
     unittest.main()

remoterf_server-1.7.4/tests/test_rpc_manager_host_legacy.py

@@ -0,0 +1,49 @@
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+sys.modules.setdefault("adi", types.ModuleType("adi"))
+
+from remoteRF_server.common.utils.process_arg import map_arg, unmap_arg
+from remoteRF_server.server import rpc_manager as rpc_module
+from remoteRF_server.server.device_manager import VirtualDevice
+from remoteRF_server.server.rpc_manager import RpcManager
+
+
+class HostLegacyTests(unittest.TestCase):
+    def test_failure_becomes_client_error_and_uses_25_second_timeout(self):
+        calls = []
+
+        def forward(registry, **kwargs):
+            calls.append(kwargs)
+            return {"Ok": map_arg(False)}
+
+        device = VirtualDevice(gid=5, host_id="host-1", device_id="d1", kind="fake")
+        with patch.object(rpc_module.hts, "handle_host_device", forward), patch.object(
+            rpc_module.hts, "get_tunnel_registry", return_value=None
+        ):
+            result = RpcManager()._dispatch_acquired(
+                function_name="Fake:gain:SET", args={"gain": map_arg(1)}, gid=5, dev=device
+            )
+
+        self.assertEqual(calls[0]["timeout_sec"], 25.0)
+        self.assertEqual(
+            unmap_arg(result["a"]),
+            "The device did not answer in time; it may still be powering on. Try again.",
+        )
+
+    def test_host_error_text_becomes_client_error(self):
+        device = VirtualDevice(gid=5, host_id="host-1", device_id="d1", kind="fake")
+        with patch.object(
+            rpc_module.hts, "handle_host_device",
+            return_value={"Error": map_arg("host failed")},
+        ), patch.object(rpc_module.hts, "get_tunnel_registry", return_value=None):
+            result = RpcManager()._dispatch_acquired(
+                function_name="Fake:gain:GET", args={}, gid=5, dev=device
+            )
+        self.assertEqual(unmap_arg(result["a"]), "host failed")
+
+
+if __name__ == "__main__":
+    unittest.main()

{remoterf_server-1.7.0 → remoterf_server-1.7.4}/tests/test_rpc_manager_rx_n.py

@@ -86,7 +86,7 @@ class RxNTests(unittest.TestCase):
             sent.append(None)
             sent.append(None)  # the next host rx answers with an Error first
             first_error = rx_n(dev, 4, gid=5)
-        self.assertEqual(unmap_arg(first_error["Error"]), "host overflow")
+        self.assertEqual(unmap_arg(first_error["a"]), "host overflow")
 
 
 if __name__ == "__main__":