Http2 on Tech Explorer

Proxygen http2 代码分析

Wed, 08 Mar 2017 00:00:00 +0000

Proxygen 的整体架构

一个 HTTPSession 对应一个 tcp 连接。

HTTPSession 中包含HTTPCodec ，HTTPCodec用来在 HTTPMessage(Request/Response) 和字节流之间做转换（就是解析/序列化）。

一个 HTTPTransaction 对应一个 HTTP2 的Stream ，也就是一次 Req/Resp Handler 是业务逻辑处理的基类。

其中 HTTP2 部分由几个类构成：

codec/HTTPCodec.h
codec/HTTP2Framer.cpp
codec/HTTP2Codec.cpp , HTTPParallelCodec.cpp
codec/Compress/HeaderCodec.cpp,HPACKCodec.cpp
session/HTTPSession.cpp
session/HTTPTransacion.cpp
session/HTTP2PriorityQueue.cpp

1. HTTPCodec.h
#

定义了 HTTPCodec 这个基类，定义了用来在内部的 HTTP Request/Response 和字节流之间做转换的公共接口，是HTTP1.1/SPDY/HTTP2 的公共基类。具体的HTTP2/HTTP1.1等各种协议的编解码，实现在 HTTP1.1/SPDY/HTTP2 等子类中。

1) HTTPCodec
#

HTTPCodec 是 HTTP1.1/ HTTP2 接口的超集，即HTTP1.1也被当成 HTTP2 实现

i. 首先所有的子类都要支持 StreamID，HTTP1.1 由于有KeepAlive，看成有多个Stream。 ii. onIngress()，传入输入数据，驱动解析。 iii. generateHeader()/ generateBody() /generateChunkHeader() /generateGoaway()/ generatePingRequest()/ generatePriority() 等，是 http1.1/http2 的超集。HTTP1xCodec.cpp 是没有实现HTTP2 的这些Frame 的generateXXX函数。HTTP1.1

2) PriorityQueue，优先级队列。
#

Session/HTTP2PriorityQueue.cpp 实现了这个接口类

3) HTTPCodec::Callback 类
#

解析的过程中，需要通知 HTTPCodec 的使用者做一些操作，因此有个接口类 HTTPCodec::Callback，HTTPCodec 的使用者实现 Callback 的子类，传给 HTTPCodec 的子类，HTTPCodec 的子类在解析过程中解析出来的各种消息都回调这个callback。 Callback 的主要方法有:

onMessageBegin()
onHeadersComplete() // HeaderList 接收完
onBody() // Body 开始
onMessageComplete() //Message 整个接收完
onWindowUpdate() // 收到 WindowUpdate Frame
onPriority()， //收到 Priority Frame等

顾名思义，处理HTTPMessage 开始事件，收到各种 HTTP2 Frame 等等。

2. HTTP2Framer.cpp
#

10种Frame 的解析/序列化工具函数，parseXXXFrame, writeXXXFrame，最底层。供HTTP2Codec 使用。

3. HTTP2Codec
#

Framing Layer，即处理 HTTPMesage , HTTP2 Frame 和输入/输出字节流之间的解析/序列化。实现了HTTPParallelCodec(HTTP2和SPDY的公共基类，HTTPCodec 的子类)，HeaderCodec两个接口类

1) 输入字节流的解析的时候，做:
#

i. HEADERS Frame，
#

做各种 Header 的变换处理。

ii. PRIORITY
#

4. compress/HeaderCodec.cpp
#

HeaderCodec 是 Header List 的编解码器。HeaderCodec解码的结果通过 HeaderCodec::StreamingCallback接口类通知给使用者（即HTTP2Codec）。HeaderCodec::StreamingCallback主要有个 onHeader(name, value) 接口(HTTP2Codec实现了)。

5. compress/HPACKCodec.cpp
#

HPACK保存 int –> string 的映射，通过发送 int，代替 string 来压缩。

HPACK编码，主要需要实现动态表，静态表，Huffman encoding，Header序列化/解析。

HPACKCodec 主要有 encode(vector

)/decode(Buffer) 两个接口。重要成员变量：

 HPACKEncoder encoder_;
 HPACKDecoder decoder_;

