proxynt 2.0.20__tar.gz → 2.0.26__tar.gz

{proxynt-2.0.20/proxynt.egg-info → proxynt-2.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: proxynt
-Version: 2.0.20
+Version: 2.0.26
 Summary: UNKNOWN
 Home-page: https://github.com/sazima/proxynt
 License: UNKNOWN

proxynt-2.0.26/client/abstract_tunnel.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+from typing import Callable
+
+class AbstractTunnel(ABC):
+    def __init__(self, peer_name: str, sock, addr, on_data_received: Callable, on_established: Callable, on_closed: Callable):
+        self.peer_name = peer_name
+        self.sock = sock
+        self.addr = addr
+        self.on_data_received = on_data_received # 应用层收到数据回调
+        self.on_established = on_established     # 握手成功回调
+        self.on_closed = on_closed               # 隧道关闭回调
+
+    @abstractmethod
+    def establish(self):
+        """开始协议层面的握手/初始化"""
+        pass
+
+    @abstractmethod
+    def send(self, uid: bytes, data: bytes) -> bool:
+        """发送业务数据"""
+        pass
+
+    @abstractmethod
+    def update(self):
+        """驱动状态机（如 KCP 需要）"""
+        pass
+
+    @abstractmethod
+    def close(self):
+        """物理关闭"""
+        pass

proxynt-2.0.26/client/data_connection_manager.py

@@ -0,0 +1,250 @@
+"""
+客户端数据连接管理器
+
+管理多个 WebSocket 数据连接：
+- 建立 N 个数据连接并加入 Session
+- 根据 UID hash 选择数据连接发送数据
+- 处理数据连接断开重连
+"""
+
+import json
+import threading
+import time
+import traceback
+from typing import List, Optional, Callable
+from urllib.parse import urlparse
+
+from common import websocket
+from common.logger_factory import LoggerFactory
+from common.nat_serialization import NatSerialization
+from constant.message_type_constnat import MessageTypeConstant
+from context.context_utils import ContextUtils
+from entity.message.message_entity import MessageEntity
+
+
+class DataConnection:
+    """单个数据连接"""
+
+    def __init__(self, channel_index: int, url: str, session_token: str,
+                 compress_support: bool, on_message_callback: Callable):
+        self.channel_index = channel_index
+        self.url = url
+        self.session_token = session_token
+        self.compress_support = compress_support
+        self.on_message_callback = on_message_callback
+        self.ws: Optional[websocket.WebSocketApp] = None
+        self.is_connected = False
+        self.is_joined = False
+        self.running = True
+        self.thread: Optional[threading.Thread] = None
+
+    def start(self):
+        """启动数据连接"""
+        self.thread = threading.Thread(target=self._run, daemon=True)
+        self.thread.start()
+
+    def _run(self):
+        """连接循环"""
+        while self.running:
+            try:
+                self.ws = websocket.WebSocketApp(
+                    self.url,
+                    on_open=self._on_open,
+                    on_message=self._on_message,
+                    on_close=self._on_close,
+                    on_error=self._on_error
+                )
+                self.ws.run_forever()
+            except Exception as e:
+                LoggerFactory.get_logger().error(f'Data connection {self.channel_index} error: {e}')
+
+            if self.running:
+                LoggerFactory.get_logger().info(f'Data connection {self.channel_index} reconnecting in 2s...')
+                time.sleep(2)
+
+    def _on_open(self, ws):
+        """连接建立后发送 JOIN_SESSION"""
+        LoggerFactory.get_logger().info(f'Data connection {self.channel_index} opened, sending JOIN_SESSION')
+        self.is_connected = True
+
+        # 发送 JOIN_SESSION 消息
+        join_message: MessageEntity = {
+            'type_': MessageTypeConstant.JOIN_SESSION,
+            'data': {
+                'session_token': self.session_token,
+                'channel_index': self.channel_index
+            }
+        }
+        try:
+            ws.send(
+                NatSerialization.dumps(join_message, ContextUtils.get_password(), self.compress_support),
+                websocket.ABNF.OPCODE_BINARY
+            )
+        except Exception as e:
+            LoggerFactory.get_logger().error(f'Failed to send JOIN_SESSION: {e}')
+
+    def _on_message(self, ws, message: bytes):
+        """处理收到的消息"""
+        try:
+            message_data: MessageEntity = NatSerialization.loads(
+                message, ContextUtils.get_password(), self.compress_support
+            )
+
+            # 处理 JOIN_SESSION 响应
+            if message_data['type_'] == MessageTypeConstant.JOIN_SESSION:
+                data = message_data['data']
+                if data.get('success'):
+                    self.is_joined = True
+                    LoggerFactory.get_logger().info(
+                        f'Data connection {self.channel_index} joined session successfully'
+                    )
+                else:
+                    LoggerFactory.get_logger().error(
+                        f'Data connection {self.channel_index} failed to join session'
+                    )
+                    ws.close()
+                return
+
+            # 其他消息转发给回调处理
+            if self.on_message_callback:
+                self.on_message_callback(message_data)
+
+        except Exception as e:
+            LoggerFactory.get_logger().error(f'Data connection {self.channel_index} message error: {e}')
+            LoggerFactory.get_logger().error(traceback.format_exc())
+
+    def _on_close(self, ws, code, reason):
+        """连接关闭"""
+        LoggerFactory.get_logger().info(
+            f'Data connection {self.channel_index} closed: code={code}, reason={reason}'
+        )
+        self.is_connected = False
+        self.is_joined = False
+
+    def _on_error(self, ws, error):
+        """连接错误"""
+        LoggerFactory.get_logger().error(f'Data connection {self.channel_index} error: {error}')
+
+    def send(self, data: bytes):
+        """发送数据"""
+        if self.ws and self.is_joined:
+            try:
+                self.ws.send(data, websocket.ABNF.OPCODE_BINARY)
+                return True
+            except Exception as e:
+                LoggerFactory.get_logger().error(f'Data connection {self.channel_index} send error: {e}')
+        return False
+
+    def stop(self):
+        """停止连接"""
+        self.running = False
+        self.is_connected = False
+        self.is_joined = False
+        if self.ws:
+            try:
+                self.ws.close()
+            except Exception:
+                pass
+
+
+class DataConnectionManager:
+    """数据连接管理器"""
+
+    def __init__(self, server_url: str, compress_support: bool, on_message_callback: Callable):
+        self.server_url = server_url
+        self.compress_support = compress_support
+        self.on_message_callback = on_message_callback
+
+        self.session_token: Optional[str] = None
+        self.num_channels: int = 4
+        self.data_connections: List[DataConnection] = []
+        self.is_multi_connection: bool = False
+        self.lock = threading.Lock()
+
+    def setup_data_connections(self, session_token: str, num_channels: int = 4):
+        """
+        设置数据连接
+
+        :param session_token: 会话令牌（hex 格式）
+        :param num_channels: 数据通道数量
+        """
+        with self.lock:
+            # 清理旧连接
+            self.stop_all()
+
+            self.session_token = session_token
+            self.num_channels = num_channels
+            self.is_multi_connection = True
+
+            LoggerFactory.get_logger().info(
+                f'Setting up {num_channels} data connections, token={session_token[:16]}...'
+            )
+
+            # 创建数据连接
+            for i in range(num_channels):
+                conn = DataConnection(
+                    channel_index=i,
+                    url=self.server_url,
+                    session_token=session_token,
+                    compress_support=self.compress_support,
+                    on_message_callback=self.on_message_callback
+                )
+                self.data_connections.append(conn)
+                conn.start()
+
+            LoggerFactory.get_logger().info(f'Started {num_channels} data connections')
+
+    def get_data_connection(self, uid: bytes) -> Optional[DataConnection]:
+        """
+        根据 UID 获取数据连接
+
+        :param uid: 连接 UID
+        :return: 数据连接，如果没有可用的返回 None
+        """
+        if not self.is_multi_connection or not self.data_connections:
+            return None
+
+        # 根据 UID hash 选择通道
+        channel_index = int.from_bytes(uid[:2], 'big') % len(self.data_connections)
+        conn = self.data_connections[channel_index]
+
+        # 检查连接是否可用
+        if conn.is_joined:
+            return conn
+
+        # 如果选中的通道不可用，尝试其他通道
+        for conn in self.data_connections:
+            if conn.is_joined:
+                return conn
+
+        return None
+
+    def send_by_uid(self, uid: bytes, data: bytes) -> bool:
+        """
+        根据 UID 发送数据
+
+        :param uid: 连接 UID
+        :param data: 要发送的数据
+        :return: 是否成功发送
+        """
+        conn = self.get_data_connection(uid)
+        if conn:
+            return conn.send(data)
+        return False
+
+    def is_ready(self) -> bool:
+        """检查是否有数据连接可用"""
+        if not self.is_multi_connection:
+            return False
+        for conn in self.data_connections:
+            if conn.is_joined:
+                return True
+        return False
+
+    def stop_all(self):
+        """停止所有数据连接"""
+        for conn in self.data_connections:
+            conn.stop()
+        self.data_connections.clear()
+        self.is_multi_connection = False
+        self.session_token = None

proxynt-2.0.26/client/kcp_tunnel_impl.py

@@ -0,0 +1,52 @@
+import time
+import threading
+import socket
+from .abstract_tunnel import AbstractTunnel
+from common.kcp import Kcp
+
+class KcpTunnelImpl(AbstractTunnel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.kcp = Kcp(12345)
+        self.kcp.output = self._udp_output
+        self.kcp.setmtu(800) # 关键：强制小于 1000
+        self.kcp.nodelay(1, 10, 2, 1)
+        self.lock = threading.Lock()
+        self.running = True
+
+    def establish(self):
+        # KCP 是无状态的，打洞成功即认为建立成功
+        threading.Thread(target=self._recv_loop, daemon=True).start()
+        # 立即通知 Manager 成功
+        self.on_established(self.peer_name)
+
+    def _udp_output(self, buf):
+        try: self.sock.sendto(buf, self.addr)
+        except: pass
+
+    def _recv_loop(self):
+        while self.running:
+            try:
+                data, addr = self.sock.recvfrom(65536)
+                with self.lock:
+                    self.kcp.input(data)
+            except: break
+
+    def update(self):
+        with self.lock:
+            self.kcp.update(int(time.time() * 1000))
+            while True:
+                data = self.kcp.recv()
+                if not data: break
+                if len(data) >= 4:
+                    self.on_data_received(data[:4], data[4:])
+
+    def send(self, uid: bytes, data: bytes) -> bool:
+        with self.lock:
+            return self.kcp.send(uid + data) >= 0
+
+    def close(self):
+        self.running = False
+        try: self.sock.close()
+        except: pass
+        self.on_closed(self.peer_name)

proxynt-2.0.26/client/n4_tunnel_manager.py

@@ -0,0 +1,246 @@
+import logging
+import socket
+import threading
+import time
+from typing import Dict, Optional, Tuple, Type, Set
+
+from common.logger_factory import LoggerFactory
+from common.n4_punch import N4PunchClient, N4Error
+from .abstract_tunnel import AbstractTunnel
+from .kcp_tunnel_impl import KcpTunnelImpl
+
+def get_pair_key(client_a: str, client_b: str) -> Tuple[str, str]:
+    """获取两个客户端唯一的配对键"""
+    return (min(client_a, client_b), max(client_a, client_b))
+
+class N4TunnelManager:
+    """
+    P2P 隧道管理器
+    负责物理打洞的协调及抽象协议隧道的生命周期管理。
+    """
+    def __init__(self, local_client_name: str, server_host: str, server_port: int,
+                 tunnel_class: Type[AbstractTunnel] = KcpTunnelImpl):
+
+        self.local_client_name = local_client_name
+        self.server_host = server_host
+        self.server_port = server_port
+
+        # 核心：解耦后的协议实现类构造器
+        self.TunnelClass = tunnel_class
+
+        # 存储已建立的隧道对象 {peer_name: AbstractTunnel}
+        self.tunnels: Dict[str, AbstractTunnel] = {}
+
+        # 正在进行的物理打洞客户端 {pair_key: N4PunchClient}
+        self.punch_clients: Dict[Tuple[str, str], N4PunchClient] = {}
+
+        # 映射关系 {uid: peer_name}
+        self.uid_to_peer: Dict[bytes, str] = {}
+
+        # 状态控制
+        self.pending_punch_requests: Set[str] = set() # 正在申请打洞的
+        self.handshaking_peers: Set[str] = set()      # 正在进行打洞或协议握手的
+        self.last_failure_time: Dict[str, float] = {} # 记录失败时间点，用于 30s 冷却
+
+        self.lock = threading.Lock()
+        self.logger = LoggerFactory.get_logger()
+
+        # 外部回调（由 run_client.py 注入）
+        self.ws_client = None
+        self.on_data_received = None # func(uid, data)
+        self.on_tunnel_closed = None # func(peer_name)
+        self.on_punch_failed = None
+
+        self.running = False
+        self.update_thread = None
+
+    def set_ws_client(self, ws):
+        self.ws_client = ws
+
+    def start(self):
+        """启动管理器：启动全局驱动线程"""
+        with self.lock:
+            if not self.running:
+                self.running = True
+                self.update_thread = threading.Thread(target=self._global_update_loop, daemon=True)
+                self.update_thread.start()
+                self.logger.info(f"N4 Tunnel Manager Started (Protocol: {self.TunnelClass.__name__})")
+
+    def _global_update_loop(self):
+        """每 10ms 驱动一次所有活跃协议的状态机"""
+        while self.running:
+            # 获取当前所有隧道的快照进行遍历
+            with self.lock:
+                active_tunnels = list(self.tunnels.values())
+
+            for tunnel in active_tunnels:
+                try:
+                    tunnel.update()
+                except Exception as e:
+                    self.logger.error(f"Error updating tunnel {tunnel.peer_name}: {e}")
+
+            time.sleep(0.01)
+
+    def send_data(self, uid: bytes, data: bytes) -> bool:
+        """
+        业务数据发送入口（无缝切换的核心）
+        返回 True: 数据已交由 P2P 隧道发送
+        返回 False: 隧道不可用，调用者应继续走 WebSocket
+        """
+        peer_name = self.uid_to_peer.get(uid)
+        if not peer_name:
+            return False
+
+        with self.lock:
+            tunnel = self.tunnels.get(peer_name)
+
+        # 1. 隧道已就绪，直接发送
+        if tunnel:
+            if tunnel.send(uid, data):
+                return True
+            else:
+                self.logger.warn(f"P2P Tunnel to {peer_name} send failed, closing.")
+                self._handle_failure(peer_name)
+                return False
+
+        # 2. 如果正在握手或打洞，静默走 WebSocket，不重复触发
+        if peer_name in self.pending_punch_requests or peer_name in self.handshaking_peers:
+            return False
+
+        # 3. 检查冷却时间：失败后 30s 内不重试打洞
+        now = time.time()
+        if now - self.last_failure_time.get(peer_name, 0) < 30:
+            return False
+
+        # 4. 既没有隧道也不在处理中，触发打洞请求
+        if self.ws_client:
+            self.logger.info(f"P2P required for {peer_name}. Initiating {self.TunnelClass.__name__} setup.")
+            with self.lock:
+                self.pending_punch_requests.add(peer_name)
+            self.ws_client._send_punch_request(peer_name)
+
+        return False
+
+    def prepare_punch(self, peer_name: str, session_id: bytes) -> Optional[socket.socket]:
+        """收到 PUNCH_REQUEST：初始化 Socket 池并返回用于 EXCHANGE 的第一个 Socket"""
+        with self.lock:
+            # 如果旧隧道还存在，先物理关闭
+            if peer_name in self.tunnels:
+                self.tunnels[peer_name].close()
+                self.tunnels.pop(peer_name, None)
+
+            punch_client = N4PunchClient(
+                ident=session_id,
+                server_host=self.server_host,
+                server_port=self.server_port
+            )
+
+            try:
+                exchange_sock = punch_client.send_exchange()
+                pair_key = get_pair_key(self.local_client_name, peer_name)
+                self.punch_clients[pair_key] = punch_client
+                return exchange_sock
+            except Exception as e:
+                self.logger.error(f"Failed to prepare punch for {peer_name}: {e}")
+                return None
+
+    def receive_peer_info(self, peer_name: str, peer_ip: str, peer_port: int):
+        """收到 PEER_INFO：后台启动物理打洞并初始化具体协议实现"""
+        pair_key = get_pair_key(self.local_client_name, peer_name)
+        punch_client = self.punch_clients.get(pair_key)
+
+        if punch_client:
+            threading.Thread(
+                target=self._run_punch_and_setup,
+                args=(punch_client, peer_name, peer_ip, peer_port, pair_key),
+                daemon=True
+            ).start()
+
+    def _run_punch_and_setup(self, punch_client: N4PunchClient, peer_name: str,
+                             peer_ip: str, peer_port: int, pair_key: Tuple[str, str]):
+        """后台线程：执行打洞 -> 实例化 TunnelImpl -> 建立握手"""
+        with self.lock:
+            self.handshaking_peers.add(peer_name)
+            self.pending_punch_requests.discard(peer_name)
+
+        try:
+            # 1. 物理打洞
+            winner_sock, peer_addr = punch_client.punch(peer_ip, peer_port, wait=15)
+            self.logger.info(f"Punch SUCCESS for {peer_name}. Setting up {self.TunnelClass.__name__}...")
+
+            # 2. 确定角色
+            is_server = self.local_client_name > peer_name
+
+            # 3. 实例化具体的隧道协议实现
+            tunnel = self.TunnelClass(
+                peer_name=peer_name,
+                sock=winner_sock,
+                addr=peer_addr,
+                on_data_received=self.on_data_received,
+                on_established=self._internal_on_established,
+                on_closed=self._internal_on_closed,
+                is_server=is_server
+            )
+
+            # 4. 开始协议激活
+            tunnel.establish()
+
+        except Exception as e:
+            self.logger.error(f"P2P setup failed for {peer_name}: {e}")
+            self._handle_failure(peer_name)
+            if self.on_punch_failed:
+                self.on_punch_failed(peer_name)
+        finally:
+            with self.lock:
+                self.punch_clients.pop(pair_key, None)
+
+    def _internal_on_established(self, tunnel: AbstractTunnel):
+        """由具体 TunnelImpl 在协议握手成功后调用"""
+        peer_name = tunnel.peer_name
+        with self.lock:
+            self.tunnels[peer_name] = tunnel
+            self.handshaking_peers.discard(peer_name)
+            self.last_failure_time.pop(peer_name, None)
+        self.logger.info(f"=== [P2P READY] {self.TunnelClass.__name__} Tunnel Established for {peer_name} ===")
+
+    def _internal_on_closed(self, peer_name: str):
+        """由具体 TunnelImpl 在连接断开时调用"""
+        self._handle_failure(peer_name)
+        if self.on_tunnel_closed:
+            self.on_tunnel_closed(peer_name)
+
+    def _handle_failure(self, peer_name: str):
+        """统一失败处理逻辑"""
+        with self.lock:
+            self.tunnels.pop(peer_name, None)
+            self.handshaking_peers.discard(peer_name)
+            self.pending_punch_requests.discard(peer_name)
+            self.last_failure_time[peer_name] = time.time()
+
+    def register_uid(self, uid: bytes, peer_name: str):
+        with self.lock:
+            self.uid_to_peer[uid] = peer_name
+
+    def unregister_uid(self, uid: bytes):
+        with self.lock:
+            self.uid_to_peer.pop(uid, None)
+
+    def is_tunnel_established(self, peer_name: str) -> bool:
+        return peer_name in self.tunnels
+
+    def has_tunnel(self, peer_name: str) -> bool:
+        return peer_name in self.tunnels or peer_name in self.pending_punch_requests or peer_name in self.handshaking_peers
+
+    def get_tunnel(self, peer_name: str) -> Optional[AbstractTunnel]:
+        return self.tunnels.get(peer_name)
+
+    def stop(self):
+        """停止管理器及所有隧道"""
+        self.running = False
+        with self.lock:
+            for tunnel in list(self.tunnels.values()):
+                tunnel.close()
+            for puncher in list(self.punch_clients.values()):
+                puncher.stop()
+            self.tunnels.clear()
+            self.punch_clients.clear()

proxynt-2.0.26/client/quic_tunnel_impl.py

@@ -0,0 +1,18 @@
+import asyncio
+from .abstract_tunnel import AbstractTunnel
+
+class QuicTunnelImpl(AbstractTunnel):
+    def establish(self):
+        # 这里封装之前 N4TunnelManager 里的 _start_quic_connection 逻辑
+        # 调用 self.on_established 或 self.on_closed
+        pass
+
+    def send(self, uid: bytes, data: bytes) -> bool:
+        # 之前的 aioquic send 逻辑
+        pass
+
+    def update(self): pass
+
+    def close(self):
+        # 之前的 close 逻辑
+        pass