remoteRF-server 1.7.14__tar.gz → 1.7.16__tar.gz

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.7.14
+Version: 1.7.16
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3
@@ -10,7 +10,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: remoterf-federation-core==0.22.0
-Requires-Dist: remoterf-device-core==0.1.2
+Requires-Dist: remoterf-device-core==0.1.3
 Requires-Dist: grpcio<2.0.0,>=1.81.1
 Requires-Dist: protobuf<7.0.0,>=6.33.5
 Requires-Dist: numpy

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "1.7.14"
+version = "1.7.16"
 description = "RemoteRF server-side control package"
 license = { text = "GPL-3.0-or-later" }
 requires-python = ">=3.10"
 dependencies = [
     "remoterf-federation-core==0.22.0",
-    "remoterf-device-core==0.1.2",
+    "remoterf-device-core==0.1.3",
   "grpcio>=1.81.1,<2.0.0",
   "protobuf>=6.33.5,<7.0.0",
   "numpy",

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/src/remoteRF_server/remote_admin_shell.py

@@ -48,7 +48,7 @@ TIERS = {
     "reservations list": READ, "groups list": READ, "codes list": READ, "hosts status": READ,
     "hosts tokens": READ, "certs list": READ, "config list": READ, "global status": READ,
     "cluster list": READ, "cluster info": READ, "users prune-proxies": READ,
-    "cluster codes list": READ, "schema browse": READ,
+    "cluster codes list": READ, "schema browse": READ, "schema served": READ,
     # write
     "devices add": WRITE, "devices remove": WRITE, "devices rename": WRITE, "groups create": WRITE,
     "groups edit": WRITE, "groups public": WRITE, "groups share": WRITE, "codes create": WRITE,

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/src/remoteRF_server/server/commands.py

@@ -162,6 +162,7 @@ def _table() -> list[Command]:
         # ---- driver schemas approved on RemoteRF Global (server/schema_registry.py) ----
         Command(("schema browse",), "Driver schemas approved on RemoteRF Global: schema browse [text]", _lazy(".schema_registry", "cmd_browse"), "Schemas"),
         Command(("schema download",), "Save one to the drivers folder, hash checked: schema download <name|hash> [-y]", _lazy(".schema_registry", "cmd_download"), "Schemas"),
+        Command(("schema served",), "Which file serves a driver type, its hash, how each drivers file loaded: schema served <type> [--json]", _daemon("cmd_schema_served"), "Schemas", where=D),
         # ---- clusters (sharing devices with other deployments) ----
         Command(("cluster list",), "Clusters shared with other deployments", _federation("list"), "Clusters"),
         Command(("cluster info",), "Every deployment, shared group and device in a cluster", _federation("info"), "Clusters"),

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/src/remoteRF_server/server/device_manager.py

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import importlib
+import inspect
 import logging
 import os
 import re
@@ -35,7 +36,8 @@ from contextlib import contextmanager
 from remoterf_federation_core import is_device_handle
 
 from ..common.utils import validate_token, get_remoterf_root, get_drivers_dir, device_name_key
-from ..common.idl.schema import get_driver_class, load_drivers
+from ..common.idl.schema import (OVERRIDE_PREFIX, get_driver_class, last_load_results, load_drivers,
+                                 override_stale)
 from ..host import host_tunnel_server as hts
 
 logger = logging.getLogger(__name__)
@@ -1384,6 +1386,33 @@ def acquire_device_by_gid(gid: int) -> Iterator[Tuple[int, object]]:
         lock.release()
 
 
+def schema_served(device_type: str) -> Dict[str, Any]:
+    """`schema served <type>`: the file whose class serves a type now, its v1 hash, and how each drivers file loaded."""
+    out: Dict[str, Any] = {"type": device_type, "hash": None, "module": None, "override": False,
+                           "source_sha256": None, "loads": last_load_results()}
+    try:
+        cls = get_driver_class(device_type)
+        out["module"] = os.path.abspath(inspect.getfile(cls))
+    except (KeyError, TypeError):
+        return out
+    out["override"] = Path(out["module"]).name.startswith(OVERRIDE_PREFIX)
+    try:
+        out["hash"] = cls().get_idl_hash()
+    except Exception:
+        pass
+    try:
+        out["source_sha256"] = _driver_sha256(Path(out["module"]))
+    except OSError:
+        pass
+    return out
+
+
+def driver_overrides() -> List[Dict[str, Any]]:
+    """The @ops-rrf overrides in the drivers folder, stale ones included (they do not load)."""
+    return [{"type": f.stem[len(OVERRIDE_PREFIX):], "file": f.name, "stale": override_stale(f)}
+            for f in sorted(get_drivers_dir().glob(f"{OVERRIDE_PREFIX}*.py"))]
+
+
 def device_inventory_snapshot() -> Dict[int, Dict[str, object]]:
     """Structured inventory for federated discovery.
 

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/src/remoteRF_server/server/global_onboarding.py

@@ -64,7 +64,9 @@ deployments), what devices it has, how many reservations are active, how many
 reservations have been made and the total time reserved so far (two numbers),
 and your LAN address. For the devices you share on Global it also sends how
 many reservations start in each hour of the day and on each day of the week
-(UTC), and the reservations and time reserved per device type (counts only).
+(UTC), the reservations and time reserved per device type, and for each
+device shared on Global its name and its daily reservation counts and time
+reserved over the last 31 days (counts only).
 Nothing else leaves your server -- no credentials, no user or reservation
 details -- and the connection only goes outward. Global publishes the network
 totals, these breakdowns, and each deployment's name, version, devices, when
@@ -867,24 +869,41 @@ def _device_type(item: dict) -> str:
     return str(item.get("device_type") or "unknown").lower()
 
 
+def _host_devices() -> dict:
+    """Device id -> DeviceInfo from the Host directory `serverrf status` lists."""
+    try:
+        from ..host import host_tunnel_server as hts
+
+        directory = hts.get_tunnel_registry().device_directory_cached(ttl_ms=0)
+    except Exception:  # noqa: BLE001 - drivers are optional at report time
+        return {}
+    return {int(device_id): info for device_id, (_host_id, info, _active) in directory.items()
+            if str(device_id).isdigit()}
+
+
 def _device_types() -> dict:
     """Device id -> type: devices.yml entries, then the Host directory `serverrf status` lists.
 
     Types are bounded the way Global accepts them: a Host names its own kinds.
     """
     types = {int(item["device_id"]): _device_type(item) for item in _registered_devices()}
-    try:
-        from ..host import host_tunnel_server as hts
-
-        directory = hts.get_tunnel_registry().device_directory_cached(ttl_ms=0)
-    except Exception:  # noqa: BLE001 - drivers are optional at report time
-        directory = {}
-    for device_id, (_host_id, info, _active) in directory.items():
-        if str(device_id).isdigit():
-            types.setdefault(int(device_id), str(getattr(info, "kind", "") or "").strip().lower() or "unknown")
+    for device_id, info in _host_devices().items():
+        types.setdefault(device_id, str(getattr(info, "kind", "") or "").strip().lower() or "unknown")
     return {gid: re.sub(r"[^a-z0-9_]", "_", kind)[:64] for gid, kind in types.items()}
 
 
+def _device_names() -> dict:
+    """Device id -> the name the devices list shows: devices.yml, then the Host's label.
+
+    Printable and at most 64 characters, the way Global accepts them.
+    """
+    names = {int(item["device_id"]): item.get("name") for item in _registered_devices()}
+    for device_id, info in _host_devices().items():
+        names.setdefault(device_id, getattr(info, "label", ""))
+    return {gid: "".join(filter(str.isprintable, str(name or ""))).strip()[:64].rstrip() or f"device {gid}"
+            for gid, name in names.items()}
+
+
 def device_summary() -> list:
     """One entry per registered device: its type and whether it is connected.
 
@@ -901,13 +920,15 @@ def device_summary() -> list:
 
 def usage_summary() -> dict:
     """Reservations made on the devices shared on Global: by the UTC hour and
-    weekday they start, and reservations and seconds reserved per device type.
+    weekday they start, reservations and seconds reserved per device type, and
+    per device by the UTC day they start over the last 31 days.
 
-    Counts only (ReservationBuckets); all zero when nothing is shared there.
+    Counts only (ReservationBuckets, ReservationDays); all zero when nothing is shared there.
     """
+    from datetime import datetime, timedelta, timezone
     from .federation import cluster
 
-    usage = {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}}
+    usage = {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}, "by_device": []}
     try:
         shared = {int(d) for group in cluster.groups(cluster.GLOBAL) for d in group["devices"]}
     except Exception:  # noqa: BLE001 - not in the global cluster (yet), or its state is unreadable
