206 lines
6.9 KiB
Python
206 lines
6.9 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
UDP大数据包发送端测试程序
|
|
用于测试接收端的功能
|
|
"""
|
|
|
|
import socket
|
|
import struct
|
|
import random
|
|
import time
|
|
import threading
|
|
from typing import List
|
|
|
|
# 包头结构定义 (与C端保持一致)
|
|
class UDPPacketHeader:
|
|
"""UDP包头结构"""
|
|
MAGIC = 0xAA55
|
|
HEADER_SIZE = 16
|
|
|
|
def __init__(self, magic: int, total_size: int, big_packet_id: int,
|
|
packet_id: int, total_packets: int, payload_len: int):
|
|
self.magic = magic
|
|
self.total_size = total_size
|
|
self.big_packet_id = big_packet_id
|
|
self.packet_id = packet_id
|
|
self.total_packets = total_packets
|
|
self.payload_len = payload_len
|
|
|
|
def to_bytes(self) -> bytes:
|
|
"""转换为字节数据"""
|
|
return struct.pack('<HHIHHH',
|
|
self.magic, self.total_size, self.big_packet_id,
|
|
self.packet_id, self.total_packets, self.payload_len)
|
|
|
|
class UDPSender:
|
|
"""UDP发送端"""
|
|
|
|
def __init__(self, target_host: str, target_port: int):
|
|
self.target_host = target_host
|
|
self.target_port = target_port
|
|
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
|
|
def send_big_packet(self, data: bytes, delay: float = 0.0) -> int:
|
|
"""
|
|
发送大数据包
|
|
"""
|
|
if len(data) > 60 * 1024: # 60KB限制
|
|
raise ValueError("数据太大,超过60KB限制")
|
|
|
|
# 生成随机大包ID
|
|
big_packet_id = random.randint(1, 0xFFFFFFFF)
|
|
|
|
# 计算包数量
|
|
max_payload_size = 1024
|
|
total_packets = (len(data) + max_payload_size - 1) // max_payload_size
|
|
|
|
print(f"发送大包: ID={big_packet_id}, 大小={len(data)} 字节, 包数={total_packets}")
|
|
|
|
# 发送所有包
|
|
for packet_id in range(total_packets):
|
|
# 计算当前包的载荷
|
|
start_offset = packet_id * max_payload_size
|
|
end_offset = min(start_offset + max_payload_size, len(data))
|
|
payload = data[start_offset:end_offset]
|
|
payload_len = len(payload)
|
|
|
|
# 创建包头
|
|
header = UDPPacketHeader(
|
|
magic=UDPPacketHeader.MAGIC,
|
|
total_size=len(data),
|
|
big_packet_id=big_packet_id,
|
|
packet_id=packet_id,
|
|
total_packets=total_packets,
|
|
payload_len=payload_len
|
|
)
|
|
|
|
# 组装完整包
|
|
packet = header.to_bytes() + payload
|
|
|
|
# 发送包
|
|
self.socket.sendto(packet, (self.target_host, self.target_port))
|
|
|
|
print(f" 发送包 {packet_id + 1}/{total_packets}, 载荷大小: {payload_len}")
|
|
|
|
# 延迟(模拟网络延迟)
|
|
if delay > 0:
|
|
time.sleep(delay)
|
|
|
|
return big_packet_id
|
|
|
|
def close(self):
|
|
"""关闭socket"""
|
|
self.socket.close()
|
|
|
|
def generate_test_data(size: int) -> bytes:
|
|
"""生成测试数据"""
|
|
return bytes([random.randint(0, 255) for _ in range(size)])
|
|
|
|
def test_single_sender():
|
|
"""测试单个发送端"""
|
|
sender = UDPSender('127.0.0.1', 8080)
|
|
|
|
try:
|
|
# 发送不同大小的数据包
|
|
test_sizes = [100, 1000, 5000, 10000, 30000]
|
|
|
|
for size in test_sizes:
|
|
print(f"\n=== 测试发送 {size} 字节数据 ===")
|
|
data = generate_test_data(size)
|
|
big_packet_id = sender.send_big_packet(data, delay=0.01)
|
|
print(f"大包 {big_packet_id} 发送完成")
|
|
time.sleep(0.5) # 等待接收端处理
|
|
|
|
finally:
|
|
sender.close()
|
|
|
|
def test_multiple_senders():
|
|
"""测试多个发送端同时发送"""
|
|
def sender_thread(sender_id: int, data_size: int):
|
|
sender = UDPSender('127.0.0.1', 8080)
|
|
try:
|
|
data = generate_test_data(data_size)
|
|
big_packet_id = sender.send_big_packet(data, delay=0.02)
|
|
print(f"发送端 {sender_id}: 大包 {big_packet_id} 发送完成")
|
|
finally:
|
|
sender.close()
|
|
|
|
# 创建多个发送线程
|
|
threads = []
|
|
for i in range(3):
|
|
data_size = random.randint(1000, 10000)
|
|
thread = threading.Thread(target=sender_thread, args=(i, data_size))
|
|
threads.append(thread)
|
|
thread.start()
|
|
|
|
# 等待所有线程完成
|
|
for thread in threads:
|
|
thread.join()
|
|
|
|
print("所有发送端完成")
|
|
|
|
def test_timeout_scenario():
|
|
"""测试超时场景(故意延迟发送)"""
|
|
sender = UDPSender('127.0.0.1', 8080)
|
|
|
|
try:
|
|
print("=== 测试超时场景 ===")
|
|
data = generate_test_data(5000)
|
|
|
|
# 只发送前几个包,然后等待超时
|
|
big_packet_id = random.randint(1, 0xFFFFFFFF)
|
|
total_packets = (len(data) + 1024 - 1) // 1024
|
|
|
|
for packet_id in range(min(3, total_packets)): # 只发送前3个包
|
|
start_offset = packet_id * 1024
|
|
end_offset = min(start_offset + 1024, len(data))
|
|
payload = data[start_offset:end_offset]
|
|
|
|
header = UDPPacketHeader(
|
|
magic=UDPPacketHeader.MAGIC,
|
|
total_size=len(data),
|
|
big_packet_id=big_packet_id,
|
|
packet_id=packet_id,
|
|
total_packets=total_packets,
|
|
payload_len=len(payload)
|
|
)
|
|
|
|
packet = header.to_bytes() + payload
|
|
sender.socket.sendto(packet, (sender.target_host, sender.target_port))
|
|
print(f"发送包 {packet_id + 1}/{total_packets} (故意不发送完整)")
|
|
|
|
print("等待超时...")
|
|
time.sleep(2) # 等待超时
|
|
|
|
finally:
|
|
sender.close()
|
|
|
|
def main():
|
|
"""主函数"""
|
|
import argparse
|
|
|
|
parser = argparse.ArgumentParser(description='UDP大数据包发送端测试程序')
|
|
parser.add_argument('--host', default='127.0.0.1', help='目标主机 (默认: 127.0.0.1)')
|
|
parser.add_argument('--port', type=int, default=8080, help='目标端口 (默认: 8080)')
|
|
parser.add_argument('--test', choices=['single', 'multiple', 'timeout'],
|
|
default='single', help='测试类型 (默认: single)')
|
|
|
|
args = parser.parse_args()
|
|
|
|
print(f"UDP发送端测试程序")
|
|
print(f"目标: {args.host}:{args.port}")
|
|
print(f"测试类型: {args.test}")
|
|
|
|
if args.test == 'single':
|
|
test_single_sender()
|
|
elif args.test == 'multiple':
|
|
test_multiple_senders()
|
|
elif args.test == 'timeout':
|
|
test_timeout_scenario()
|
|
|
|
print("测试完成")
|
|
|
|
if __name__ == '__main__':
|
|
main()
|