proxynt 2.0.24__tar.gz → 2.0.26__tar.gz

{proxynt-2.0.24 → proxynt-2.0.26}/PKG-INFO

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

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.24 → proxynt-2.0.26}/client/tcp_forward_client.py

@@ -146,6 +146,9 @@ class TcpForwardClient:
         # N4 Tunnel Manager for P2P data transfer
         self.tunnel_manager = None
 
+        # 多连接支持：DataConnectionManager（由 run_client 注入）
+        self.data_conn_manager = None
+
         # Pending data buffer: uid -> list of (data, timestamp)
         # Used to buffer P2P data that arrives before connection is established
         self.pending_data: Dict[bytes, list] = {}
@@ -295,14 +298,8 @@ class TcpForwardClient:
         if not connection:
             return
 
-        if data.speed_limiter and data.speed_limiter.is_exceed()[0]:
-            self.socket_event_loop.unregister_and_register_delay(each, data, 1)
-            return
-
         try:
             recv = each.recv(data.read_size)
-            if data.speed_limiter:
-                data.speed_limiter.add(len(recv))
         except OSError:
             recv = b''
 
@@ -311,11 +308,11 @@ class TcpForwardClient:
             # 尝试走 P2P 隧道
             if self.tunnel_manager.send_data(connection.uid, recv):
                 # 如果发送成功返回 True，逻辑结束
-                if not recv: # 本地连接关闭，通知隧道
+                if not recv:  # 本地连接关闭，通知隧道
                     self.close_connection(each)
                 return
 
-                # --- 回退/初始逻辑：走 WebSocket ---
+        # --- 回退/初始逻辑：走 WebSocket ---
         send_message: MessageEntity = {
             'type_': MessageTypeConstant.WEBSOCKET_OVER_TCP,
             'data': {
@@ -326,9 +323,21 @@ class TcpForwardClient:
             }
         }
 
-        connection.sender.enqueue_message(
-            NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
-        )
+        # 发送端限速：在发送前等待
+        if data.speed_limiter and recv:
+            wait_time = data.speed_limiter.acquire(len(recv))
+            if wait_time > 0:
+                time.sleep(wait_time)
+
+        # 多连接模式：优先使用数据连接
+        message_bytes = NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
+        if self.data_conn_manager and self.data_conn_manager.is_ready():
+            if not self.data_conn_manager.send_by_uid(connection.uid, message_bytes):
+                # 数据连接发送失败，回退到控制连接
+                connection.sender.enqueue_message(message_bytes)
+        else:
+            # 单连接模式：使用控制连接
+            connection.sender.enqueue_message(message_bytes)
 
         if not recv:
             try:
@@ -487,7 +496,16 @@ class TcpForwardClient:
             }
         }
         start_time = time.time()
-        self.ws.send(NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support), websocket.ABNF.OPCODE_BINARY)
+        message_bytes = NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
+
+        # 多连接模式：优先使用数据连接
+        if self.data_conn_manager and self.data_conn_manager.is_ready():
+            if not self.data_conn_manager.send_by_uid(connection.uid, message_bytes):
+                # 数据连接发送失败，回退到控制连接
+                self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
+        else:
+            # 单连接模式
+            self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
         LoggerFactory.get_logger().debug(f'Send to websocket cost time {time.time() - start_time}')
 
     def send_by_uid(self, uid: bytes, msg: bytes):

{proxynt-2.0.24 → proxynt-2.0.26}/client/udp_forward_client.py

@@ -53,6 +53,9 @@ class UdpForwardClient:
         self.c2c_listeners: Dict[str, socket.socket] = {}   # rule_name → listener socket
         self.c2c_uid_to_rule: Dict[bytes, str] = {}         # UID → rule_name
 
+        # 多连接支持：DataConnectionManager（由 run_client 注入）
+        self.data_conn_manager = None
+
     def set_running(self, running: bool):
         """Set running state"""
         self.running = running
@@ -131,6 +134,9 @@ class UdpForwardClient:
         protocol = rule['protocol']
         speed_limit = rule.get('speed_limit', 0.0)
 