@@ -927,6 +948,24 @@ def usage_summary() -> dict:
             usage["by_hour" if bucket[0] == "h" else "by_weekday"][int(bucket[1:])] += n
     busiest = sorted((kv for kv in by_type.items() if kv[1]["reservations"]), key=lambda kv: -kv[1]["reservations"])
     usage["by_type"] = dict(busiest[:64])  # Global takes at most 64 types
+
+    # Global takes at most 128 devices and 1000 days in all: the oldest days go first.
+    today = datetime.now(timezone.utc).date()
+    by_device, entries = {}, 0
+    for device_id, day, n, seconds in _rows(
+            _db_dir() / "reservations.db",
+            "SELECT device_id, day, reservations, CAST(ROUND(seconds) AS INTEGER) FROM ReservationDays "
+            "WHERE day BETWEEN ? AND ? ORDER BY day DESC, device_id",
+            (str(today - timedelta(days=30)), str(today))):
+        if device_id not in shared or not (n or seconds) or (device_id not in by_device and len(by_device) == 128):
+            continue
+        if entries == 1000:
+            break
+        by_device.setdefault(device_id, {})[day] = [min(n, 2**31), min(seconds, 2**31)]
+        entries += 1
+    names = _device_names()
+    usage["by_device"] = [{"id": gid, "name": names.get(gid, f"device {gid}"), "type": types.get(gid, "unknown"),
+                           "days": days} for gid, days in sorted(by_device.items())]
     return usage
 
 
