#!/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(' 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()