remoteRF-server 1.0.3__tar.gz → 1.0.4__tar.gz

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/PKG-INFO

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

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/pyproject.toml

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

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/src/remoteRF_server/common/idl/schema.py

@@ -6,7 +6,7 @@ Admin writes one .py per device TYPE, drops it in ~/.config/remoterf/drivers/,
 and the server auto-discovers it on startup via load_drivers().
 
     ~/.config/remoterf/
-        devices.env                 ← "I have 3 plutos at these serials"
+        devices.yml                 ← "I have 3 devices at these serials"
         drivers/
             pluto_schema.py         ← "here's what a pluto IS"
             hackrf_schema.py
@@ -531,7 +531,7 @@ class DeviceSchema:
     Base for all device schemas.  Admin subclasses this once per device type.
 
     Class attributes (admin sets these):
-        device_type      str   — must match the TYPE in devices.env
+        device_type      str   — must match device_type in devices.yml
         driver_version   str   — semver
 
     Admin implements:

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/src/remoteRF_server/server/device_manager.py

@@ -314,6 +314,11 @@ def _load_device_records() -> Dict[int, Dict[str, str]]:
 def _connect_from_record(rec: Dict[str, Any]):
     """Returns (schema_instance_or_None, ident, dtype)."""
     dtype = (rec.get("TYPE") or "").strip().lower()
+    # Older serverrf builds serialized the --pluto shorthand as "pluto",
+    # while the packaged schema has always registered as "adalm_pluto".
+    # Keep those inventories usable while all new writes use the canonical type.
+    if dtype == "pluto":
+        dtype = "adalm_pluto"
     ident = (rec.get("IDENT") or "").strip()
     init_kwargs = rec.get("INIT") or {}
 
@@ -873,7 +878,7 @@ def acquire_device(api_token: str) -> Iterator[Tuple[int, object]]:
 
 def reload_devices() -> None:
     """
-    Reload devices.env and reconnect local devices.
+    Reload devices.yml and reconnect local devices.
     Preserves existing salt/hash for devices that remain (same gid),
     and preserves host virtual devices + their auth state.
     """

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/src/remoteRF_server/server/grpc_server.py

@@ -214,6 +214,18 @@ def _load_server_credentials(cert_dir: Path):
     )
 
 
+def _print_tls_credentials_error(cert_dir: Path, error: Exception) -> None:
+    messages = (
+        "TLS certs/keys not found or unreadable.",
+        f"Expected in: {cert_dir}",
+        f"Fix: run serverrf --gen-certs {local_ip} --force",
+        "Or set REMOTERF_CERT_DIR to your cert folder.",
+        f"Details: {error}",
+    )
+    for message in messages:
+        printf(message, Sty.MAGENTA)
+
+
 def start_server_runtime(
     *,
     bind_host: str | None = None,
@@ -258,11 +270,7 @@ def start_server_runtime(
     try:
         server_credentials = _load_server_credentials(cert_dir)
     except Exception as e:
-        printf("TLS certs/keys not found or unreadable.", Sty.RED)
-        printf("Expected in: ", Sty.DEFAULT, f"{cert_dir}", Sty.MAGENTA)
-        printf("Fix: run ", Sty.DEFAULT, "RRRFcerts --ip ", Sty.GREEN, f"{local_ip}", Sty.MAGENTA, " --force", Sty.DEFAULT)
-        printf("Or set REMOTERF_CERT_DIR to your cert folder.", Sty.GRAY)
-        print(f"\nDetails: {e}\n", file=sys.stderr)
+        _print_tls_credentials_error(cert_dir, e)
         raise SystemExit(2)
 
     if include_host_tunnel:

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/src/remoteRF_server/serverrf_cli.py

@@ -135,7 +135,7 @@ def _server_env_path() -> Path:
 
 
 def _devices_env_path() -> Path:
-    # Legacy mirror retained for older tooling.
+    # Read-only migration source for pre-YAML installations.
     return _cfg_dir() / "devices.env"
 
 
@@ -156,11 +156,11 @@ def _gen_certs_path() -> Path:
     return (_repo_root() / "tools" / "gen_certs.py").resolve()
 
 def _gist_env_path() -> Path:
-    # Stored alongside server.env/devices.env under ~/.config/remoterf by default
+    # Stored alongside server.env/devices.yml under ~/.config/remoterf by default
     return _cfg_dir() / "gist.env"
 
 def _tos_ack_path() -> Path:
-    # Stored alongside server.env/devices.env under ~/.config/remoterf by default
+    # Stored alongside server.env/devices.yml under ~/.config/remoterf by default
     return _cfg_dir() / "tos.env"
 
 
@@ -262,6 +262,7 @@ def print_help() -> None:
         "\n"
         "Devices:\n"
         "  serverrf -d | --device [options]\n"
+        "  Inventory: ~/.config/remoterf/devices.yml (canonical YAML)\n"
         "\n"
         "Device options:\n"
         "  --add --pluto <id:name:iio_serial>  Add an ADALM-Pluto\n"
@@ -811,7 +812,11 @@ def _read_device_records() -> Dict[int, Dict[str, Any]]:
                 recs[gid] = {
                     "TYPE": dtype,
                     "NAME": str(item.get("name") or f"device-{gid}").strip(),
-                    "IDENT_KIND": "iio_serial" if dtype == "pluto" else "serial",
+                    "IDENT_KIND": (
+                        "iio_serial"
+                        if dtype in {"pluto", "adalm_pluto"}
+                        else "serial"
+                    ),
                     "IDENT": ident,
                     "INIT": dict(init),
                 }
@@ -833,7 +838,6 @@ def _read_device_records() -> Dict[int, Dict[str, Any]]:
 
 def _write_device_records(recs: Dict[int, Dict[str, Any]]) -> None:
     devices: List[Dict[str, Any]] = []
-    out: Dict[str, str] = {}
     for gid in sorted(recs.keys()):
         fields = recs[gid]
         dtype = str(fields.get("TYPE") or "").strip().lower()
@@ -852,22 +856,14 @@ def _write_device_records(recs: Dict[int, Dict[str, Any]]) -> None:
                 "init": init,
             }
         )
