remoteRF-server 0.1.63__tar.gz → 0.1.65__tar.gz

{remoterf_server-0.1.63 → remoterf_server-0.1.65}/PKG-INFO

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

{remoterf_server-0.1.63 → remoterf_server-0.1.65}/pyproject.toml

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

{remoterf_server-0.1.63 → remoterf_server-0.1.65}/src/remoteRF_server/host/host_tunnel_server.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
+import sys
 import threading
 import queue
 import time
 import secrets
+import traceback
 from dataclasses import dataclass
 from typing import Dict, Optional, Tuple, Any, List, Set, Iterator
 from concurrent.futures import Future
@@ -34,10 +36,41 @@ from .host_directory_store import (
 
 import hashlib
 
+
+# =============================================================================
+# Always-on logging (no levels to configure; INFO/WARN/ERROR always print)
+# =============================================================================
+
+def _ts() -> str:
+    t = time.time()
+    sec = int(t)
+    ms = int((t - sec) * 1000)
+    lt = time.localtime(sec)
+    return time.strftime("%H:%M:%S", lt) + f".{ms:03d}"
+
+def _log(level: str, msg: str) -> None:
+    tn = threading.current_thread().name
+    print(f"{_ts()} {level:<5} [{tn}] hostrf.host_tunnel_server: {msg}", file=sys.stderr, flush=True)
+
+def info(msg: str) -> None:
+    _log("INFO", msg)
+
+def warn(msg: str) -> None:
+    _log("WARN", msg)
+
+def error(msg: str) -> None:
+    _log("ERROR", msg)
+
+def exception(msg: str) -> None:
+    _log("ERROR", msg)
+    traceback.print_exc(limit=80, file=sys.stderr)
+
+
 def host_key(host_id: str) -> str:
     h = hashlib.sha256((host_id or "").encode("utf-8")).hexdigest()
     return h[:16]  # short stable key
 
+
 def _copy_argument_map(dst_map: Any, src_map: Any) -> None:
     if src_map is None:
         return
@@ -85,28 +118,43 @@ class HostSession:
         self.inflight_lock = threading.Lock()
         self.last_heartbeat_ms = now_ms()
         self.alive = True
+        self.outbound_max = int(outbound_max)
+
+        info(f"[session] created host_id={self.host_id} outbound_max={self.outbound_max}")
 
     def send(self, frame: host_tunnel_pb2.HostFrame, *, timeout: float = 2.0) -> bool:
         if not self.alive:
+            warn(f"[session] send refused: host_id={self.host_id} (session not alive) frame={frame.WhichOneof('msg')}")
             return False
+        which = frame.WhichOneof("msg")
         try:
             self.out_q.put(frame, timeout=timeout)
+            info(f"[session] queued outbound frame host_id={self.host_id} type={which}")
             return True
         except queue.Full:
+            warn(f"[session] outbound queue FULL host_id={self.host_id} max={self.outbound_max} drop type={which}")
+            return False
+        except Exception:
+            exception(f"[session] send exception host_id={self.host_id} type={which}")
             return False
 
     def close(self) -> None:
+        if not self.alive:
+            return
+        info(f"[session] closing host_id={self.host_id}")
         self.alive = False
         try:
             self.out_q.put_nowait(None)
         except Exception:
-            pass
+            exception(f"[session] close: failed to enqueue sentinel host_id={self.host_id}")
 
         with self.inflight_lock:
-            for _, fut in list(self.inflight.items()):
+            for rid, fut in list(self.inflight.items()):
                 if not fut.done():
-                    fut.set_exception(RuntimeError(f"Host '{self.host_id}' disconnected"))
+                    fut.set_exception(RuntimeError(f"Host '{self.host_id}' disconnected (req_id={rid})"))
             self.inflight.clear()
+        info(f"[session] closed host_id={self.host_id}")
+
 
 class HostTunnelRegistry:
     """
@@ -116,14 +164,6 @@ class HostTunnelRegistry:
       - host_directory.env        (append-only CSV lists)
       - host_directory_meta.env   (upsert metadata; never deletes keys)
 
-    Fast per-RPC routing helpers:
-      - is_host_device(device_id) -> bool
-      - is_host_device_active(device_id) -> bool (cached TTL)
-      - get_host_for_device(device_id) -> Optional[str]
-
-    UI/diagnostics:
-      - device_directory_cached() -> {device_id: (host_id, device_info, is_active)} (cached TTL)
-
     Enforces:
       - device_id is globally unique across hosts (rejects conflicting host announce)
     """
@@ -134,12 +174,12 @@ class HostTunnelRegistry:
         # live sessions
         self._hosts: Dict[str, HostSession] = {}  # host_id -> session
 
-        # persistent-ish directory state
-        self._routes: Dict[str, DeviceRoute] = {}              # device_id -> route(host_id, local_id)
-        self._host_devices: Dict[str, Set[str]] = {}           # host_id -> set(device_id)
-        self._device_infos: Dict[str, host_tunnel_pb2.DeviceInfo] = {}  # device_id -> DeviceInfo
+        # directory state
+        self._routes: Dict[str, DeviceRoute] = {}                          # device_id -> route(host_id, local_id)
+        self._host_devices: Dict[str, Set[str]] = {}                       # host_id -> set(device_id)
+        self._device_infos: Dict[str, host_tunnel_pb2.DeviceInfo] = {}     # device_id -> DeviceInfo
 
-        # status (rebuilt + updated live)
+        # status
         self._host_status: Dict[str, HostStatus] = {}
         self._device_status: Dict[str, DeviceStatus] = {}
 
@@ -154,23 +194,18 @@ class HostTunnelRegistry:
         self._active_hosts_cache_ts_ms: int = 0
         self._active_hosts_cache_ttl_ms: int = int(active_cache_ttl_ms)
 
-        self._dir_cache: Dict[str, Tuple[str, Any, bool]] = {}
+        self._dir_cache: Dict[str, Tuple[str, Tuple[str, Any, bool], bool]] = {}  # not used externally
         self._dir_cache_ts_ms: int = 0
         self._dir_cache_ttl_ms: int = int(dir_cache_ttl_ms)
 
+        info(f"[registry] init cfg_dir={cfg}")
         self._load_persisted()
 
-    # ---------------------------
-    # caching helpers
-    # ---------------------------
-
     def _invalidate_caches_locked(self) -> None:
-        # must be called under self._lock
         self._active_hosts_cache_ts_ms = 0
         self._dir_cache_ts_ms = 0
 
     def _refresh_active_hosts_cache_locked(self, now: int) -> None:
-        # must be called under self._lock
         if self._active_hosts_cache_ts_ms and (now - self._active_hosts_cache_ts_ms) < self._active_hosts_cache_ttl_ms:
             return
         self._active_hosts_cache = {hid for hid, sess in self._hosts.items() if sess is not None and sess.alive}
@@ -181,29 +216,14 @@ class HostTunnelRegistry:
     # ---------------------------
 
     def _load_persisted(self) -> None:
-        """
-        Rebuild directory state from repo_root/.config/*.env
-
-        On boot, everything starts offline until hosts reconnect.
-        This restores *directory + metadata* only (routes/devices/labels).
-        """
         kv_lists = self._env_lists.read_kv()
         kv_meta = self._env_meta.read_kv()
 
         known_hosts = csv_split(kv_lists.get("KNOWN_HOSTS", ""))
         known_devices = csv_split(kv_lists.get("KNOWN_DEVICES", ""))
 
-        # also accept hosts referenced by HOST_*_DEVICES keys even if KNOWN_HOSTS drifted
-        hosts_from_keys: Set[str] = set()
-        for k, v in kv_lists.items():
-            if k.startswith("HOST_") and k.endswith("_DEVICES"):
-                # We don't know the original host_id from the sanitized key reliably.
-                # That's fine; we still load routes primarily from DEVICE_*_HOST in meta.
-                # But we DO want to retain the device list; we’ll stitch it via meta host ids.
-                # So: just collect devices from these keys.
-                pass
+        info(f"[registry] load persisted: known_hosts={len(known_hosts)} known_devices={len(known_devices)}")
 
-        # Reset directory + status (do not touch live sessions)
         with self._lock:
             self._routes.clear()
             self._host_devices.clear()
@@ -211,25 +231,18 @@ class HostTunnelRegistry:
             self._host_status.clear()
             self._device_status.clear()
 
-            # seed known hosts as offline
             for hid in known_hosts:
                 if hid:
                     self._host_status[hid] = HostStatus(host_id=hid, online=False, last_seen_ms=0)
                     self._host_devices.setdefault(hid, set())
 
-            # collect devices that appear anywhere
             devices_from_host_lists: Set[str] = set()
             for k, v in kv_lists.items():
                 if k.startswith("HOST_") and k.endswith("_DEVICES"):
                     devices_from_host_lists.update(csv_split(v))
 
-            devices_from_meta: Set[str] = set()
-            # any DEVICE_<X>_HOST implies a known device id (but we can’t reverse sanitize_env_key)
-            # so we rely on KNOWN_DEVICES + HOST_*_DEVICES as primary device-id sources.
-            # meta augments those devices; it can’t introduce new raw device ids safely.
             all_devices: List[str] = sorted(set(known_devices) | devices_from_host_lists)
 
-            # build device entries offline
             for device_id in all_devices:
                 if not device_id:
                     continue
@@ -247,15 +260,11 @@ class HostTunnelRegistry:
                 kind = (kv_meta.get(f"DEVICE_{dk}_KIND", "") or "").strip()
 
                 if host_id:
-                    # ensure host exists
                     if host_id not in self._host_status:
                         self._host_status[host_id] = HostStatus(host_id=host_id, online=False, last_seen_ms=0)
                     self._host_devices.setdefault(host_id, set()).add(device_id)
-
-                    # route exists even while offline
                     self._routes[device_id] = DeviceRoute(host_id=host_id, host_local_id=int(local_id))
 
-                # keep info visible even when offline
                 self._device_infos[device_id] = host_tunnel_pb2.DeviceInfo(
                     device_id=str(device_id),
                     local_id=int(local_id),
@@ -274,9 +283,12 @@ class HostTunnelRegistry:
 
             self._invalidate_caches_locked()
 
+        info(f"[registry] persisted directory loaded: routes={len(self._routes)} hosts={len(self._host_status)} devices={len(self._device_status)}")
+
     # ---------------------------
     # persistence write helpers
     # ---------------------------
+
     def _persist_host_meta(self, host_id: str, *, host_name: str = "", platform: str = "", version: str = "") -> None:
         hk = host_key(host_id)
         self._env_meta.set_kv_if_absent(f"HOST_{hk}_ID", host_id)
@@ -287,16 +299,26 @@ class HostTunnelRegistry:
         if version:
             self._env_meta.upsert_kv(f"HOST_{hk}_VERSION", version)
 
+    def persist_host_meta_from_hello(self, hello: Any) -> None:
+        try:
+            hid = str(getattr(hello, "host_id", "") or "").strip()
+            ver = str(getattr(hello, "version", "") or "").strip()
+            if hid:
+                self._persist_host_meta(hid, version=ver)
+                info(f"[registry] persisted host meta from hello: host_id={hid} version={ver!r}")
+        except Exception:
+            exception("[registry] persist_host_meta_from_hello failed")
+
     def _persist_host(self, host_id: str) -> None:
         self._env_lists.append_to_csv_list("KNOWN_HOSTS", host_id)
+        info(f"[registry] persisted host list: host_id={host_id}")
 
     def _persist_device(self, host_id: str, device_id: str, local_id: int, device_info: Any) -> None:
         self._env_lists.append_to_csv_list("KNOWN_DEVICES", device_id)
         hk = host_key(host_id)
-        self._env_meta.set_kv_if_absent(f"HOST_{hk}_ID", host_id)  # reverse map
+        self._env_meta.set_kv_if_absent(f"HOST_{hk}_ID", host_id)
         self._env_lists.append_to_csv_list(f"HOST_{hk}_DEVICES", device_id)
 
-
         dk = sanitize_env_key(device_id)
         self._env_meta.upsert_kv(f"DEVICE_{dk}_HOST", host_id)
         self._env_meta.upsert_kv(f"DEVICE_{dk}_LOCAL_ID", str(int(local_id)))
@@ -312,14 +334,18 @@ class HostTunnelRegistry:
         if kind:
             self._env_meta.upsert_kv(f"DEVICE_{dk}_KIND", kind)
 
+        info(f"[registry] persisted device: host_id={host_id} device_id={device_id} local_id={int(local_id)} label={label!r} serial={serial!r} kind={kind!r}")
+
     # ---------------------------
     # directory/status mutators
     # ---------------------------
 
     def register_host(self, host_id: str, session: HostSession) -> None:
+        info(f"[registry] register_host: host_id={host_id}")
         with self._lock:
             old = self._hosts.get(host_id)
             if old is not None:
+                warn(f"[registry] register_host: replacing existing session host_id={host_id}")
                 old.close()
 
             self._hosts[host_id] = session
@@ -333,7 +359,10 @@ class HostTunnelRegistry:
             self._persist_host(host_id)
             self._invalidate_caches_locked()
 
+        info(f"[registry] register_host done: host_id={host_id} online=True")
+
     def drop_host(self, host_id: str) -> None:
+        info(f"[registry] drop_host: host_id={host_id}")
         with self._lock:
             sess = self._hosts.pop(host_id, None)
             if sess is not None:
@@ -344,7 +373,6 @@ class HostTunnelRegistry:
             hs.last_seen_ms = now_ms()
             self._host_status[host_id] = hs
 
-            # mark that host's devices offline (keep routes)
             for did in self._host_devices.get(host_id, set()):
                 ds = self._device_status.get(did)
                 if ds is not None:
@@ -353,6 +381,8 @@ class HostTunnelRegistry:
 
             self._invalidate_caches_locked()
 
+        info(f"[registry] drop_host done: host_id={host_id} online=False")
+
     def heartbeat(self, host_id: str, unix_ms: int = 0) -> None:
         now = int(unix_ms) or now_ms()
         with self._lock:
@@ -367,16 +397,14 @@ class HostTunnelRegistry:
                     ds.online = True
                     ds.last_seen_ms = now
 
-            # no need to invalidate full cache; active-cache TTL handles this
-            # but host status flips can matter; be conservative:
             self._invalidate_caches_locked()
 
+        info(f"[registry] heartbeat: host_id={host_id} unix_ms={now}")
+
     def announce_devices(self, host_id: str, devices: list) -> None:
-        """
-        Enforce global uniqueness of device_id:
-          - If any device_id is already owned by a different host -> raise DeviceIdConflictError.
-        """
-        # conflict check first (no partial apply)
+        info(f"[registry] announce_devices: host_id={host_id} n={len(devices)}")
+
+        # conflict check (no partial apply)
         with self._lock:
             for d in devices:
                 device_id = str(getattr(d, "device_id", "")).strip()
@@ -384,6 +412,7 @@ class HostTunnelRegistry:
                     continue
                 existing = self._routes.get(device_id)
                 if existing is not None and existing.host_id != host_id:
+                    warn(f"[registry] device_id conflict: device_id={device_id} existing_host={existing.host_id} new_host={host_id}")
                     raise DeviceIdConflictError(
                         device_id=device_id,
                         existing_host=existing.host_id,
@@ -397,19 +426,23 @@ class HostTunnelRegistry:
             for d in devices:
                 device_id = str(getattr(d, "device_id", "")).strip()
                 if not device_id:
+                    warn(f"[registry] announce_devices: skipping device with empty device_id host_id={host_id}")
                     continue
 
-                # local_id is basically not used; keep for completeness
                 try:
                     local_id = int(getattr(d, "local_id", 0))
                 except Exception:
                     local_id = 0
 
-                # route
+                label = str(getattr(d, "label", "") or "")
+                serial = str(getattr(d, "serial", "") or "")
+                kind = str(getattr(d, "kind", "") or "")
+
+                info(f"[registry] device: host_id={host_id} local_id={local_id} device_id={device_id!r} label={label!r} serial={serial!r} kind={kind!r}")
+
                 self._routes[device_id] = DeviceRoute(host_id=host_id, host_local_id=local_id)
                 self._host_devices[host_id].add(device_id)
 
-                # status
                 ds = self._device_status.get(device_id) or DeviceStatus(
                     device_id=device_id,
                     host_id=host_id,
@@ -421,34 +454,30 @@ class HostTunnelRegistry:
                 ds.last_seen_ms = now
                 self._device_status[device_id] = ds
 
-                # info (copy protobuf if possible)
                 try:
                     tmp = host_tunnel_pb2.DeviceInfo()
                     tmp.CopyFrom(d)
                     self._device_infos[device_id] = tmp
                 except Exception:
-                    # fallback minimal
                     self._device_infos[device_id] = host_tunnel_pb2.DeviceInfo(
                         device_id=device_id,
                         local_id=int(local_id),
-                        label=str(getattr(d, "label", "") or ""),
-                        serial=str(getattr(d, "serial", "") or ""),
-                        kind=str(getattr(d, "kind", "") or ""),
+                        label=label,
+                        serial=serial,
+                        kind=kind,
                     )
 
                 self._persist_device(host_id, device_id, local_id, d)
 
             self._invalidate_caches_locked()
 
+        info(f"[registry] announce_devices done: host_id={host_id} routes={len(self._routes)}")
+
     # ---------------------------
     # FAST PATHS (use per-RPC)
     # ---------------------------
 
     def is_host_device(self, device_id: str) -> bool:
-        """
-        O(1): does the directory route this device_id to a host?
-        (Host may be offline.)
-        """
         did = (device_id or "").strip()
         if not did:
             return False
@@ -456,14 +485,9 @@ class HostTunnelRegistry:
             return did in self._routes
 
     def is_host_device_active(self, device_id: str) -> bool:
-        """
-        O(1) route lookup + cached host-alive check (TTL).
-        True iff device routes to a host AND that host's tunnel session is alive.
-        """
         did = (device_id or "").strip()
         if not did:
             return False
-
         now = now_ms()
         with self._lock:
             route = self._routes.get(did)
@@ -485,37 +509,31 @@ class HostTunnelRegistry:
     # ---------------------------
 
     def device_directory_cached(self, *, ttl_ms: Optional[int] = None) -> Dict[str, Tuple[str, Any, bool]]:
-        """
-        Returns:
-          { device_id: (host_id, device_info, is_active) }
-
-        Cached rebuild at most once per ttl_ms.
-        """
         now = now_ms()
         ttl = int(self._dir_cache_ttl_ms if ttl_ms is None else ttl_ms)
 
         with self._lock:
             if self._dir_cache_ts_ms and (now - self._dir_cache_ts_ms) < ttl:
-                return dict(self._dir_cache)
+                # rebuild from saved cache is omitted (original returned dict(self._dir_cache))
+                pass
 
             self._refresh_active_hosts_cache_locked(now)
 
             out: Dict[str, Tuple[str, Any, bool]] = {}
             for device_id, route in self._routes.items():
                 info0 = self._device_infos.get(device_id)
-                info = info0
+                info_obj = info0
                 if info0 is not None:
                     tmp = host_tunnel_pb2.DeviceInfo()
                     try:
                         tmp.CopyFrom(info0)
-                        info = tmp
+                        info_obj = tmp
                     except Exception:
-                        info = info0
+                        info_obj = info0
 
                 is_active = route.host_id in self._active_hosts_cache
-                out[device_id] = (route.host_id, info, is_active)
+                out[device_id] = (route.host_id, info_obj, is_active)
 
-            self._dir_cache = out
             self._dir_cache_ts_ms = now
             return dict(out)
 
@@ -536,7 +554,7 @@ class HostTunnelRegistry:
             return dict(self._device_status)
 
     # ---------------------------
-    # forwarding (unchanged)
+    # forwarding
     # ---------------------------
 
     def _get_session_and_route(self, device_id: str) -> Tuple[HostSession, DeviceRoute]:
@@ -560,7 +578,15 @@ class HostTunnelRegistry:
         deadline_unix_ms: int = 0,
         cancel_on_timeout: bool = False,
     ) -> "generic_pb2.GenericRPCResponse":
-        sess, route = self._get_session_and_route(str(device_id))
+        info(f"[forward] device_id={device_id!r} fn={getattr(request,'function_name','')!r} timeout={timeout_sec}")
+        try:
+            sess, route = self._get_session_and_route(str(device_id))
+        except Exception:
+            exception(f"[forward] route/session lookup failed device_id={device_id!r}")
+            r = generic_pb2.GenericRPCResponse()
+            r.results["Ok"].CopyFrom(map_arg(False))
+            r.results["Error"].CopyFrom(map_arg("Route/session lookup failed (see server logs)."))
+            return r
 
         req_id = secrets.token_hex(12)
         fut: Future = Future()
@@ -578,6 +604,8 @@ class HostTunnelRegistry:
 
         frame = host_tunnel_pb2.HostFrame(rpc_request=rpc_req)
 
+        info(f"[forward] -> host_id={sess.host_id} req_id={req_id} local_id={route.host_local_id}")
+
         if not sess.send(frame, timeout=2.0):
             with sess.inflight_lock:
                 sess.inflight.pop(req_id, None)
@@ -590,11 +618,13 @@ class HostTunnelRegistry:
         try:
             resp: host_tunnel_pb2.RpcResponse = fut.result(timeout=timeout_sec)
         except Exception as e:
+            warn(f"[forward] timeout/exception waiting resp req_id={req_id} err={e!r}")
             if cancel_on_timeout:
                 try:
                     sess.send(host_tunnel_pb2.HostFrame(cancel=host_tunnel_pb2.Cancel(req_id=req_id)))
+                    info(f"[forward] sent cancel req_id={req_id}")
                 except Exception:
-                    pass
+                    exception(f"[forward] failed sending cancel req_id={req_id}")
 
             with sess.inflight_lock:
                 sess.inflight.pop(req_id, None)
@@ -607,6 +637,8 @@ class HostTunnelRegistry:
         with sess.inflight_lock:
             sess.inflight.pop(req_id, None)
 
+        info(f"[forward] <- resp req_id={req_id} ok={resp.ok} err={resp.error!r}")
+
         if not resp.ok:
             r = generic_pb2.GenericRPCResponse()
             r.results["Ok"].CopyFrom(map_arg(False))
@@ -628,12 +660,14 @@ class HostTunnelRegistry:
         with self._lock:
             route = self._routes.get(str(device_id))
             if route is None:
+                warn(f"[forward] unknown device_id={device_id!r}")
                 r = generic_pb2.GenericRPCResponse()
                 r.results["Ok"].CopyFrom(map_arg(False))
                 r.results["Error"].CopyFrom(map_arg(f"Unknown device_id={device_id}"))
                 return r
 
             if route.host_id != host_id:
+                warn(f"[forward] device_id={device_id!r} not on host_id={host_id!r} (actual={route.host_id!r})")
                 r = generic_pb2.GenericRPCResponse()
                 r.results["Ok"].CopyFrom(map_arg(False))
                 r.results["Error"].CopyFrom(map_arg(f"device_id={device_id} is not on host_id={host_id}"))
@@ -647,6 +681,7 @@ class HostTunnelRegistry:
             cancel_on_timeout=cancel_on_timeout,
         )
 
+
 def handle_host_device(
     registry: HostTunnelRegistry,
     *,
@@ -656,6 +691,7 @@ def handle_host_device(
     args: Any,
     timeout_sec: float = 10.0,
 ) -> Dict[str, Any]:
+    info(f"[handle_host_device] host_id={host_id!r} device_id={device_id!r} fn={function_name!r}")
     req = generic_pb2.GenericRPCRequest(function_name=str(function_name))
     _copy_argument_map(req.args, args)
 
@@ -677,6 +713,7 @@ def handle_host_device_request(
     request: "generic_pb2.GenericRPCRequest",
     timeout_sec: float = 10.0,
 ) -> "generic_pb2.GenericRPCResponse":
+    info(f"[handle_host_device_request] host_id={host_id!r} device_id={device_id!r} fn={getattr(request,'function_name','')!r}")
     return registry.forward_request_by_host_device(
         host_id=host_id,
         device_id=device_id,
@@ -691,6 +728,14 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
         self.registry = registry
 
     def Connect(self, request_iterator: Iterator[host_tunnel_pb2.HostFrame], context):
+        peer = ""
+        try:
+            peer = context.peer()
+        except Exception:
+            peer = "unknown-peer"
+
+        info(f"[Connect] new stream peer={peer}")
+
         host_id: Optional[str] = None
         session: Optional[HostSession] = None
         stop = threading.Event()
@@ -698,90 +743,184 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
 
         def inbound_loop():
             nonlocal host_id, session
+            info(f"[inbound] start peer={peer}")
             try:
                 for frame in request_iterator:
                     which = frame.WhichOneof("msg")
                     if which is None:
+                        warn(f"[inbound] received frame with no msg (peer={peer})")
                         continue
 
+                    info(f"[inbound] frame type={which} peer={peer} host_id={host_id or '?'}")
+
                     if which == "hello":
                         hello = frame.hello
-                        host_id = str(hello.host_id).strip() or "unknown-host"
+                        host_id = str(getattr(hello, "host_id", "")).strip() or "unknown-host"
+                        ver = str(getattr(hello, "version", "") or "")
+                        info(f"[inbound] HELLO host_id={host_id!r} version={ver!r} peer={peer}")
+
                         session = HostSession(host_id)
                         self.registry.register_host(host_id, session)
                         self.registry.persist_host_meta_from_hello(hello)
 
+                        # Ask host for metadata immediately on join
                         try:
-                            session.send(
+                            mrid = secrets.token_hex(12)
+                            ok = session.send(
+                                host_tunnel_pb2.HostFrame(
+                                    meta_request=host_tunnel_pb2.MetaRequest(
+                                        req_id=mrid,
+                                        include_platform=True,
+                                        include_env=True,
+                                        include_devices=True,
+                                    )
+                                )
+                            )
+                            info(f"[inbound] sent MetaRequest req_id={mrid} ok={ok} host_id={host_id}")
+                        except Exception:
+                            exception("[inbound] FAILED sending MetaRequest")
+
+                        # Also ping/ack
+                        try:
+                            ok = session.send(
                                 host_tunnel_pb2.HostFrame(
                                     heartbeat=host_tunnel_pb2.Heartbeat(unix_ms=now_ms())
                                 )
                             )
+                            info(f"[inbound] sent heartbeat ack ok={ok} host_id={host_id}")
                         except Exception:
-                            pass
+                            exception("[inbound] FAILED sending heartbeat ack")
 
                     elif which == "device_announce":
                         if session is None or host_id is None:
+                            warn("[inbound] device_announce before hello; ignoring")
                             continue
+
                         ann = frame.device_announce
+                        info(f"[inbound] DEVICE_ANNOUNCE host_id={host_id} n={len(ann.devices)} unix_ms={int(getattr(ann,'unix_ms',0) or 0)} full_snapshot={bool(getattr(ann,'full_snapshot',False))}")
+
+                        for d in list(ann.devices):
+                            info(
+                                f"[inbound]  device local_id={int(getattr(d,'local_id',0))} "
+                                f"label={str(getattr(d,'label','') or '')!r} "
+                                f"device_id={str(getattr(d,'device_id','') or '')!r} "
+                                f"serial={str(getattr(d,'serial','') or '')!r} "
+                                f"kind={str(getattr(d,'kind','') or '')!r}"
+                            )
+
                         try:
                             self.registry.announce_devices(host_id, list(ann.devices))
+                            info(f"[inbound] registry announce applied host_id={host_id}")
                         except DeviceIdConflictError as e:
+                            error(f"[inbound] DeviceIdConflictError host_id={host_id} err={e}")
                             fatal["code"] = "ALREADY_EXISTS"
                             fatal["details"] = str(e)
                             stop.set()
                             return
+                        except Exception:
+                            exception(f"[inbound] announce_devices crashed host_id={host_id}")
 
+                        # ack heartbeat
                         try:
-                            session.send(
+                            ok = session.send(
                                 host_tunnel_pb2.HostFrame(
                                     heartbeat=host_tunnel_pb2.Heartbeat(unix_ms=now_ms())
                                 )
                             )
+                            info(f"[inbound] sent heartbeat ack after announce ok={ok} host_id={host_id}")
                         except Exception:
-                            pass
+                            exception("[inbound] FAILED sending heartbeat ack after announce")
 
                     elif which == "rpc_response":
                         if session is None:
+                            warn("[inbound] rpc_response before session; ignoring")
                             continue
                         resp = frame.rpc_response
-                        rid = str(resp.req_id)
+                        rid = str(getattr(resp, "req_id", ""))
+
+                        info(f"[inbound] RPC_RESPONSE req_id={rid} ok={bool(getattr(resp,'ok',False))} err={str(getattr(resp,'error','') or '')!r}")
 
                         with session.inflight_lock:
                             fut = session.inflight.get(rid)
 
                         if fut is not None and not fut.done():
                             fut.set_result(resp)
+                            info(f"[inbound] rpc_response delivered to inflight future req_id={rid}")
+                        else:
+                            warn(f"[inbound] rpc_response has no inflight waiter req_id={rid}")
+
+                    elif which == "meta_response":
+                        try:
+                            mr = frame.meta_response
+                            ok = bool(getattr(mr, "ok", False))
+                            err_s = str(getattr(mr, "error", "") or "")
+                            info(f"[inbound] META_RESPONSE ok={ok} error={err_s!r}")
+
+                            # Print full proto for maximum visibility
+                            try:
+                                info(f"[inbound] META_RESPONSE proto:\n{mr}")
+                            except Exception:
+                                pass
+
+                        except Exception:
+                            exception("[inbound] meta_response handling crashed")
 
                     elif which == "heartbeat":
                         if session is not None and host_id is not None:
-                            session.last_heartbeat_ms = int(frame.heartbeat.unix_ms) or now_ms()
-                            self.registry.heartbeat(host_id, int(frame.heartbeat.unix_ms) or 0)
+                            ms = int(getattr(frame.heartbeat, "unix_ms", 0) or 0) or now_ms()
+                            session.last_heartbeat_ms = ms
+                            self.registry.heartbeat(host_id, ms)
+                            info(f"[inbound] HEARTBEAT host_id={host_id} unix_ms={ms}")
+                        else:
+                            warn("[inbound] heartbeat before hello/session; ignoring")
 
                     elif which == "cancel":
-                        pass
+                        # not used on server inbound, but log it if it happens
+                        try:
+                            rid = str(getattr(frame.cancel, "req_id", "") or "")
+                            warn(f"[inbound] CANCEL frame received from host?? req_id={rid}")
+                        except Exception:
+                            exception("[inbound] cancel frame parsing failed")
+
+                    else:
+                        warn(f"[inbound] unknown frame type={which}")
 
             except Exception:
-                pass
+                exception(f"[inbound] loop crashed peer={peer} host_id={host_id or '?'}")
             finally:
+                info(f"[inbound] exiting peer={peer} host_id={host_id or '?'}")
                 stop.set()
                 if host_id is not None:
-                    self.registry.drop_host(host_id)
+                    try:
+                        self.registry.drop_host(host_id)
+                    except Exception:
+                        exception(f"[inbound] registry.drop_host failed host_id={host_id}")
                 if session is not None:
-                    session.close()
+                    try:
+                        session.close()
+                    except Exception:
+                        exception(f"[inbound] session.close failed host_id={host_id}")
 
-        t = threading.Thread(target=inbound_loop, daemon=True)
+        t = threading.Thread(target=inbound_loop, daemon=True, name=f"inbound_{peer}")
         t.start()
 
+        info(f"[Connect] outbound pump starting peer={peer}")
+
+        # outbound pump
+        saw_session = False
         while not stop.is_set():
             if fatal:
                 code = fatal.get("code", "")
                 details = fatal.get("details", "fatal")
+                error(f"[Connect] aborting stream peer={peer} code={code} details={details}")
                 if code == "ALREADY_EXISTS":
                     context.abort(grpc.StatusCode.ALREADY_EXISTS, details)
                 context.abort(grpc.StatusCode.UNKNOWN, details)
 
             if session is None:
+                if not saw_session:
+                    info(f"[Connect] waiting for HELLO peer={peer}")
+                    saw_session = True
                 time.sleep(0.05)
                 continue
 
@@ -789,11 +928,20 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                 out = session.out_q.get(timeout=0.5)
             except queue.Empty:
                 continue
+            except Exception:
+                exception(f"[Connect] outbound queue get failed peer={peer} host_id={host_id or '?'}")
+                continue
 
             if out is None:
+                info(f"[Connect] outbound sentinel -> end stream peer={peer} host_id={host_id or '?'}")
                 break
+
+            out_type = out.WhichOneof("msg")
+            info(f"[Connect] OUT frame type={out_type} peer={peer} host_id={host_id or '?'}")
             yield out
 
+        info(f"[Connect] stream ended peer={peer} host_id={host_id or '?'}")
+
 
 def build_server_credentials(
     *,
@@ -802,13 +950,14 @@ def build_server_credentials(
     client_ca_pem: Optional[bytes] = None,
     require_client_auth: bool = True,
 ) -> grpc.ServerCredentials:
+    info(f"[creds] build_server_credentials client_ca={'yes' if bool(client_ca_pem) else 'no'} require_client_auth={require_client_auth}")
     if client_ca_pem:
         return grpc.ssl_server_credentials(
             ((private_key_pem, certificate_chain_pem,),),
             root_certificates=client_ca_pem,
             require_client_auth=require_client_auth,
         )
-    return grpc.ssl_server_credentials(((private_key_pem, certificate_chain_pem,),))
+    return grpc.ssl_server_credentials(((private_key_pem, certificate_chain_pem),))
 
 
 def start_host_tunnel_server(
@@ -830,18 +979,33 @@ def start_host_tunnel_server(
         ("grpc.keepalive_permit_without_calls", 1),
     ]
 
+    info(f"[server] creating grpc.server max_workers={max_workers} bind={host}:{int(port)}")
     server = grpc.server(
         futures.ThreadPoolExecutor(max_workers=max_workers),
         options=options,
     )
 
     host_tunnel_pb2_grpc.add_HostTunnelServicer_to_server(HostTunnelServicer(reg), server)
-    server.add_secure_port(f"{host}:{int(port)}", server_credentials)
+
+    bind_addr = f"{host}:{int(port)}"
+    try:
+        added = server.add_secure_port(bind_addr, server_credentials)
+        info(f"[server] add_secure_port addr={bind_addr} -> {added}")
+    except Exception:
+        exception(f"[server] add_secure_port failed addr={bind_addr}")
+        raise
 
     def run():
-        server.start()
-        server.wait_for_termination()
+        try:
+            info(f"[server] starting on {bind_addr}")
+            server.start()
+            info(f"[server] started on {bind_addr} (waiting for termination)")
+            server.wait_for_termination()
+            info("[server] wait_for_termination returned")
+        except Exception:
+            exception("[server] run() crashed")
+            raise
 
-    th = threading.Thread(target=run, daemon=True)
+    th = threading.Thread(target=run, daemon=True, name="host_tunnel_server")
     th.start()
-    return server, th, reg
+    return server, th, reg

{remoterf_server-0.1.63 → remoterf_server-0.1.65}/src/remoteRF_server.egg-info/PKG-INFO

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