1
子循环 Poll 返回该连接
2
  → Connection::HandleRead：
3
      ret = NonBlockRecv(buf, 65536)
4
      → ret > 0：_in_buffer.WriteAndPush → 数据进输入缓冲
5
      → ret == 0（EAGAIN）：没数据，返回等下次
6
      → ret < 0（出错/对端关）：ShutdownInLoop（半关闭，见阶段 5）
7
      → if (_in_buffer 有数据) _message_callback(shared_from_this(), &_in_buffer)

1
void OnMessage(conn, buf)
2
{
3
    conn->Send(全部数据);        // ① 同步走（见 3.2）
4
    buf->MoveReadOffset(全部);    // ② 消费缓冲
5
    conn->ShutDown();             // ③ 半关闭（见阶段 5）
6
}

1
while (buffer->ReadAbleSize() > 0)          // 粘包：一条消息可能含多个请求
2
{
3
    context->RecvHttpRequest(buffer);       // 喂给解析状态机
4
    // 因果：状态机推进失败分两种：
5
    //   半包 → 状态原地不动 → 下面 RecvStatu != OVER → return
6
    //          → 数据留在 _in_buffer，等下次 HandleRead 再喂（缓冲跨事件存活！）
7
    //   出错 → 状态码 400/414 → 错误页 + 断连
8
    if (context->RecvStatu() != RECV_HTTP_OVER) return;   // 半包：等下一包
9

10
    Route(req, &rsp);          // 路由：静态文件优先 → 正则路由表 → 405
11
    WriteResponse(conn, req, rsp);   // 拼报文 → conn->Send（走 3.2）
12
    context->ReSet();          // 重置解析器 → 因果：才能解析下一条（粘包循环的续）
13
    if (rsp.Close()) conn->ShutDown();   // 短连接 → 半关闭
14
}

1
void Send(data, len)
2
{
3
    Buffer buf;  buf.WriteAndPush(data, len);   // ① 拷贝（防调用方临时数据悬垂）
4
    _loop->RunInLoop(SendInLoop, move(buf));    // ② 同线程 → 同步执行 ↓
5
}
6
void SendInLoop(Buffer &buf)
7
{
8
    if (_statu == DISCONNECTED) return;
9
    _out_buffer.WriteBufferAndPush(buf);        // 数据进输出缓冲
10
    if (!_channel.WriteAble())
11
        _channel.EnableWrite();                 // ★ 因果：注册 EPOLLOUT
12
}

1
EnableWrite → 下一次子循环 Poll 返回 EPOLLOUT → HandleWrite：
2
    ret = NonBlockSend(out_buffer 的全部)
3
    → ret < 0：发送出错 → 处理残留输入 → Release（阶段 6）
4
    → ret >= 0：MoveReadOffset(ret)   // 可能只发了一半（TCP 缓冲满）
5
         → 还有剩余 → 等下次 EPOLLOUT 继续（因果：循环直到发完）
6
         → 发完了：
7
              DisableWrite()   // ★ 因果：不关的话 LT 会疯狂触发 EPOLLOUT，CPU 空转
8
              if (_statu == DISCONNECTING)   // 优雅关闭等待者
9
                  Release()    // ★ 因果：数据发完，可以释放了（阶段 6）

1
if (_enable_inactive_release)
2
    _loop->TimerRefresh(_conn_id);   // 把超时任务挪到当前刻度之后 = 续命

1
timerfd（内核定时器，每秒可读一次）挂在本子循环的 epoll 上
2
  → 每秒 Poll 返回 → TimerWheel::OnTime
3
  → read(timerfd) 拿超时次数（防阻塞错漏）→ 秒针前进 times 格
4
  → _wheel[tick].clear()：
5
       该刻度所有 TimerTask 的 shared_ptr 引用归零 → 析构
6
       析构函数：if (!_canceled) _task_cb();    ← 任务回调在这里执行！
7
       回调 = Connection::Release
8
  → QueueInLoop 投递 ReleaseInLoop → 本阶段事件处理结束后，RunAllTask 执行（阶段 6）

1
浏览器 TCP 连接建立
2
  → 主线程 accept → NewConnection → 子线程 EstablishedInLoop
3
  → 业务 connected 回调 = HttpServer::OnConnected：
4
        conn->SetContext(HttpContext());
5
  → 因果：这个连接从此有了专属解析器（存在 Any _context 里），
6
          半包状态有了"存放地"——没有它，跨包解析无从谈起
7
  → EnableRead 已先行完成，该连接的读事件进入监控

1
浏览器发送：
2
    GET /index.html HTTP/1.1\r\n
3
    Host: 127.0.0.1:8085\r\n
4
    Connection: keep-alive\r\n
5
    \r\n
6
  → 内核：fd 可读 → 子循环 Poll 返回 → HandleRead
7
  → recv 成功 → _in_buffer.WriteAndPush（可能只收到一部分！半包）
8
  → _in_buffer 有数据 → 调 HttpServer::OnMessage