实际的动态表/静态表逻辑，是一个HeaderTable，主要数据结构就是vector + ，

HPACKDecoder 里面的动态表对应的是 HPACKContext，先 peek 一个字节，判断是否用了HPACKDecodeBuffer来解码

Integer比特编解码，literal编解码，都实现在 HPACKDecodeBuffer / HPACKEncodeBuffer里面。

Huffman encoding 实际使用的是 256位的trie，不是2位的，为了优化性能。

在 HeaderTable.cpp 中，可以看到，实际的 vector 是当成一个环形队列来用的，实际是把 RFC 中规定的 [ 1 — n ] 的区间，逆向映射到这个环形队列中，即 index 1 是，对应到环形队列的尾，index n 是对应到环形队列的头。这样，按照 RFC，增加 Header 进来的时候，应该是加在 1 前面，并把所有的已有 Header 往后挪1个位置，实现上就可以不用做 “挪动”，而且已有的 name–>index 的映射也不用改。这是一种实现上的小技巧。

并用一个

unordered_map<Header.name , list<index> > 

的形式存储 Header.name 到一组 vector 中的 index 的映射，这是由于有相同 name ，对应多个 value 的情况，而且要支持 “查找 name+value 匹配” 和 ”查找 name 匹配“ 两种查找。

6. session/HTTP2PriorityQueue.cpp
#

每一个 Stream都依赖一个 Stream 或者 Stream 0。一个 Stream A 依赖 Stream B ，那么 A 就是 B 的子节点。形成依赖树。 Stream 0 是树的根节点。

HTTP2PriorityQueue实现了PriorityQueue接口类，实现了 addPriorityNode(StreamID id, StreamID parent) 接口

主要的逻辑实现在 Node这个内部类里面。

PriorityQueue 的数据成员，主要是一个 unorder_map<streamID, Node>

Node内部的数据成员：

Node {
 HTTP2PriorityQueue& queue_; //属于哪个 PriorityQueue
 Node *parent_{nullptr}; 		//树中的父节点
 HTTPCodec::StreamID id_{0}; //
 uint16_t weight_{16}; //权重
 HTTPTransaction *txn_{nullptr}; 

 bool isPermanent_{false};
 bool enqueued_{false}; //enqueued 表示在 有输出数据的队列中

 uint64_t totalEnqueuedWeight_{0}; 
 uint64_t totalChildWeight_{0};

 std::list<std::unique_ptr<Node>> children_; // 子节点
 std::list<std::unique_ptr<Node>>::iterator self_; 

 folly::IntrusiveListHook enqueuedHook_; //一个侵入式链表
 folly::IntrusiveList<Node, &Node::enqueuedHook_> enqueuedChildren_; //

}

有输出数据等待发送 (pending Egress) 的 HTTPTransaction ，会加入

signalPendingEgress() ，通知 HTTP2PriorityQueue 某一个 Stream 产生了输出数据。内部实现是把这 Stream加入

clearPendingEgress()，通知一个 Stream 发完了输出数据。

addOrUpdatePriorityNode()，

nextEgress() ，获取有输出数据等待发送的 HTTPTransaction 的列表，列表的每个元素是 pair< HTTPTransaction * ，double weight > ，按照 weight 从大到小排列，列表中的所有weight 加起来等于1。

7. session/HTTPTransaction.cpp
#

HTTPTransaction 表示一次 Req／Resp，HTTPTransaction 需要和 HTTPSession 交互写入 HTTPMessage 所以提出了Transport 这个概念，这样依赖关系就是单向的，没有 HTTPTransaction – HTTPSession 之间不会产生双向依赖。实际处理业务的代码，定义成一个个 Handler，需要与Handler 交互，

1) HTTPTransaction::Transport
#

是 HTTPTransaction 的下层为 HTTPTransaction 提供的输出HTTPMessage 服务。(下层具体指的是 HTTPSession)。

Transport 的方法有：sendHeaders()/sendBody()/pauseIngress()/resumeIngress()/ sendPriority() / 等

2) HTTPTransactionHandler
#

