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

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

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

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

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

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

@@ -8,11 +8,14 @@ import queue
 import time
 import secrets
 import traceback
+import hashlib
+import re
+
 from dataclasses import dataclass
 from typing import Dict, Optional, Tuple, Any, List, Set, Iterator
+
 from concurrent.futures import Future
 from concurrent import futures
-from pathlib import Path
 
 import grpc
 
@@ -34,11 +37,8 @@ from .host_directory_store import (
     cfg_dir_from_file,
 )
 
-import hashlib
-
-
 # =============================================================================
-# Always-on logging (no levels to configure; INFO/WARN/ERROR always print)
+# Always-on logging (INFO/WARN/ERROR always print; no config/levels)
 # =============================================================================
 
 def _ts() -> str:
@@ -66,10 +66,17 @@ def exception(msg: str) -> None:
     traceback.print_exc(limit=80, file=sys.stderr)
 
 
+# =============================================================================
+# Helpers
+# =============================================================================
+
 def host_key(host_id: str) -> str:
     h = hashlib.sha256((host_id or "").encode("utf-8")).hexdigest()
     return h[:16]  # short stable key
 
+def _safe_thread_tag(s: str) -> str:
+    s = s or "peer"
+    return re.sub(r"[^A-Za-z0-9_.-]+", "_", s)[:64]
 
 def _copy_argument_map(dst_map: Any, src_map: Any) -> None:
     if src_map is None:
@@ -82,19 +89,21 @@ def _copy_argument_map(dst_map: Any, src_map: Any) -> None:
             dst_map[str(k)].CopyFrom(v)
 
 
+# =============================================================================
+# Types
+# =============================================================================
+
 @dataclass(frozen=True)
 class DeviceRoute:
     host_id: str
     host_local_id: int
 
-
 @dataclass
 class HostStatus:
     host_id: str
     online: bool = False
     last_seen_ms: int = 0
 
-
 @dataclass
 class DeviceStatus:
     device_id: str
@@ -104,6 +113,10 @@ class DeviceStatus:
     last_seen_ms: int = 0
 
 
+# =============================================================================
+# Session
+# =============================================================================
+
 class HostSession:
     """
     Represents one connected host (one bidi stream).
@@ -113,48 +126,54 @@ class HostSession:
     """
     def __init__(self, host_id: str, *, outbound_max: int = 2048) -> None:
         self.host_id = host_id
-        self.out_q: "queue.Queue[Optional[host_tunnel_pb2.HostFrame]]" = queue.Queue(maxsize=outbound_max)
+        self.out_q: "queue.Queue[Optional[host_tunnel_pb2.HostFrame]]" = queue.Queue(maxsize=int(outbound_max))
         self.inflight: Dict[str, Future] = {}
         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}")
+        info(f"[session] created host_id={self.host_id!r} outbound_max={self.outbound_max}")
 
     def send(self, frame: host_tunnel_pb2.HostFrame, *, timeout: float = 2.0) -> bool:
+        which = frame.WhichOneof("msg")
         if not self.alive:
-            warn(f"[session] send refused: host_id={self.host_id} (session not alive) frame={frame.WhichOneof('msg')}")
+            warn(f"[session] send refused (dead session) host_id={self.host_id!r} type={which}")
             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}")
+            info(f"[session] queued outbound host_id={self.host_id!r} 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}")
+            warn(f"[session] outbound queue FULL host_id={self.host_id!r} max={self.outbound_max} drop type={which}")
             return False
         except Exception:
-            exception(f"[session] send exception host_id={self.host_id} type={which}")
+            exception(f"[session] send exception host_id={self.host_id!r} type={which}")
             return False
 
     def close(self) -> None:
         if not self.alive:
             return
-        info(f"[session] closing host_id={self.host_id}")
+        info(f"[session] closing host_id={self.host_id!r}")
         self.alive = False
+
         try:
             self.out_q.put_nowait(None)
         except Exception:
-            exception(f"[session] close: failed to enqueue sentinel host_id={self.host_id}")
+            exception(f"[session] close: failed to enqueue sentinel host_id={self.host_id!r}")
 
         with self.inflight_lock:
             for rid, fut in list(self.inflight.items()):
                 if not fut.done():
                     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}")
 
