314 lines
12 KiB
Python
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()
|