第28天：HTTP/2协议特性

# day28_http2_analyzer.py
# 功能：HTTP/2协议分析器

import ssl
import socket
from typing import Dict, List, Tuple
import time

# 注意：需要安装 hyper 库来处理HTTP/2
# pip install hyper

try:
    from hyper import HTTPConnection
    from hyper.common.headers import HTTPHeaderMap
except ImportError:
    print("请先安装hyper库: pip install hyper")
    exit(1)


class HTTP2Analyzer:
    """
    HTTP/2协议分析器

    功能：
        1. 发送HTTP/2请求
        2. 分析响应性能
        3. 对比HTTP/1.1和HTTP/2
        4. 演示多路复用
    """

    def __init__(self, host: str, port: int = 443):
        """
        初始化HTTP/2连接

        参数：
            host: 目标主机
            port: 端口（默认443 for HTTPS）
        """
        self.host = host
        self.port = port
        self.conn = None

    def connect(self):
        """
        建立HTTP/2连接

        工作原理：
            1. 创建SSL/TLS连接
            2. 通过ALPN协商HTTP/2
            3. 建立HTTP/2连接
        """
        try:
            print(f"\n正在连接到 {self.host}:{self.port}...")
            self.conn = HTTPConnection(self.host, self.port)
            print("✅ HTTP/2连接建立成功")
            return True
        except Exception as e:
            print(f"❌ 连接失败: {e}")
            return False

    def request_single(self, path: str = '/') -> Tuple[float, int]:
        """
        发送单个HTTP/2请求

        参数：
            path: 请求路径

        返回值：
            (响应时间, 响应大小)
        """
        try:
            start_time = time.time()

            # 发送GET请求
            stream_id = self.conn.request('GET', path)

            # 获取响应
            response = self.conn.get_response(stream_id)

            # 读取响应体
            body = response.read()

            end_time = time.time()
            elapsed = (end_time - start_time) * 1000  # 转换为毫秒

            print(f"  {path}")
            print(f"    状态码: {response.status}")
            print(f"    响应时间: {elapsed:.2f}ms")
            print(f"    响应大小: {len(body)} bytes")

            return elapsed, len(body)

        except Exception as e:
            print(f"  ❌ 请求失败: {e}")
            return 0, 0

    def request_multiple(self, paths: List[str]) -> Dict[str, Tuple[float, int]]:
        """
        并发发送多个HTTP/2请求（演示多路复用）

        参数：
            paths: 路径列表

        返回值：
            {路径: (响应时间, 响应大小)}

        工作原理：
            HTTP/2允许在单个连接上并发多个请求
            不需要等待前一个请求完成
        """
        results = {}
        stream_ids = {}

        print(f"\n正在并发请求 {len(paths)} 个资源...")

        # 第一步：发送所有请求（不等待响应）
        start_time = time.time()

        for path in paths:
            try:
                stream_id = self.conn.request('GET', path)
                stream_ids[stream_id] = path
                print(f"  发送请求: {path} (流ID: {stream_id})")
            except Exception as e:
                print(f"  ❌ 发送请求失败 {path}: {e}")

        # 第二步：接收所有响应
        for stream_id, path in stream_ids.items():
            try:
                response = self.conn.get_response(stream_id)
                body = response.read()

                elapsed = (time.time() - start_time) * 1000
                results[path] = (elapsed, len(body))

                print(f"  接收响应: {path}")
                print(f"    状态码: {response.status}")
                print(f"    大小: {len(body)} bytes")

            except Exception as e:
                print(f"  ❌ 接收响应失败 {path}: {e}")
                results[path] = (0, 0)

        total_time = (time.time() - start_time) * 1000
        print(f"\n总耗时: {total_time:.2f}ms")

        return results

    def analyze_headers(self):
        """
        分析HTTP/2头部压缩效果

        演示：
            发送多个请求，观察头部压缩带来的性能提升
        """
        print("\n" + "="*60)
        print(" HTTP/2头部压缩分析")
        print("="*60)

        paths = ['/', '/about', '/contact']

        for i, path in enumerate(paths, 1):
            print(f"\n请求 {i}: {path}")
            self.request_single(path)

        print("""
头部压缩说明：
- 第一个请求发送完整头部
- 后续请求只发送头部索引
- HPACK算法压缩率可达90%
        """)

    def compare_http_versions(self):
        """
        对比HTTP/1.1和HTTP/2性能

        说明：
            这是一个简化的对比演示
            实际性能差异需要真实环境测试
        """
        print("\n" + "="*60)
        print(" HTTP/1.1 vs HTTP/2 性能对比")
        print("="*60)

        print("""
假设场景：加载一个网页，包含：
- 1个HTML文件
- 3个CSS文件
- 5个JS文件
- 10个图片文件
共19个资源

HTTP/1.1（6个并发连接）：
┌────────────────────────────────────────┐
│ 连接1: [HTML]                          │
│ 连接2: [CSS1][CSS2][CSS3]              │
│ 连接3: [JS1][JS2]                      │
│ 连接4: [JS3][JS4][JS5]                 │
│ 连接5: [IMG1][IMG2][IMG3][IMG4]        │
│ 连接6: [IMG5][IMG6][IMG7][IMG8]        │
│ 等待队列: [IMG9][IMG10]                │
└────────────────────────────────────────┘
总耗时：约800ms（估算）
- 6个TCP连接建立：6 × 100ms = 600ms
- 资源下载：200ms

HTTP/2（单个连接，多路复用）：
┌────────────────────────────────────────┐
│ 单个连接:                               │
│ [HTML][CSS1][CSS2][CSS3][JS1][JS2]...  │
│ 所有19个资源并行传输                    │
└────────────────────────────────────────┘
总耗时：约150ms（估算）
- 1个TCP连接建立：100ms
- 资源下载（并行）：50ms

性能提升：(800-150)/800 = 81.25%
        """)

    def demonstrate_multiplexing(self):
        """
        演示多路复用

        工作原理：
            在单个TCP连接上，同时发送多个请求
            不需要等待前一个请求完成
        """
        print("\n" + "="*60)
        print(" 多路复用演示")
        print("="*60)

        # 模拟请求多个资源
        paths = [
            '/',
            '/favicon.ico',
            '/robots.txt'
        ]

        print("\n方式1：顺序请求（模拟HTTP/1.1）")
        print("-" * 60)
        total_sequential = 0
        for path in paths:
            elapsed, size = self.request_single(path)
            total_sequential += elapsed
        print(f"\n顺序请求总耗时: {total_sequential:.2f}ms")

        # 重新连接
        self.connect()

        print("\n方式2：并发请求（HTTP/2多路复用）")
        print("-" * 60)
        results = self.request_multiple(paths)

        print(f"""
对比结果：
- 顺序请求: {total_sequential:.2f}ms
- 并发请求: {max(r[0] for r in results.values()):.2f}ms
- 性能提升: {(1 - max(r[0] for r in results.values())/total_sequential)*100:.1f}%

说明：HTTP/2多路复用允许多个请求/响应并行传输
      避免了队头阻塞，显著提升性能
        """)

    def close(self):
        """关闭连接"""
        if self.conn:
            self.conn.close()
            print("\n连接已关闭")


