remoteRF-server-testing 0.0.5__tar.gz → 0.0.6__tar.gz

{remoterf_server_testing-0.0.5 → remoterf_server_testing-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server-testing
-Version: 0.0.5
+Version: 0.0.6
 Summary: RemoteRF server-side control package
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

{remoterf_server_testing-0.0.5 → remoterf_server_testing-0.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server-testing"
-version = "0.0.5"
+version = "0.0.6"
 description = "RemoteRF server-side control package"
 requires-python = ">=3.8"
 dependencies = [

{remoterf_server_testing-0.0.5 → remoterf_server_testing-0.0.6}/src/remoteRF_server/server/rpc_manager.py

@@ -55,6 +55,11 @@ from ..common.utils import *
 from .device_manager import acquire_device, VirtualDevice, get_device_schema, find_device_id_by_name, get_schema_by_token, resolve_gid_for_token
 from ..host import host_tunnel_server as hts
 
+
+def _normalize_device_rpc_type(value: str) -> str:
+    return "".join(ch for ch in str(value or "").lower() if ch.isalnum())
+
+
 class RpcManager:
     def __init__(self):
         self.debug = False
@@ -62,60 +67,6 @@ class RpcManager:
     def run_rpc(self, *, function_name, args) -> map:
         fn_type = function_name.split(':', 1)[0]
 
-        if fn_type == "Pluto":
-            if 'a' not in args:
-                return {'a': map_arg('No token provided')}
-
-            api_token = unmap_arg(args['a'])
-
-            try:
-                with acquire_device(api_token) as (gid, dev):
-
-                    if isinstance(dev, VirtualDevice):
-                        fwd_args = dict(args)
-                        fwd_args.pop('a', None)
-                        fwd_args['g'] = map_arg(int(gid))
-                        return 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,
-                        )
-
-                    # Schema-based local dispatch.
-                    # Wire format: "Pluto:{prop}:{verb}"  verb = GET | SET | CALL0 | CALL1
-                    parts = function_name.split(':')
-                    prop = parts[1]
-                    verb = parts[2] if len(parts) > 2 else ""
-
-                    if verb == "GET":
-                        result = dev.dispatch(f"get_{prop}", {})
-                        return {prop: map_arg(result)}
-
-                    elif verb == "SET":
-                        value = unmap_arg(args[prop])
-                        dev.dispatch(f"set_{prop}", {"value": value})
-                        return {}
-
-                    elif verb == "CALL0":
-                        result = dev.dispatch(f"call_{prop}", {})
-                        return {prop: map_arg(result)} if result is not None else {prop: map_arg('None')}
-
-                    elif verb == "CALL1":
-                        if 'arg1' not in args:
-                            raise ValueError("CALL1 requires 'arg1' in args")
-                        value = unmap_arg(args['arg1'])
-                        result = dev.dispatch(f"call_{prop}", {"value": value})
-                        return {prop: map_arg(result)} if result is not None else {prop: map_arg('None')}
-
-                    else:
-                        raise ValueError(f"Unknown verb {verb!r} in {function_name!r}")
-
-            except Exception as e:
-                return {'a': map_arg(str(e))}
-
         if fn_type == "IDL":
             return self._handle_idl(function_name.split(':', 1)[1], args)
 
@@ -125,10 +76,111 @@ class RpcManager:
         if function_name == "echo":
             return args
 
+        if self._looks_like_device_rpc(function_name):
+            return self._handle_device_rpc(function_name=function_name, args=args)
+
         return {'a': map_arg(f'Unknown RPC: {function_name}')}
 
     # ── IDL control-plane ────────────────────────────────────────────
 
+    def _looks_like_device_rpc(self, function_name: str) -> bool:
+        parts = function_name.split(':', 2)
+        return len(parts) == 3 and all(parts)
+
+    def _handle_device_rpc(self, *, function_name: str, args: dict) -> dict:
+        if 'a' not in args:
+            return {'a': map_arg('No token provided')}
+
+        api_token = unmap_arg(args['a'])
+
+        try:
+            with acquire_device(api_token) as (gid, dev):
+                self._validate_device_rpc_type(function_name=function_name, gid=gid, dev=dev)
+
+                if self._should_use_builtin_ip_fallback(function_name=function_name, gid=gid, dev=dev):
+                    return {"ip": map_arg(self._builtin_ip_fallback(gid=gid, dev=dev))}
+
+                if isinstance(dev, VirtualDevice):
+                    fwd_args = dict(args)
+                    fwd_args.pop('a', None)
+                    fwd_args['g'] = map_arg(int(gid))
+                    return 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,
+                    )
+
+                return self._dispatch_local_schema(function_name=function_name, args=args, dev=dev)
+
+        except Exception as e:
+            return {'a': map_arg(str(e))}
+
+    def _validate_device_rpc_type(self, *, function_name: str, gid: int, dev: object) -> None:
+        requested_type = function_name.split(':', 1)[0]
+        actual_type = self._resolve_device_type(gid=gid, dev=dev)
+
+        if not actual_type:
+            return
+
+        if _normalize_device_rpc_type(requested_type) != _normalize_device_rpc_type(actual_type):
+            raise ValueError(
+                f"RPC device type {requested_type!r} does not match reserved device type {actual_type!r}"
+            )
+
+    def _should_use_builtin_ip_fallback(self, *, function_name: str, gid: int, dev: object) -> bool:
+        _, prop, verb = function_name.split(':', 2)
+        if prop != "ip" or verb != "CALL0":
+            return False
+
+        schema = dev if hasattr(dev, "list_exposed") else get_device_schema(gid)
+        if schema is None or not hasattr(schema, "list_exposed"):
+            return True
+
+        calls = schema.list_exposed().get("calls", [])
+        return "call_ip" not in calls
+
+    def _builtin_ip_fallback(self, *, gid: int, dev: object) -> str:
+        actual_type = self._resolve_device_type(gid=gid, dev=dev) or "device"
+        return f"{actual_type}:{int(gid)}"
+
+    def _resolve_device_type(self, *, gid: int, dev: object) -> str:
+        for candidate in (getattr(dev, "device_type", None), getattr(dev, "kind", None)):
+            if candidate:
+                return str(candidate)
+
+        schema = get_device_schema(gid)
+        if schema is None:
+            return ""
+        return str(getattr(schema, "device_type", "") or "")
+
+    def _dispatch_local_schema(self, *, function_name: str, args: dict, dev: object) -> dict:
+        _, prop, verb = function_name.split(':', 2)
+
+        if verb == "GET":
+            result = dev.dispatch(f"get_{prop}", {})
+            return {prop: map_arg(result)}
+
+        if verb == "SET":
+            value = unmap_arg(args[prop])
+            dev.dispatch(f"set_{prop}", {"value": value})
+            return {}
+
+        if verb == "CALL0":
+            result = dev.dispatch(f"call_{prop}", {})
+            return {prop: map_arg(result)} if result is not None else {prop: map_arg('None')}
+
+        if verb == "CALL1":
+            if 'arg1' not in args:
+                raise ValueError("CALL1 requires 'arg1' in args")
+            value = unmap_arg(args['arg1'])
+            result = dev.dispatch(f"call_{prop}", {"value": value})
+            return {prop: map_arg(result)} if result is not None else {prop: map_arg('None')}
+
+        raise ValueError(f"Unknown verb {verb!r} in {function_name!r}")
+
     def _handle_idl(self, sub: str, args: dict) -> dict:
         """
         IDL:get_drivers  →  schema + driver metadata for a device.
@@ -190,4 +242,4 @@ class RpcManager:
 
         return {'error': map_arg(f'Unknown IDL call: {sub!r}')}
 
-rpc_manager = RpcManager()
+rpc_manager = RpcManager()

{remoterf_server_testing-0.0.5 → remoterf_server_testing-0.0.6}/src/remoteRF_server_testing.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server-testing
-Version: 0.0.5
+Version: 0.0.6
 Summary: RemoteRF server-side control package
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

{remoterf_server_testing-0.0.5 → remoterf_server_testing-0.0.6}/src/remoteRF_server_testing.egg-info/SOURCES.txt

@@ -44,4 +44,5 @@ src/remoteRF_server_testing.egg-info/SOURCES.txt
 src/remoteRF_server_testing.egg-info/dependency_links.txt
 src/remoteRF_server_testing.egg-info/entry_points.txt
 src/remoteRF_server_testing.egg-info/requires.txt
-src/remoteRF_server_testing.egg-info/top_level.txt
+src/remoteRF_server_testing.egg-info/top_level.txt
+tests/test_rpc_manager.py

remoterf_server_testing-0.0.6/tests/test_rpc_manager.py

@@ -0,0 +1,166 @@
+from contextlib import contextmanager
+import importlib
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+
+def _install_rpc_manager_stubs():
+    reservation_mod = types.ModuleType("remoteRF_server.server.reservation")
+
+    class _ReservationHandler:
+        def handle_call(self, *, function_name, args):
+            return {"handled": (function_name, args)}
+
+    reservation_mod.reservation_handler = _ReservationHandler()
+    sys.modules["remoteRF_server.server.reservation"] = reservation_mod
+
+    utils_mod = types.ModuleType("remoteRF_server.common.utils")
+    utils_mod.map_arg = lambda value: value
+    utils_mod.unmap_arg = lambda value: value
+    sys.modules["remoteRF_server.common.utils"] = utils_mod
+
+    device_manager_mod = types.ModuleType("remoteRF_server.server.device_manager")
+
+    class VirtualDevice:
+        def __init__(self, *, gid, host_id, device_id, label="", serial="", kind=""):
+            self.gid = gid
+            self.host_id = host_id
+            self.device_id = device_id
+            self.label = label
+            self.serial = serial
+            self.kind = kind
+
+    @contextmanager
+    def acquire_device(_api_token):
+        raise NotImplementedError("patched per test")
+        yield
+
+    device_manager_mod.VirtualDevice = VirtualDevice
+    device_manager_mod.acquire_device = acquire_device
+    device_manager_mod.get_device_schema = lambda _gid: None
+    device_manager_mod.find_device_id_by_name = lambda _name: None
+    device_manager_mod.get_schema_by_token = lambda _token: None
+    device_manager_mod.resolve_gid_for_token = lambda _token: None
+    sys.modules["remoteRF_server.server.device_manager"] = device_manager_mod
+
+    host_tunnel_mod = types.ModuleType("remoteRF_server.host.host_tunnel_server")
+    host_tunnel_mod.get_tunnel_registry = lambda create=False: None
+    host_tunnel_mod.handle_host_device = lambda *args, **kwargs: {}
+    sys.modules["remoteRF_server.host.host_tunnel_server"] = host_tunnel_mod
+
+
+_install_rpc_manager_stubs()
+sys.modules.pop("remoteRF_server.server.rpc_manager", None)
+rpc_manager_module = importlib.import_module("remoteRF_server.server.rpc_manager")
+
+
+class _FakeSchemaDevice:
+    device_type = "hackrf"
+
+    def __init__(self):
+        self.calls = []
+
+    def dispatch(self, method_name, args):
+        self.calls.append((method_name, args))
+
+        if method_name == "call_get_serial_no":
+            return "SERIAL-123"
+
+        if method_name == "set_center_freq":
+            return None
+
+        raise AssertionError(f"Unexpected dispatch: {method_name} {args}")
+
+
+@contextmanager
+def _acquired_device(gid, dev):
+    yield gid, dev
+
+
+class RpcManagerDeviceDispatchTests(unittest.TestCase):
+    def setUp(self):
+        self.rpc = rpc_manager_module.RpcManager()
+
+    def test_routes_non_pluto_schema_call(self):
+        dev = _FakeSchemaDevice()
+
+        with patch.object(
+            rpc_manager_module,
+            "acquire_device",
+            return_value=_acquired_device(7, dev),
+        ):
+            result = self.rpc.run_rpc(
+                function_name="Hackrf:get_serial_no:CALL0",
+                args={"a": "token"},
+            )
+
+        self.assertEqual(result["get_serial_no"], "SERIAL-123")
+        self.assertEqual(dev.calls, [("call_get_serial_no", {})])
+
+    def test_rejects_mismatched_schema_namespace(self):
+        dev = _FakeSchemaDevice()
+
+        with patch.object(
+            rpc_manager_module,
+            "acquire_device",
+            return_value=_acquired_device(7, dev),
+        ):
+            result = self.rpc.run_rpc(
+                function_name="Pluto:get_serial_no:CALL0",
+                args={"a": "token"},
+            )
+
+        self.assertIn("does not match", result["a"])
+
+    def test_uses_builtin_ip_ping_for_schemas_without_call_ip(self):
+        dev = _FakeSchemaDevice()
+
+        with patch.object(
+            rpc_manager_module,
+            "acquire_device",
+            return_value=_acquired_device(7, dev),
+        ):
+            result = self.rpc.run_rpc(
+                function_name="Hackrf:ip:CALL0",
+                args={"a": "token"},
+            )
+
+        self.assertEqual(result["ip"], "hackrf:7")
+        self.assertEqual(dev.calls, [])
+
+    def test_forwards_host_devices_for_non_pluto_schema_calls(self):
+        dev = rpc_manager_module.VirtualDevice(
+            gid=9,
+            host_id="host-1",
+            device_id="9",
+            kind="hackrf",
+        )
+
+        with patch.object(
+            rpc_manager_module,
+            "acquire_device",
+            return_value=_acquired_device(9, dev),
+        ), patch.object(
+            rpc_manager_module.hts,
+            "get_tunnel_registry",
+            return_value=object(),
+        ), patch.object(
+            rpc_manager_module.hts,
+            "handle_host_device",
+            return_value={"get_serial_no": "HOST-SERIAL"},
+        ) as handle_host_device:
+            result = self.rpc.run_rpc(
+                function_name="Hackrf:get_serial_no:CALL0",
+                args={"a": "token"},
+            )
+
+        self.assertEqual(result["get_serial_no"], "HOST-SERIAL")
+        forwarded_args = handle_host_device.call_args.kwargs["args"]
+        self.assertNotIn("a", forwarded_args)
+        self.assertEqual(forwarded_args["g"], 9)
+
+
+if __name__ == "__main__":
+    unittest.main()