@@ -980,15 +1019,17 @@ def send_status() -> None:
 
     payload = status_payload()
     # A Global older than a field refuses the note: drop the newest first
-    # (`usage`, then `reservations`), then `proxies`/`reserved_s`, as the note
-    # was before each of them.
-    steps = ((), ("usage",), ("usage", "reservations"), ("usage", "reservations", "proxies", "reserved_s"))
-    for drop in steps:
+    # (`usage.by_device`, `usage`, then `reservations`), then
+    # `proxies`/`reserved_s`, as the note was before each of them.
+    steps = [payload, dict(payload, usage={k: v for k, v in payload["usage"].items() if k != "by_device"})]
+    for drop in (("usage",), ("usage", "reservations"), ("usage", "reservations", "proxies", "reserved_s")):
+        steps.append({k: v for k, v in payload.items() if k not in drop})
+    for status in steps:
         try:
-            call("POST", REPORT_PATH, {"kind": "status", "status": {k: v for k, v in payload.items() if k not in drop}})
+            call("POST", REPORT_PATH, {"kind": "status", "status": status})
             break
         except GlobalError as exc:
-            if exc.code != "invalid_status" or drop is steps[-1]:
+            if exc.code != "invalid_status" or status is steps[-1]:
                 raise
     update(GLOBAL_LAST_REPORT_AT=datetime.now(timezone.utc).isoformat())
 

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/src/remoteRF_server/server/grpc_server.py

@@ -55,7 +55,8 @@ from .host_dynamic_v2 import host_session_proxy
 from .acc_perms import perms
 from ..common.utils import *
 from .device_manager import (close_local_devices, reload_devices, get_registered_devices,
-                             get_all_devices_str, handle_report, device_inventory_snapshot)
+                             get_all_devices_str, handle_report, device_inventory_snapshot,
+                             driver_overrides, schema_served)
 from .user_group_cli import make_user_group_local, edit_user_group_local, list_user_groups_local, remove_user_group_local, make_enrollment_codes_local, remove_enrollment_code_local, list_enrollment_codes_local, export_user_groups_csv_local, export_enrollment_codes_csv_local
 from .user_group_handler import start_usergroup_cleanup_loop
 from .global_onboarding import start_agent
@@ -1205,6 +1206,7 @@ def _status_json() -> dict:
         "devices_total": len(devices),
         "devices_online": sum(bool(item["online"]) for item in devices.values()),
         "reservations_active": int(active),
