RemoteRF 2.5.0__tar.gz → 2.5.1__tar.gz

{remoterf-2.5.0/src/remoterf.egg-info → remoterf-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.5.0
+Version: 2.5.1
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
 Author-email: Ethan Ge <ethoGalaxy@gmail.com>
 License-Expression: GPL-3.0-or-later

{remoterf-2.5.0 → remoterf-2.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.5.0"
+version = "2.5.1"
 description = "A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{remoterf-2.5.0 → remoterf-2.5.1}/src/remoterf/core/direct_path.py

@@ -691,17 +691,25 @@ _partners: dict[str, DirectPath] = {}  # device token -> the path to the lab tha
 _partner_owners: dict[str, str] = {}  # device token -> owner deployment id
 
 
-def _offer_rpc(username: str, secret: str, token: Optional[str] = None) -> Callable[[dict], dict]:
-    """The offer RPC; with ``token`` the home has the partner lab answer instead."""
+def _offer_rpc(username: Optional[str], secret: Optional[str], token: Optional[str] = None) -> Callable[[dict], dict]:
+    """The offer RPC; with ``token`` the home has the partner lab answer instead.
+
+    Without a login (``username`` None) the partner token alone authorizes it."""
     def send(offer: dict) -> dict:
         from .grpc_client import rpc_client
 
-        args = {"un": map_arg(username), "pw": map_arg(secret), "ice": map_arg(json.dumps(offer))}
+        args = {"ice": map_arg(json.dumps(offer))}
+        if username is not None:
+            args.update(un=map_arg(username), pw=map_arg(secret))
         if token is not None:
             args["a"] = map_arg(token)
         response = rpc_client(function_name="ACC:direct_offer", args=args)
         if "ace" in response.results:
-            raise PathError(unmap_arg(response.results["ace"]))
+            reason = unmap_arg(response.results["ace"])
+            if username is None and reason.startswith("Internal server error"):
+                # A home Server that predates token offers fails on the missing login.
+                raise PathUnavailable("the home's Server needs a login for a direct path")
+            raise PathError(reason)
         answer = json.loads(unmap_arg(response.results["ice"]))
         for key in ("server_name", "ca_pem"):
             if key in response.results:
@@ -811,12 +819,18 @@ def _side_path(key: str, make: Callable[[], Optional[DirectPath]]) -> Optional[D
 def _partner(token: str) -> Optional[DirectPath]:
     """The path to the lab owning the device behind ``token``, punched on first use."""
     def make() -> Optional[DirectPath]:
+        owner = _partner_owners.get(token)
         credentials = _credentials()
         if credentials is None:
-            return None
+            # No login (a token-only script): the token is its own credential.
+            # Its own memo, so an old home refusing it cannot hold back a
+            # logged-in process's path to the same lab.
+            return DirectPath(
+                offer=_offer_rpc(None, None, token=token), server_name="", ca_pem=b"",
+                memo=owner and f"{owner}|token",
+            )
         return DirectPath(
-            offer=_offer_rpc(*credentials, token=token), server_name="", ca_pem=b"",
-            memo=_partner_owners.get(token),
+            offer=_offer_rpc(*credentials, token=token), server_name="", ca_pem=b"", memo=owner,
         )
 
     return _side_path(token, make)
@@ -890,18 +904,27 @@ def describe() -> str:
         return f"relay (direct path unavailable: {_BROKEN}; fix: pip install --force-reinstall remoterf)"
     if not enabled():
         return "relay (direct path disabled: REMOTERF_DIRECT=0)"
+    partners = "; ".join(
+        f"partner {_partner_owners[key]}: "
+        + (path.describe() if path.ready else path.describe().replace("relay", "via HOME", 1))
+        for key, path in list(_partners.items()) if key in _partner_owners
+    )
     path = _path
     if path is not None:
-        return path.describe()
-    try:
-        from .grpc_client import _current_profile
-
-        route = _active_route(_current_profile())
-    except Exception:  # noqa: BLE001 - not configured, no home: nothing to add
-        route = None
-    if route is None or route["kind"] == "relay":
-        return "relay (direct path off)"
-    return "LAN (direct)" if route["kind"] == "lan" else str(route["kind"])
+        home = path.describe()
+    else:
+        try:
+            from .grpc_client import _current_profile
+
+            route = _active_route(_current_profile())
+        except Exception:  # noqa: BLE001 - not configured, no home: nothing to add
+            route = None
+        if route is None or route["kind"] == "relay":
+            if partners:  # the home path is not what these device calls take
+                return partners
+            return "relay (direct path off)"
+        home = "LAN (direct)" if route["kind"] == "lan" else str(route["kind"])
+    return f"{home}; {partners}" if partners else home
 
 
 def stop() -> None:

{remoterf-2.5.0 → remoterf-2.5.1/src/remoterf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.5.0
+Version: 2.5.1
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
 Author-email: Ethan Ge <ethoGalaxy@gmail.com>
 License-Expression: GPL-3.0-or-later

{remoterf-2.5.0 → remoterf-2.5.1}/tests/test_direct_path_partner.py

@@ -51,6 +51,9 @@ def setup_function(function):
     FakePath.instances.clear()
 
 
+teardown_function = setup_function  # no fake path outlives its test
+
+
 def test_a_marked_token_gets_its_own_path_and_other_tokens_do_not(monkeypatch):
     monkeypatch.setenv("REMOTERF_DIRECT", "1")
     monkeypatch.setattr(direct_path, "DirectPath", FakePath)
@@ -105,21 +108,80 @@ def test_rpc_client_routes_by_the_token_the_call_carries(monkeypatch):
     assert routed[-1] is None  # only a string token can name a partner path
 
 
-def test_no_login_means_no_partner_path_and_disabled_means_none(monkeypatch):
+def test_no_login_offers_with_the_token_alone_and_disabled_means_none(monkeypatch):
     monkeypatch.setattr(direct_path, "DirectPath", FakePath)
     monkeypatch.setattr(direct_path, "_from_stored_login", lambda: None)
     monkeypatch.setattr(direct_path, "_stored_login", lambda: None)
     direct_path._login = None
     monkeypatch.setenv("REMOTERF_DIRECT", "1")
     direct_path.mark_partner("tok", "owner-uuid")
-    assert direct_path.current(token="tok") is None and FakePath.instances == []  # nothing to log in with
+    path = direct_path.current(token="tok")
+    assert path is FakePath.instances[0] and path.memo == "owner-uuid|token"  # its own memo scope
+    seen = {}
+
+    def fake_rpc(*, function_name, args, connection=None):
+        seen.update(function_name=function_name, args={k: unmap_arg(v) for k, v in args.items()})
+        return grpc_pb2.GenericRPCResponse(results={"ice": map_arg("{}")})
+
+    monkeypatch.setattr(grpc_client, "rpc_client", fake_rpc)
+    path.offer({"id": "x"})
+    assert seen["function_name"] == "ACC:direct_offer" and sorted(seen["args"]) == ["a", "ice"]
+    assert seen["args"]["a"] == "tok"
+    direct_path.stop()
     direct_path._login = ("alice", "secret")
-    assert direct_path.current(token="tok") is FakePath.instances[0]
+    assert direct_path.current(token="tok").memo == "owner-uuid"  # a login signs as before
     monkeypatch.setenv("REMOTERF_DIRECT", "0")
     assert direct_path.current(token="tok") is None  # disabled: nothing, however marked
     direct_path._login = None
 
 
+def test_an_old_home_refusing_a_token_offer_means_no_direct_path(monkeypatch):
+    replies = []
+    monkeypatch.setattr(grpc_client, "rpc_client", lambda **k: grpc_pb2.GenericRPCResponse(
+        results={"ace": map_arg(replies.pop())}))
+    send = direct_path._offer_rpc(None, None, token="tok")
+    # A Server older than token offers fails reading the missing login.
+    replies.append("Internal server error; please try again or contact your instructor.")
+    try:
+        send({})
+    except direct_path.PathUnavailable as exc:
+        assert "needs a login" in str(exc)
+    else:
+        raise AssertionError("an old home must stop the path")
+    replies.append("That reservation is not active now.")  # a new home's refusal: retried later
+    try:
+        send({})
+    except direct_path.PathError as exc:
+        assert not isinstance(exc, direct_path.PathUnavailable)
+    else:
+        raise AssertionError("a refusal is no answer")
+
+
+def test_describe_reports_partner_paths(monkeypatch):
+    monkeypatch.setattr(direct_path, "DirectPath", FakePath)
+    monkeypatch.setattr(direct_path, "_from_stored_login", lambda: None)
+    monkeypatch.setattr(grpc_client, "_current_profile", lambda: None)
+    monkeypatch.setattr(direct_path, "_active_route", lambda profile: None)
+    monkeypatch.setattr(direct_path, "_credentials", lambda: None)
+    monkeypatch.setenv("REMOTERF_DIRECT", "1")
+    assert direct_path.describe() == "relay (direct path off)"  # nothing partnered yet
+    direct_path.mark_partner("tok", "lab-b")
+    path = direct_path.current(token="tok")
+    path.describe = lambda: "direct 192.0.2.7:4433 (3 calls)"
+    assert direct_path.describe() == "partner lab-b: direct 192.0.2.7:4433 (3 calls)"
+    path.state = "down"
+    path.describe = lambda: "relay (direct path down: timed out; retrying)"
+    assert direct_path.describe() == "partner lab-b: via HOME (direct path down: timed out; retrying)"
+    direct_path._path = home = FakePath(offer=None, server_name="", ca_pem=b"")
+    home.describe = lambda: "direct 192.0.2.1:4433"
+    assert direct_path.describe() == (
+        "direct 192.0.2.1:4433; partner lab-b: via HOME (direct path down: timed out; retrying)"
+    )
+    direct_path._path = None
+    monkeypatch.setattr(direct_path, "_active_route", lambda profile: {"kind": "lan"})
+    assert direct_path.describe().startswith("LAN (direct); partner lab-b: via HOME")
+
+
 def test_a_partner_path_that_is_down_sends_the_call_to_the_home(monkeypatch):
     monkeypatch.setattr(direct_path, "DirectPath", FakePath)
     direct_path._login = ("alice", "secret")