class SimpleHTTP2Demo:
    """
    简化的HTTP/2概念演示
    （不依赖外部库，纯Python实现概念演示）
    """

    @staticmethod
    def show_frame_structure():
        """
        展示HTTP/2帧结构
        """
        print("\n" + "="*60)
        print(" HTTP/2帧结构演示")
        print("="*60)

        print("""
HTTP/2帧格式：
┌──────────────────────────────────────────────────────┐
│  +-----------------------------------------------+   │
│  |                 Length (24)                   |   │
│  +---------------+---------------+---------------+   │
│  |   Type (8)    |   Flags (8)   |                   │
│  +-+-------------+---------------+------...------+   │
│  |R|                 Stream ID (31)               |   │
│  +=+===========================================+   │
│  |                   Frame Payload               |   │
│  +-----------------------------------------------+   │
└──────────────────────────────────────────────────────┘

字段说明：
- Length: 24位，帧负载的长度
- Type: 8位，帧类型
  * 0x0: DATA
  * 0x1: HEADERS
  * 0x2: PRIORITY
  * 0x3: RST_STREAM
  * 0x4: SETTINGS
  * 0x5: PUSH_PROMISE
  * 0x6: PING
  * 0x7: GOAWAY
  * 0x8: WINDOW_UPDATE
  * 0x9: CONTINUATION
- Flags: 8位，特定于帧类型的标志
- R: 1位，保留位
- Stream ID: 31位，流标识符

示例帧（HEADERS帧）：
┌──────────────────────────────────────┐
│ Length: 0x000012 (18字节)            │
│ Type: 0x01 (HEADERS)                 │
│ Flags: 0x04 (END_HEADERS)            │
│ Stream ID: 0x00000001                │
│ Payload: (压缩的头部数据)            │
└──────────────────────────────────────┘
        """)

    @staticmethod
    def show_stream_states():
        """
        展示流状态转换
        """
        print("\n" + "="*60)
        print(" HTTP/2流状态转换")
        print("="*60)

        print("""
流的生命周期：

                        +--------+
                        | idle   |  初始状态
                        +--------+
                             |
                             | 发送/接收 HEADERS
                             |
                             v
                        +--------+
                        | open   |  打开状态（双向通信）
                        +--------+
                             |
                ┌────────────┴────────────┐
                |                         |
                | 发送 END_STREAM         | 接收 END_STREAM
                v                         v
          +-------------+           +-------------+
          | half-closed |           | half-closed |
          | (local)     |           | (remote)    |
          +-------------+           +-------------+
                |                         |
                | 接收 END_STREAM         | 发送 END_STREAM
                └────────────┬────────────┘
                             v
                        +--------+
                        | closed |  关闭状态
                        +--------+

状态说明：
- idle: 未使用的流
- open: 活跃的流，可以双向发送帧
- half-closed: 一端已关闭，只能单向通信
- closed: 流已关闭，不能再发送帧
        """)

    @staticmethod
    def show_hpack_example():
        """
        展示HPACK压缩示例
        """
        print("\n" + "="*60)
        print(" HPACK头部压缩示例")
        print("="*60)

        print("""
场景：发送两个相似的HTTP请求

请求1（未压缩）：
:method: GET
:scheme: https
:path: /index.html
:authority: www.example.com
user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
accept: text/html,application/xhtml+xml
accept-language: zh-CN,zh;q=0.9
accept-encoding: gzip, deflate, br
cookie: session_id=abc123; user_id=456

原始大小：约 280 字节

请求1（HPACK压缩后）：
使用索引编码：
  :method: GET       → 2 (静态表索引)
  :scheme: https     → 7 (静态表索引)
  :path: /index.html → 动态编码
  :authority: ...    → 动态编码
  user-agent: ...    → 动态编码并加入动态表
  accept: ...        → 动态编码并加入动态表
  其他头部...        → 动态编码并加入动态表

压缩后大小：约 150 字节
压缩率：46%

---

请求2（利用动态表）：
:method: GET           → 2 (静态表)
:scheme: https         → 7 (静态表)
:path: /style.css      → 动态编码（只有路径不同）
:authority: ...        → 62 (动态表索引)
user-agent: ...        → 63 (动态表索引)
accept: ...            → 64 (动态表索引)
accept-language: ...   → 65 (动态表索引)
accept-encoding: ...   → 66 (动态表索引)
cookie: ...            → 67 (动态表索引)

压缩后大小：约 30 字节
压缩率：89%

动态表内容：
┌───┬──────────────────┬─────────────────────┐
│索引│  名称            │  值                  │
├───┼──────────────────┼─────────────────────┤
│62 │ :authority       │ www.example.com     │
│63 │ user-agent       │ Mozilla/5.0...      │
│64 │ accept           │ text/html,...       │
│65 │ accept-language  │ zh-CN,zh;q=0.9      │
│66 │ accept-encoding  │ gzip, deflate, br   │
│67 │ cookie           │ session_id=abc123...│
└───┴──────────────────┴─────────────────────┘

总结：
- 第一个请求建立动态表
- 后续请求复用动态表
- 压缩率随着请求增加而提高
        """)


