Envoy整体架构和模块交互

graph TB
    subgraph "客户端层"
        A[客户端应用]
    end
    
    subgraph "Envoy代理层"
        B[Listener层]
        C[Filter链层]
        D[路由层]
        E[集群管理层]
        F[负载均衡层]
        G[连接池层]
    end
    
    subgraph "上游服务层"
        H[上游服务实例]
    end
    
    subgraph "配置管理层"
        I[xDS配置服务]
        J[本地配置文件]
    end
    
    subgraph "可观测性层"
        K[统计指标]
        L[访问日志]
        M[链路追踪]
        N[Admin接口]
    end
    
    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
    G --> H
    
    I --> B
    I --> C
    I --> D
    I --> E
    J --> B
    
    B --> K
    C --> L
    D --> M
    E --> N

graph TB
    subgraph "应用层 (L7)"
        A1[HTTP/gRPC过滤器]
        A2[路由决策]
        A3[负载均衡]
    end
    
    subgraph "会话层 (L5-L6)"
        B1[TLS终止]
        B2[会话管理]
    end
    
    subgraph "传输层 (L4)"
        C1[TCP/UDP处理]
        C2[连接管理]
        C3[流量控制]
    end
    
    subgraph "网络层 (L3)"
        D1[IP路由]
        D2[地址转换]
    end
    
    subgraph "数据链路层 (L2)"
        E1[以太网帧处理]
    end
    
    A1 --> A2
    A2 --> A3
    A3 --> B1
    B1 --> B2
    B2 --> C1
    C1 --> C2
    C2 --> C3
    C3 --> D1
    D1 --> D2
    D2 --> E1

graph LR
    subgraph "主线程"
        A[配置管理]
        B[xDS订阅]
        C[集群管理]
        D[统计收集]
    end
    
    subgraph "Worker线程1"
        E[Event Loop]
        F[连接处理]
        G[请求处理]
    end
    
    subgraph "Worker线程N"
        H[Event Loop]
        I[连接处理]
        J[请求处理]
    end
    
    subgraph "共享状态"
        K[ThreadLocalStorage]
        L[统计数据]
        M[配置快照]
    end
    
    A --> K
    B --> M
    C --> M
    D --> L
    
    K --> E
    K --> H
    M --> F
    M --> I
    L --> G
    L --> J

sequenceDiagram
    participant C as 客户端
    participant L as Listener
    participant NF as 网络过滤器
    participant HCM as HTTP连接管理器
    participant HF as HTTP过滤器
    participant R as Router
    participant LB as 负载均衡器
    participant CP as 连接池
    participant U as 上游服务
    
    Note over C,U: HTTP请求处理完整流程
    
    C->>L: 1. TCP连接建立
    L->>NF: 2. 网络过滤器处理
    NF->>HCM: 3. HTTP连接管理
    
    C->>HCM: 4. HTTP请求
    HCM->>HF: 5. HTTP过滤器链
    activate HF
    
    HF->>HF: 6. 认证/授权
    HF->>HF: 7. 限流检查
    HF->>HF: 8. 请求转换
    
    HF->>R: 9. 路由匹配
    R->>LB: 10. 负载均衡选择
    LB-->>R: 11. 选中的主机
    R->>CP: 12. 获取连接
    CP-->>R: 13. 可用连接
    
    R->>U: 14. 转发请求
    U-->>R: 15. 响应数据
    R->>HF: 16. 响应处理
    
    HF->>HF: 17. 响应转换
    HF->>HF: 18. 统计记录
    deactivate HF
    
    HCM->>C: 19. HTTP响应
    
    Note over C,U: 连接保持或关闭

graph TB
    subgraph "入站数据流"
        A[TCP字节流]
        B[HTTP解析]
        C[Header处理]
        D[Body处理]
        E[路由决策]
    end
    
    subgraph "过滤器处理"
        F[认证过滤器]
        G[授权过滤器]
        H[限流过滤器]
        I[转换过滤器]
        J[路由过滤器]
    end
    
    subgraph "上游处理"
        K[集群选择]
        L[负载均衡]
        M[连接池]
        N[请求转发]
    end
    
    subgraph "出站数据流"
        O[响应接收]
        P[响应过滤]
        Q[响应转换]
        R[TCP发送]
    end
    
    A --> B
    B --> C
    C --> D
    D --> E
    
    E --> F
    F --> G
    G --> H
    H --> I
    I --> J
    
    J --> K
    K --> L
    L --> M
    M --> N
    
    N --> O
    O --> P
    P --> Q
    Q --> R