+        "driver_overrides": driver_overrides(),
     }
 
 
@@ -1457,6 +1459,27 @@ def cmd_stats_purge(argv):
 def cmd_devices_list(argv): get_devices(json_output="--json" in argv)
 
 
+def cmd_schema_served(argv):
+    words = [a for a in argv if a != "--json"]
+    if len(words) != 1 or not re.fullmatch(r"[a-z0-9_]{1,64}", words[0]):
+        print("Usage: schema served <type> [--json]")
+        return 2
+    value = schema_served(words[0])
+    if "--json" in argv:
+        from .json_output import print_json
+
+        print_json(value)
+        return 0
+    print(f"{value['type']}: {value['hash'] or 'no driver registered'}")
+    if value["module"]:
+        print(f"  served by {value['module']}{' (rrfops override)' if value['override'] else ''}")
+        print(f"  file sha256 {value['source_sha256'] or '-'}")
+    for load in value["loads"]:
+        if not load["ok"]:
+            print(f"  {load['file']}: {load['error']}")
+    return 0
+
+
 def cmd_diag(argv):
     from . import diag
 

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/src/remoteRF_server/server/reservation.py

@@ -258,9 +258,14 @@ class ReservationHandler:
         # Reported to Global as `usage`, for the devices shared there. Seeded
         # only into an empty table: the bucket names follow the process TZ, so a
         # restart under another TZ must not count the current rows again.
+        # ReservationDays keeps them per UTC date of the start (`usage.by_device`).
         hour = lambda r: f"'h' || strftime('%H', {r}.start_time, 'utc')"  # noqa: E731
         day = lambda r: f"'d' || ((CAST(strftime('%w', {r}.start_time, 'utc') AS INTEGER) + 6) % 7)"  # noqa: E731
+        utc_date = lambda r: f"date({r}.start_time, 'utc')"  # noqa: E731
         length = lambda r: f"(julianday({r}.end_time) - julianday({r}.start_time)) * 86400"  # noqa: E731
+        cancel = '''reservations = MAX(reservations - (OLD.start_time > datetime('now', 'localtime')), 0),
+                seconds = MAX(seconds - MAX(0,
+                    (julianday(OLD.end_time) - julianday(MAX(OLD.start_time, datetime('now', 'localtime')))) * 86400), 0)'''
         self.cursor.executescript(f'''
         BEGIN IMMEDIATE;
         CREATE TABLE IF NOT EXISTS ReservationBuckets (device_id INTEGER NOT NULL, bucket TEXT NOT NULL,
@@ -283,12 +288,26 @@ class ReservationHandler:
         END;
         CREATE TRIGGER IF NOT EXISTS reservation_buckets_del AFTER DELETE ON Reservations
         WHEN OLD.device_id < 1000000 BEGIN
-            UPDATE ReservationBuckets SET
-                reservations = MAX(reservations - (OLD.start_time > datetime('now', 'localtime')), 0),
-                seconds = MAX(seconds - MAX(0,
-                    (julianday(OLD.end_time) - julianday(MAX(OLD.start_time, datetime('now', 'localtime')))) * 86400), 0)
+            UPDATE ReservationBuckets SET {cancel}
             WHERE device_id = OLD.device_id AND bucket IN ('all', {hour("OLD")}, {day("OLD")});
         END;
+        CREATE TABLE IF NOT EXISTS ReservationDays (device_id INTEGER NOT NULL, day TEXT NOT NULL,
+            reservations INTEGER NOT NULL, seconds REAL NOT NULL, PRIMARY KEY (device_id, day));
+        INSERT INTO ReservationDays
+            SELECT device_id, {utc_date("r")} AS day, COUNT(*), SUM({length("r")}) FROM Reservations r
+            WHERE device_id < 1000000 AND NOT EXISTS (SELECT 1 FROM ReservationDays)
+            GROUP BY device_id, day;
+        CREATE TRIGGER IF NOT EXISTS reservation_days_ins AFTER INSERT ON Reservations
+        WHEN NEW.device_id < 1000000 BEGIN
+            INSERT INTO ReservationDays VALUES (NEW.device_id, {utc_date("NEW")}, 1, {length("NEW")})
+            ON CONFLICT (device_id, day) DO UPDATE
+                SET reservations = reservations + 1, seconds = seconds + excluded.seconds;
+        END;
+        CREATE TRIGGER IF NOT EXISTS reservation_days_del AFTER DELETE ON Reservations
+        WHEN OLD.device_id < 1000000 BEGIN
+            UPDATE ReservationDays SET {cancel}
+            WHERE device_id = OLD.device_id AND day = {utc_date("OLD")};
+        END;
         COMMIT;
         ''')
 

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/src/remoteRF_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.7.14
+Version: 1.7.16
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3
@@ -10,7 +10,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: remoterf-federation-core==0.22.0
-Requires-Dist: remoterf-device-core==0.1.2
+Requires-Dist: remoterf-device-core==0.1.3
 Requires-Dist: grpcio<2.0.0,>=1.81.1
 Requires-Dist: protobuf<7.0.0,>=6.33.5
 Requires-Dist: numpy

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/src/remoteRF_server.egg-info/requires.txt

