第29天：HTTP/3和QUIC协议

# day29_http3_demo.py
# 功能：HTTP/3和QUIC协议概念演示

import time
import random
from typing import Dict, List, Tuple
from enum import Enum


class PacketType(Enum):
    """QUIC数据包类型"""
    INITIAL = "Initial"
    HANDSHAKE = "Handshake"
    RETRY = "Retry"
    ZERORTT = "0-RTT"
    ONERTT = "1-RTT"


class QUICPacket:
    """
    QUIC数据包模拟

    属性：
        packet_type: 数据包类型
        connection_id: 连接ID
        packet_number: 包序号
        payload: 负载数据
    """

    def __init__(self, packet_type: PacketType, connection_id: str,
                 packet_number: int, payload: str = ""):
        self.packet_type = packet_type
        self.connection_id = connection_id
        self.packet_number = packet_number
        self.payload = payload
        self.timestamp = time.time()

    def __repr__(self):
        return (f"QUICPacket(type={self.packet_type.value}, "
                f"conn_id={self.connection_id}, "
                f"pkt_num={self.packet_number})")


class QUICConnection:
    """
    QUIC连接模拟

    功能：
        1. 连接建立（1-RTT和0-RTT）
        2. 数据传输
        3. 连接迁移
    """

    def __init__(self, connection_id: str):
        """
        初始化QUIC连接

        参数：
            connection_id: 连接标识符
        """
        self.connection_id = connection_id
        self.is_established = False
        self.packet_number = 0
        self.rtt = 50  # 模拟往返时间（毫秒）
        self.sent_packets = []
        self.received_packets = []
        self.session_ticket = None  # 用于0-RTT
        self.client_ip = "192.168.1.100"
        self.server_ip = "93.184.216.34"

    def handshake_1rtt(self):
        """
        1-RTT握手（首次连接）

        工作流程：
            客户端 → Initial (Client Hello)
            服务器 → Handshake (Server Hello, Certificate, Finished)
            客户端 → Handshake (Finished) + 1-RTT (Application Data)
        """
        print("\n" + "="*60)
        print(" QUIC 1-RTT握手演示")
        print("="*60)

        print(f"\n连接ID: {self.connection_id}")
        print(f"客户端: {self.client_ip}")
        print(f"服务器: {self.server_ip}")
        print(f"RTT: {self.rtt}ms")

        start_time = time.time()

        # 步骤1：客户端发送Initial包
        print("\n[0ms] 客户端 → Initial Packet")
        initial_pkt = QUICPacket(
            PacketType.INITIAL,
            self.connection_id,
            self.packet_number,
            "Client Hello + QUIC Parameters"
        )
        self.sent_packets.append(initial_pkt)
        self.packet_number += 1
        print(f"  内容: {initial_pkt.payload}")

        # 模拟网络延迟
        time.sleep(self.rtt / 2000)  # RTT的一半

        # 步骤2：服务器响应Handshake包
        print(f"\n[{self.rtt//2}ms] 服务器 → Handshake Packet")
        handshake_pkt = QUICPacket(
            PacketType.HANDSHAKE,
            self.connection_id,
            0,
            "Server Hello + Certificate + Finished"
        )
        self.received_packets.append(handshake_pkt)
        print(f"  内容: {handshake_pkt.payload}")

        # 模拟网络延迟
        time.sleep(self.rtt / 2000)

        # 步骤3：客户端发送Finished和应用数据
        print(f"\n[{self.rtt}ms] 客户端 → Handshake + 1-RTT Data")
        finished_pkt = QUICPacket(
            PacketType.HANDSHAKE,
            self.connection_id,
            self.packet_number,
            "Finished"
        )
        self.sent_packets.append(finished_pkt)
        self.packet_number += 1
        print(f"  握手完成")

        data_pkt = QUICPacket(
            PacketType.ONERTT,
            self.connection_id,
            self.packet_number,
            "HTTP/3 GET /index.html"
        )
        self.sent_packets.append(data_pkt)
        self.packet_number += 1
        print(f"  应用数据: {data_pkt.payload}")

        # 连接建立完成
        self.is_established = True

        # 保存会话票据用于0-RTT
        self.session_ticket = f"ticket_{self.connection_id}_{int(time.time())}"

        elapsed = (time.time() - start_time) * 1000
        print(f"\n✅ 连接建立完成！")
        print(f"总耗时: {elapsed:.2f}ms (约1-RTT)")
        print(f"会话票据: {self.session_ticket}")

        return elapsed

    def handshake_0rtt(self):
        """
        0-RTT握手（再次连接）

        工作原理：
            客户端使用之前保存的会话票据和密钥
            可以在第一个数据包中就发送应用数据
        """
        if not self.session_ticket:
            print("❌ 没有会话票据，无法使用0-RTT")
            return None

        print("\n" + "="*60)
        print(" QUIC 0-RTT握手演示")
        print("="*60)

        print(f"\n连接ID: {self.connection_id}")
        print(f"会话票据: {self.session_ticket}")
        print("使用之前保存的密钥")

        start_time = time.time()

        # 步骤1：客户端直接发送应用数据
        print("\n[0ms] 客户端 → Initial + 0-RTT Data")
        initial_pkt = QUICPacket(
            PacketType.ZERORTT,
            self.connection_id,
            self.packet_number,
            "HTTP/3 GET /style.css"
        )
        self.sent_packets.append(initial_pkt)
        self.packet_number += 1
        print(f"  会话票据: {self.session_ticket}")
        print(f"  应用数据: {initial_pkt.payload}")

        elapsed = (time.time() - start_time) * 1000
        print(f"\n✅ 0-RTT发送完成！无需等待握手！")
        print(f"总耗时: {elapsed:.2f}ms (0-RTT)")

        return elapsed

    def migrate_connection(self, new_ip: str):
        """
        连接迁移演示

        参数：
            new_ip: 新的IP地址

        工作原理：
            使用Connection ID标识连接
            IP变化不影响连接状态
        """
        print("\n" + "="*60)
        print(" QUIC连接迁移演示")
        print("="*60)

        old_ip = self.client_ip

        print(f"\n网络切换检测:")
        print(f"  旧IP: {old_ip} (WiFi)")
        print(f"  新IP: {new_ip} (4G)")
        print(f"  连接ID: {self.connection_id}")

        start_time = time.time()

        # 更新IP
        self.client_ip = new_ip

        # 使用新IP发送数据包
        print(f"\n使用新IP发送数据包...")
        migration_pkt = QUICPacket(
            PacketType.ONERTT,
            self.connection_id,  # Connection ID不变
            self.packet_number,
            "Path Challenge"
        )
        self.sent_packets.append(migration_pkt)
        self.packet_number += 1

        # 模拟网络延迟
        time.sleep(self.rtt / 1000)

        print(f"  服务器识别Connection ID: {self.connection_id}")
        print(f"  更新路径: {old_ip} → {new_ip}")
        print(f"  验证新路径...")

        response_pkt = QUICPacket(
            PacketType.ONERTT,
            self.connection_id,
            0,
            "Path Response"
        )
        self.received_packets.append(response_pkt)

        elapsed = (time.time() - start_time) * 1000
        print(f"\n✅ 连接迁移完成！")
        print(f"总耗时: {elapsed:.2f}ms")
        print(f"无需重新握手，继续使用原连接！")

        return elapsed

    def send_data(self, data: str, stream_id: int):
        """
        发送应用数据

        参数：
            data: 要发送的数据
            stream_id: 流ID
        """
        pkt = QUICPacket(
            PacketType.ONERTT,
            self.connection_id,
            self.packet_number,
            f"Stream {stream_id}: {data}"
        )
        self.sent_packets.append(pkt)
        self.packet_number += 1
        print(f"发送数据: {pkt.payload}")