+        # 创建限速器
+        speed_limiter = SpeedLimiter(speed_limit) if speed_limit > 0 else None
+
         # Check if using direct mode (target_ip + target_port) or service mode (target_service)
         use_direct_mode = 'target_ip' in rule and 'target_port' in rule
 
@@ -205,10 +211,22 @@ class UdpForwardClient:
                         'ip_port': f"{source_addr[0]}:{source_addr[1]}"
                     }
                 }
-                self.ws.send(
-                    NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support),
-                    websocket.ABNF.OPCODE_BINARY
-                )
+
+                # 发送端限速：在发送前等待
+                if speed_limiter and data:
+                    wait_time = speed_limiter.acquire(len(data))
+                    if wait_time > 0:
+                        time.sleep(wait_time)
+
+                message_bytes = NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
+                # 多连接模式：优先使用数据连接
+                if self.data_conn_manager and self.data_conn_manager.is_ready():
+                    if not self.data_conn_manager.send_by_uid(uid, message_bytes):
+                        # 数据连接发送失败，回退到控制连接
+                        self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
+                else:
+                    # 单连接模式
+                    self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
                 LoggerFactory.get_logger().debug(f'C2C UDP data forwarded: {rule_name} UID: {uid.hex()}, len: {len(data)}')
 
             except OSError as e:
@@ -246,15 +264,6 @@ class UdpForwardClient:
 
     def _handle_udp_data(self, conn: UdpSocketConnection, data: bytes, addr):
         """Handle received UDP data"""
-        # Speed limit handling
-        if conn.speed_limiter and conn.speed_limiter.is_exceed()[0]:
-            if LoggerFactory.get_logger().isEnabledFor(logging.DEBUG):
-                LoggerFactory.get_logger().debug('UDP speed limit exceeded')
-            return
-
-        if conn.speed_limiter:
-            conn.speed_limiter.add(len(data))
-
         # Construct UDP message and send to public server via WebSocket
         send_message: MessageEntity = {
             'type_': MessageTypeConstant.WEBSOCKET_OVER_UDP,
@@ -270,7 +279,21 @@ class UdpForwardClient:
             LoggerFactory.get_logger().debug(f'Sending UDP to WebSocket, uid: {conn.uid}, len: {len(data)}')
 
         try:
-            self.ws.send(NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support), websocket.ABNF.OPCODE_BINARY)
+            # 发送端限速：在发送前等待
+            if conn.speed_limiter and data:
+                wait_time = conn.speed_limiter.acquire(len(data))
+                if wait_time > 0:
+                    time.sleep(wait_time)
+
+            message_bytes = NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
+            # 多连接模式：优先使用数据连接
+            if self.data_conn_manager and self.data_conn_manager.is_ready():
+                if not self.data_conn_manager.send_by_uid(conn.uid, message_bytes):
+                    # 数据连接发送失败，回退到控制连接
+                    self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
+            else:
+                # 单连接模式
+                self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
         except Exception as e:
             LoggerFactory.get_logger().error(f"Failed to send UDP to WebSocket: {e}")
 

proxynt-2.0.26/common/speed_limit.py