@@ -1,5 +1,5 @@
 remoterf-federation-core==0.22.0
-remoterf-device-core==0.1.2
+remoterf-device-core==0.1.3
 grpcio<2.0.0,>=1.81.1
 protobuf<7.0.0,>=6.33.5
 numpy

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/tests/test_client_sessions.py

@@ -207,7 +207,7 @@ class ReservationCountTests(unittest.TestCase):
 
 
 class ReservationBucketsTests(unittest.TestCase):
-    """Per device, by UTC hour and weekday of the start: counted like the totals above."""
+    """Per device, by UTC hour, weekday and date of the start: counted like the totals above."""
 
     def setUp(self):
         import time
@@ -244,6 +244,11 @@ class ReservationBucketsTests(unittest.TestCase):
         rows = db.execute("SELECT bucket, reservations, seconds FROM ReservationBuckets WHERE device_id = ?", (device_id,))
         return {bucket: (n, round(seconds)) for bucket, n, seconds in rows}
 
+    @staticmethod
+    def days(db, device_id):
+        rows = db.execute("SELECT day, reservations, seconds FROM ReservationDays WHERE device_id = ?", (device_id,))
+        return {day: (n, round(seconds)) for day, n, seconds in rows}
+
     def test_buckets_by_utc_hour_and_weekday_survive_purge_and_skip_partner_devices(self):
         from datetime import datetime
         from remoteRF_server.server.federation.home_devices import ALIAS_BASE
@@ -256,8 +261,12 @@ class ReservationBucketsTests(unittest.TestCase):
         expected = {"all": (2, 3 * 3600), "h20": (1, 3600), "d6": (1, 3600), "h06": (1, 2 * 3600), "d2": (1, 2 * 3600)}
         self.assertEqual(self.buckets(db, 1), expected)
         self.assertEqual(self.buckets(db, ALIAS_BASE), {})
+        days = {"2026-11-01": (1, 3600), "2026-11-04": (1, 2 * 3600)}  # the first starts the UTC day before
+        self.assertEqual(self.days(db, 1), days)
+        self.assertEqual(self.days(db, ALIAS_BASE), {})
         db.execute("DELETE FROM Reservations WHERE end_time < ?", (datetime.now(),))  # purge: no change
         self.assertEqual(self.buckets(db, 1), expected)
+        self.assertEqual(self.days(db, 1), days)
 
     def test_a_cancel_gives_back_like_the_totals_and_never_below_zero(self):
         from datetime import datetime, timedelta
@@ -268,17 +277,18 @@ class ReservationBucketsTests(unittest.TestCase):
         self.add(db, 2, now + timedelta(hours=1), now + timedelta(hours=3))
         self.add(db, 3, now - timedelta(hours=1), now + timedelta(hours=1))
         self.add(db, 4, now + timedelta(hours=1), now + timedelta(hours=2))
-        values = lambda device_id: sorted(self.buckets(db, device_id).values())  # noqa: E731
-        self.assertEqual(values(2), [(1, 2 * 3600)] * 3)
+        values = lambda gid: sorted([*self.buckets(db, gid).values(), *self.days(db, gid).values()])  # noqa: E731
+        self.assertEqual(values(2), [(1, 2 * 3600)] * 4)
         db.execute("DELETE FROM Reservations WHERE device_id = 2")  # cancel before start: all given back