是一个个业务Handler 的基类，Handler的方法有:onHeadersComplete()/onBody()/onChunk/onTrailers/onEgressPaused()/ onEgressResumed等，就是解析出 HTTP Message的各个部分，或者流控发现无法再写了时候的通知。

i. HTTPTransaction::Handler 有好几种,业务Handler 比如直接生成 ErrorPage 的 HTTPDirectResponseHandler就是生成 404 页面的 Handler，在其内部，实现 onHeadersComplete 方法，在这个方法内生成回包数据，然后调用 HTTPTransaction 的 sendHeaders/sendBody 等方法发回给客户端。

3) HTTPTransactionIngressSM
#

由于 HTTPTransaction 要调用 Handler 的好几种方法，内部要记录当前已经处理到哪一步了，不能允许在任意时机，任意来的数据都触发回调，所以搞了两个状态机，HTTPTransactionIngressSM/ HTTPTransactionEgressSM 来明确地规定回调可以触发的顺序。

4) HTTPTransaction 的重要成员变量：
#

streamId, handler_ , transport_ ,egressState_ , ingressState_, recvWindow_ , sendWindow_, HTTP2PrioprityQueue::Handle queueHande_,

8. session/HTTPSession.cpp
#

HTTPSession 针对 HTTP2/HTTP1.1/SPDY的超集的，HTTPSession是一个 HTTPCodec::Callback（接受解析出来的各种 Frame），是 HTTPTransaction::Callback（供HTTPTransaction发送输出 HTTP Message）,是 FlowControlFilter::Callback（接受输出状态打开/关闭的通知）。

1) 重要成员变量：
#

{
 folly::IOBufQueue readBuf_,
 folly::IOBufQueue writeBuf_,
 map<StreamID, HTTPTransaction>transactions_,
 HTTP2PriorityQueue queue,
 FlowControlFilter connFlowControl_,
}			
			

2) getNextToSend()
#

是做发送的，可以看到，proxygen 是按相对权重来分派带宽的。txnEgressQueue_.nextEgress() 取出当前可发送的 HTTPTransaction + 相对权重的列表，然后把可发送字节数按照相对权重分给各个HTTPTransaction。

9. 细节
#

1) IOBufQueue
#

多处用到的基础类：IOBufQueue，Zero-Copy，引用计数。一个 Bufffer Chain，设计类似 linux kernel 的sk_buff, BSD 的 mbuf 。

https://github.com/facebook/folly/blob/master/folly/io/IOBuf.h

 * An IOBuf is a pointer to a buffer of data. *
 * IOBuf objects are intended to be used primarily for networking code, and are
 * modelled somewhat after FreeBSD's mbuf data structure, and Linux's sk_buff structure.
 * IOBuf objects facilitate zero-copy network programming, by allowing multiple
 * IOBuf objects to point to the same underlying buffer of data, using a
 * reference count to track when the buffer is no longer needed and can be freed.

2) HTTPHeaders
#

HTTPHeaders 有个性能优化，用了静态完美hash函数，把常用的 83个 Header 各自唯一地hash 成1 字节，HeaderList 的查找使用汇编实现的memchr。

https://github.com/facebook/proxygen/blob/master/proxygen/lib/http/HTTPHeaders.h

* Headers are stored as Name/Value pairs, in the order they are received on
 * the wire. We hash the names of all common HTTP headers (using a static
 * perfect hash function generated using gperf from HTTPCommonHeaders.gperf)
 * into 1-byte hashes (we call them "codes") and only store these. We search
 * them using memchr, which has an x86_64 assembly implementation with
 * complexity O(n/16) ;)
 

TrafficServer http2 代码分析

Wed, 08 Mar 2017 00:00:00 +0000

TrafficServer 是Apache基金会的 HTTP/HTTP2 代理服务器。

TrafficServer 的 HTTP2 部分主要的代码在 :

