remoteRF-server 0.1.77__tar.gz → 0.1.79__tar.gz

{remoterf_server-0.1.77 → remoterf_server-0.1.79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 0.1.77
+Version: 0.1.79
 Description-Content-Type: text/markdown
 Requires-Dist: grpcio
 Requires-Dist: protobuf
@@ -348,9 +348,11 @@ todo:
 
 <!-- HostRF meta data -> push upon connection + retry connection on host side. -->
 
-Host ID (NEEDS TO BE UNIQUE AND TELL THE HOST THAT) (or if device also does it as well.)
+<!-- Host ID (NEEDS TO BE UNIQUE AND TELL THE HOST THAT) (or if device also does it as well.) -->
 
-ServerRF display meta data as part of devices list / reservation + online/activity status (appended into device name) + (plus host side warning if the device id is NOT globally unique!)
+ServerRF display meta data as part of devices list / reservation 
+
++ online/activity status (appended into device name) + (plus host side warning if the device id is NOT globally unique!)
 
 set_device token (virtual devices) + routing/relay to proper host (multiplexed)
 

{remoterf_server-0.1.77 → remoterf_server-0.1.79}/README.md

@@ -337,9 +337,11 @@ todo:
 
 <!-- HostRF meta data -> push upon connection + retry connection on host side. -->
 
-Host ID (NEEDS TO BE UNIQUE AND TELL THE HOST THAT) (or if device also does it as well.)
+<!-- Host ID (NEEDS TO BE UNIQUE AND TELL THE HOST THAT) (or if device also does it as well.) -->
 
-ServerRF display meta data as part of devices list / reservation + online/activity status (appended into device name) + (plus host side warning if the device id is NOT globally unique!)
+ServerRF display meta data as part of devices list / reservation 
+
++ online/activity status (appended into device name) + (plus host side warning if the device id is NOT globally unique!)
 
 set_device token (virtual devices) + routing/relay to proper host (multiplexed)
 

{remoterf_server-0.1.77 → remoterf_server-0.1.79}/pyproject.toml

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

{remoterf_server-0.1.77 → remoterf_server-0.1.79}/src/remoteRF_server/host/host_tunnel_server.py

@@ -10,7 +10,7 @@ import secrets
 import traceback
 import hashlib
 import re
-import os
+import uuid
 
 from dataclasses import dataclass
 from typing import Dict, Optional, Tuple, Any, List, Set, Iterator
@@ -47,12 +47,13 @@ from .host_directory_store import (
 #   LOG_MODE = "ALL"   -> show everything (INFO + WARN + ERROR)
 # =============================================================================
 
-LOG_MODE = "OFF"  # <-- change this
+LOG_MODE = "WARN"  # <-- set to ALL while debugging session UUIDs
 
 _LOG_LOCK = threading.Lock()
 
 HOST_ID_RE = re.compile(r"^[A-Za-z0-9_.-]{1,64}$")  # adjust if you want
 
+
 class HostIdConflictError(RuntimeError):
     def __init__(self, host_id: str, *, age_ms: int, replace_after_ms: int) -> None:
         super().__init__(
@@ -63,6 +64,7 @@ class HostIdConflictError(RuntimeError):
         self.age_ms = age_ms
         self.replace_after_ms = replace_after_ms
 
+
 def _validate_host_id(raw: str) -> str:
     hid = (raw or "").strip()
     if not hid:
@@ -76,6 +78,7 @@ def _validate_host_id(raw: str) -> str:
         )
     return hid
 
+
 def _ts() -> str:
     t = time.time()
     sec = int(t)
@@ -83,6 +86,7 @@ def _ts() -> str:
     lt = time.localtime(sec)
     return time.strftime("%H:%M:%S", lt) + f".{ms:03d}"
 
+
 def _should_log(level: str) -> bool:
     lvl = (level or "").upper()
     mode = (LOG_MODE or "").upper()
@@ -92,28 +96,34 @@ def _should_log(level: str) -> bool:
         return lvl in ("WARN", "ERROR")
     if mode == "ALL":
         return lvl in ("INFO", "WARN", "ERROR")
-    # safe default if mis-set
     return lvl in ("WARN", "ERROR")
 
+
 def _log(level: str, msg: str) -> None:
     if not _should_log(level):
         return
     tn = threading.current_thread().name
-    print(f"{_ts()} {level:<5} [{tn}] hostrf.host_tunnel_server: {msg}", file=sys.stderr, flush=True)
+    with _LOG_LOCK:
+        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)
 
+
 # =============================================================================
 # Helpers
 # =============================================================================
@@ -122,10 +132,12 @@ 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:
         return
@@ -136,6 +148,7 @@ def _copy_argument_map(dst_map: Any, src_map: Any) -> None:
         for k, v in dict(src_map).items():
             dst_map[str(k)].CopyFrom(v)
 
+
 # =============================================================================
 # Types
 # =============================================================================
@@ -145,12 +158,14 @@ 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
@@ -159,19 +174,17 @@ class DeviceStatus:
     online: bool = False
     last_seen_ms: int = 0
 
+
 # =============================================================================
 # Session
 # =============================================================================
 
 class HostSession:
-    """
-    Represents one connected host (one bidi stream).
-    Owns:
-      - outbound frame queue
-      - inflight req_id -> Future
-    """
-    def __init__(self, host_id: str, *, outbound_max: int = 2048) -> None:
+    def __init__(self, host_id: str, *, peer: str = "<?>", session_uuid: str = "", outbound_max: int = 2048) -> None:
         self.host_id = host_id
+        self.peer = peer
+        self.session_uuid = (session_uuid or uuid.uuid4().hex[:10])
+
         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()
@@ -179,34 +192,40 @@ class HostSession:
         self.alive = True
         self.outbound_max = int(outbound_max)
 
-        info(f"[session] created host_id={self.host_id!r} outbound_max={self.outbound_max}")
+        info(
+            f"[session] created host_id={self.host_id!r} sess={self.session_uuid} "
+            f"peer={self.peer} 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 (dead session) host_id={self.host_id!r} type={which}")
+            warn(f"[session] send refused (dead session) host_id={self.host_id!r} sess={self.session_uuid} type={which}")
             return False
         try:
             self.out_q.put(frame, timeout=timeout)
-            info(f"[session] queued outbound host_id={self.host_id!r} type={which}")
+            info(f"[session] queued outbound host_id={self.host_id!r} sess={self.session_uuid} type={which}")
             return True
         except queue.Full:
-            warn(f"[session] outbound queue FULL host_id={self.host_id!r} max={self.outbound_max} drop type={which}")
+            warn(
+                f"[session] outbound queue FULL host_id={self.host_id!r} sess={self.session_uuid} "
+                f"max={self.outbound_max} drop type={which}"
+            )
             return False
         except Exception:
-            exception(f"[session] send exception host_id={self.host_id!r} type={which}")
+            exception(f"[session] send exception host_id={self.host_id!r} sess={self.session_uuid} type={which}")
             return False
 
     def close(self) -> None:
         if not self.alive:
             return
-        info(f"[session] closing host_id={self.host_id!r}")
+        info(f"[session] closing host_id={self.host_id!r} sess={self.session_uuid} peer={self.peer}")
         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!r}")
