feat:初始化工程

endpoint/tcp_server.py

@@ -0,0 +1,161 @@
+import socket
+import signal
+import threading
+from concurrent.futures import ThreadPoolExecutor
+
+from config.setting import settings
+from model.index import UNKNOWN_MESSAGE
+from processor.tcp_processor import TcpMessageProcessor
+from config.logger_config import logger
+
+
+class TCPServer:
+    def __init__(self):
+        self.host = settings.host
+        self.port = settings.port
+
+        self.max_workers = settings.max_workers
+        self.timeout = settings.timeout
+
+        self.server_socket = None
+        self.running = False
+        self.thread_pool = ThreadPoolExecutor(max_workers=self.max_workers)
+        self.message_processor = TcpMessageProcessor()
+
+        # 已经连接的客户端
+        self.clients = {}
+        self.client_lock = threading.Lock()
+
+        self.server_thread = None
+
+        signal.signal(signal.SIGTERM, self._handle_signal)
+        signal.signal(signal.SIGINT, self._handle_signal)
+
+    def _handle_signal(self, signum, frame):
+        """处理终止信号，触发优雅关闭"""
+        logger.info(f"收到信号 {signum}，准备关闭服务器...")
+        self.running = False
+
+    def _start_loop(self):
+        """启动服务器"""
+        try:
+            self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            self.server_socket.bind((self.host, self.port))
+            self.server_socket.listen(5)
+            self.server_socket.settimeout(1.0)
+            self.running = True
+
+            logger.info(f"TCP服务器启动，监听 {self.host}:{self.port} "
+                        f"（最大线程: {self.max_workers}, 超时: {self.timeout}s）")
+
+            while self.running:
+                try:
+                    client_socket, client_address = self.server_socket.accept()
+                    client_ip = client_address[0]
+                    client_socket.settimeout(self.timeout)
+                    logger.info(f"新连接: {client_address}")
+
+                    # 存储客户端
+                    with self.client_lock:
+                        self.clients[client_ip] = client_socket
+
+                    # 提交到线程池处理
+                    self.thread_pool.submit(self.handle_client, client_socket, client_ip)
+                except socket.timeout:
+                    continue
+                except Exception as e:
+                    if self.running:
+                        logger.error(f"接受连接失败: {str(e)}")
+        except Exception as e:
+            logger.error(f"TCP服务器启动失败: {str(e)}")
+        finally:
+            self.stop()
+
+    def start(self):
+        self.server_thread = threading.Thread(target=self._start_loop, daemon=True)
+        self.server_thread.start()
+
+    def stop(self):
+        if not self.running:
+            return
+
+        self.running = False
+        logger.info("开始关闭服务器...")
+
+        # 移除客户端
+        with self.client_lock:
+            for client_socket in self.clients.values():
+                try:
+                    client_socket.close()
+                except Exception as e:
+                    logger.warning(f"关闭客户端连接失败: {str(e)}")
+            self.clients.clear()
+
+        # 关闭线程池
+        self.thread_pool.shutdown(wait=True)
+        logger.info("所有客户端处理线程已结束")
+
+        # 关闭连接
+        if self.server_socket:
+            self.server_socket.close()
+        logger.info(f"服务器已关闭（{self.host}:{self.port}）")
+
+    def handle_client(self, client_socket, client_ip):
+        """处理客户端连接"""
+        try:
+            while True:
+                data = client_socket.recv(1024)
+                if not data:
+                    logger.info(f"客户端 {client_ip} 主动断开连接")
+                    break
+
+                message = data.decode('utf-8').strip()
+                logger.info(f"收到 {client_ip} 的消息: {message}")
+
+                # 放到消息处理器里面处理
+                response = self.message_processor.process(message)
+
+                # 回复消息
+                if response != UNKNOWN_MESSAGE:
+                    client_socket.sendall(response.encode('utf-8'))
+                    logger.info(f"回复 {client_ip}: {response}")
+        except socket.timeout:
+            logger.warning(f"客户端 {client_ip} 超时未活动")
+        except Exception as e:
+            logger.error(f"处理 {client_ip} 出错: {str(e)}")
+        finally:
+            # 异常情况下关闭连接
+            with self.client_lock:
+                if client_ip in self.clients:
+                    del self.clients[client_ip]
+
+            try:
+                client_socket.close()
+                logger.info(f"客户端 {client_ip} 连接已关闭")
+            except Exception as e:
+                logger.warning(f"关闭 {client_ip} 连接失败: {str(e)}")
+
+    def send_to_client(self, client_ip, message):
+        # 先获取客户端连接（加锁保护）
+        with self.client_lock:
+            client_socket = self.clients.get(client_ip)
+            if not client_socket:
+                logger.warning(f"客户端 {client_ip} 不存在或已断开连接")
+                return False
+
+        # 发送消息
+        try:
+            client_socket.sendall(message.encode('utf-8'))
+            logger.info(f"主动发送消息给 {client_ip}: {message}")
+            return True
+        except Exception as e:
+            logger.error(f"向 {client_ip} 发送消息失败: {str(e)}")
+            # 发送失败时移除无效连接
+            with self.client_lock:
+                if client_ip in self.clients:
+                    del self.clients[client_ip]
+            return False
+
+
+tcp_server = TCPServer()