trafficserver/proxy/http2/HTTP2.h, HTTP2.cc
trafficserver/proxy/http2/Http2Stream.h, Http2Stream.cc
trafficserver/proxy/http2/Http2ClientSession.h, Http2ClientSession.cc
trafficserver/proxy/http2/Http2ConnectionState.h, Http2ConnectionState.cc
trafficserver/proxy/http2/ Http2DependencyTree.h, Http2DependencyTree.cc
trafficserver/proxy/http2/HPACK.h, HPACK.cc
trafficserver/proxy/http2/HuffmanCodec.h, HuffmanCodec.cc

1. trafficserver/proxy/http2/HTTP2.h, HTTP2.cc
#

10种Frame 的struct定义，解析/序列化函数，HeaderList转换函数，一些常量定义

2. trafficserver/proxy/http2/Http2ClientSession.h, Http2ClientSession.cc
#

Http2ClientSession 处理 io event 事件，解析 FrameHeader，

调用顺序：

Http2ClientSession::main_event_handler()

--> state_read_connection_preface()

--> state_start_frame_read()

--> state_process_frame_read() 解析出一个完整的Frame

--> do_complete_frame_read()

--> Http2ConnectionState::main_event_handler(HTTP2_SESSION_EVENT_RECV )

3. trafficserver/proxy/http2/Http2ConnectionState.h, Http2ConnectionState.cc
#

Http2ConnectionState，对应一个 HTTP2 连接，代码基本等价于 proxygen 的 HTTPSession，主要的成员变量：

{ 
 双链表<Http2Stream> //略挫，有个find_stream 用的遍历，改map好点。

 Http2ClientSession，

 HpackHandle 2个，

 DependencyTree，

 Http2ConnectionSettingsclient_settings server_settings，连接的几个 Settings 配置项，一个int数组
}