graph TB
    subgraph "Server核心"
        A[InstanceBase]
        B[MainCommon]
    end
    
    subgraph "配置管理"
        C[ConfigurationImpl]
        D[XdsManager]
    end
    
    subgraph "网络层"
        E[ListenerManager]
        F[ConnectionManager]
    end
    
    subgraph "HTTP层"
        G[FilterManager]
        H[RouteManager]
    end
    
    subgraph "上游管理"
        I[ClusterManager]
        J[LoadBalancer]
    end
    
    subgraph "运行时服务"
        K[Runtime]
        L[Stats]
        M[Admin]
    end
    
    A --> C
    A --> E
    A --> I
    A --> K
    
    C --> D
    E --> F
    F --> G
    G --> H
    H --> I
    I --> J
    
    K --> L
    K --> M

graph TB
    subgraph "ConnectionManagerImpl"
        A[连接管理]
        B[编解码器]
        C[ActiveStream]
    end
    
    subgraph "过滤器链"
        D[DecoderFilters]
        E[EncoderFilters]
        F[RouterFilter]
    end
    
    subgraph "路由系统"
        G[RouteConfiguration]
        H[VirtualHost]
        I[Route]
    end
    
    subgraph "上游集成"
        J[ClusterManager]
        K[UpstreamRequest]
        L[ConnectionPool]
    end
    
    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    
    F --> G
    G --> H
    H --> I
    
    F --> J
    J --> K
    K --> L

graph TB
    subgraph "集群发现"
        A[ClusterDiscovery]
        B[EDS/CDS]
        C[DNS解析]
    end
    
    subgraph "健康检查"
        D[HealthChecker]
        E[HTTP检查]
        F[TCP检查]
    end
    
    subgraph "负载均衡"
        G[LoadBalancer]
        H[轮询算法]
        I[一致性哈希]
        J[最少连接]
    end
    
    subgraph "连接管理"
        K[ConnectionPool]
        L[HTTP/1.1池]
        M[HTTP/2池]
        N[TCP池]
    end
    
    A --> B
    A --> C
    B --> D
    D --> E
    D --> F
    
    B --> G
    G --> H
    G --> I
    G --> J
    
    G --> K
    K --> L
    K --> M
    K --> N

sequenceDiagram
    participant CS as 配置服务器
    participant XDS as XdsManager
    participant LDS as LDS订阅
    participant RDS as RDS订阅
    participant CDS as CDS订阅
    participant EDS as EDS订阅
    participant LM as ListenerManager
    participant CM as ClusterManager
    
    Note over CS,CM: xDS配置分发流程
    
    CS->>XDS: gRPC流建立
    XDS->>LDS: 订阅监听器配置
    XDS->>CDS: 订阅集群配置
    
    CS->>LDS: 监听器配置更新
    LDS->>LM: 应用监听器配置
    LM->>RDS: 订阅路由配置
    
    CS->>RDS: 路由配置更新
    RDS->>LM: 应用路由配置
    
    CS->>CDS: 集群配置更新
    CDS->>CM: 应用集群配置
    CM->>EDS: 订阅端点配置
    
    CS->>EDS: 端点配置更新
    EDS->>CM: 应用端点配置
    
    Note over CS,CM: 配置生效

graph TB
    subgraph "Bootstrap配置"
        A[Node标识]
        B[Admin配置]
        C[静态资源]
        D[动态资源]
    end
    
    subgraph "Listener配置"
        E[监听地址]
        F[过滤器链]
        G[TLS配置]
    end
    
    subgraph "RouteConfiguration"
        H[虚拟主机]
        I[路由规则]
        J[重试策略]
    end
    
    subgraph "Cluster配置"
        K[端点发现]
        L[负载均衡]
        M[健康检查]
        N[连接池]
    end
    
    A --> C
    C --> E
    C --> K
    D --> E
    D --> K
    
    E --> F
    F --> H
    H --> I
    I --> J
    
    K --> L
    K --> M
    K --> N

/**
 * 主线程主要职责
 * - 配置管理和热更新
 * - xDS订阅和处理
 * - 集群状态管理
 * - 统计数据收集
 * - Admin接口处理
 */