def main():
    """主程序"""
    print("""
    ╔══════════════════════════════════════════════════════════╗
    ║       HTTP/2协议分析器 v1.0                               ║
    ║       HTTP/2 Protocol Analyzer                           ║
    ╚══════════════════════════════════════════════════════════╝
    """)

    # 首先展示概念演示（不需要网络连接）
    demo = SimpleHTTP2Demo()

    print("\n【第一部分：HTTP/2基础概念】")
    demo.show_frame_structure()
    input("\n按Enter继续...")

    demo.show_stream_states()
    input("\n按Enter继续...")

    demo.show_hpack_example()
    input("\n按Enter继续...")

    # 实际HTTP/2连接演示（需要网络）
    print("\n【第二部分：HTTP/2实际连接演示】")

    choice = input("\n是否进行实际HTTP/2连接测试？(y/n): ").strip().lower()

    if choice == 'y':
        # 使用支持HTTP/2的网站进行测试
        host = input("请输入测试网站（默认：www.google.com）: ").strip()
        if not host:
            host = "www.google.com"

        analyzer = HTTP2Analyzer(host)

        if analyzer.connect():
            try:
                # 单个请求
                print("\n1. 单个请求测试")
                analyzer.request_single('/')

                input("\n按Enter继续...")

                # 多路复用演示
                print("\n2. 多路复用演示")
                analyzer.demonstrate_multiplexing()

                input("\n按Enter继续...")

                # 性能对比
                print("\n3. 性能对比")
                analyzer.compare_http_versions()

            except Exception as e:
                print(f"\n测试过程出错: {e}")
            finally:
                analyzer.close()
    else:
        print("\n跳过实际连接测试")

    print("""
    \n总结：
    HTTP/2通过以下技术显著提升了Web性能：
    1. 二进制分帧 - 更高效的传输
    2. 多路复用 - 消除队头阻塞
    3. 头部压缩 - 减少带宽消耗
    4. 服务器推送 - 主动推送资源
    5. 请求优先级 - 优化加载顺序

    下一节我们将学习HTTP/3和QUIC协议！
    """)


if __name__ == "__main__":
    main()