Files
2026-08-24 15:49:57 +08:00

314 lines
12 KiB
Python

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
UDP大数据包接收端
支持多个发送方同时发送,包含1秒超时机制
"""
import socket
import struct
import threading
import time
from collections import defaultdict
from typing import Dict, List, Tuple, Optional
import logging
# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
# 包头结构定义 (与C端保持一致)
class UDPPacketHeader:
"""UDP包头结构"""
MAGIC = 0xAA55
HEADER_SIZE = 16 # 包头大小
def __init__(self, data: bytes):
"""
从字节数据解析包头
"""
if len(data) < self.HEADER_SIZE:
raise ValueError("数据长度不足,无法解析包头")
# 解析包头字段 (小端序)
(self.magic, self.total_size, self.big_packet_id,
self.packet_id, self.total_packets, self.payload_len) = struct.unpack('<HHIHHH', data[:16])
# 验证魔数
if self.magic != self.MAGIC:
raise ValueError(f"无效的魔数: {self.magic:04X}, 期望: {self.MAGIC:04X}")
class PacketReassembler:
"""包重组器,处理单个大包的重组"""
def __init__(self, big_packet_id: int, total_size: int, total_packets: int,
sender_addr: Tuple[str, int], timeout: float = 1.0):
self.big_packet_id = big_packet_id
self.total_size = total_size
self.total_packets = total_packets
self.sender_addr = sender_addr
self.timeout = timeout
self.start_time = time.time()
# 存储接收到的包
self.packets: Dict[int, bytes] = {}
self.received_count = 0
self.completed = False
self.data = None
def add_packet(self, packet_id: int, payload: bytes) -> bool:
"""
添加一个包到重组器
返回True如果包是新接收的,False如果包已存在
"""
if packet_id in self.packets:
return False # 包已存在
self.packets[packet_id] = payload
self.received_count += 1
# 检查是否所有包都已接收
if self.received_count == self.total_packets:
self._reassemble()
return True
return True
def _reassemble(self):
"""重组完整数据"""
try:
# 按包序号排序
sorted_packets = sorted(self.packets.items())
# 重组数据
reassembled_data = b''
for packet_id, payload in sorted_packets:
reassembled_data += payload
# 截取到指定长度
self.data = reassembled_data[:self.total_size]
self.completed = True
logger.info(f"大包 {self.big_packet_id} 重组完成,大小: {len(self.data)} 字节")
except Exception as e:
logger.error(f"重组大包 {self.big_packet_id} 时出错: {e}")
def is_timeout(self) -> bool:
"""检查是否超时"""
return time.time() - self.start_time > self.timeout
def is_completed(self) -> bool:
"""检查是否完成重组"""
return self.completed
def get_data(self) -> Optional[bytes]:
"""获取重组后的数据"""
return self.data if self.completed else None
class UDPReceiver:
"""UDP接收端主类"""
def __init__(self, host: str = '0.0.0.0', port: int = 8080, timeout: float = 1.0):
self.host = host
self.port = port
self.timeout = timeout
self.socket = None
self.running = False
# 存储所有正在重组的大包
# key: (sender_addr, big_packet_id), value: PacketReassembler
self.reassemblers: Dict[Tuple[Tuple[str, int], int], PacketReassembler] = {}
self.reassembler_lock = threading.Lock()
# 清理线程
self.cleanup_thread = None
def start(self):
"""启动接收端"""
try:
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.bind((self.host, self.port))
self.socket.settimeout(0.1) # 设置socket超时,用于检查停止信号
self.running = True
logger.info(f"UDP接收端启动,监听 {self.host}:{self.port}")
# 启动清理线程
self.cleanup_thread = threading.Thread(target=self._cleanup_timeout_packets, daemon=True)
self.cleanup_thread.start()
# 主接收循环
self._receive_loop()
except Exception as e:
logger.error(f"启动接收端失败: {e}")
self.stop()
def stop(self):
"""停止接收端"""
self.running = False
if self.socket:
self.socket.close()
logger.info("UDP接收端已停止")
def _receive_loop(self):
"""主接收循环"""
while self.running:
try:
data, addr = self.socket.recvfrom(2048) # 最大接收2048字节
self._process_packet(data, addr)
except socket.timeout:
continue # 超时继续循环
except Exception as e:
if self.running: # 只有在运行状态下才记录错误
logger.error(f"接收数据时出错: {e}")
def _process_packet(self, data: bytes, addr: Tuple[str, int]):
"""处理接收到的数据包"""
try:
# 解析包头
header = UDPPacketHeader(data)
# 提取载荷数据
payload = data[UDPPacketHeader.HEADER_SIZE:UDPPacketHeader.HEADER_SIZE + header.payload_len]
# 获取或创建重组器
reassembler = self._get_or_create_reassembler(header, addr)
if reassembler is None:
return # 超时或无效的包
# 添加包到重组器
if reassembler.add_packet(header.packet_id, payload):
logger.debug(f"接收包 {header.packet_id}/{header.total_packets} "
f"来自 {addr}, 大包ID: {header.big_packet_id}")
# 检查是否完成重组
if reassembler.is_completed():
self._handle_completed_packet(reassembler)
except Exception as e:
logger.error(f"处理来自 {addr} 的数据包时出错: {e}")
def _get_or_create_reassembler(self, header: UDPPacketHeader, addr: Tuple[str, int]) -> Optional[PacketReassembler]:
"""获取或创建包重组器"""
key = (addr, header.big_packet_id)
with self.reassembler_lock:
# 检查是否已存在
if key in self.reassemblers:
reassembler = self.reassemblers[key]
# 检查是否超时
if reassembler.is_timeout():
logger.warning(f"大包 {header.big_packet_id} 超时,丢弃")
del self.reassemblers[key]
return None
return reassembler
# 创建新的重组器
reassembler = PacketReassembler(
header.big_packet_id,
header.total_size,
header.total_packets,
addr,
self.timeout
)
self.reassemblers[key] = reassembler
logger.info(f"创建新的大包重组器: ID={header.big_packet_id}, "
f"大小={header.total_size}, 包数={header.total_packets}, 来源={addr}")
return reassembler
def _handle_completed_packet(self, reassembler: PacketReassembler):
"""处理完成重组的数据包"""
data = reassembler.get_data()
if data:
# 这里可以添加自定义的数据处理逻辑
logger.info(f"收到完整数据包: 大小={len(data)} 字节, "
f"来源={reassembler.sender_addr}, ID={reassembler.big_packet_id}")
# 示例:保存到文件
filename = f"received_data_{reassembler.big_packet_id}_{int(time.time())}.bin"
with open(filename, 'wb') as f:
f.write(data)
logger.info(f"数据已保存到文件: {filename}")
# 从重组器列表中移除
with self.reassembler_lock:
key = (reassembler.sender_addr, reassembler.big_packet_id)
if key in self.reassemblers:
del self.reassemblers[key]
def _cleanup_timeout_packets(self):
"""清理超时的包(在后台线程中运行)"""
while self.running:
time.sleep(0.5) # 每0.5秒检查一次
with self.reassembler_lock:
timeout_keys = []
for key, reassembler in self.reassemblers.items():
if reassembler.is_timeout():
timeout_keys.append(key)
# 移除超时的包
for key in timeout_keys:
reassembler = self.reassemblers[key]
logger.warning(f"清理超时的大包: ID={reassembler.big_packet_id}, "
f"来源={reassembler.sender_addr}, "
f"已接收={reassembler.received_count}/{reassembler.total_packets}")
del self.reassemblers[key]
def get_stats(self) -> Dict:
"""获取统计信息"""
with self.reassembler_lock:
return {
'active_reassemblers': len(self.reassemblers),
'reassemblers': [
{
'big_packet_id': r.big_packet_id,
'sender': r.sender_addr,
'received': r.received_count,
'total': r.total_packets,
'progress': f"{r.received_count}/{r.total_packets}",
'time_elapsed': time.time() - r.start_time
}
for r in self.reassemblers.values()
]
}
def main():
"""主函数"""
import argparse
parser = argparse.ArgumentParser(description='UDP大数据包接收端')
parser.add_argument('--host', default='0.0.0.0', help='监听地址 (默认: 0.0.0.0)')
parser.add_argument('--port', type=int, default=8080, help='监听端口 (默认: 8080)')
parser.add_argument('--timeout', type=float, default=1.0, help='包超时时间,秒 (默认: 1.0)')
parser.add_argument('--debug', action='store_true', help='启用调试日志')
args = parser.parse_args()
if args.debug:
logging.getLogger().setLevel(logging.DEBUG)
# 创建并启动接收端
receiver = UDPReceiver(args.host, args.port, args.timeout)
try:
# 启动接收端
receiver.start()
except KeyboardInterrupt:
logger.info("收到中断信号,正在停止...")
receiver.stop()
except Exception as e:
logger.error(f"运行时出错: {e}")
receiver.stop()
if __name__ == '__main__':
main()