class MainThread {
public:
  void run() {
    // 1. 初始化配置系统
    initializeConfiguration();
    
    // 2. 启动xDS订阅
    startXdsSubscriptions();
    
    // 3. 初始化集群管理器
    initializeClusterManager();
    
    // 4. 启动工作线程
    startWorkerThreads();
    
    // 5. 运行主事件循环
    dispatcher_->run(Event::Dispatcher::RunType::Block);
  }

private:
  void handleConfigUpdate();
  void updateWorkerThreads();
  void collectStats();
};

/**
 * Worker线程架构
 * - 处理客户端连接
 * - 执行请求/响应处理
 * - 管理连接池
 * - 本地统计收集
 */
class WorkerThread {
public:
  WorkerThread(ThreadLocalStore& tls) : tls_(tls) {
    // 从TLS获取配置快照
    auto config_snapshot = tls_.getTyped<ConfigSnapshot>();
    
    // 初始化线程本地组件
    initializeLocalComponents(config_snapshot);
  }

  void processConnection(Network::ConnectionPtr connection) {
    // 1. 创建连接处理器
    auto handler = createConnectionHandler(connection);
    
    // 2. 设置事件回调
    connection->addConnectionCallbacks(*handler);
    
    // 3. 注册到事件循环
    dispatcher_->addConnection(std::move(connection));
  }

private:
  Event::DispatcherImpl dispatcher_;
  ThreadLocalStore& tls_;
  std::unique_ptr<ConnectionHandler> connection_handler_;
};

graph TB
    subgraph "主线程"
        A[配置更新]
        B[集群变更]
        C[统计聚合]
    end
    
    subgraph "ThreadLocalStore"
        D[配置快照]
        E[集群快照]
        F[统计快照]
    end
    
    subgraph "Worker线程1"
        G[本地配置]
        H[本地集群]
        I[本地统计]
    end
    
    subgraph "Worker线程N"
        J[本地配置]
        K[本地集群]
        L[本地统计]
    end
    
    A --> D
    B --> E
    C --> F
    
    D --> G
    D --> J
    E --> H
    E --> K
    F --> I
    F --> L

/**
 * 智能指针使用策略
 * - shared_ptr: 需要在多个地方共享的对象
 * - unique_ptr: 独占所有权的对象
 * - weak_ptr: 避免循环引用
 */
class ObjectLifecycleManager {
public:
  // 配置对象通常使用shared_ptr，因为需要在多线程间共享
  using ConfigPtr = std::shared_ptr<const Configuration>;
  
  // 连接对象使用unique_ptr，生命周期明确
  using ConnectionPtr = std::unique_ptr<Network::Connection>;
  
  // 避免循环引用的回调使用weak_ptr
  using CallbackWeakPtr = std::weak_ptr<CallbackInterface>;

  void updateConfiguration(ConfigPtr new_config) {
    // 原子更新配置指针
    std::atomic_store(&current_config_, new_config);
    
    // 通知所有worker线程
    tls_.runOnAllThreads([new_config](ThreadLocalObject& obj) {
      static_cast<WorkerState&>(obj).updateConfig(new_config);
    });
  }

private:
  std::shared_ptr<const Configuration> current_config_;
  ThreadLocalStore tls_;
};

/**
 * 零拷贝缓冲区管理
 * 使用Buffer::Instance接口实现高效的数据传输
 */
class BufferManager {
public:
  /**
   * 移动语义避免数据拷贝
   */
  void transferData(Buffer::Instance& source, Buffer::Instance& destination) {
    // 直接移动数据，不进行拷贝
    destination.move(source);
  }
  
  /**
   * 链式缓冲区避免大块内存分配
   */
  void appendData(Buffer::Instance& buffer, const void* data, size_t length) {
    buffer.add(data, length);
  }
  
  /**
   * 水位线控制内存使用
   */
  void checkWatermarks(Buffer::Instance& buffer) {
    if (buffer.length() > high_watermark_) {
      triggerBackpressure();
    } else if (buffer.length() < low_watermark_) {
      releaseBackpressure();
    }
  }

private:
  size_t high_watermark_ = 1024 * 1024;  // 1MB
  size_t low_watermark_ = 512 * 1024;    // 512KB
};

/**
 * 关键路径性能优化
 * - 内联函数减少调用开销
 * - 分支预测优化
 * - 缓存友好的数据结构
 */