-        self.assertEqual(values(2), [(0, 0)] * 3)
+        self.assertEqual(values(2), [(0, 0)] * 4)
         db.execute("DELETE FROM Reservations WHERE device_id = 3")  # cancel after start: unused hour back
         for n, seconds in values(3):
             self.assertEqual(n, 1)
             self.assertAlmostEqual(seconds, 3600, delta=2)
-        db.execute("UPDATE ReservationBuckets SET reservations = 0, seconds = 0 WHERE device_id = 4")
+        for table in ("ReservationBuckets", "ReservationDays"):
+            db.execute(f"UPDATE {table} SET reservations = 0, seconds = 0 WHERE device_id = 4")
         db.execute("DELETE FROM Reservations WHERE device_id = 4")
-        self.assertEqual(values(4), [(0, 0)] * 3)  # never negative
+        self.assertEqual(values(4), [(0, 0)] * 4)  # never negative
 
     def test_buckets_seed_from_old_rows_once(self):
         import time
@@ -292,15 +302,33 @@ class ReservationBucketsTests(unittest.TestCase):
         self.add(db, 1, "2026-11-02 02:15:00", "2026-11-02 02:45:00")
         self.add(db, ALIAS_BASE, "2026-11-02 02:00:00", "2026-11-02 03:00:00")
         expected = {"all": (2, 5400), "h20": (2, 5400), "d6": (2, 5400)}
+        days = {"2026-11-01": (2, 5400)}
         self.handler()
         self.assertEqual(self.buckets(db, 1), expected)
         self.assertEqual(self.buckets(db, ALIAS_BASE), {})
+        self.assertEqual(self.days(db, 1), days)
+        self.assertEqual(self.days(db, ALIAS_BASE), {})
         self.handler()  # a restart does not seed again
         self.assertEqual(self.buckets(db, 1), expected)
+        self.assertEqual(self.days(db, 1), days)
         with mock.patch.dict("os.environ", {"TZ": "UTC0"}):
             time.tzset()
-            self.handler()  # nor one under another TZ, where the rows map to h02/d0
+            self.handler()  # nor one under another TZ, where the rows map to h02/d0/2026-11-02
         time.tzset()
         self.assertEqual(self.buckets(db, 1), expected)
+        self.assertEqual(self.days(db, 1), days)
         self.add(db, 1, "2026-11-02 02:20:00", "2026-11-02 02:50:00")  # 20:50 UTC
         self.assertEqual(self.buckets(db, 1)["h20"], (3, 7200))
+        self.assertEqual(self.days(db, 1), {"2026-11-01": (3, 7200)})
+
+    def test_days_seed_into_an_existing_lab_that_already_has_buckets(self):
+        """A lab upgrading from 1.7.14 has ReservationBuckets but no ReservationDays yet."""
+        self.handler()
+        db = self.connect()
+        db.executescript("DROP TRIGGER reservation_days_ins; DROP TRIGGER reservation_days_del; "
+                         "DROP TABLE ReservationDays;")
+        self.add(db, 1, "2026-11-04 12:00:00", "2026-11-04 13:00:00")
+        buckets = self.buckets(db, 1)
+        self.handler()
+        self.assertEqual(self.days(db, 1), {"2026-11-04": (1, 3600)})
+        self.assertEqual(self.buckets(db, 1), buckets)

{remoterf_server-1.7.14 → remoterf_server-1.7.16}/tests/test_global_onboarding.py

@@ -509,7 +509,8 @@ class StatusReportTests(TunnelTests):
         self.assertEqual(payload["proxies"], 1)
         self.assertEqual(payload["active_reservations"], 1)
         self.assertEqual(payload["reservations"], 5)
-        self.assertEqual(payload["usage"], {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}})  # not on global
+        self.assertEqual(payload["usage"],  # not on global
+                         {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}, "by_device": []})
         self.assertEqual(
             sorted(entry["type"] for entry in payload["devices"]),
             ["adalm_pluto", "usrp_2901"],
@@ -528,7 +529,8 @@ class StatusReportTests(TunnelTests):
         text = " ".join(g.CONSENT_TEXT.split())
         for item in ("name, version", "devices", "joined", "last online", "how many reservations",
                      "time reserved, at https://{domain}/stats.json", "devices you share on Global",
-                     "each hour of the day", "each day of the week", "per device type", "these breakdowns"):
+                     "each hour of the day", "each day of the week", "per device type", "these breakdowns",
+                     "for each device shared on Global its name and its daily reservation counts and time reserved"):
             self.assertIn(item, text)
 
     def test_status_payload_survives_missing_state(self):