+            exception(f"[session] close: failed to enqueue sentinel host_id={self.host_id!r} sess={self.session_uuid}")
 
         with self.inflight_lock:
             for rid, fut in list(self.inflight.items()):
@@ -214,7 +233,8 @@ class HostSession:
                     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!r}")
+        info(f"[session] closed host_id={self.host_id!r} sess={self.session_uuid}")
+
 
 # =============================================================================
 # Registry
@@ -352,7 +372,10 @@ 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)}")
+        info(
+            f"[registry] persisted directory loaded: routes={len(self._routes)} "
+            f"hosts={len(self._host_status)} devices={len(self._device_status)}"
+        )
 
     # ---------------------------
     # persistence write helpers
@@ -412,28 +435,33 @@ class HostTunnelRegistry:
     # directory/status mutators
     # ---------------------------
 
-    def register_host(
-        self,
-        host_id: str,
-        session: HostSession,
-        *,
-        replace_if_stale_ms: int = 15_000,  # tweak: how long without heartbeat before we allow replacement
-    ) -> None:
-        info(f"[registry] register_host: host_id={host_id!r}")
+    def register_host(self, host_id: str, session: HostSession, *, replace_if_stale_ms: int = 15_000) -> None:
+        info(
+            f"[registry] register_host: host_id={host_id!r} incoming_sess={session.session_uuid} "
+            f"incoming_peer={session.peer}"
+        )
 
         with self._lock:
             old = self._hosts.get(host_id)
             if old is not None and old.alive:
                 age_ms = int(now_ms() - int(getattr(old, "last_heartbeat_ms", 0) or 0))