+        info(f"[session] closed host_id={self.host_id!r}")
+
+
+# =============================================================================
+# Registry
+# =============================================================================
 
 class HostTunnelRegistry:
     """
@@ -175,9 +194,9 @@ class HostTunnelRegistry:
         self._hosts: Dict[str, HostSession] = {}  # host_id -> session
 
         # 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
+        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
         self._host_status: Dict[str, HostStatus] = {}
@@ -194,13 +213,17 @@ 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, Tuple[str, Any, bool], bool]] = {}  # not used externally
+        self._dir_cache: Dict[str, Tuple[str, Any, bool]] = {}
         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:
         self._active_hosts_cache_ts_ms = 0
         self._dir_cache_ts_ms = 0
@@ -231,6 +254,7 @@ class HostTunnelRegistry:
             self._host_status.clear()
             self._device_status.clear()
 
+            # seed hosts offline
             for hid in known_hosts:
                 if hid:
                     self._host_status[hid] = HostStatus(host_id=hid, online=False, last_seen_ms=0)
@@ -305,13 +329,13 @@ class HostTunnelRegistry:
             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}")
+                info(f"[registry] persisted host meta from hello: host_id={hid!r} 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}")
+        info(f"[registry] persisted host list: host_id={host_id!r}")
 
     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)
@@ -334,18 +358,21 @@ 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}")
+        info(
+            f"[registry] persisted device: host_id={host_id!r} device_id={device_id!r} local_id={int(local_id)} "
+            f"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}")
+        info(f"[registry] register_host: host_id={host_id!r}")
         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}")
+                warn(f"[registry] register_host: replacing existing session host_id={host_id!r}")
                 old.close()
 
             self._hosts[host_id] = session
@@ -359,10 +386,10 @@ class HostTunnelRegistry:
             self._persist_host(host_id)
             self._invalidate_caches_locked()
 
-        info(f"[registry] register_host done: host_id={host_id} online=True")
+        info(f"[registry] register_host done: host_id={host_id!r} online=True")
 
     def drop_host(self, host_id: str) -> None:
-        info(f"[registry] drop_host: host_id={host_id}")
+        info(f"[registry] drop_host: host_id={host_id!r}")
         with self._lock:
             sess = self._hosts.pop(host_id, None)
             if sess is not None:
@@ -381,7 +408,7 @@ class HostTunnelRegistry:
 
             self._invalidate_caches_locked()
 
-        info(f"[registry] drop_host done: host_id={host_id} online=False")
+        info(f"[registry] drop_host done: host_id={host_id!r} online=False")
 
     def heartbeat(self, host_id: str, unix_ms: int = 0) -> None:
         now = int(unix_ms) or now_ms()
@@ -399,12 +426,12 @@ class HostTunnelRegistry:
 
             self._invalidate_caches_locked()
 
-        info(f"[registry] heartbeat: host_id={host_id} unix_ms={now}")
+        info(f"[registry] heartbeat: host_id={host_id!r} unix_ms={now}")
 
     def announce_devices(self, host_id: str, devices: list) -> None:
-        info(f"[registry] announce_devices: host_id={host_id} n={len(devices)}")
+        info(f"[registry] announce_devices: host_id={host_id!r} n={len(devices)}")
 
-        # conflict check (no partial apply)
+        # conflict check first (no partial apply)
         with self._lock:
             for d in devices:
                 device_id = str(getattr(d, "device_id", "")).strip()
@@ -412,7 +439,10 @@ 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}")
+                    warn(
+                        f"[registry] device_id conflict: device_id={device_id!r} "
+                        f"existing_host={existing.host_id!r} new_host={host_id!r}"
+                    )
                     raise DeviceIdConflictError(
                         device_id=device_id,
                         existing_host=existing.host_id,
@@ -426,7 +456,7 @@ 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}")
+                    warn(f"[registry] announce_devices: skipping device with empty device_id host_id={host_id!r}")
                     continue
 
                 try:
@@ -438,7 +468,10 @@ class HostTunnelRegistry:
                 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}")
+                info(
+                    f"[registry] device: host_id={host_id!r} local_id={local_id} "
+                    f"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)
@@ -471,7 +504,7 @@ class HostTunnelRegistry:
 
             self._invalidate_caches_locked()
 
-        info(f"[registry] announce_devices done: host_id={host_id} routes={len(self._routes)}")
+        info(f"[registry] announce_devices done: host_id={host_id!r} routes={len(self._routes)}")
 
     # ---------------------------
     # FAST PATHS (use per-RPC)
@@ -514,8 +547,7 @@ class HostTunnelRegistry:
 
         with self._lock:
             if self._dir_cache_ts_ms and (now - self._dir_cache_ts_ms) < ttl:
-                # rebuild from saved cache is omitted (original returned dict(self._dir_cache))
-                pass
+                return dict(self._dir_cache)
 
             self._refresh_active_hosts_cache_locked(now)
 
@@ -534,6 +566,7 @@ class HostTunnelRegistry:
                 is_active = route.host_id in self._active_hosts_cache
                 out[device_id] = (route.host_id, info_obj, is_active)
 
+            self._dir_cache = out
             self._dir_cache_ts_ms = now
             return dict(out)
 
@@ -578,14 +611,16 @@ class HostTunnelRegistry:
         deadline_unix_ms: int = 0,
         cancel_on_timeout: bool = False,
     ) -> "generic_pb2.GenericRPCResponse":
-        info(f"[forward] device_id={device_id!r} fn={getattr(request,'function_name','')!r} timeout={timeout_sec}")
+        fn = str(getattr(request, "function_name", "") or "")
+        info(f"[forward] device_id={device_id!r} fn={fn!r} timeout_sec={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}")
+        except Exception as e:
+            exception(f"[forward] route/session lookup failed device_id={device_id!r} err={e!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)."))
+            r.results["Error"].CopyFrom(map_arg(f"Route/session lookup failed: {e}"))
             return r
 
         req_id = secrets.token_hex(12)
@@ -604,7 +639,7 @@ 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}")
+        info(f"[forward] -> host_id={sess.host_id!r} req_id={req_id} local_id={route.host_local_id}")
 
         if not sess.send(frame, timeout=2.0):
             with sess.inflight_lock:
@@ -615,14 +650,17 @@ class HostTunnelRegistry:
             r.results["Error"].CopyFrom(map_arg(f"Host '{sess.host_id}' outbound queue full / not writable."))
             return r
 
+        t0 = time.time()
         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}")
+            dt_ms = int((time.time() - t0) * 1000)
+            warn(f"[forward] wait failed req_id={req_id} dt_ms={dt_ms} 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}")
+                    ok = sess.send(host_tunnel_pb2.HostFrame(cancel=host_tunnel_pb2.Cancel(req_id=req_id)))
+                    info(f"[forward] sent cancel req_id={req_id} ok={ok}")
                 except Exception:
                     exception(f"[forward] failed sending cancel req_id={req_id}")
 
@@ -637,7 +675,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}")
+        dt_ms = int((time.time() - t0) * 1000)
+        info(f"[forward] <- resp req_id={req_id} ok={bool(resp.ok)} dt_ms={dt_ms} err={str(resp.error or '')!r}")
 
         if not resp.ok:
             r = generic_pb2.GenericRPCResponse()
@@ -682,6 +721,10 @@ class HostTunnelRegistry:
         )
 
 
+# =============================================================================
+# Convenience forwarders
+# =============================================================================
+
 def handle_host_device(
     registry: HostTunnelRegistry,
     *,
@@ -704,7 +747,6 @@ def handle_host_device(
     )
     return dict(resp.results)
 
-
 def handle_host_device_request(
     registry: HostTunnelRegistry,
     *,
@@ -713,7 +755,10 @@ 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}")
+    info(
+        f"[handle_host_device_request] host_id={host_id!r} device_id={device_id!r} "
+        f"fn={str(getattr(request,'function_name','') or '')!r}"
+    )
     return registry.forward_request_by_host_device(
         host_id=host_id,
         device_id=device_id,
@@ -723,17 +768,21 @@ def handle_host_device_request(
     )
 
 
+# =============================================================================
+# Servicer
+# =============================================================================
+
 class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
     def __init__(self, registry: HostTunnelRegistry) -> None:
         self.registry = registry
 
     def Connect(self, request_iterator: Iterator[host_tunnel_pb2.HostFrame], context):
-        peer = ""
         try:
             peer = context.peer()
         except Exception:
             peer = "unknown-peer"
 
+        peer_tag = _safe_thread_tag(peer)
         info(f"[Connect] new stream peer={peer}")
 
         host_id: Optional[str] = None
@@ -744,14 +793,15 @@ 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})")
+                        warn(f"[inbound] frame with no msg peer={peer}")
                         continue
 
-                    info(f"[inbound] frame type={which} peer={peer} host_id={host_id or '?'}")
+                    info(f"[inbound] IN type={which} peer={peer} host_id={host_id or '?'}")
 
                     if which == "hello":
                         hello = frame.hello
@@ -776,28 +826,28 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                                     )
                                 )
                             )
-                            info(f"[inbound] sent MetaRequest req_id={mrid} ok={ok} host_id={host_id}")
+                            info(f"[inbound] sent MetaRequest req_id={mrid} ok={ok} host_id={host_id!r}")
                         except Exception:
                             exception("[inbound] FAILED sending MetaRequest")
 
-                        # Also ping/ack
+                        # heartbeat 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}")
+                            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!r}")
                         except Exception:
                             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")
+                            warn(f"[inbound] device_announce before hello/session: ignoring peer={peer}")
                             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))}")
+                        n = len(getattr(ann, "devices", []))
+                        info(
+                            f"[inbound] DEVICE_ANNOUNCE host_id={host_id!r} n={n} "
+                            f"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(
@@ -810,42 +860,40 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
 
                         try:
                             self.registry.announce_devices(host_id, list(ann.devices))
-                            info(f"[inbound] registry announce applied host_id={host_id}")
+                            info(f"[inbound] registry announce applied host_id={host_id!r}")
                         except DeviceIdConflictError as e:
-                            error(f"[inbound] DeviceIdConflictError host_id={host_id} err={e}")
+                            error(f"[inbound] DeviceIdConflictError host_id={host_id!r} 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}")
+                            exception(f"[inbound] announce_devices crashed host_id={host_id!r}")
 
-                        # ack heartbeat
+                        # heartbeat ack after announce
                         try:
-                            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}")
+                            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!r}")
                         except Exception:
                             exception("[inbound] FAILED sending heartbeat ack after announce")
 
                     elif which == "rpc_response":
                         if session is None:
-                            warn("[inbound] rpc_response before session; ignoring")
+                            warn(f"[inbound] rpc_response before session: ignoring peer={peer}")
                             continue
-                        resp = frame.rpc_response
-                        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}")
+                        resp = frame.rpc_response
+                        rid = str(getattr(resp, "req_id", "") or "")
+                        ok = bool(getattr(resp, "ok", False))
+                        err_s = str(getattr(resp, "error", "") or "")
+                        info(f"[inbound] RPC_RESPONSE req_id={rid} ok={ok} error={err_s!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}")
+                            info(f"[inbound] delivered rpc_response to waiter req_id={rid}")
                         else:
                             warn(f"[inbound] rpc_response has no inflight waiter req_id={rid}")
 
@@ -855,13 +903,10 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                             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")
 
@@ -870,20 +915,19 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                             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}")
+                            info(f"[inbound] HEARTBEAT host_id={host_id!r} unix_ms={ms}")
                         else:
-                            warn("[inbound] heartbeat before hello/session; ignoring")
+                            warn(f"[inbound] heartbeat before hello/session: ignoring peer={peer} host_id={(host_id or '?')!r}")
 
                     elif which == "cancel":
-                        # 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}")
+                            warn(f"[inbound] CANCEL received from host?? req_id={rid} peer={peer}")
                         except Exception:
-                            exception("[inbound] cancel frame parsing failed")
+                            exception("[inbound] cancel frame parse failed")
 
                     else:
-                        warn(f"[inbound] unknown frame type={which}")
+                        warn(f"[inbound] unknown frame type={which} peer={peer}")
 
             except Exception:
                 exception(f"[inbound] loop crashed peer={peer} host_id={host_id or '?'}")
@@ -894,20 +938,19 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                     try:
                         self.registry.drop_host(host_id)
                     except Exception:
-                        exception(f"[inbound] registry.drop_host failed host_id={host_id}")
+                        exception(f"[inbound] registry.drop_host failed host_id={host_id!r}")
                 if session is not None:
                     try:
                         session.close()
                     except Exception:
-                        exception(f"[inbound] session.close failed host_id={host_id}")
+                        exception(f"[inbound] session.close failed host_id={host_id!r}")
 
-        t = threading.Thread(target=inbound_loop, daemon=True, name=f"inbound_{peer}")
+        t = threading.Thread(target=inbound_loop, daemon=True, name=f"inbound_{peer_tag}")
         t.start()
 
         info(f"[Connect] outbound pump starting peer={peer}")
 
-        # outbound pump
-        saw_session = False
+        printed_waiting = False
         while not stop.is_set():
             if fatal:
                 code = fatal.get("code", "")
@@ -918,9 +961,9 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                 context.abort(grpc.StatusCode.UNKNOWN, details)
 
             if session is None:
-                if not saw_session:
+                if not printed_waiting:
                     info(f"[Connect] waiting for HELLO peer={peer}")
-                    saw_session = True
+                    printed_waiting = True
                 time.sleep(0.05)
                 continue
 
@@ -937,12 +980,16 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                 break
 
             out_type = out.WhichOneof("msg")
-            info(f"[Connect] OUT frame type={out_type} peer={peer} host_id={host_id or '?'}")
+            info(f"[Connect] OUT type={out_type} peer={peer} host_id={host_id or '?'}")
             yield out
 
         info(f"[Connect] stream ended peer={peer} host_id={host_id or '?'}")
 
 
+# =============================================================================
+# Credentials + server start
+# =============================================================================
+
 def build_server_credentials(
     *,
     private_key_pem: bytes,
@@ -979,7 +1026,9 @@ 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)}")
+    bind_addr = f"{host}:{int(port)}"
+    info(f"[server] creating grpc.server max_workers={max_workers} bind={bind_addr}")
+
     server = grpc.server(
         futures.ThreadPoolExecutor(max_workers=max_workers),
         options=options,
@@ -987,7 +1036,6 @@ def start_host_tunnel_server(
 
     host_tunnel_pb2_grpc.add_HostTunnelServicer_to_server(HostTunnelServicer(reg), server)
 
-    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}")

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

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