@@ -539,7 +541,7 @@ class StatusReportTests(TunnelTests):
         self.assertEqual(payload["proxies"], 0)
         self.assertEqual(payload["reservations"], 0)
         self.assertEqual(payload["devices"], [])
-        self.assertEqual(payload["usage"], {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}})
+        self.assertEqual(payload["usage"], {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}, "by_device": []})
         self.assertIsNone(payload["cert_sha256"])
 
     def test_usage_counts_only_the_devices_shared_on_global(self):
@@ -568,7 +570,76 @@ class StatusReportTests(TunnelTests):
                                             "unknown": {"reservations": 1, "seconds": 60}})
 
         with mock.patch.object(cluster, "groups", side_effect=cluster.ClusterError("no cluster named global")):
-            self.assertEqual(g.usage_summary(), {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}})
+            self.assertEqual(g.usage_summary(),
+                             {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}, "by_device": []})
+
+    def days_table(self, rows):
+        import sqlite3
+
+        with sqlite3.connect(g.cfg_dir() / "db" / "reservations.db") as conn:
+            conn.execute("CREATE TABLE ReservationDays (device_id INTEGER, day TEXT, reservations INTEGER, "
+                         "seconds REAL, PRIMARY KEY (device_id, day))")
+            conn.executemany("INSERT INTO ReservationDays VALUES (?,?,?,?)", rows)
+
+    def test_by_device_reports_the_last_31_days_of_shared_devices_by_name(self):
+        from datetime import datetime, timedelta, timezone
+        from remoteRF_server.server.federation import cluster
+
+        self.seed()
+        (g.cfg_dir() / "devices.yml").write_text(
+            "devices:\n"
+            "  - {device_id: 0, device_type: adalm_pluto, name: Bench Pluto}\n"
+            "  - {device_id: 1, device_type: usrp_2901, name: Not shared}\n"
+            "  - {device_id: 2, device_type: adalm_pluto, name: \"\\e[31mRed\\nPluto \"}\n"
+            "  - {device_id: 3, device_type: adalm_pluto, name: \"\\t\"}\n"
+            f"  - {{device_id: 4, device_type: adalm_pluto, name: {'x' * 80}}}\n",
+            encoding="utf-8",
+        )
+        self.use_host_registry([("host-a", 200, "adalm_pluto_mimo_ykush")])
+        today = datetime.now(timezone.utc).date()
+        day = lambda n: str(today - timedelta(days=n))  # noqa: E731
+        self.days_table([
+            (0, day(0), 2, 5400.4), (0, day(30), 1, 60.0), (0, day(31), 9, 999.0),  # day 31 is out of the window
+            (0, str(today + timedelta(days=1)), 1, 60.0),  # not started yet
+            (0, day(3), 0, 0.2),  # every reservation cancelled
+            (1, day(0), 4, 400.0),  # not shared on Global
+            (2, day(1), 1, 30.0), (3, day(1), 0, 30.0), (4, day(1), 1, 0.0),
+            (5, day(2), 1, 60.0),  # gone from devices.yml
+            (6, day(31), 1, 60.0),  # nothing left in the window
+            (200, day(5), 3, 180.0),
+        ])
+        shared = [{"devices": [0, 2, 3, 4, 5, 6]}, {"devices": [200]}]
+        with mock.patch.object(cluster, "groups", return_value=shared):
+            by_device = g.usage_summary()["by_device"]
+        self.assertEqual(by_device, [
+            {"id": 0, "name": "Bench Pluto", "type": "adalm_pluto", "days": {day(0): [2, 5400], day(30): [1, 60]}},
+            {"id": 2, "name": "[31mRedPluto", "type": "adalm_pluto", "days": {day(1): [1, 30]}},
+            {"id": 3, "name": "device 3", "type": "adalm_pluto", "days": {day(1): [0, 30]}},
+            {"id": 4, "name": "x" * 64, "type": "adalm_pluto", "days": {day(1): [1, 0]}},
+            {"id": 5, "name": "device 5", "type": "unknown", "days": {day(2): [1, 60]}},
+            {"id": 200, "name": "Pluto 200", "type": "adalm_pluto_mimo_ykush", "days": {day(5): [3, 180]}},
+        ])
+
+        # A rename shows on the next note.
+        path = g.cfg_dir() / "devices.yml"
+        path.write_text(path.read_text(encoding="utf-8").replace("Bench Pluto", "Bench A"), encoding="utf-8")
+        with mock.patch.object(cluster, "groups", return_value=shared):
+            self.assertEqual(g.usage_summary()["by_device"][0]["name"], "Bench A")
+
+    def test_by_device_drops_the_oldest_days_first_to_fit_globals_caps(self):
+        from datetime import datetime, timedelta, timezone
+        from remoteRF_server.server.federation import cluster
+
+        self.seed()
+        today = datetime.now(timezone.utc).date()
+        self.days_table([(gid, str(today - timedelta(days=n)), 1, 60.0) for gid in range(130) for n in range(10)])
+        with mock.patch.object(cluster, "groups", return_value=[{"devices": list(range(130))}]):
+            by_device = g.usage_summary()["by_device"]
+        self.assertEqual([entry["id"] for entry in by_device], list(range(128)))
+        days = [d for entry in by_device for d in entry["days"]]
+        self.assertEqual(len(days), 1000)
+        self.assertEqual(min(days), str(today - timedelta(days=7)))  # days 8 and 9 dropped, day 7 cut short
+        self.assertEqual(sum(d == min(days) for d in days), 1000 - 7 * 128)
 
     def use_host_registry(self, persisted=(), online_hosts=()):
         """The Host directory as the server loads it at boot, with online_hosts connected."""
