remoteRF-server 0.1.74__tar.gz → 0.1.75__tar.gz

{remoterf_server-0.1.74 → remoterf_server-0.1.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 0.1.74
+Version: 0.1.75
 Description-Content-Type: text/markdown
 Requires-Dist: grpcio
 Requires-Dist: protobuf

{remoterf_server-0.1.74 → remoterf_server-0.1.75}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "0.1.74"
+version = "0.1.75"
 dependencies = [
   "grpcio",
   "protobuf",

{remoterf_server-0.1.74 → remoterf_server-0.1.75}/src/remoteRF_server/server/grpc_server.py

@@ -461,24 +461,96 @@ def _repo_root_guess() -> Path:
     # fallback
     return p.parents[3] if len(p.parents) >= 4 else p.parent
 
+from __future__ import annotations
+from pathlib import Path
+import os
+import re
+import time
+from typing import Any
+
+# Optional: if you later add "kick" support (see section 2)
+HOST_TUNNEL_EPOCH = 0
+
+def _read_env_kv_file(path: Path) -> dict[str, str]:
+    out: dict[str, str] = {}
+    if not path.exists():
+        return out
+    for raw in path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, v = line.split("=", 1)
+        out[k.strip()] = v.strip().strip('"').strip("'")
+    return out
+
+def _env_values_as_paths(env_path: Path) -> list[Path]:
+    """
+    Parse an env file and treat values that look like filesystem paths as candidate dirs.
+    Relative paths are resolved relative to the env file's directory.
+    """
+    kv = _read_env_kv_file(env_path)
+    base = env_path.parent
+    out: list[Path] = []
+
+    for _, v in kv.items():
+        if not v:
+            continue
+        # heuristics: looks like a path
+        if ("/" not in v) and ("\\" not in v) and (not v.startswith(".")) and (not v.startswith("~")):
+            continue
+
+        p = Path(v).expanduser()
+        if not p.is_absolute():
+            p = (base / p).resolve()
+        out.append(p)
+
+    return out
+
 def _host_state_dirs() -> list[Path]:
     """
-    Places host-directory persistence might live in your codebase:
-      - User config dir: ~/.config/remoterf (REMOTERF_CONFIG_DIR override)
-      - Repo-local: <repo>/.config
-      - Server config dir you referenced: <repo>/src/remoteRF_server/config (because of .env.host_directory)
+    Aggressive candidate list:
+      - user config (~/.config/remoterf or REMOTERF_CONFIG_DIR)
+      - repo/.config
+      - repo/config  (+ common subdirs)
+      - src/remoteRF_server/config
+      - plus env overrides + paths referenced by .env.host_directory (if present)
     """
-    cands = [
+    repo = _repo_root_guess()
+
+    cands: list[Path] = [
         _cfg_dir(),
-        _repo_root_guess() / ".config",
-        (Path(__file__).resolve().parent.parent / "config"),  # <repo>/src/remoteRF_server/config
+        repo / ".config",
+        repo / "config",
+        repo / "config" / "remoteRF_server",
+        repo / "config" / "remoteRF_host",
+        repo / "src" / "remoteRF_server" / "config",
+        (Path(__file__).resolve().parent.parent / "config"),
     ]
 
+    # Environment overrides (add any you might plausibly use)
+    for k in (
+        "REMOTERF_HOSTDIR_DIR",
+        "REMOTERF_HOST_DIRECTORY_DIR",
+        "REMOTERF_HOST_DIR",
+        "HOST_DIRECTORY_DIR",
+        "HOST_DIRECTORY_PATH",
+        "REMOTERF_STATE_DIR",
+    ):
+        v = os.getenv(k)
+        if v:
+            cands.append(Path(v).expanduser())
+
+    # If you have a .env.host_directory file, harvest any path-like values from it
+    env_host_dir = repo / "src" / "remoteRF_server" / "config" / ".env.host_directory"
+    if env_host_dir.exists():
+        cands.extend(_env_values_as_paths(env_host_dir))
+
+    # de-dupe + keep only dirs (or dirs that could exist)
     out: list[Path] = []
     seen: set[str] = set()
     for d in cands:
         try:
-            rp = str(d.resolve())
+            rp = str(d.expanduser().resolve())
         except Exception:
             rp = str(d)
         if rp not in seen:
@@ -488,20 +560,42 @@ def _host_state_dirs() -> list[Path]:
 
 def _host_state_files() -> list[Path]:
     """
-    Exact files your HostTunnelRegistry has historically used.
-    Also includes a conservative glob for future additions.
+    Broader scan than just host_directory.env:
+    We only match filenames that clearly look like host/tunnel/registry state.
     """
+    patterns = [
+        "host_directory*.env",
+        "host_directory*.json",
+        "host_directory*.db",
+        "host_directory*.sqlite*",
+        "host_directory*.pkl",
+        "host_tunnel*.env",
+        "host_tunnel*.json",
+        "tunnel_registry*.env",
+        "tunnel_registry*.json",
+        "*host*registry*.json",
+        "*host*registry*.db",
+        "*host*registry*.sqlite*",
+        "*host*state*.json",
+        "*host*state*.db",
+        "*host*state*.sqlite*",
+    ]
+
     files: list[Path] = []
     for d in _host_state_dirs():
-        files.append(d / "host_directory.env")
-        files.append(d / "host_directory_meta.env")
-        # If you later add more persisted host-dir files, keep them discoverable.
         try:
-            for p in sorted(d.glob("host_directory*.env")):
-                files.append(p)
+            if not d.exists() or not d.is_dir():
+                continue
         except Exception:
-            pass
+            continue
+
+        for pat in patterns:
+            try:
+                files.extend(sorted(d.glob(pat)))
+            except Exception:
+                pass
 
+    # de-dupe
     out: list[Path] = []
     seen: set[str] = set()
     for p in files:
@@ -514,27 +608,67 @@ def _host_state_files() -> list[Path]:
             out.append(p)
     return out
 
-def _cmd_hosts_persisted() -> None:
-    files = _host_state_files()
-    found_any = False
-    printf("Host directory (persisted) state files:", Sty.BOLD)
-    for p in files:
-        if p.exists():
-            found_any = True
-            try:
-                size = p.stat().st_size
-            except Exception:
-                size = -1
-            printf("  - ", Sty.DEFAULT, f"{p}", Sty.MAGENTA, f" ({size} bytes)", Sty.GRAY)
-        else:
-            printf("  - ", Sty.DEFAULT, f"{p}", Sty.GRAY, " (missing)", Sty.GRAY)
-    if not found_any:
-        printf("  (none found)", Sty.GRAY)
+def _deep_clear_state(obj: Any) -> list[str]:
+    """
+    Best-effort: clear dict/list/set fields on an object, recursively,
+    but only for fields that look like state (host/device/route/session/cache/store/etc).
+    """
+    cleared: list[str] = []
+    seen: set[int] = set()
+
+    state_name = re.compile(r"(host|device|route|session|dir|store|cache|meta|seen|status)", re.I)
+
+    def walk(x: Any, prefix: str) -> None:
+        oid = id(x)
+        if oid in seen:
+            return
+        seen.add(oid)
+
+        # containers
+        if isinstance(x, dict):
+            x.clear()
+            cleared.append(prefix)
+            return
+        if isinstance(x, list):
+            x.clear()
+            cleared.append(prefix)
+            return
+        if isinstance(x, set):
+            x.clear()
+            cleared.append(prefix)
+            return
+
+        # objects with __dict__
+        d = getattr(x, "__dict__", None)
+        if not isinstance(d, dict):
+            return
+
+        for k, v in list(d.items()):
+            # never touch locks/threads/etc
+            if k in ("_lock", "lock", "_thread", "thread", "_executor", "executor"):
+                continue
+            if not state_name.search(k):
+                continue
+
+            if isinstance(v, (dict, list, set)):
+                try:
+                    v.clear()
+                    cleared.append(f"{prefix}.{k}")
+                except Exception:
+                    pass
+            else:
+                # recurse into nested state objects (EnvStore, etc.)
+                walk(v, f"{prefix}.{k}")
+
+    walk(obj, obj.__class__.__name__)
+    return cleared
 
 def _try_clear_registry_in_memory(reg: object) -> list[str]:
     """
-    Best-effort in-memory wipe without knowing exact internals.
-    Uses registry lock if present.
+    Stronger in-memory clear:
+      - calls obvious reset/clear methods if present
+      - clears common containers
+      - recursively clears state-like fields (even if names differ)
     """
     cleared: list[str] = []
 
@@ -545,31 +679,18 @@ def _try_clear_registry_in_memory(reg: object) -> list[str]:
             lock.acquire()
             acquired = True
 
-        # common private dict fields
-        for attr in (
-            "_hosts",
-            "_devices",
-            "_host_by_id",
-            "_device_by_id",
-            "_device_routes",
-            "_routes",
-            "_sessions",
-            "_host_sessions",
+        # Prefer explicit APIs if you have them
+        for meth in (
+            "clear",
+            "reset",
+            "wipe",
+            "wipe_all",
+            "wipe_state",
+            "clear_state",
+            "reset_state",
+            "prune",
+            "gc",
         ):
-            d = getattr(reg, attr, None)
-            if isinstance(d, dict):
-                d.clear()
-                cleared.append(attr)
-
-        # common private sets/lists
-        for attr in ("_connected", "_online_hosts"):
-            s = getattr(reg, attr, None)
-            if isinstance(s, set):
-                s.clear()
-                cleared.append(attr)
-
-        # if there is an explicit method, prefer it (won’t hurt if absent)
-        for meth in ("clear", "reset", "wipe", "wipe_all", "wipe_state"):
             fn = getattr(reg, meth, None)
             if callable(fn):
                 try:
@@ -578,6 +699,18 @@ def _try_clear_registry_in_memory(reg: object) -> list[str]:
                 except Exception:
                     pass
 
+        # Clear obvious containers by direct attribute scan
+        for attr, v in list(getattr(reg, "__dict__", {}).items()):
+            if isinstance(v, (dict, list, set)):
+                try:
+                    v.clear()
+                    cleared.append(attr)
+                except Exception:
+                    pass
+
+        # Recursive targeted clear (for EnvStore etc.)
+        cleared.extend(_deep_clear_state(reg))
+
     finally:
         if acquired:
             try:
@@ -585,13 +718,19 @@ def _try_clear_registry_in_memory(reg: object) -> list[str]:
             except Exception:
                 pass
 
-    return cleared
+    # de-dupe
+    out: list[str] = []
+    seen: set[str] = set()
+    for x in cleared:
+        if x not in seen:
+            seen.add(x)
+            out.append(x)
+    return out
 
 def _cmd_hosts_wipe(*, yes: bool = False) -> None:
-    # confirm
     if not yes:
         try:
-            resp = session.prompt(stylize("Type 'wipe-hosts' to confirm wiping persisted host state: ", Sty.RED))
+            resp = session.prompt(stylize("Type 'wipe-hosts' to confirm wiping host state: ", Sty.RED))
         except KeyboardInterrupt:
             printf("Cancelled.", Sty.GRAY)
             return
@@ -599,10 +738,10 @@ def _cmd_hosts_wipe(*, yes: bool = False) -> None:
             printf("Wipe aborted.", Sty.GRAY)
             return
 
-    # delete persisted files
+    # 1) delete persisted files (if any)
     files = [p for p in _host_state_files() if p.exists()]
     if not files:
-        printf("No persisted host directory files found to wipe.", Sty.GRAY)
+        printf("No persisted host directory files found (searched common dirs/patterns).", Sty.YELLOW)
     else:
         for p in files:
             try:
@@ -612,20 +751,25 @@ def _cmd_hosts_wipe(*, yes: bool = False) -> None:
                 printf("ERROR deleting: ", Sty.RED, f"{p} -> {e}", Sty.DEFAULT)
                 return
 
-    # clear in-memory registry (so you don’t have to restart for live state)
+    # 2) clear in-memory registry (THIS is what drives `hosts status`)
     global TUNNEL_REGISTRY
     reg = TUNNEL_REGISTRY
     if reg is None:
-        printf("Host tunnel registry not initialized; persisted files wiped only.", Sty.GRAY)
+        printf("Host tunnel registry not initialized; only persisted wipe attempted.", Sty.GRAY)
     else:
         cleared = _try_clear_registry_in_memory(reg)
         if cleared:
-            printf("Cleared in-memory registry fields: ", Sty.DEFAULT, ", ".join(cleared), Sty.GRAY)
+            printf("Cleared in-memory registry state:", Sty.GREEN)
+            # keep output short-ish
+            for item in cleared[:20]:
+                printf("  - ", Sty.DEFAULT, item, Sty.GRAY)
+            if len(cleared) > 20:
+                printf("  ...", Sty.GRAY)
         else:
-            printf("WARNING: Could not confirm in-memory registry clear (unknown internals). Restart server if needed.", Sty.YELLOW)
+            printf("WARNING: in-memory wipe could not confirm any cleared fields.", Sty.YELLOW)
+            printf("If `hosts status` still shows data, it is almost certainly being repopulated by live connections.", Sty.YELLOW)
 
-    printf("Host state wipe complete.", Sty.GREEN)
-    printf("NOTE: If hosts reconnect, persisted files will be recreated.", Sty.GRAY)
+    printf("Host wipe complete.", Sty.GREEN)
 
 # def help():
 #     printf("/------- HELP -------/", Sty.BOLD)

{remoterf_server-0.1.74 → remoterf_server-0.1.75}/src/remoteRF_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 0.1.74
+Version: 0.1.75
 Description-Content-Type: text/markdown
 Requires-Dist: grpcio
 Requires-Dist: protobuf