class ProtocolComparison:
    """
    协议性能对比
    """

    @staticmethod
    def compare_handshake():
        """
        对比握手性能
        """
        print("\n" + "="*60)
        print(" 协议握手性能对比")
        print("="*60)

        rtt = 50  # 假设RTT为50ms

        print(f"\n假设条件：RTT = {rtt}ms\n")

        # HTTP/1.1
        print("HTTP/1.1 over TCP + TLS:")
        print("  TCP握手:     1-RTT ({rtt}ms)")
        print("  TLS握手:     2-RTT ({rtt*2}ms)")
        print("  HTTP请求:    1-RTT ({rtt}ms)")
        http1_total = rtt * 4
        print(f"  总计:        4-RTT ({http1_total}ms)")

        # HTTP/2
        print(f"\nHTTP/2 over TCP + TLS 1.3:")
        print(f"  TCP握手:     1-RTT ({rtt}ms)")
        print(f"  TLS 1.3握手: 1-RTT ({rtt}ms)")
        print(f"  HTTP请求:    1-RTT ({rtt}ms)")
        http2_total = rtt * 3
        print(f"  总计:        3-RTT ({http2_total}ms)")

        # HTTP/3 (1-RTT)
        print(f"\nHTTP/3 over QUIC (1-RTT):")
        print(f"  QUIC握手+请求: 1-RTT ({rtt}ms)")
        http3_1rtt = rtt
        print(f"  总计:        1-RTT ({http3_1rtt}ms)")

        # HTTP/3 (0-RTT)
        print(f"\nHTTP/3 over QUIC (0-RTT):")
        print(f"  直接发送数据: 0-RTT (0ms)")
        http3_0rtt = 0
        print(f"  总计:        0-RTT ({http3_0rtt}ms)")

        # 总结
        print(f"\n性能提升：")
        print(f"  HTTP/3(1-RTT) vs HTTP/1.1: {(1 - http3_1rtt/http1_total)*100:.1f}%")
        print(f"  HTTP/3(1-RTT) vs HTTP/2:   {(1 - http3_1rtt/http2_total)*100:.1f}%")
        print(f"  HTTP/3(0-RTT) vs HTTP/2:   {(1 - http3_0rtt/http2_total)*100:.1f}%")

    @staticmethod
    def compare_packet_loss():
        """
        对比丢包影响
        """
        print("\n" + "="*60)
        print(" 丢包影响对比")
        print("="*60)

        print("""
场景：同时传输3个流，每个流10个包，第2个流丢失1个包

HTTP/2 over TCP:
┌─────────────────────────────────────────────────────┐
│ 流1: [1][2][3][4][5][6][7][8][9][10] ⏸️ 等待      │
│ 流2: [1][X][等待重传...] ⏸️ 阻塞                  │
│ 流3: [1][2][3][4][5][6][7][8][9][10] ⏸️ 等待      │
└─────────────────────────────────────────────────────┘
问题：TCP要求按序交付，流2的丢包阻塞所有流
影响：所有30个包都要等待流2重传完成

HTTP/3 over QUIC:
┌─────────────────────────────────────────────────────┐
│ 流1: [1][2][3][4][5][6][7][8][9][10] ✅ 完成       │
│ 流2: [1][X][等待重传...] ⏸️ 只影响流2            │
│ 流3: [1][2][3][4][5][6][7][8][9][10] ✅ 完成       │
└─────────────────────────────────────────────────────┘
优势：每个流独立，流2的丢包只影响流2自己
影响：只有1个包需要重传，其他29个包正常传输

性能差异（丢包率5%）：
- HTTP/2: 所有传输被阻塞，延迟增加200%+
- HTTP/3: 只有受影响的流需要重传，延迟增加10%

结论：在弱网环境下，HTTP/3性能优势更明显
        """)


