remoteRF-server 1.7.12__tar.gz → 1.7.13__tar.gz

{remoterf_server-1.7.12 → remoterf_server-1.7.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.7.12
+Version: 1.7.13
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3
@@ -953,37 +953,6 @@ serverrf --host --delete host-name
 serverrf --host --wipe
 ```
 
-## Status (Optional)
-
-If you desire to pull the server information (ie: live updates of reservation, server usage parameters, etc.)
-
-It uses GitHub Gists to push the status updates.
-
-Create public gist on your github. Keep note of the file name: (example)
-https://gist.github.com/ethange1/2a35e08a90bf88a70dfe7f42a55685ed
-
-The last one is the "GIST_ID" part of the URL, e.g. "2a35e08a90bf88a70dfe7f42a55685ed"
-
-Creating the GitHub PAT Token
-
-* GitHub → Settings
-* Developer settings
-* Personal access tokens → Fine-grained tokens
-* Generate new token
-* Set repository access to "Public Respositories"
-* Permissions: enable Gists: Read and write
-* Generate + copy the token (you only see it once)
-
-```bash
-serverrf --gist --set --id <gist_id> --file <filename>
-```
-
-Run the server normally, and you should see your gist change every minute!
-
-```bash
-serverrf -s
-```
-
 <!-- todo: -->
 <!-- Adding plutos via the CLI -->
 <!-- Testing functionality (disregarding Host pipeline) -->

{remoterf_server-1.7.12 → remoterf_server-1.7.13}/README.md

@@ -920,37 +920,6 @@ serverrf --host --delete host-name
 serverrf --host --wipe
 ```
 
-## Status (Optional)
-
-If you desire to pull the server information (ie: live updates of reservation, server usage parameters, etc.)
-
-It uses GitHub Gists to push the status updates.
-
-Create public gist on your github. Keep note of the file name: (example)
-https://gist.github.com/ethange1/2a35e08a90bf88a70dfe7f42a55685ed
-
-The last one is the "GIST_ID" part of the URL, e.g. "2a35e08a90bf88a70dfe7f42a55685ed"
-
-Creating the GitHub PAT Token
-
-* GitHub → Settings
-* Developer settings
-* Personal access tokens → Fine-grained tokens
-* Generate new token
-* Set repository access to "Public Respositories"
-* Permissions: enable Gists: Read and write
-* Generate + copy the token (you only see it once)
-
-```bash
-serverrf --gist --set --id <gist_id> --file <filename>
-```
-
-Run the server normally, and you should see your gist change every minute!
-
-```bash
-serverrf -s
-```
-
 <!-- todo: -->
 <!-- Adding plutos via the CLI -->
 <!-- Testing functionality (disregarding Host pipeline) -->

{remoterf_server-1.7.12 → remoterf_server-1.7.13}/pyproject.toml

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

{remoterf_server-1.7.12 → remoterf_server-1.7.13}/src/remoteRF_server/remote_admin_shell.py

@@ -47,7 +47,7 @@ TIERS = {
     "help": READ, "status": READ, "devices list": READ, "users list": READ, "users perms": READ,
     "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, "gist list": READ, "users prune-proxies": READ,
+    "cluster list": READ, "cluster info": READ, "users prune-proxies": READ,
     "cluster codes list": READ, "schema browse": READ,
     # write
     "devices add": WRITE, "devices remove": WRITE, "devices rename": WRITE, "groups create": WRITE,
@@ -63,7 +63,7 @@ TIERS = {
     "groups remove": DESTRUCTIVE, "devices wipe": DESTRUCTIVE, "reservations purge": DESTRUCTIVE,
     "stats purge": DESTRUCTIVE, "hosts wipe": DESTRUCTIVE, "hosts forget": DESTRUCTIVE,
     "certs reset": DESTRUCTIVE, "certs wipe": DESTRUCTIVE, "config ports": DESTRUCTIVE,
-    "cluster remove": DESTRUCTIVE, "gist set": DESTRUCTIVE, "gist wipe": DESTRUCTIVE,
+    "cluster remove": DESTRUCTIVE,
     # never remote: they cut remote access, nuke everything, or pin admins
     "stop": NEVER, "detach": NEVER, "clear": NEVER, "wipe": NEVER, "users purge": NEVER, "db purge": NEVER,
     "global cluster": NEVER,  # an old alias for every `cluster` verb, remove included: use `cluster …`
@@ -74,7 +74,7 @@ TIERS = {
 }
 DENY_FLAGS = {"--secrets"}
 # Destructive commands whose own confirmation -y answers (the step-up asked already).
-TAKES_YES = {"devices wipe", "stats purge", "hosts wipe", "certs wipe", "gist wipe", "users prune-proxies",
+TAKES_YES = {"devices wipe", "stats purge", "hosts wipe", "certs wipe", "users prune-proxies",
              "hosts tokens", "certs reset"}
 KEEP_BACKUPS = 10
 PAIR_CODE = re.compile(r"[A-Z2-7]{4}-[A-Z2-7]{4}-[A-Z2-7]{4}-[A-Z2-7]{4}")

{remoterf_server-1.7.12 → remoterf_server-1.7.13}/src/remoteRF_server/server/commands.py

@@ -178,10 +178,6 @@ def _table() -> list[Command]:
         Command(("cluster peers",), "Partner listeners this deployment dials directly: cluster peers [add <id> <host:port> --ca <ca.crt> | remove <id>]", _federation("peers"), "Clusters"),
         Command(("cluster accept",), "", _federation("accept"), "Clusters", hidden=True),
         Command(("global cluster",), "", _federation("cluster"), "Global", hidden=True),
-        # ---- gist ----
-        Command(("gist list",), "Show gist status settings [--secrets]", _shell("cmd_gist_show"), "Gist status"),
-        Command(("gist set",), "gist set <gist_id> <file> [--token-stdin]", _shell("cmd_gist_set"), "Gist status"),
-        Command(("gist wipe",), "Forget the gist settings [-y]", _shell("cmd_gist_wipe"), "Gist status"),
         # ---- database ----
         Command(("db export",), "Archive DBs, devices, keys, certs to ~/Downloads [dir]", _shell("cmd_db_export"), "Database"),
         Command(("stats purge",), "Delete the activity log (reservation stats) [-y]", _daemon("cmd_stats_purge"), "Database", where=D),
@@ -244,7 +240,6 @@ _SECTION_BLURB = {
     "Global": "public address and relay",
     "Clusters": "sharing devices with other deployments",
     "Schemas": "driver schemas approved on RemoteRF Global",
-    "Gist status": "publishing status to a GitHub gist",
     "Database": "export, or wipe everything",
     "Remote admin": "admins who reach this console from anywhere",
 }

{remoterf_server-1.7.12 → remoterf_server-1.7.13}/src/remoteRF_server/server/global_onboarding.py

@@ -62,11 +62,14 @@ Once an hour it sends Global a short note: this deployment's name and
 ID, version, uptime, how many accounts (and how many visit from partner
 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. Nothing else leaves your server -- no credentials, no
-user or reservation details -- and the connection only goes outward.
-Global publishes the network totals, and each deployment's name, version,
-devices, when it joined and was last online, and how many reservations it
-has had and the time reserved, at https://{domain}/stats.json.
+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).
+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
+it joined and was last online, and how many reservations it has had and the
+time reserved, at https://{domain}/stats.json.
 
 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
@@ -737,6 +740,7 @@ STATUS_FIELDS = frozenset(
         "active_reservations",
         "reservations",
         "reserved_s",
+        "usage",
         "lan_address",
         "cert_sha256",
     }
@@ -758,23 +762,24 @@ def _db_dir() -> Path:
     return cfg_dir() / "db"
 
 
-def _count(database: Path, sql: str, params=()) -> int:
+def _rows(database: Path, sql: str, params=()) -> list:
     import sqlite3
 
     if not database.exists():
-        return 0
+        return []
     try:
         with sqlite3.connect(f"file:{database}?mode=ro", uri=True, timeout=2.0) as db:
-            return int(db.execute(sql, params).fetchone()[0])
+            return db.execute(sql, params).fetchall()
     except sqlite3.Error:
-        return 0
+        return []
 
 
-def device_summary() -> list:
-    """One entry per registered device: its type and whether it is connected.
+def _count(database: Path, sql: str, params=()) -> int:
+    rows = _rows(database, sql, params)
+    return int(rows[0][0]) if rows else 0
 
-    Types and counts only — never a device identifier, serial, or any data.
-    """
+
+def _registered_devices() -> list:
     import yaml
 
     path = cfg_dir() / "devices.yml"
@@ -783,23 +788,74 @@ def device_summary() -> list:
         devices = data.get("devices") or []
     except (OSError, yaml.YAMLError):
         return []
+    return [item for item in devices if type(item) is dict and "device_id" in item]
+
+
+def _device_type(item: dict) -> str:
+    return str(item.get("device_type") or "unknown").lower()
+
+
+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")
+    return {gid: re.sub(r"[^a-z0-9_]", "_", kind)[:64] for gid, kind in types.items()}
+
+
+def device_summary() -> list:
+    """One entry per registered device: its type and whether it is connected.
+
+    Types and counts only — never a device identifier, serial, or any data.
+    """
     try:
         from . import device_manager
 
         connected = set(device_manager.get_all_devices())
     except Exception:  # noqa: BLE001 - drivers are optional at report time
         connected = set()
-    summary = []
-    for item in devices:
-        if type(item) is not dict or "device_id" not in item:
+    return [{"type": kind, "online": gid in connected} for gid, kind in _device_types().items()]
+
+
+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.
+
+    Counts only (ReservationBuckets); all zero when nothing is shared there.
+    """
+    from .federation import cluster
+
+    usage = {"by_hour": [0] * 24, "by_weekday": [0] * 7, "by_type": {}}
+    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
+        return usage
+    types = _device_types()
+    by_type = {}
+    for device_id, bucket, n, seconds in _rows(
+            _db_dir() / "reservations.db",
+            "SELECT device_id, bucket, reservations, CAST(ROUND(seconds) AS INTEGER) FROM ReservationBuckets"):
+        if device_id not in shared:
             continue
-        summary.append(
-            {
-                "type": str(item.get("device_type") or "unknown").lower(),
-                "online": int(item["device_id"]) in connected,
-            }
-        )
-    return summary
+        if bucket == "all":
+            totals = by_type.setdefault(types.get(device_id, "unknown"), {"reservations": 0, "seconds": 0})
+            totals["reservations"] += n
+            totals["seconds"] = min(totals["seconds"] + seconds, 2**31)
+        else:
+            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
+    return usage
 
 
 def cert_sha256() -> Optional[str]:
@@ -832,6 +888,7 @@ def status_payload() -> dict:
         ),
         "reservations": _count(reservations, "SELECT n FROM ReservationCount"),
         "reserved_s": _count(reservations, "SELECT CAST(ROUND(seconds) AS INTEGER) FROM ReservedTotal"),
+        "usage": usage_summary(),
         "lan_address": lan_endpoint(),
         "cert_sha256": cert_sha256(),
     }
@@ -851,8 +908,9 @@ def send_status() -> None:
 
     payload = status_payload()
     # A Global older than a field refuses the note: drop the newest first
-    # (`reservations`), then `proxies`/`reserved_s`, as the note was before them.
-    steps = ((), ("reservations",), ("reservations", "proxies", "reserved_s"))
+    # (`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:
         try:
             call("POST", REPORT_PATH, {"kind": "status", "status": {k: v for k, v in payload.items() if k not in drop}})

{remoterf_server-1.7.12 → remoterf_server-1.7.13}/src/remoteRF_server/server/grpc_server.py

@@ -69,7 +69,6 @@ from prompt_toolkit import PromptSession
 from prompt_toolkit.input import DummyInput
 from prompt_toolkit.output import DummyOutput
 
-from ..tools.gist_status import start_status_publisher
 from .cert_provider import start_cert_provider, stop_cert_provider
 try:
     from . import direct_path
@@ -296,7 +295,6 @@ def start_server_runtime(
     cert_dir: Path | None = None,
     include_host_tunnel: bool = True,
     run_reservation_updates: bool = True,
-    publish_status: bool = True,
     federation_executor: Any = None,
     home_federation_enroller: Any = None,
     home_federation_permissions: Any = None,
@@ -444,8 +442,6 @@ def start_server_runtime(
             )
             update_thread.start()
             start_usergroup_cleanup_loop(interval_sec=60)
-        if publish_status:
-            start_status_publisher()
     except BaseException:  # Ctrl-C during the startup check too: close_local_devices powers Plutos down
         stop_event.set()
         server.stop(0)

{remoterf_server-1.7.12 → remoterf_server-1.7.13}/src/remoteRF_server/server/reservation.py

@@ -252,6 +252,46 @@ class ReservationHandler:
         END;
         ''')
 
+        # The same two counts per own device: overall ('all'), by the UTC hour
+        # of the start ('h00'..'h23') and by its UTC weekday ('d0' = Monday ..
+        # 'd6'). Reservations hold local time, hence the 'utc' modifier.
+        # 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.
+        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
+        length = lambda r: f"(julianday({r}.end_time) - julianday({r}.start_time)) * 86400"  # noqa: E731
+        self.cursor.executescript(f'''
+        BEGIN IMMEDIATE;
+        CREATE TABLE IF NOT EXISTS ReservationBuckets (device_id INTEGER NOT NULL, bucket TEXT NOT NULL,
+            reservations INTEGER NOT NULL, seconds REAL NOT NULL, PRIMARY KEY (device_id, bucket));
+        INSERT INTO ReservationBuckets
+            SELECT device_id, bucket, COUNT(*), SUM(seconds) FROM (
+                SELECT device_id, 'all' AS bucket, {length("r")} AS seconds FROM Reservations r
+                UNION ALL SELECT device_id, {hour("r")}, {length("r")} FROM Reservations r
+                UNION ALL SELECT device_id, {day("r")}, {length("r")} FROM Reservations r)
+            WHERE device_id < 1000000 AND NOT EXISTS (SELECT 1 FROM ReservationBuckets)
+            GROUP BY device_id, bucket;
+        CREATE TRIGGER IF NOT EXISTS reservation_buckets_ins AFTER INSERT ON Reservations
+        WHEN NEW.device_id < 1000000 BEGIN
+            INSERT INTO ReservationBuckets VALUES
+                (NEW.device_id, 'all', 1, {length("NEW")}),
+                (NEW.device_id, {hour("NEW")}, 1, {length("NEW")}),
+                (NEW.device_id, {day("NEW")}, 1, {length("NEW")})
+            ON CONFLICT (device_id, bucket) DO UPDATE
+                SET reservations = reservations + 1, seconds = seconds + excluded.seconds;
+        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)
+            WHERE device_id = OLD.device_id AND bucket IN ('all', {hour("OLD")}, {day("OLD")});
+        END;
+        COMMIT;
+        ''')
+
         # "Stay logged in" for the deployment protocol: a random token the
         # client keeps instead of the password. Only its hash lives here, so
         # the table reveals nothing; a row is revoked by logout or purge.
@@ -1454,172 +1494,6 @@ class ReservationHandler:
         except (sqlite3.Error, ValueError):
             return {}
             
-    @db_connection
-    def get_obfuscated_device_reservations_grouped_past_days(self, days: int) -> dict[str, dict[str, int]]:
-        try:
-            days = int(days)
-        except Exception:
-            return {}
-
-        if days < 0:
-            return {}
-
-        now = datetime.now()
-        cutoff = now - timedelta(days=days)
-
-        def _parse_logged_int(v) -> int:
-            if isinstance(v, int):
-                return v
-            if isinstance(v, float):
-                return int(v)
-
-            s = str(v).strip()
-
-            # Handles strings like:
-            #   "int64_value: 2"
-            #   "int64_value: 1772587800"
-            if ":" in s:
-                s = s.split(":", 1)[1].strip()
-
-            # remove quotes/newlines if present
-            s = s.strip().strip('"').strip("'")
-            return int(float(s))
-
-        # Take a consistent snapshot of the log file under the same lock used by writers.
-        try:
-            with log_lock:
-                activity_log = _load_logs()
-        except Exception:
-            activity_log = []
-
-        out: dict[str, dict[str, int]] = {}
-
-        for entry in activity_log:
-            try:
-                if not isinstance(entry, dict):
-                    continue
-
-                if str(entry.get("action", "")).strip() != "reserve_device":
-                    continue
-
-                details = entry.get("details", {})
-                if not isinstance(details, dict):
-                    continue
-
-                args = details.get("args", {})
-                result = details.get("result", {})
-
-                if not isinstance(args, dict) or not isinstance(result, dict):
-                    continue
-
-                # Only count SUCCESSFUL reservations
-                if "Token" not in result:
-                    continue
-
-                raw_device_id = args.get("dd")
-                raw_start = args.get("st")
-                raw_end = args.get("et")
-
-                if raw_device_id is None or raw_start is None or raw_end is None:
-                    continue
-
-                device_id = _parse_logged_int(raw_device_id)
-                start_ts = _parse_logged_int(raw_start)
-                end_ts = _parse_logged_int(raw_end)
-
-                start_dt = datetime.fromtimestamp(start_ts)
-                end_dt = datetime.fromtimestamp(end_ts)
-
-                # Same overlap semantics as before
-                if end_dt < cutoff or start_dt > now:
-                    continue
-
-                dev_key = str(device_id)
-                day_key = start_dt.date().isoformat()
-
-                if dev_key not in out:
-                    out[dev_key] = {}
-
-                out[dev_key][day_key] = out[dev_key].get(day_key, 0) + 1
-
-            except Exception:
-                continue
-
-        return dict(sorted(out.items(), key=lambda kv: int(kv[0])))
-    
-    @db_connection
-    def get_obfuscated_usage_summary(self) -> dict[str, int | float]:
-
-        int_re = re.compile(r'int64_value:\s*([0-9]+)')
-        str_re = re.compile(r'string_value:\s*"([^"]*)"')
-
-        def _parse_proto_value(v):
-            if isinstance(v, (int, float)):
-                return v
-            if not isinstance(v, str):
-                return v
-
-            m_int = int_re.search(v)
-            if m_int:
-                return int(m_int.group(1))
-
-            m_str = str_re.search(v)
-            if m_str:
-                return m_str.group(1)
-
-            return v
-
-        try:
-            with log_lock:
-                activity_log = _load_logs()
-        except Exception:
-            activity_log = []
-
-        accounts: set[str] = set()
-        total_reservations = 0
-        total_reserved_seconds = 0
-
-        for entry in activity_log:
-            try:
-                if not isinstance(entry, dict):
-                    continue
-
-                action = entry.get("action")
-                username = entry.get("username")
-                details = entry.get("details", {}) or {}
-                args = details.get("args", {}) or {}
-                result = details.get("result", {}) or {}
-
-                if not isinstance(args, dict) or not isinstance(result, dict):
-                    continue
-
-                # Count accounts from successful logins
-                if action == "login" and "UC" in result:
-                    uc_name = _parse_proto_value(result.get("UC"))
-                    if uc_name:
-                        accounts.add(str(uc_name))
-                    elif username:
-                        accounts.add(str(username))
-
-                # Count reservations + reserved time
-                if action == "reserve_device":
-                    total_reservations += 1
-
-                    st = _parse_proto_value(args.get("st"))
-                    et = _parse_proto_value(args.get("et"))
-
-                    if isinstance(st, int) and isinstance(et, int) and et > st:
-                        total_reserved_seconds += (et - st)
-
-            except Exception:
-                continue
-
-        return {
-            "account_count": len(accounts),
-            "total_reservations": int(total_reservations),
-            "total_reserved_hours": round(total_reserved_seconds / 3600.0, 1),
-        }
-            
     def get_reservation_count(self, username):
         self.cursor.execute("SELECT COUNT(*) FROM Reservations WHERE username = ?", (username,))
         count = self.cursor.fetchone()[0]