-        order = ["TYPE", "NAME", "IDENT_KIND", "IDENT"]
-        for f in order:
-            if f in fields and fields[f] != "":
-                out[f"DEVICE_{gid}_{f}"] = str(fields[f])
-        for f in sorted(fields.keys()):
-            if f in order or f == "INIT":
-                continue
-            if fields[f] != "":
-                out[f"DEVICE_{gid}_{f}"] = str(fields[f])
     _cfg_dir().mkdir(parents=True, exist_ok=True)
     _devices_yaml_path().write_text(
         yaml.safe_dump({"devices": devices}, sort_keys=False),
         encoding="utf-8",
     )
-    # Maintain the original env representation for older CLI consumers.
-    _write_env_kv(_devices_env_path(), out)
+    # Once a legacy inventory has been migrated successfully, remove it so
+    # there is exactly one authoritative device manifest.
+    _devices_env_path().unlink(missing_ok=True)
 
 
 def _device_add_pluto(spec: str) -> int:
@@ -894,14 +890,14 @@ def _device_add_pluto(spec: str) -> int:
             return 2
 
     recs[gid] = {
-        "TYPE": "pluto",
+        "TYPE": "adalm_pluto",
         "NAME": name,
         "IDENT_KIND": "iio_serial",
         "IDENT": iio_serial,
     }
     _write_device_records(recs)
 
-    print(f"Added device: {gid} type=pluto name={name} iio_serial={iio_serial}")
+    print(f"Added device: {gid} type=adalm_pluto name={name} iio_serial={iio_serial}")
     return 0
 
 

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/src/remoteRF_server.egg-info/PKG-INFO

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

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/tests/test_cert_provider.py

@@ -59,6 +59,30 @@ class CertificateProviderTests(unittest.TestCase):
         self.assertEqual(served, ca_pem)
         self.assertNotEqual(served, leaf_pem)
 
+    def test_missing_tls_guidance_is_visible_and_uses_serverrf(self):
+        from remoteRF_server.server import grpc_server
+
+        cert_dir = Path("/tmp/remoterf-test-certs")
+        error = FileNotFoundError("missing server.key")
+        with patch.object(grpc_server, "printf") as mock_printf:
+            grpc_server._print_tls_credentials_error(cert_dir, error)
+
+        rendered = [call.args for call in mock_printf.call_args_list]
+        self.assertEqual(
+            [message for message, _style in rendered],
+            [
+                "TLS certs/keys not found or unreadable.",
+                f"Expected in: {cert_dir}",
+                f"Fix: run serverrf --gen-certs {grpc_server.local_ip} --force",
+                "Or set REMOTERF_CERT_DIR to your cert folder.",
+                "Details: missing server.key",
+            ],
+        )
+        self.assertTrue(
+            all(style is grpc_server.Sty.MAGENTA for _message, style in rendered)
+        )
+        self.assertNotIn("RRRFcerts", "\n".join(message for message, _style in rendered))
+
 
 if __name__ == "__main__":
     unittest.main()

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/tests/test_dynamic_v2.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from unittest.mock import patch
 
 import numpy as np
+import yaml
 
 from remoteRF_server import serverrf_cli
 from remoteRF_server.common.grpc import grpc_pb2