@@ -647,6 +718,7 @@ class StatusReportTests(TunnelTests):
         with mock.patch.object(g, "call", side_effect=old_global):
             g.send_status()
         self.assertEqual(sent, [
+            set(g.STATUS_FIELDS),
             set(g.STATUS_FIELDS),
             set(g.STATUS_FIELDS) - {"usage"},
             set(g.STATUS_FIELDS) - {"usage", "reservations"},
@@ -665,6 +737,7 @@ class StatusReportTests(TunnelTests):
         with mock.patch.object(g, "call", side_effect=global_with_reserved_s):
             g.send_status()
         self.assertEqual(sent, [
+            set(g.STATUS_FIELDS),
             set(g.STATUS_FIELDS),
             set(g.STATUS_FIELDS) - {"usage"},
             set(g.STATUS_FIELDS) - {"usage", "reservations"},
@@ -681,7 +754,21 @@ class StatusReportTests(TunnelTests):
 
         with mock.patch.object(g, "call", side_effect=global_with_reservations):
             g.send_status()
-        self.assertEqual(sent, [set(g.STATUS_FIELDS), set(g.STATUS_FIELDS) - {"usage"}])
+        self.assertEqual(sent, [set(g.STATUS_FIELDS), set(g.STATUS_FIELDS), set(g.STATUS_FIELDS) - {"usage"}])
+
+    def test_status_drops_only_by_device_for_a_global_that_predates_it(self):
+        self.activate()
+        sent = []
+
+        def global_with_usage(method, path, body):
+            sent.append(body["status"])
+            if "by_device" in body["status"]["usage"]:
+                raise g.GlobalError("invalid_status")
+
+        with mock.patch.object(g, "call", side_effect=global_with_usage):
+            g.send_status()
+        self.assertEqual([set(status) for status in sent], [set(g.STATUS_FIELDS)] * 2)
+        self.assertEqual(sent[1]["usage"], {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}})
 
     def test_status_gives_up_when_even_the_oldest_note_is_refused(self):
         self.activate()
@@ -689,7 +776,7 @@ class StatusReportTests(TunnelTests):
         with mock.patch.object(g, "call", side_effect=g.GlobalError("invalid_status")) as call:
             with self.assertRaises(g.GlobalError):
                 g.send_status()
-        self.assertEqual(call.call_count, 4)
+        self.assertEqual(call.call_count, 5)
 
     def test_reports_only_flow_once_active(self):
         self.join()