@@ -0,0 +1,89 @@
+import time
+import threading
+
+
+class SpeedLimiter:
+    """
+    令牌桶限速器（发送端限速）
+
+    使用方式：
+        limiter = SpeedLimiter(max_speed_mb=1.0)  # 1 MB/s
+
+        # 同步使用
+        wait_time = limiter.acquire(len(data))
+        if wait_time > 0:
+            time.sleep(wait_time)
+        send(data)
+
+        # 异步使用
+        wait_time = limiter.acquire(len(data))
+        if wait_time > 0:
+            await asyncio.sleep(wait_time)
+        await send(data)
+    """
+
+    def __init__(self, max_speed_mb=0):
+        """
+        :param max_speed_mb: 最大速度，单位 MB/s，0 表示不限速
+        """
+        self.max_speed = max_speed_mb * 1024 * 1024  # 转换为字节/秒
+        self.tokens = self.max_speed  # 初始令牌数（允许突发）
+        self.last_time = time.time()
+        self.lock = threading.Lock()
+
+    def acquire(self, data_len):
+        """
+        获取发送许可
+
+        :param data_len: 要发送的数据长度（字节）
+        :return: 需要等待的时间（秒），0 表示不需要等待
+        """
+        if self.max_speed <= 0:
+            return 0
+
+        with self.lock:
+            now = time.time()
+            elapsed = now - self.last_time
+            self.last_time = now
+
+            # 补充令牌（按时间流逝补充，最多补充到 max_speed）
+            self.tokens = min(self.max_speed, self.tokens + elapsed * self.max_speed)
+
+            # 消耗令牌
+            self.tokens -= data_len
+
+            if self.tokens >= 0:
+                return 0  # 有足够令牌，不需要等待
+
+            # 令牌不足，计算需要等待的时间
+            wait_time = -self.tokens / self.max_speed
+            return wait_time
+
+    def set_max_speed(self, max_speed_mb):
+        """
+        动态调整限速
+
+        :param max_speed_mb: 新的最大速度，单位 MB/s
+        """
+        with self.lock:
+            self.max_speed = max_speed_mb * 1024 * 1024
+            # 重置令牌，避免突然加速
+            self.tokens = min(self.tokens, self.max_speed)
+
+    # 保留旧接口的兼容性（但不推荐使用）
+    def add(self, data_len):
+        """兼容旧接口，等同于 acquire 但不返回等待时间"""
+        self.acquire(data_len)
+
+    def is_exceed(self):
+        """兼容旧接口，返回 (是否超速, 剩余量)"""
+        if self.max_speed <= 0:
+            return False, 0
+        with self.lock:
+            now = time.time()
+            elapsed = now - self.last_time
+            # 不更新 last_time，只是检查
+            current_tokens = min(self.max_speed, self.tokens + elapsed * self.max_speed)
+            if current_tokens >= 0:
+                return False, current_tokens
+            return True, -current_tokens

{proxynt-2.0.24 → proxynt-2.0.26}/constant/message_type_constnat.py

@@ -28,4 +28,7 @@ class MessageTypeConstant:
     P2P_PRE_CONNECT = 'g'
     P2P_EXCHANGE = 'h'        # UDP exchange to establish NAT mapping
     P2P_PEER_INFO = 'i'       # Server sends peer's actual UDP port
-    P2P_PUNCH_REQUEST = 'j'   # Request to initiate P2P hole punching
+    P2P_PUNCH_REQUEST = 'j'   # Request to initiate P2P hole punching
+
+    # 多连接支持
+    JOIN_SESSION = 'k'        # 数据连接加入会话（携带 session_token）

{proxynt-2.0.24 → proxynt-2.0.26}/constant/system_constant.py

@@ -15,7 +15,7 @@ class SystemConstant:
 
     COOKIE_EXPIRE_SECONDS = 3600 * 24
 
-    VERSION = '2.0.24'
+    VERSION = '2.0.26'
 
     GITHUB = 'https://github.com/sazima/proxynt'
 

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

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

{proxynt-2.0.24 → proxynt-2.0.26}/proxynt.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ setup.py
 ./client/__init__.py
 ./client/abstract_tunnel.py
 ./client/clear_nonce_task.py
+./client/data_connection_manager.py
 ./client/heart_beat_task.py
 ./client/kcp_tunnel_impl.py
 ./client/n4_tunnel_manager.py
@@ -74,6 +75,7 @@ setup.py
 ./server/admin_http_handler.py
 ./server/n4.py
 ./server/n4_signal_service.py
+./server/session_manager.py
 ./server/tcp_forward_client.py
 ./server/udp_forward_client.py
 ./server/websocket_handler.py

proxynt-2.0.26/proxynt.egg-info/requires.txt

@@ -0,0 +1,12 @@
+tornado
+typing_extensions
+xxhash>=3.0.0
+
+[:sys_platform != "win32"]
+uvloop>=0.14.0
+
+[:sys_platform == "win32"]
+winloop>=0.1.0
+
+[snappy]
+python-snappy