2026-10-09 16:41:13 +08:00

123 lines
4.9 KiB
Python

import socket
import threading
import traceback
from .utils import *
import time
from XPolicyLab.utils.process_data import decode_obs_images
class ModelServer:
def __init__(self, model, host="localhost", port=None):
self.model = model
self.host = host
self.port = port
self.server_socket = None
self.running = False
self.wait_interval = 10
self.client_threads = []
def start(self):
"""Start the model server and listen for incoming client connections"""
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.bind((self.host, self.port))
self.server_socket.settimeout(self.wait_interval)
self.server_socket.listen(5)
self.running = True
print(f"🚀 Model server started on {self.host}:{self.port}")
print("🔄 Server is waiting for client connections...")
self._accept_connections()
def stop(self):
"""Stop the server and clean up resources gracefully"""
self.running = False
if self.server_socket:
try:
self.server_socket.close()
except:
pass
for t in self.client_threads:
t.join(timeout=1)
print("🛑 Server has been stopped")
def _accept_connections(self):
"""Accept and handle new client connections"""
while self.running:
try:
client_socket, addr = self.server_socket.accept()
print(f"✅ Client connected from {addr}")
# Handle each client in a separate thread
t = threading.Thread(target=self._handle_client, args=(client_socket,), daemon=True)
t.start()
self.client_threads.append(t)
except socket.timeout:
continue
except Exception as e:
if self.running:
print(f"⚠️ Error accepting connection: {e}")
break
def _handle_client(self, client_socket):
"""Process requests from a single client"""
with client_socket:
while self.running:
try:
# Read message length header (4 bytes, big-endian)
len_bytes = client_socket.recv(4)
if not len_bytes:
print("🔌 Client disconnected")
break
msg_length = int.from_bytes(len_bytes, "big")
# Read the full message based on length
chunks = []
remaining = msg_length
while remaining > 0:
chunk = client_socket.recv(min(remaining, 4096))
if not chunk:
raise ConnectionError("Incomplete data received")
chunks.append(chunk)
remaining -= len(chunk)
raw_msg = b"".join(chunks).decode("utf-8")
# Deserialize JSON to Python, reconstruct any numpy arrays
data = json_to_numpy(raw_msg)
# data = pickle.loads(raw_msg)
# Extract command and observation
cmd = data.get("cmd")
obs = data.get("obs") # None if not provided
# Decode every payload-carrying command, matching the ws
# server: custom RPCs can ship camera frames too, and
# decode_obs_images leaves non-observation payloads alone.
if obs is not None:
obs = decode_obs_images(obs)
# Find corresponding model method
method = getattr(self.model, cmd, None)
if not callable(method):
raise AttributeError(f"No model method named '{cmd}'")
# Call method with or without obs
st = time.monotonic()
result = method(obs) if obs is not None else method()
response = {"res": result}
# Serialize response and send back with length header
resp_bytes = numpy_to_json(response).encode("utf-8")
client_socket.sendall(len(resp_bytes).to_bytes(4, "big"))
client_socket.sendall(resp_bytes)
except (ConnectionResetError, BrokenPipeError):
print("🔌 Client connection lost")
break
except Exception as e:
err = f"Error handling request: {e}"
print(f"⚠️ {err}")
tb = traceback.format_exc()
error_resp = numpy_to_json({"error": err, "traceback": tb}).encode("utf-8")
client_socket.sendall(len(error_resp).to_bytes(4, "big"))
client_socket.sendall(error_resp)
break