+
                 if age_ms < replace_if_stale_ms:
-                    # conflict: someone else is already using this host_id
+                    warn(
+                        f"[registry] HostIdConflict host_id={host_id!r} age_ms={age_ms} "
+                        f"incoming_sess={session.session_uuid} incoming_peer={session.peer} "
+                        f"existing_sess={getattr(old,'session_uuid','?')} existing_peer={getattr(old,'peer','?')}"
+                    )
                     raise HostIdConflictError(host_id, age_ms=age_ms, replace_after_ms=replace_if_stale_ms)
 
-                # stale: allow replacement
-                warn(f"[registry] register_host: replacing STALE session host_id={host_id!r} age_ms={age_ms}")
+                warn(
+                    f"[registry] replacing STALE host_id={host_id!r} age_ms={age_ms} "
+                    f"incoming_sess={session.session_uuid} incoming_peer={session.peer} "
+                    f"existing_sess={getattr(old,'session_uuid','?')} existing_peer={getattr(old,'peer','?')}"
+                )
                 old.close()
 
-            self._hosts[host_id] = session
+            self._hosts[host_id] = session  # (removed duplicate assignment)
 
             hs = self._host_status.get(host_id) or HostStatus(host_id=host_id)
             hs.online = True
@@ -444,7 +472,7 @@ class HostTunnelRegistry:
             self._persist_host(host_id)
             self._invalidate_caches_locked()
 
-        info(f"[registry] register_host done: host_id={host_id!r} online=True")
+        info(f"[registry] register_host done: host_id={host_id!r} online=True incoming_sess={session.session_uuid}")
 
     def drop_host(self, host_id: str) -> None:
         info(f"[registry] drop_host: host_id={host_id!r}")
@@ -778,6 +806,7 @@ class HostTunnelRegistry:
             cancel_on_timeout=cancel_on_timeout,
         )
 
+
 # =============================================================================
 # Convenience forwarders
 # =============================================================================
@@ -804,6 +833,7 @@ def handle_host_device(
     )
     return dict(resp.results)
 
+
 def handle_host_device_request(
     registry: HostTunnelRegistry,
     *,
@@ -824,6 +854,7 @@ def handle_host_device_request(
         cancel_on_timeout=True,
     )
 
+
 # =============================================================================
 # Servicer
 # =============================================================================
@@ -839,7 +870,8 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
             peer = "unknown-peer"
 
         peer_tag = _safe_thread_tag(peer)
-        info(f"[Connect] new stream peer={peer}")
+        stream_uuid = uuid.uuid4().hex[:10]
+        info(f"[Connect] new stream peer={peer} stream_sess={stream_uuid}")
 
         host_id: Optional[str] = None
         session: Optional[HostSession] = None
@@ -848,46 +880,50 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
 
         def inbound_loop():
             nonlocal host_id, session
-            info(f"[inbound] start peer={peer}")
+            info(f"[inbound] start peer={peer} stream_sess={stream_uuid}")
 
             try:
                 for frame in request_iterator:
                     which = frame.WhichOneof("msg")
                     if which is None:
-                        warn(f"[inbound] frame with no msg peer={peer}")
+                        warn(f"[inbound] frame with no msg peer={peer} stream_sess={stream_uuid}")
                         continue
 
-                    info(f"[inbound] IN type={which} peer={peer} host_id={host_id or '?'}")
+                    info(f"[inbound] IN type={which} peer={peer} stream_sess={stream_uuid} host_id={host_id or '?'}")
 
                     if which == "hello":
                         hello = frame.hello
                         raw = str(getattr(hello, "host_id", "") or "")
+
                         try:
                             host_id = _validate_host_id(raw)
                         except ValueError as e:
-                            error(f"[inbound] invalid hello.host_id peer={peer} err={e}")
+                            error(f"[inbound] invalid hello.host_id peer={peer} stream_sess={stream_uuid} err={e}")
                             fatal["code"] = "INVALID_ARGUMENT"
                             fatal["details"] = str(e)
                             stop.set()
                             return
 
                         ver = str(getattr(hello, "version", "") or "")
-                        info(f"[inbound] HELLO host_id={host_id!r} version={ver!r} peer={peer}")
+                        info(f"[inbound] HELLO host_id={host_id!r} version={ver!r} peer={peer} stream_sess={stream_uuid}")
 
-                        session = HostSession(host_id)
+                        # ONE session per stream
+                        session = HostSession(host_id, peer=peer, session_uuid=stream_uuid)
+
+                        # ONE register per stream
                         try:
                             self.registry.register_host(host_id, session, replace_if_stale_ms=15_000)
                         except HostIdConflictError as e:
-                            error(f"[inbound] HostIdConflictError host_id={host_id!r} err={e}")
+                            error(f"[inbound] HostIdConflictError host_id={host_id!r} stream_sess={stream_uuid} err={e}")
                             fatal["code"] = "ALREADY_EXISTS"
                             fatal["details"] = str(e)
+                            try:
+                                session.close()
+                            except Exception:
+                                pass
                             stop.set()
                             return
-                        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
@@ -903,26 +939,30 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                                     )
                                 )
                             )