class HotPathOptimization {
public:
  // 使用FORCE_INLINE确保关键函数内联
  FORCE_INLINE bool fastPathCheck(const RequestHeaders& headers) {
    // 使用likely/unlikely提示分支预测
    if (ENVOY_LIKELY(headers.Path() != nullptr)) {
      return processNormalPath(headers);
    } else {
      return ENVOY_UNLIKELY(processSpecialPath(headers));
    }
  }
  
  // 使用数组而非map提升缓存性能
  struct alignas(64) CacheLineAlignedData {
    uint64_t counter;
    uint64_t timestamp;
  };

private:
  // 按缓存行大小对齐
  alignas(64) std::array<CacheLineAlignedData, 16> hot_counters_;
};

/**
 * 无锁数据结构
 * 使用原子操作和无锁算法提升并发性能
 */
class LockFreeOptimization {
public:
  // 原子计数器避免锁竞争
  void incrementCounter() {
    counter_.fetch_add(1, std::memory_order_relaxed);
  }
  
  // 无锁环形缓冲区
  bool tryPush(const Item& item) {
    uint64_t head = head_.load(std::memory_order_relaxed);
    uint64_t next_head = (head + 1) % capacity_;
    
    if (next_head == tail_.load(std::memory_order_acquire)) {
      return false;  // 队列满
    }
    
    buffer_[head] = item;
    head_.store(next_head, std::memory_order_release);
    return true;
  }

private:
  std::atomic<uint64_t> counter_{0};
  std::atomic<uint64_t> head_{0};
  std::atomic<uint64_t> tail_{0};
  std::vector<Item> buffer_;
  size_t capacity_;
};

graph TB
    subgraph "错误类型"
        A[网络错误]
        B[协议错误]
        C[配置错误]
        D[上游错误]
    end
    
    subgraph "错误处理"
        E[错误检测]
        F[错误分类]
        G[错误恢复]
        H[错误报告]
    end
    
    subgraph "容错策略"
        I[重试机制]
        J[熔断器]
        K[降级策略]
        L[故障转移]
    end
    
    A --> E
    B --> E
    C --> E
    D --> E
    
    E --> F
    F --> G
    F --> H
    
    G --> I
    G --> J
    G --> K
    G --> L

/**
 * 熔断器实现
 * 当错误率超过阈值时，快速失败以保护系统
 */
class CircuitBreaker {
public:
  enum class State { Closed, Open, HalfOpen };
  
  bool allowRequest() {
    std::lock_guard<std::mutex> lock(mutex_);
    
    switch (state_) {
    case State::Closed:
      return true;
      
    case State::Open:
      if (shouldAttemptReset()) {
        state_ = State::HalfOpen;
        return true;
      }
      return false;
      
    case State::HalfOpen:
      return requests_in_half_open_ < max_requests_in_half_open_;
    }
  }
  
  void recordSuccess() {
    std::lock_guard<std::mutex> lock(mutex_);
    
    if (state_ == State::HalfOpen) {
      if (++successful_requests_in_half_open_ >= min_requests_in_half_open_) {
        state_ = State::Closed;
        reset();
      }
    }
  }
  
  void recordFailure() {
    std::lock_guard<std::mutex> lock(mutex_);
    
    failure_count_++;
    
    if (state_ == State::Closed) {
      if (failure_count_ >= failure_threshold_) {
        state_ = State::Open;
        last_failure_time_ = std::chrono::steady_clock::now();
      }
    } else if (state_ == State::HalfOpen) {
      state_ = State::Open;
      last_failure_time_ = std::chrono::steady_clock::now();
    }
  }

private:
  mutable std::mutex mutex_;
  State state_ = State::Closed;
  uint32_t failure_count_ = 0;
  uint32_t failure_threshold_ = 5;
  std::chrono::steady_clock::time_point last_failure_time_;
  
  bool shouldAttemptReset() const {
    auto now = std::chrono::steady_clock::now();
    return now - last_failure_time_ > std::chrono::seconds(30);
  }
};

graph TB
    subgraph "指标生成"
        A[Counter计数器]
        B[Gauge测量值]
        C[Histogram直方图]
        D[TextReadout文本]
    end
    
    subgraph "指标聚合"
        E[ThreadLocalStats]
        F[CentralStats]
        G[PeriodicFlush]
    end
    
    subgraph "指标输出"
        H[Prometheus格式]
        I[StatsD协议]
        J[Admin接口]
        K[自定义Sink]
    end
    
    A --> E
    B --> E
    C --> E
    D --> E
    
    E --> F
    F --> G
    
    G --> H
    G --> I
    G --> J
    G --> K