主要的方法：各个 rcv_xxx_frame() 和 send_xxx_frame(0 Http2ConnectionState::main_event_handler(HTTP2_SESSION_EVENT_RECV )里面，解析输入的各种 Frame

rcv_data_frame, // HTTP2_FRAME_TYPE_DATA
rcv_headers_frame, // HTTP2_FRAME_TYPE_HEADERS
rcv_priority_frame, // HTTP2_FRAME_TYPE_PRIORITY
rcv_rst_stream_frame, // HTTP2_FRAME_TYPE_RST_STREAM
rcv_settings_frame, // HTTP2_FRAME_TYPE_SETTINGS
rcv_push_promise_frame, // HTTP2_FRAME_TYPE_PUSH_PROMISE
rcv_ping_frame, // HTTP2_FRAME_TYPE_PING
rcv_goaway_frame, // HTTP2_FRAME_TYPE_GOAWAY
rcv_window_update_frame, // HTTP2_FRAME_TYPE_WINDOW_UPDATE
rcv_continuation_frame, // HTTP2_FRAME_TYPE_CONTINUATION

还有发送各类 frame 的接口，send_data_frames()/send_headers_frame() / send_push_promise_frame() / send_rst_stream_frame() 等。

具体地：

rcv_data_frame :
#

find_stream,然后检查stream的state是不是OPEN/HALF_CLOSE_LOCAL，去除 padding，处理END_STREAM flag，检查本端流量控制 window_size ，保存buffer，更新本地的window，发回 Connection 和 Stream Level 的WindowUpdate Frame。

rcv_headers_frame：
#

find_stream/create_stream，处理padding，处理PRIORITY flag添加到 PriorityTree 里面，如果 Header Block 结束了（即有END_HEADERS FLAG），那就http2_decode_header_blocks() 做HPACK 解压缩，调用 Http2Stream 处理解析出的HeaderList

rcv_priority_frame:
#

find_stream，reprioritize，重新调整树。

rcv_rst_stream_frame
#

rcv_settings_frame:
#

parse检查收到的各个配置项，更新到client_settings中，并发送SETTINGS_ACK

rcv_push_promise_frame 等
#

包括 rcv_ping_frame

rcv_goaway_frame:

rcv_window_update_frame

比较简单，略。

rcv_continuation_frame
#

类似 rcv_headers_frame

send_data_frames_depends_on_priority
#

取了 DependencyTree的top()，

send_data_frames 等
#

send_a_data_frame

send_headers_frame

send_push_promise_frame

send_rst_stream_frame

send_settings_frame

send_ping_frame

send_goaway_frame

send_window_update_frame

比较简单，就是检查字段合法性，序列化，然后发送。

4. trafficserver/proxy/http2/Http2Stream.h, Http2Stream.cc
#

对应实现HTTP2 的Stream，重要的成员变量有：

Http2StreamState _state;//实现IDLE，OPEN，RESERVED，HALF_CLOSE等的切换。

DependencyTree::Node *priority_node;// Priority Tree中的节点指针。

5. trafficserver/proxy/http2/Http2DependencyTree.h, Http2DependencyTree.cc
#

Http2DependencyTree::Node 表示一个Stream，成员变量有：

{
 bool actived; //是否有输出数据
 bool queued; //是否在 actived 队列中
 uint32_t id;
 uint32_t weight;
 uint32_t point; //queue中的节点按照这个 point 做优先级排序
 Node *parent; //父节点
 DLL<Node> children; //子节点的双列表
 
 PriorityQueueEntry<Node *> *entry; // 
 PriorityQueue<Node *> *queue; //有输出数据的所有子节点的队列，按point 优先级降序排列

 Http2Stream *t;
}

Http2DependencyTree 中有个 Node * root 指向树的根节点。

Http2DependencyTree的主要方法有：

Node *find(uint32_t id);
DFS 递归遍历树，查找一个Stream。
Node *add(uint32_t parent_id, uint32_t id, uint32_t weight, bool exclusive, T t); 就是插入 parent 的 children 链表中，兼做 exclusive 处理。
void remove(Node *node); 从parent 的 queue 中移除自己，把自己的 queue 全转给 parent，把自己的 children 全转给 parent
void reprioritize(uint32_t new_parent_id, uint32_t id, bool exclusive); 重排优先级，就是移动节点
Node *top(); 返回整个树中，point 最高的叶子节点。递归实现。
void activate(Node *node); 往上遍历，如果当前节点没有在 parent 的 queue中，加入
void deactivate(Node *node, uint32_t sent); 从parent 的queue中去除自己。
void update(Node *node, uint32_t sent);

这里使用 Weighted Fair Queue (WFQ) Scheduling 来调度 Stream 之间的优先级。

Http2ConnectionState::send_data_frames_depends_on_priority() 中，是直接取了树的 top() 节点，

6. trafficserver/proxy/http2/HPACK.h, HPACK.cc
#

实现 HPACK 压缩/解压缩

7. trafficserver/proxy/http2/HuffmanCodec.h, HuffmanCodec.cc
#

实现静态的 Huffman 表，接口简单，只有4个函数，，

是实现成二叉树，相比proxygen估计效率会低一些。

Http2 on Tech Explorer

Proxygen http2 代码分析

1. HTTPCodec.h #

1) HTTPCodec #

2) PriorityQueue，优先级队列。 #

3) HTTPCodec::Callback 类 #

2. HTTP2Framer.cpp #

3. HTTP2Codec #

1) 输入字节流的解析的时候，做: #

i. HEADERS Frame， #

ii. PRIORITY #

4. compress/HeaderCodec.cpp #

5. compress/HPACKCodec.cpp #

TrafficServer http2 代码分析

1. trafficserver/proxy/http2/HTTP2.h, HTTP2.cc #

2. trafficserver/proxy/http2/Http2ClientSession.h, Http2ClientSession.cc #

3. trafficserver/proxy/http2/Http2ConnectionState.h, Http2ConnectionState.cc #

rcv_data_frame : #

rcv_headers_frame： #

rcv_priority_frame: #

rcv_rst_stream_frame #

rcv_settings_frame: #

rcv_push_promise_frame 等 #

rcv_continuation_frame #

send_data_frames_depends_on_priority #

send_data_frames 等 #

4. trafficserver/proxy/http2/Http2Stream.h, Http2Stream.cc #

5. trafficserver/proxy/http2/Http2DependencyTree.h, Http2DependencyTree.cc #

6. trafficserver/proxy/http2/HPACK.h, HPACK.cc #

7. trafficserver/proxy/http2/HuffmanCodec.h, HuffmanCodec.cc #