@@ -875,7 +876,7 @@ class DynamicV2ServerTests(unittest.TestCase):
                 entry.active_operation = ""
             manager.close_all()
 
-    def test_usrp_cli_writes_runtime_yaml_inventory_and_legacy_mirror(self):
+    def test_usrp_cli_writes_only_canonical_yaml_inventory(self):
         with tempfile.TemporaryDirectory() as tmp:
             with patch.dict(
                 os.environ,
@@ -894,7 +895,72 @@ class DynamicV2ServerTests(unittest.TestCase):
                 records = serverrf_cli._read_device_records()
                 self.assertEqual(records[7]["TYPE"], "usrp")
                 self.assertEqual(records[7]["IDENT"], "31A2B3C")
-                self.assertTrue(Path(tmp, "devices.env").exists())
+                self.assertFalse(Path(tmp, "devices.env").exists())
+
+    def test_pluto_cli_uses_registered_adalm_pluto_device_type(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch.dict(
+                os.environ,
+                {"REMOTERF_CONFIG_DIR": tmp},
+                clear=False,
+            ):
+                self.assertEqual(
+                    serverrf_cli._device_add_pluto("1:Pluto A:104473f6"),
+                    0,
+                )
+                inventory = Path(tmp, "devices.yml")
+                text = inventory.read_text(encoding="utf-8")
+                self.assertIn("device_type: adalm_pluto", text)
+                self.assertIn("serial: 104473f6", text)
+                records = serverrf_cli._read_device_records()
+                self.assertEqual(records[1]["TYPE"], "adalm_pluto")
+                self.assertEqual(records[1]["IDENT"], "104473f6")
+                self.assertEqual(records[1]["IDENT_KIND"], "iio_serial")
+                self.assertFalse(Path(tmp, "devices.env").exists())
+
+    def test_device_cli_migrates_legacy_env_inventory_to_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch.dict(
+                os.environ,
+                {"REMOTERF_CONFIG_DIR": tmp},
+                clear=False,
+            ):
+                Path(tmp, "devices.env").write_text(
+                    "DEVICE_1_TYPE=adalm_pluto\n"
+                    "DEVICE_1_NAME=Pluto A\n"
+                    "DEVICE_1_IDENT_KIND=iio_serial\n"
+                    "DEVICE_1_IDENT=104473f6\n",
+                    encoding="utf-8",
+                )
+
+                self.assertEqual(
+                    serverrf_cli._device_add_usrp("7:lab_usrp:31A2B3C"),
+                    0,
+                )
+
+                inventory = yaml.safe_load(
+                    Path(tmp, "devices.yml").read_text(encoding="utf-8")
+                )
+                self.assertEqual(
+                    inventory,
+                    {
+                        "devices": [
+                            {
+                                "device_id": 1,
+                                "device_type": "adalm_pluto",
+                                "name": "Pluto A",
+                                "init": {"serial": "104473f6"},
+                            },
+                            {
+                                "device_id": 7,
+                                "device_type": "usrp",
+                                "name": "lab_usrp",
+                                "init": {"serial": "31A2B3C"},
+                            },
+                        ]
+                    },
+                )
+                self.assertFalse(Path(tmp, "devices.env").exists())
 
     def test_server_cli_exposes_headless_runtime(self):
         with (

{remoterf_server-1.0.3 → remoterf_server-1.0.4}/tests/test_pluto_compat.py

@@ -12,6 +12,7 @@ sys.modules.setdefault("adi", types.ModuleType("adi"))
 from remoteRF_server.common.idl.pluto_schema import PlutoSchema
 from remoteRF_server.common.utils import map_arg, unmap_arg
 from remoteRF_server.drivers.adalm_pluto.pluto_remote_server import PlutoServer
+from remoteRF_server.server import device_manager
 
 
 class FakePluto:
@@ -79,6 +80,20 @@ class PlutoCompatTests(unittest.TestCase):
         self.assertIsNone(schema.dispatch("call_tx", {"value": samples}))
         np.testing.assert_allclose(self.device.tx_samples, samples)
 
+    def test_legacy_pluto_inventory_type_resolves_to_packaged_schema(self) -> None:
+        with patch.object(PlutoSchema, "make_device", return_value=self.device):
+            schema, ident, dtype = device_manager._connect_from_record(
+                {
+                    "TYPE": "pluto",
+                    "IDENT": "104473f6",
+                    "INIT": {"serial": "104473f6"},
+                }
+            )
+
+        self.assertIsInstance(schema, PlutoSchema)
+        self.assertEqual(ident, "104473f6")
+        self.assertEqual(dtype, "adalm_pluto")
+
 
 if __name__ == "__main__":
     unittest.main()