1
while (buffer->ReadAbleSize() > 0)          // 粘包预留：缓冲里可能有多条请求
2
{
3
    HttpContext *context = conn->Getcontext()->Get<HttpContext>();  // 取回解析器
4
    context->RecvHttpRequest(buffer);

1
穿透式 switch 开始推进：
2
    RECV_HTTP_LINE → GetLineAndPop 取请求行
3
        → 数据不足一行 → 返回，状态原地不动
4
        → 因果：OnMessage 里 RecvStatu() != OVER → return
5
                 数据留在 _in_buffer（跨 HandleRead 存活）
6
                 等下一包到达 → 回到 ②，再次喂解析器（半包闭环 ✅）
7
        → 行太长(>8192) → 状态 ERROR，状态码 414
8
    → 正则解析成功 → 状态 → HEAD
9
    RECV_HTTP_HEAD → 循环取行 → 遇到空行 → 状态 → BODY
10
    RECV_HTTP_BODY → ContentLength() = 0 → 直接 OVER

1
Route(req, &rsp);

1
IsFileHandler 检查（环环相扣的四个条件）：
2
    ① _basedir 已设置？      → 没设置 → 走功能路由
3
    ② 方法是 GET/HEAD？      → 不是 → 走功能路由
4
    ③ VaildPath 合法？       → /../ 穿越 → 拒绝（安全）
5
    ④ 拼路径存在且是普通文件？ → IsRegular 检查
6
        → 请求 / → 自动补 index.html（首页默认）
7
        → 不是文件 → 走功能路由
8
全部通过 → FileHandler：
9
    ReadFile 读文件内容 → rsp->_body
10
    ExtMime 查后缀 → Content-Type: text/html
11
    → 因果：响应体填好了，类型也对了——浏览器才能正确渲染而不是下载
12
（若走功能路
13
由：正则逐个匹配 → 命中执行 Hello/Login...；全不中 → 404）

1
// 因果：req.Close() 决定连接头——请求说 keep-alive 就回 keep-alive
2
if (req.Close()) rsp.SetHeader("Connection", "close");
3
else             rsp.SetHeader("Connection", "keep-alive");
4

5
if (rsp._body.size() && !rsp.HasHeader("Content-length"))
6
    rsp.SetHeader("Content-length", std::to_string(rsp._body.size()));  // 自动补长度
7
// （还有默认 Content-Type、重定向 Location 的自动补全）
8

9
rsp_str << req._version << " " << 200 << " " << "OK" << "\r\n"   // 状态行
10
        << 各头部 << "\r\n" << rsp._body;                        // 头部+正文
11
conn->Send(...);

1
OnMessage 在子线程跑 → Send → RunInLoop 同线程 → 同步 SendInLoop
2
  → out_buffer + EnableWrite → 下次 Poll 回报 EPOLLOUT → HandleWrite 真正发出
3
  → 发完 → DisableWrite → 若 DISCONNECTING → Release

1
context->ReSet();                    // 解析器复位：状态回 LINE、请求清空
2
if (rsp.Close())                     // 请求头 Connection: close？
3
    conn->ShutDown();                //  是 → 优雅关闭（框架收尾，见下）
4
// 否 → 什么都不做，函数返回

1
分支 A（本场景）：keep-alive 长连接
2
    → 不关闭，OnMessage 返回
3
    → 因果：连接留在 epoll 里等下一个请求
4
            10 秒内没新请求 → 时间轮到期 → 踢出（超时兜底）
5
            新请求来了 → 回到 ②，用 ReSet 后的解析器重新解析（连接复用闭环 ✅）
6

7
分支 B：Connection: close 短连接
8
    → ShutDown → ShutdownInLoop → DISCONNECTING
9
    → 响应数据已在发送中/已发完 → 发完 → HandleWrite 发现 DISCONNECTING → Release
10
    → 框架释放流程：移除监控 → 关 fd → 业务告别 → 投回主线程 → 析构

1
缓冲里同时有 3 条完整请求 → OnMessage 的 while 循环：
2
    第 1 条：解析 → 路由 → 响应 → ReSet
3
    第 2 条：继续（缓冲还有数据）→ 解析 → 响应 → ReSet
4
    第 3 条：同上
5
    缓冲空了 → 退出 while → 返回
6
    → 因果：3 个响应依次发出，每个都独立正确（test/client5 验证的就是这个）

1
解析失败（请求行格式错）        → 400 → ErrorHandler 拼错误页 → 响应 → 断连
2
单行超长（>8192）              → 414 → 同上
3
路径非法（/../ 穿越）           → VaildPath 拦截 → 不进文件服务 → 路由未命中 → 404
4
资源不存在                    → IsRegular false → 路由未命中 → 404
5
方法不支持（PATCH 等）          → 405
6
静态文件读取失败               → FileHandler 直接返回（rsp 空）→ 空响应体（教学简化）

1
无论哪条分支，连接最终走向三种结局之一：
2
    主动关闭（close 头 / 错误断连）→ ShutDown → 发完 → Release
3
    对端断开 → HandleClose → Release
4
    10 秒无活动（keep-alive 挂机）→ 时间轮到期 → Release
5
统一收尾（框架层）：移除监控 → 关 fd → 取消定时器
6
    → 业务 closed 回调（HttpServer 未注册 → 跳过）
7
    → 投回主线程 → _conns.erase → 引用归零 → 析构 ✅