-                            info(f"[inbound] sent MetaRequest req_id={mrid} ok={ok} host_id={host_id!r}")
+                            info(f"[inbound] sent MetaRequest req_id={mrid} ok={ok} host_id={host_id!r} stream_sess={stream_uuid}")
                         except Exception:
                             exception("[inbound] FAILED sending MetaRequest")
 
                         # 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!r}")
+                            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} stream_sess={stream_uuid}")
                         except Exception:
                             exception("[inbound] FAILED sending heartbeat ack")
 
                     elif which == "device_announce":
                         if session is None or host_id is None:
-                            warn(f"[inbound] device_announce before hello/session: ignoring peer={peer}")
+                            warn(f"[inbound] device_announce before hello/session: ignoring peer={peer} stream_sess={stream_uuid}")
                             continue
 
                         ann = frame.device_announce
                         n = len(getattr(ann, "devices", []))
                         info(
-                            f"[inbound] DEVICE_ANNOUNCE host_id={host_id!r} n={n} "
+                            f"[inbound] DEVICE_ANNOUNCE host_id={host_id!r} n={n} stream_sess={stream_uuid} "
                             f"unix_ms={int(getattr(ann,'unix_ms',0) or 0)} full_snapshot={bool(getattr(ann,'full_snapshot',False))}"
                         )
 
@@ -937,49 +977,53 @@ 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!r}")
+                            info(f"[inbound] registry announce applied host_id={host_id!r} stream_sess={stream_uuid}")
                         except DeviceIdConflictError as e:
-                            error(f"[inbound] DeviceIdConflictError host_id={host_id!r} err={e}")
+                            error(f"[inbound] DeviceIdConflictError host_id={host_id!r} stream_sess={stream_uuid} 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!r}")
+                            exception(f"[inbound] announce_devices crashed host_id={host_id!r} stream_sess={stream_uuid}")
 
                         # 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!r}")
+                            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} stream_sess={stream_uuid}")
                         except Exception:
                             exception("[inbound] FAILED sending heartbeat ack after announce")
 
                     elif which == "rpc_response":
                         if session is None:
-                            warn(f"[inbound] rpc_response before session: ignoring peer={peer}")
+                            warn(f"[inbound] rpc_response before session: ignoring peer={peer} stream_sess={stream_uuid}")
                             continue
 
                         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}")
+                        info(f"[inbound] RPC_RESPONSE req_id={rid} ok={ok} error={err_s!r} stream_sess={stream_uuid}")
 
                         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] delivered rpc_response to waiter req_id={rid}")
+                            info(f"[inbound] delivered rpc_response to waiter req_id={rid} stream_sess={stream_uuid}")
                         else:
-                            warn(f"[inbound] rpc_response has no inflight waiter req_id={rid}")
+                            warn(f"[inbound] rpc_response has no inflight waiter req_id={rid} stream_sess={stream_uuid}")
 
                     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}")
+                            info(f"[inbound] META_RESPONSE ok={ok} error={err_s!r} stream_sess={stream_uuid}")
                             try:
                                 info(f"[inbound] META_RESPONSE proto:\n{mr}")
                             except Exception:
