feat: 长保持连接，控制端可重启

backend/monitoring/control.py

@@ -33,6 +33,9 @@ class OmniSocketControlSender:
         self._send_errors = 0
         self._drain_errors = 0
         self._last_error = ""
+        self._reconnect_count = 0
+        self._ever_connected = False
+        self._registered = False
         self._load_backend()
 
     def _load_backend(self) -> None:
@@ -78,6 +81,8 @@ class OmniSocketControlSender:
             return
 
         with self._lock:
+            if self._closing.is_set():
+                return
             if self._started and self._session is not None:
                 return
             session, target_peer = self._connect_session()
@@ -86,6 +91,11 @@ class OmniSocketControlSender:
             self._closing.clear()
             self._started = True
             self._last_error = ""
+            self._registered = bool(dict(session.stats()).get("registered", 0))
+            if self._ever_connected:
+                self._reconnect_count += 1
+            else:
+                self._ever_connected = True
             self._drain_thread = threading.Thread(
                 target=self._drain_loop,
                 name="omnisocket-control-drain",
@@ -100,6 +110,7 @@ class OmniSocketControlSender:
             current = self._session
             self._session = None
             self._started = False
+            self._registered = False
         if current is not None:
             try:
                 current.close()
@@ -146,31 +157,50 @@ class OmniSocketControlSender:
             try:
                 result = session.recv(timeout_ms=100)
             except Exception as error:
+                last_server_error = ""
+                try:
+                    last_server_error = str(dict(session.stats()).get("last_server_error", "") or "")
+                except Exception:
+                    last_server_error = ""
                 with self._lock:
                     self._drain_errors += 1
-                    self._last_error = str(error)
+                    self._registered = False
+                    self._last_error = last_server_error or str(error)
                 if not self._closing.is_set():
                     self._reset_session(session)
                 return
 
             if result is None:
+                try:
+                    stats = dict(session.stats())
+                except Exception:
+                    stats = {}
+                with self._lock:
+                    self._registered = bool(stats.get("registered", 0))
+                    if stats.get("last_server_error"):
+                        self._last_error = str(stats.get("last_server_error"))
                 continue
 
             from_peer, msg_type, payload = result
             if msg_type == self._msg_type_error:
                 text = payload.decode("utf-8", errors="replace")
+                try:
+                    stats = dict(session.stats())
+                except Exception:
+                    stats = {}
                 with self._lock:
                     self._last_error = f"server error from {from_peer}: {text}"
+                    self._registered = bool(stats.get("registered", 0))
 
     def session_stats(self) -> dict[str, Any]:
         with self._lock:
             session = self._session
         if session is None:
-            return {"connected": 0}
+            return {"connected": 0, "registered": 0, "last_server_error": self._last_error}
         try:
             return dict(session.stats())
         except Exception:
-            return {"connected": 0}
+            return {"connected": 0, "registered": 0, "last_server_error": self._last_error}
 
     def session_kcp_stats(self) -> dict[str, Any]:
         with self._lock:
@@ -180,16 +210,20 @@ class OmniSocketControlSender:
     def get_status(self) -> dict[str, Any]:
         config = load_omnisocket_config()
         control_cfg = config.get("control_sender", {})
+        session_stats = self.session_stats()
         with self._lock:
             return {
                 "backend_ready": self._session_cls is not None,
                 "started": self._started,
                 "connected": self._session is not None,
+                "registered": bool(session_stats.get("registered", 0)),
                 "peer_id": str(control_cfg.get("peer_id", "")),
                 "target_peer": str(control_cfg.get("target_peer", "")),
                 "send_count": self._send_count,
                 "send_errors": self._send_errors,
                 "drain_errors": self._drain_errors,
+                "reconnect_count": self._reconnect_count,
+                "last_server_error": str(session_stats.get("last_server_error", "") or ""),
                 "last_error": self._last_error,
             }
 
@@ -228,6 +262,8 @@ class ControlArbiter:
     def ensure_started(self) -> None:
         self._load_config()
         with self._lock:
+            if self._closing.is_set():
+                return
             if self._started:
                 return
             self._started = True