def main():
    """主程序"""
    print("""
    ╔══════════════════════════════════════════════════════════╗
    ║       HTTP/3 & QUIC 协议演示 v1.0                         ║
    ║       HTTP/3 & QUIC Protocol Demo                        ║
    ╚══════════════════════════════════════════════════════════╝
    """)

    # 生成Connection ID
    conn_id = f"conn_{random.randint(10000, 99999)}"

    # 创建QUIC连接
    conn = QUICConnection(conn_id)

    # 1. 演示1-RTT握手
    print("\n【演示1：首次连接 - 1-RTT握手】")
    rtt_1 = conn.handshake_1rtt()
    input("\n按Enter继续...")

    # 2. 演示0-RTT握手
    print("\n【演示2：再次连接 - 0-RTT握手】")
    rtt_0 = conn.handshake_0rtt()
    input("\n按Enter继续...")

    # 3. 演示连接迁移
    print("\n【演示3：网络切换 - 连接迁移】")
    conn.migrate_connection("10.0.0.50")
    input("\n按Enter继续...")

    # 4. 性能对比
    print("\n【演示4：协议性能对比】")
    ProtocolComparison.compare_handshake()
    input("\n按Enter继续...")

    ProtocolComparison.compare_packet_loss()

    # 总结
    print("\n" + "="*60)
    print(" 总结")
    print("="*60)
    print("""
HTTP/3 和 QUIC 的核心优势：

1. 更快的连接建立
   ✅ 1-RTT或0-RTT，比HTTP/2快2-3倍

2. 消除队头阻塞
   ✅ 每个流独立，丢包只影响单个流

3. 连接迁移
   ✅ 网络切换无需重新连接

4. 改进的拥塞控制
   ✅ 基于QUIC，更灵活的拥塞控制算法

5. 内置加密
   ✅ 默认TLS 1.3加密，更安全

6. 更快的发展
   ✅ 基于UDP，在用户空间实现，更新更快

适用场景：
- 移动网络（频繁切换）
- 弱网环境（高丢包率）
- 实时应用（低延迟要求）
- 视频流媒体
- Web应用

下一节我们将学习RESTful API设计！
    """)


if __name__ == "__main__":
    main()