@@ -992,24 +1036,27 @@ 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!r} unix_ms={ms}")
+                            info(f"[inbound] HEARTBEAT host_id={host_id!r} unix_ms={ms} stream_sess={stream_uuid}")
                         else:
-                            warn(f"[inbound] heartbeat before hello/session: ignoring peer={peer} host_id={(host_id or '?')!r}")
+                            warn(
+                                f"[inbound] heartbeat before hello/session: ignoring peer={peer} stream_sess={stream_uuid} "
+                                f"host_id={(host_id or '?')!r}"
+                            )
 
                     elif which == "cancel":
                         try:
                             rid = str(getattr(frame.cancel, "req_id", "") or "")
-                            warn(f"[inbound] CANCEL received from host?? req_id={rid} peer={peer}")
+                            warn(f"[inbound] CANCEL received from host?? req_id={rid} peer={peer} stream_sess={stream_uuid}")
                         except Exception:
                             exception("[inbound] cancel frame parse failed")
 
                     else:
-                        warn(f"[inbound] unknown frame type={which} peer={peer}")
+                        warn(f"[inbound] unknown frame type={which} peer={peer} stream_sess={stream_uuid}")
 
             except Exception:
-                exception(f"[inbound] loop crashed peer={peer} host_id={host_id or '?'}")
+                exception(f"[inbound] loop crashed peer={peer} stream_sess={stream_uuid} host_id={host_id or '?'}")
             finally:
-                info(f"[inbound] exiting peer={peer} host_id={host_id or '?'}")
+                info(f"[inbound] exiting peer={peer} stream_sess={stream_uuid} host_id={host_id or '?'}")
                 stop.set()
                 if host_id is not None:
                     try:
@@ -1025,14 +1072,14 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
         t = threading.Thread(target=inbound_loop, daemon=True, name=f"inbound_{peer_tag}")
         t.start()
 
-        info(f"[Connect] outbound pump starting peer={peer}")
+        info(f"[Connect] outbound pump starting peer={peer} stream_sess={stream_uuid}")
 
         printed_waiting = 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}")
+                error(f"[Connect] aborting stream peer={peer} stream_sess={stream_uuid} code={code} details={details}")
                 if code == "ALREADY_EXISTS":
                     context.abort(grpc.StatusCode.ALREADY_EXISTS, details)
                 if code == "INVALID_ARGUMENT":
@@ -1041,7 +1088,7 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
 
             if session is None:
                 if not printed_waiting:
-                    info(f"[Connect] waiting for HELLO peer={peer}")
+                    info(f"[Connect] waiting for HELLO peer={peer} stream_sess={stream_uuid}")
                     printed_waiting = True
                 time.sleep(0.05)
                 continue
@@ -1051,18 +1098,19 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
             except queue.Empty:
                 continue
             except Exception:
-                exception(f"[Connect] outbound queue get failed peer={peer} host_id={host_id or '?'}")
+                exception(f"[Connect] outbound queue get failed peer={peer} stream_sess={stream_uuid} host_id={host_id or '?'}")
                 continue
 
             if out is None:
-                info(f"[Connect] outbound sentinel -> end stream peer={peer} host_id={host_id or '?'}")
+                info(f"[Connect] outbound sentinel -> end stream peer={peer} stream_sess={stream_uuid} host_id={host_id or '?'}")
                 break
 
             out_type = out.WhichOneof("msg")
-            info(f"[Connect] OUT type={out_type} peer={peer} host_id={host_id or '?'}")
+            info(f"[Connect] OUT type={out_type} peer={peer} stream_sess={stream_uuid} host_id={host_id or '?'}")
             yield out
 
-        info(f"[Connect] stream ended peer={peer} host_id={host_id or '?'}")
+        info(f"[Connect] stream ended peer={peer} stream_sess={stream_uuid} host_id={host_id or '?'}")
+
 
 # =============================================================================
 # Credentials + server start
@@ -1084,6 +1132,7 @@ def build_server_credentials(
         )
     return grpc.ssl_server_credentials(((private_key_pem, certificate_chain_pem),))
 
+
 def start_host_tunnel_server(
     *,
     host: str,

{remoterf_server-0.1.77 → remoterf_server-0.1.79}/src/remoteRF_server/server/device_manager.py

@@ -1,243 +1,10 @@
-# # device_manager.py
-
-# import adi
-# # import uhd
-# # from hackrf import *
-# from ..common.utils import *
-# import subprocess
-
-# import time
-# import gc
-
-# #* Device manager *
-# '''
-# Responsible for starting and managing queues for devices.
-# '''
-
-# # TODO: Implement multiple device support
-# #region PlutoSDR
-
-# def connect_pluto(*, ip='', usb=''):
-#     try:
-#         if ip == '':
-#             device = adi.Pluto(f'usb:{usb}')
-#             print(f"Connected to Pluto usb:{usb}")
-#         else:
-#             device = adi.Pluto(f'ip:{ip}')
-#             print(f"Connected to Pluto ip:{ip}")
-#         return device
-#     except Exception as e:
-#         print(f"Pluto {ip}: {e}")
-#         return None
-
-# import subprocess
-# import re
-
-# def get_usb_port_from_serial(serial):
-#     try:
-#         # Run iio_info -s and get the output
-#         output = subprocess.check_output(["iio_info", "-s"]).decode("utf-8")
-#     except Exception as e:
-#         print(f"Error running iio_info: {e}")
-#         return None
-
-#     # Regex to find the USB port associated with the given serial number
-#     pattern = re.compile(rf"\d+:.*serial={serial}\s+\[usb:(\S+)\]")
-
-#     for line in output.splitlines():
-#         match = pattern.search(line)
-#         if match:
-#             return match.group(1)  # Return the USB port
-
-#     print(f"No device found with serial {serial}")
-#     return None
-
-# # def connect_hackrf(device_index):
-# #     try:
-# #         device = HackRF(device_index=device_index)
-# #         print(f"Connected to HackRF {device_index}")
-# #         return device
-# #     except Exception as e:
-# #         print(f"HackRF {device_index}: {e}")
-# #         return None
-    
-# # def connect_usrp2901():
-# #     usrp = uhd.usrp.MultiUSRP()
-# #     print(f"Connected to USRP 2901")
-# #     return usrp
-
-# device_serialization = {
-#     0: '10447392da11001009001500f02af8a678',
-#     1: '10447392da110010f9ff1500612ff8ecb0',
-#     # 2: '104473b04a06000ffbff3900f5de83267e', # GONE?
-#     2: '10447318ac0f0003050036008365171a2d',
-#     3: '10447376de0b00130b00200023119a89c6',
-#     4: '1044732a98110002faff1500f92ae517bf',
-    
-#     5: '10447318ac0f001915003200073317bbca',
-#     6: '104473e6a60f00020d003900e21716bf22',
-#     7: '104473e6a60f000cf3ff17000b3917d48f',
-#     8: '10447318ac0f0016faff2500998717eacf',
-# }
-
-# master_token = 'SuperCoolTokenForIan'
-
-# # print("New Version")
-
-# devices = { # device, salt, hash
-    
-#     # iio_info -s
-#     # ^ find usb serial ports
-    
-#     # 0: (connect_pluto(usb=get_usb_port_from_serial(device_serialization[0])),'',''),
-#     # 1: (connect_pluto(usb=get_usb_port_from_serial(device_serialization[1])),'',''),
-#     # 2: (connect_pluto(usb=get_usb_port_from_serial(device_serialization[2])),'',''),
-#     # 3: (connect_pluto(usb=get_usb_port_from_serial(device_serialization[3])),'',''),
-#     # 4: (connect_pluto(usb=get_usb_port_from_serial(device_serialization[4])),'',''),
-    
-    
-#     # 5: (connect_pluto(usb=get_usb_port_from_serial(device_serialization[5])),'',''),
-#     # 6: (connect_pluto(usb=get_usb_port_from_serial(device_serialization[6])),'',''),
-#     # 7: (connect_pluto(usb=get_usb_port_from_serial(device_serialization[7])),'',''),
-#     # 8: (connect_pluto(usb=get_usb_port_from_serial(device_serialization[8])),'',''),
-    
-#     # 0: (connect_pluto(usb='1.8.5'),'',''),
-#     # 1: (connect_pluto(usb='1.18.5'),'',''),
-#     # 2: (connect_pluto(usb='1.8.5'),'',''),
-#     # 1: (connect_pluto(usb='1.8.5'),'',''),
-    
-#     # hackrf
-#     # 10: (connect_hackrf(0),'',''),
-    
-#     # 20: (connect_usrp2901(),'',''),
-    
-# }
-
-# devices_info = {    # device, info
-#     0: "Pluto SDR (Loopback)",
-#     1: "Pluto SDR (Loopback)",
-#     2: "Pluto SDR (OTA + BPF)",
-#     3: "Pluto SDR (OTA + BPF)",
-#     4: "Pluto SDR (OTA + BPF)",
-#     5: "Pluto SDR (OTA)",
-#     6: "Pluto SDR (OTA)",
-#     7: "Pluto SDR (OTA)",
-#     8: "Pluto SDR (OTA)",
-# }
-
-# # transmitter = subprocess.Popen(['python3', 'transmitter.py'])
-# # transmitter.terminate()
-
-# def start_transmitter():
-#     pass
-#     # global transmitter
-#     # transmitter = subprocess.Popen(['python3', 'transmitter.py'])
-    
-# def terminate_transmitter():
-#     pass
-#     # global transmitter
-#     # transmitter.terminate()
-    
-# def get_transmitter_state():
-#     global transmitter
-#     return transmitter.poll() == None
-
-# def get_device(device_id):
-#     return devices[device_id]
-
-# def get_all_devices() -> dict:
-#     return {k: v for k, v in devices.items() if v is not None}
-
-# def get_all_devices_str() -> dict:
-#     return devices_info
-
-# def parse_mastertoken(token: str):
-#     """
-#     Matches:
-#       {master_token}_0
-#       {master_token}-1
-#       {master_token}_0_force
-
-#     Returns (device_id:int, force:bool) or None.
-#     """
-#     if not token:
-#         return None
-
-#     prefix = re.escape(master_token)
-#     pattern = re.compile(rf"^{prefix}[_-](\d+)(?:_force)?$")
-
-#     m = pattern.match(token)
-#     if not m:
-#         return None
-
-#     device_id = int(m.group(1))
-#     force = token.endswith("_force")
-#     return (device_id, force)
-# def device_exists(device_id: int) -> bool:
-#     if device_id not in devices:
-#         return False
-#     dev, _, _ = devices[device_id]
-#     return dev is not None
-
-# def device_is_available(device_id: int) -> bool:
-#     if device_id not in devices:
-#         return False
-#     dev, salt, hsh = devices[device_id]
-#     return (dev is not None) and (salt == '') and (hsh == '')
-
-# def get_device_by_id(device_id: int):
-#     return devices[device_id]
-
-# def get_device(*, api_token):
-    
-#     if api_token == master_token:
-#         # Check for the first empty device
-#         for key, value in devices.items():
-#             if value[1] == '' and value[2] == '':
-#                 return value[0]
-            
-#         return None
-    
-#     parsed = parse_mastertoken(api_token) # Special args for specific devices
-#     if parsed:
-#         device_id, force = parsed
-
-#         if not device_exists(device_id):
-#             return None
-
-#         if force:
-#             # Force access if the device exists (ignores reservation state)
-#             return devices[device_id][0]
-
-#         # Non-force: only if device exists AND is not reserved
-#         if device_is_available(device_id):
-#             return devices[device_id][0]
-
-#         return None
-    
-#     # Regular Behavior
-#     for key, value in devices.items():
-#         if validate_token(value[1], value[2], api_token):
-#             return value[0]
-#     return None
-    
-# def set_device(device_id, salt, hash):
-#     devices[device_id] = (devices[device_id][0], salt, hash)
-    
-# def set_pluto(ip='192.168.2.1'):
-#     # try:
-#     #     global device_pluto
-#     #     del device_pluto
-#     #     device_pluto = adi.Pluto(f'ip:{ip}')
-#     # except Exception as e:
-#     #     print(f"PlutoError: {e}")
-#     # NO IMPLEMENTATION SHOUlD BE GIVEN, AS THIS IS FOR DEVICE SETUP. Keeping it just to support common Pluto code
-#     pass
-# device_manager.py
-# device_manager.py
+# src/remoteRF_server/server/device_manager.py
 
 from __future__ import annotations
 
+import hashlib
+from typing import Dict, Tuple, Optional, Any
+
 import os
 import re
 import subprocess
@@ -250,7 +17,7 @@ from contextlib import contextmanager
 import adi
 
 from ..common.utils import validate_token  # your salt/hash validator
-
+from ..host import host_tunnel_server as hts  # gives access to hts.TUNNEL_REGISTRY
 
 # -----------------------------
 # Config paths (server-side)
@@ -266,6 +33,54 @@ def _cfg_dir() -> Path:
 def _devices_env_path() -> Path:
     return _cfg_dir() / "devices.env"
 
+# -----------------------------
+# Host stuff
+# -----------------------------
+
+def _get_host_registry():
+    # host_tunnel_server sets this when the tunnel server starts
+    return getattr(hts, "TUNNEL_REGISTRY", None)
+
+
+def _host_devices_str_snapshot() -> Dict[int, str]:
+    """
+    Pull a FRESH host-device directory snapshot every call.
+    Assumes host device_ids are numeric strings that should be treated as gids.
+    """
+    reg = _get_host_registry()
+    if reg is None:
+        return {}
+
+    # ttl_ms=0 => force refresh (no caching)
+    snap = reg.device_directory_cached(ttl_ms=0)  # device_id -> (host_id, info_obj, is_active)
+
+    out: Dict[int, str] = {}
+    for device_id, (host_id, info_obj, is_active) in snap.items():
+        # You said host device IDs are already globally unique => treat as gid.
+        try:
+            gid = int(str(device_id))
+        except Exception:
+            # If something non-numeric ever sneaks in, just skip it.
+            continue
+
+        local_id = int(getattr(info_obj, "local_id", 0) or 0)
+        label = str(getattr(info_obj, "label", "") or "").strip()
+        serial = str(getattr(info_obj, "serial", "") or "").strip()
+        kind = str(getattr(info_obj, "kind", "") or "").strip()
+
+        status = "online" if bool(is_active) else "offline"
+        name = label or f"host-device-{gid}"
+
+        # keep it human-readable for CLI/UI
+        out[gid] = (
+            f"{name} "
+            f"[host={host_id}, local_id={local_id}"
+            f"{', kind=' + kind if kind else ''}"
+            f"{', serial=' + serial if serial else ''}"
+            f"] ({status})"
+        )
+
+    return out
 
 # -----------------------------
 # Pluto helpers
@@ -536,8 +351,13 @@ def get_all_devices() -> Dict[int, Tuple[object, str, str]]:
         return out
 
 def get_all_devices_str() -> Dict[int, str]:
+    # local snapshot (fast)
     with _state_lock:
-        return dict(devices_info)
+        out = dict(devices_info)
+
+    # host snapshot (fresh pull each call)
+    out.update(_host_devices_str_snapshot())
+    return out
 
 def set_device(device_id: int, salt: str, hash: str):
     # update ONLY reservation/auth state
@@ -549,9 +369,19 @@ def set_device(device_id: int, salt: str, hash: str):
         st.hsh = str(hash or "")
 
 def device_exists(device_id: int) -> bool:
+    did = int(device_id)
+
+    # local
     with _state_lock:
-        st = _devices.get(int(device_id))
-        return bool(st and st.dev is not None)
+        st = _devices.get(did)
+        if st and st.dev is not None:
+            return True
+
+    # host
+    reg = _get_host_registry()
+    if reg is None:
+        return False
+    return bool(reg.is_host_device(str(did)))
 
 def device_is_available(device_id: int) -> bool:
     with _state_lock:

{remoterf_server-0.1.77 → remoterf_server-0.1.79}/src/remoteRF_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 0.1.77
+Version: 0.1.79
 Description-Content-Type: text/markdown
 Requires-Dist: grpcio
 Requires-Dist: protobuf
@@ -348,9 +348,11 @@ todo:
 
 <!-- HostRF meta data -> push upon connection + retry connection on host side. -->
 
-Host ID (NEEDS TO BE UNIQUE AND TELL THE HOST THAT) (or if device also does it as well.)
+<!-- Host ID (NEEDS TO BE UNIQUE AND TELL THE HOST THAT) (or if device also does it as well.) -->
 
-ServerRF display meta data as part of devices list / reservation + online/activity status (appended into device name) + (plus host side warning if the device id is NOT globally unique!)
+ServerRF display meta data as part of devices list / reservation 
+
++ online/activity status (appended into device name) + (plus host side warning if the device id is NOT globally unique!)
 
 set_device token (virtual devices) + routing/relay to proper host (multiplexed)