diff --git a/doc/multiloop-design.md b/doc/multiloop-design.md index 65c6f8ae..9264116b 100644 --- a/doc/multiloop-design.md +++ b/doc/multiloop-design.md @@ -677,7 +677,7 @@ W4 之后改成了**连接自己那条**(`client->get_loop()`),分片用 **理由要写准(2026-09-22 按源码核过,原先那句不成立)**:不能说成"在**别的循环的线程**上 `delete` 一个持有那条循环句柄的 `uvcpp_ws_connection` 在 libuv 层面不成立" —— -`notify_retired()`(`src/web/uvcpp_ws_connection.cpp:115-143`)在对象进 `retired_` **之前** +`notify_retired()`(`src/web/uvcpp_ws_connection.cpp:115-154`)在对象进 `retired_` **之前** 就跑完了:它清零 `close_observer_id_`、摘掉关闭观察者、把 `tcp_` 置空 (`src/web/uvcpp_ws_connection.cpp:133`);而 `~uvcpp_ws_connection` (`src/web/uvcpp_ws_connection.cpp:35-48`)在 `tcp_ == nullptr` 时 diff --git a/doc/web-ws-guide.md b/doc/web-ws-guide.md index 6cd85929..1a5b3017 100644 --- a/doc/web-ws-guide.md +++ b/doc/web-ws-guide.md @@ -46,16 +46,16 @@ HTTP 的服务端与 WS 的服务端会在同一个 `uvcpp_http_server` 上碰 |---|---|---| | `uvcpp_ws_server` | `src/web/uvcpp_ws_server.h:46` | 挂在 HTTP 服务器上做**握手**(识别升级 → 算 Accept → 回 101 → 建会话)。自己不管帧收发 | | `uvcpp_ws_client` | `src/web/uvcpp_ws_client.h:56` | 解析 `ws://` / `wss://`、发升级请求、校验 101、建会话。**同时持有自己的 loop** | -| `uvcpp_ws_connection` | `src/web/uvcpp_ws_connection.h:61` | 真正的 WS 语义:帧解析与序列化、掩码、分片重组、压缩、Close 握手、发送队列 | +| `uvcpp_ws_connection` | `src/web/uvcpp_ws_connection.h:62-62` | 真正的 WS 语义:帧解析与序列化、掩码、分片重组、压缩、Close 握手、发送队列 | | `uvcpp_ws_sessions` | `src/web/uvcpp_ws_sessions.h:36` | 会话归属表 + **延迟回收器**。不是广播器 | | `uvcpp_ws_parser` | `src/web/uvcpp_ws_parser.h:38` | 纯字节流解析器。正常用不到,`uvcpp_ws_connection` 内部自己持有一个 | | `uvcpp_ws_ext` | `src/web/uvcpp_ws_ext.h:110` | `permessage-deflate` 的语法层与策略层 | **服务端与客户端拿到的是同一个类**(`uvcpp_ws_connection`),靠 `ws_role` 区分方向 -(`src/web/uvcpp_ws_connection.h:56`):服务端 `new uvcpp_ws_connection(client, ws_role::SERVER)` +(`src/web/uvcpp_ws_connection.h:57-57`):服务端 `new uvcpp_ws_connection(client, ws_role::SERVER)` (`src/web/uvcpp_ws_server.cpp:286-286`),客户端 `new uvcpp_ws_connection(tcp_, ws_role::CLIENT)`(`src/web/uvcpp_ws_client.cpp:374`)。 -两侧唯一的差别是掩码方向(`src/web/uvcpp_ws_connection.cpp:230`)与压缩窗口方向 +两侧唯一的差别是掩码方向(`src/web/uvcpp_ws_connection.cpp:241-241`)与压缩窗口方向 (`src/web/uvcpp_ws_parser.cpp:278`)。 --- @@ -170,12 +170,12 @@ h2/h3 的 WS(extended CONNECT)只回客户端提议里的**第一个** — ```cpp // doc-snippet: fragment — 两行签名摘录,不是完整翻译单元 -bool is_open() const; // src/web/uvcpp_ws_connection.h:148-148 -uvcpp_tcp_client* get_tcp_client(); // src/web/uvcpp_ws_connection.h:305-305,终结后返回 nullptr +bool is_open() const; // src/web/uvcpp_ws_connection.h:149-149 +uvcpp_tcp_client* get_tcp_client(); // src/web/uvcpp_ws_connection.h:329-329,终结后返回 nullptr ``` 所有回调都在**跑 `run()` 的那个线程**上同步调用(解析器帧回调 → `on_ws_frame` → -用户回调,`src/web/uvcpp_ws_parser.cpp:193` → `src/web/uvcpp_ws_connection.cpp:210`)。 +用户回调,`src/web/uvcpp_ws_parser.cpp:193` → `src/web/uvcpp_ws_connection.cpp:221-221`)。 ### 在回调里装回调是正常写法 @@ -199,7 +199,7 @@ void doc_install(uvcpp::uvcpp_ws_connection* c) { } ``` -`on_close` 的触发条件只有两种(`src/web/uvcpp_ws_connection.h:188`): +`on_close` 的触发条件只有两种(`src/web/uvcpp_ws_connection.h:189`): - 对端发了 Close 帧 → 帧里的码与原因; - 对端**没发** Close 就断 → `ABNORMAL_CLOSE`(1006)加空原因。 @@ -212,8 +212,8 @@ void doc_install(uvcpp::uvcpp_ws_connection* c) { ## 6. 收 `on_text` / `on_binary` **每条完整消息各一次**,分片已经在层内重组好了 -(`src/web/uvcpp_ws_connection.h:181-181`)。`data` 指针只在回调期间有效 —— -实现里 `message_payload_.clear()` 紧跟在回调之后(`src/web/uvcpp_ws_connection.cpp:425`), +(`src/web/uvcpp_ws_connection.h:182-182`)。`data` 指针只在回调期间有效 —— +实现里 `message_payload_.clear()` 紧跟在回调之后(`src/web/uvcpp_ws_connection.cpp:430-436`), 存下来就是悬垂。 **逐帧观察:`on_frame`(`1.8.2` 起)。** 与消息级回调**可以同时注册**: @@ -225,15 +225,15 @@ permessage-deflate,此时 `payload` 是压缩字节、本回调不解压。客 转发了一个 `on_frame()`,可以在 `connect()` 之前装,不会漏掉对端一升级就 推来的帧。 -**控制帧与数据帧可以交错**:`src/web/uvcpp_ws_connection.cpp:244` 的控制帧分支不碰 +**控制帧与数据帧可以交错**:`src/web/uvcpp_ws_connection.cpp:255-255` 的控制帧分支不碰 `in_message_` 那几个状态,所以一条长分片消息中间夹一个 ping 是合法的、也是正常的。 -反过来,**数据帧插在分片消息中间是协议错误**(`src/web/uvcpp_ws_connection.cpp:293`)。 +反过来,**数据帧插在分片消息中间是协议错误**(`src/web/uvcpp_ws_connection.cpp:304-304`)。 两条"层内自动做掉"的事,使用者不用管: - **掩码**:接收侧在解析器里就地 XOR,且**跨多次 read 的相位是对的** (`off = payload_received_ % 4`,`src/web/uvcpp_ws_parser.cpp:166`); -- **收 ping 自动回 pong**(`src/web/uvcpp_ws_connection.cpp:246`)—— 注意这是**被动**回, +- **收 ping 自动回 pong**(`src/web/uvcpp_ws_connection.cpp:257-257`)—— 注意这是**被动**回, 这一层没有主动发心跳的定时器(§14)。 --- @@ -243,17 +243,17 @@ permessage-deflate,此时 `payload` 是压缩字节、本回调不解压。客 ```cpp // doc-snippet: fragment — 对着头文件抄的接口清单,不是完整翻译单元 int send_text(const char* data, size_t len, - std::function cb = nullptr); // src/web/uvcpp_ws_connection.h:170-170 + std::function cb = nullptr); // src/web/uvcpp_ws_connection.h:171-171 int send_binary(const char* data, size_t len, - std::function cb = nullptr); // src/web/uvcpp_ws_connection.h:171-171 -int send_ping(const char* data = nullptr, size_t len = 0); // src/web/uvcpp_ws_connection.h:172-172 -int send_pong(const char* data = nullptr, size_t len = 0); // src/web/uvcpp_ws_connection.h:173-173 + std::function cb = nullptr); // src/web/uvcpp_ws_connection.h:172-172 +int send_ping(const char* data = nullptr, size_t len = 0); // src/web/uvcpp_ws_connection.h:173-173 +int send_pong(const char* data = nullptr, size_t len = 0); // src/web/uvcpp_ws_connection.h:174-174 int send_close(ws_close_code code = ws_close_code::NORMAL, - const std::string& reason = ""); // src/web/uvcpp_ws_connection.h:174-174 + const std::string& reason = ""); // src/web/uvcpp_ws_connection.h:175-175 ``` **逐帧发送:`send_frame(frame, cb)`(`1.8.2` 起)。** `send_text` / `send_binary` -仍然每次造一个 `fin = true` 的单帧(`src/web/uvcpp_ws_connection.cpp:597`); +仍然每次造一个 `fin = true` 的单帧(`src/web/uvcpp_ws_connection.cpp:608-608`); 要发**分片**、控制帧或自己压好的 permessage-deflate 负载时用 `send_frame`: 掩码按本端角色处理(客户端加、服务端不加),`rsv1` 与分片边界由调用方负责 (本层既不替你压缩,也不校验分片序列),帧序与 `send_text` 共用同一条队列。 @@ -264,14 +264,14 @@ int send_close(ws_close_code code = ws_close_code::NORMAL, 失败只能看返回值。 **连接已经终结时**,`send_frame` 第一句是 -`if (!tcp_) { if (cb) cb(-1); return -1; }`(`src/web/uvcpp_ws_connection.cpp:457`): +`if (!tcp_) { if (cb) cb(-1); return -1; }`(`src/web/uvcpp_ws_connection.cpp:468-468`): - 返回**裸 `-1`**,**不是** `UV_ENOTCONN` 之类的 libuv 码 —— 别拿 `uv_strerror()` 解释它; - 传了回调的话,回调**同步**被叫 `cb(-1)`; - 不传回调就是静默丢弃。 如果发送通道此前已经坏过,走的是粘性错误 `send_error_` -(`src/web/uvcpp_ws_connection.cpp:463`):所有排队的帧都以同一个错误结算。 +(`src/web/uvcpp_ws_connection.cpp:474-474`):所有排队的帧都以同一个错误结算。 --- @@ -333,7 +333,7 @@ void doc_run_client() { ### 客户端没有 `on_ping` / `on_pong` 转发 `cli.on_*` 只有 text / binary / close / error 四个(`src/web/uvcpp_ws_client.h:132-135`), -而连接层有 ping / pong(`src/web/uvcpp_ws_connection.h:186-186`)。要观测 ping/pong 得 +而连接层有 ping / pong(`src/web/uvcpp_ws_connection.h:187-187`)。要观测 ping/pong 得 `cli.session()->on_ping(...)` 自己拿指针装 —— 注意 `session()` 终结后返回 `nullptr` (`src/web/uvcpp_ws_client.cpp:425`)。连接层仍会自动回 pong,不受影响。 @@ -367,24 +367,24 @@ TLS 本身由 `tcp_->enable_tls(ssl_ctx_)` 的 memory-BIO 过滤器做(`:277` ```cpp // doc-snippet: fragment — 两行签名摘录,不是完整翻译单元 void close(ws_close_code code = ws_close_code::NORMAL, - const std::string& reason = std::string()); // src/web/uvcpp_ws_connection.h:156-156 -void terminate(); // src/web/uvcpp_ws_connection.h:165-165 + const std::string& reason = std::string()); // src/web/uvcpp_ws_connection.h:157-157 +void terminate(); // src/web/uvcpp_ws_connection.h:166-166 ``` `close()` 的实现只有两句(`src/web/uvcpp_ws_connection.cpp:100`): 置 `close_notified_`,然后 `send_close(code, reason)`。而 `send_close` 的完成回调是 "自己的 Close 帧一写进 TCP,就立刻关底层连接" -(`src/web/uvcpp_ws_connection.cpp:695`)。 +(`src/web/uvcpp_ws_connection.cpp:706-706`)。 **也就是说它不等对端回 Close 帧。** RFC 6455 §7.1.1 的关闭握手在这一层只做了一半, -而且**没有任何超时或定时器**兜底。头文件 `src/web/uvcpp_ws_connection.h:150` 的措辞与实现 +而且**没有任何超时或定时器**兜底。头文件 `src/web/uvcpp_ws_connection.h:151` 的措辞与实现 是相符的,但 `src/web/uvcpp_ws_sessions.h:107` 与 `src/web/uvcpp_ws_server.h:123` 把它称作 "优雅关闭" —— 那是**名义上的优雅**,不是 RFC 的完整语义。 `terminate()` 是立即终结、**不发** Close 帧(`src/web/uvcpp_ws_connection.cpp:109`)。 两个别混。 -`send_close` 会把 reason **静默截断到 123 字节**(`src/web/uvcpp_ws_connection.cpp:693`)—— +`send_close` 会把 reason **静默截断到 123 字节**(`src/web/uvcpp_ws_connection.cpp:704-704`)—— 控制帧负载上限 125,扣掉 2 字节状态码。截断是有意的:不截就会拼出一个对端 **必须拒绝**的帧。 @@ -412,7 +412,7 @@ enum class ws_close_code : uint16_t { // src/web/uvcpp_ws_frame.h:41 上表里的含义是按 RFC 补的。缺 1004、1012 / 1013 / 1014。 **没有"1005 / 1006 不能发"的保护**:`send_close(NO_STATUS)` 会照发一个含 1005 的帧 -—— `send_close` 只截断长度,不校验码(`src/web/uvcpp_ws_connection.cpp:689`)。 +—— `send_close` 只截断长度,不校验码(`src/web/uvcpp_ws_connection.cpp:700-700`)。 --- @@ -440,7 +440,7 @@ enum class ws_close_code : uint16_t { // src/web/uvcpp_ws_frame.h:41 **只支持 `permessage-deflate`(RFC 7692),没有别的扩展。** `rsv2` / `rsv3` 在帧结构里标着"保留给 RFC 8441(HTTP/2 上的 WebSocket)", 但**没有实现** —— 收到 rsv2/rsv3 一律回 1002 -(`src/web/uvcpp_ws_connection.cpp:274`,理由串写的是 +(`src/web/uvcpp_ws_connection.cpp:285-285`,理由串写的是 `"RSV2/RSV3 set but no extension negotiated"`)。 **用 `uvcpp_ws_server` / `uvcpp_ws_client` 的人什么都不用做**:两侧默认**开启**协商 @@ -452,12 +452,12 @@ enum class ws_close_code : uint16_t { // src/web/uvcpp_ws_frame.h:41 `UVCPP_ZLIB_ENABLE=1` 时编译**)。 阈值 `set_compress_min_size(size_t n)` 默认 `0`,也就是**都压** -(`src/web/uvcpp_ws_connection.h:290-290`)。 +(`src/web/uvcpp_ws_connection.h:314-314`)。 只有"自己手搓握手"的路线才需要手动调 `conn->enable_compression(bool is_server, const uvcpp_ws_deflate_params& p)` -(`src/web/uvcpp_ws_connection.h:278-278`)—— 注意 `is_server` **必填、无默认值**, -理由写在 `src/web/uvcpp_ws_connection.h:271-271`。 +(`src/web/uvcpp_ws_connection.h:302-302`)—— 注意 `is_server` **必填、无默认值**, +理由写在 `src/web/uvcpp_ws_connection.h:295-295`。 **如实记一条边界**:解压**不检测截断**(`src/web/uvcpp_ws_parser.h:179-187` 自己写明了)。 @@ -465,19 +465,19 @@ enum class ws_close_code : uint16_t { // src/web/uvcpp_ws_frame.h:41 ## 12. 上限与解析器 -**两级上限,都必须卡**(`src/web/uvcpp_ws_connection.h:261-261`、`src/web/uvcpp_ws_parser.h:96`): +**两级上限,都必须卡**(`src/web/uvcpp_ws_connection.h:285-285`、`src/web/uvcpp_ws_parser.h:96`): ```cpp // doc-snippet: fragment — 两个 setter 的签名摘录,展示"两级都要设"这件事; // 单独包成 TU 也编不出什么,它们要连着 §12 的说明读。 void set_max_frame_size(uint64_t n); // src/web/uvcpp_ws_parser.h:100,默认 0 = 不限 -void set_max_message_size(size_t n); // src/web/uvcpp_ws_connection.h:261-261,默认 16 MiB +void set_max_message_size(size_t n); // src/web/uvcpp_ws_connection.h:285-285,默认 16 MiB ``` - 解析器的**单帧**上限默认 `0`,就是**不限**(`src/web/uvcpp_ws_parser.h:238`, 检查点在长度字段解析完成那一刻,`src/web/uvcpp_ws_parser.cpp:201`); - 连接层的**单条消息**上限默认 `16u * 1024u * 1024u` = 16 MiB - (`src/web/uvcpp_ws_connection.h:407-407`)。 + (`src/web/uvcpp_ws_connection.h:435-435`)。 两条都要设的理由是**它们互相绕得过**:分片绕得过单帧(每条分片都合法但合起来巨大), 单帧绕得过消息(一个声明了 1 GiB 长度的帧根本不进聚合)。连接层构造时会把消息上限 @@ -496,11 +496,11 @@ void set_max_message_size(size_t n); // src/web/uvcpp_ws_connection.h:261-261 | 场景 | 表达 | 位置 | |---|---|---| -| 收到非法帧 | 先发对应 Close 帧再关连接,然后 `on_error(code, reason)` | `src/web/uvcpp_ws_connection.cpp:428` | -| 消息聚合超限 | 1009 加 `on_error` | `src/web/uvcpp_ws_connection.cpp:319` | -| 文本消息不是合法 UTF-8 | 1007 加 `on_error` | `src/web/uvcpp_ws_connection.cpp:411` | -| 解压失败 | 1007 加 `on_error` | `src/web/uvcpp_ws_connection.cpp:395` | -| 掩码方向不对 | 1002 加 `on_error` | `src/web/uvcpp_ws_connection.cpp:231` | +| 收到非法帧 | 先发对应 Close 帧再关连接,然后 `on_error(code, reason)` | `src/web/uvcpp_ws_connection.cpp:439-439` | +| 消息聚合超限 | 1009 加 `on_error` | `src/web/uvcpp_ws_connection.cpp:330-330` | +| 文本消息不是合法 UTF-8 | 1007 加 `on_error` | `src/web/uvcpp_ws_connection.cpp:422-422` | +| 解压失败 | 1007 加 `on_error` | `src/web/uvcpp_ws_connection.cpp:406-406` | +| 掩码方向不对 | 1002 加 `on_error` | `src/web/uvcpp_ws_connection.cpp:242-242` | | 对端没发 Close 就断 | `on_close(ABNORMAL_CLOSE, "")` | `src/web/uvcpp_ws_connection.cpp:92` | | 终结时队列里还有帧 | 逐条以 `-1` 结算回调 | `src/web/uvcpp_ws_connection.cpp:136` | | 客户端无会话时 send | 返回 `UV_ENOTCONN` 并**立刻**回调 | `src/web/uvcpp_ws_client.cpp:437` | @@ -546,9 +546,9 @@ void set_max_message_size(size_t n); // src/web/uvcpp_ws_connection.h:261-261 else if (on_conn_) { on_conn_(conn); }` —— 用带 `on_ready` 的那个重载时, **不会**再走 `on_connection`。 -**单帧超限被映射成 1002,消息超限是 1009。** `src/web/uvcpp_ws_connection.cpp:201` +**单帧超限被映射成 1002,消息超限是 1009。** `src/web/uvcpp_ws_connection.cpp:212-212` 把**任何**解析错误一律转成 `PROTOCOL_ERROR`,包括解析器的 `-6`(单帧超限); -而消息聚合超限走的是 `MESSAGE_TOO_BIG`(`src/web/uvcpp_ws_connection.cpp:319`)。同一份 `max_message_size_` +而消息聚合超限走的是 `MESSAGE_TOO_BIG`(`src/web/uvcpp_ws_connection.cpp:330-330`)。同一份 `max_message_size_` 值下达的两级限制,对端看到的码不同 —— 对端按 RFC 会把 1009 当"我扩容量重试"、 把 1002 当"你实现错了"。 @@ -569,7 +569,7 @@ PageHeap 下实测 SEGFAULT(`src/web/uvcpp_ws_client.cpp:124-145`)。 - **没有 `Sec-WebSocket-Protocol` 子协议协商**([§4](#4-握手))。 - **没有主动心跳、没有闲置超时、没有任何默认的定时器。** 唯一的 ping 相关行为是 - 收到 ping 自动回 pong(`src/web/uvcpp_ws_connection.cpp:246`)。 + 收到 ping 自动回 pong(`src/web/uvcpp_ws_connection.cpp:257-257`)。 - **`uvcpp_ws_client` 没有自动重连** —— 那是 `webapp/` 框架层的事([§8](#8-客户端))。 - **`send_text` / `send_binary` 自己不拆帧**;要发分片得用 `send_frame` 自己 写 `fin` 与 `CONTINUATION`([§7](#7-发))。接收方向仍由消息级回调重组。 diff --git a/doc/webapp-guide.md b/doc/webapp-guide.md index d3e8b9e2..651f045d 100644 --- a/doc/webapp-guide.md +++ b/doc/webapp-guide.md @@ -41,6 +41,7 @@ 18. [已知限制](#18-已知限制) 19. [横向扩展:多循环(`set_loops`)](#19-横向扩展多循环set_loops) 20. [可观测性:`/health` / `/ready` / `/metrics`](#20-可观测性health--ready--metrics) +21. [WebSocket 房间与广播](#21-websocket-房间与广播) --- @@ -1568,6 +1569,38 @@ reg.register_gauge("db_pool_in_use", "Borrowed connections", --- +## 21. WebSocket 房间与广播 + +`uvcpp_ws_rooms`(`#include `)把三件事收在一起: +`join/leave`、按房间群发、慢客户端策略。 + +```cpp +// doc-snippet: fragment — 装配摘录,不是完整翻译单元。 +uvcpp::uvcpp_ws_rooms rooms; // 活得比所有会话久(归 app 所有) + +app.websocket("/chat/:room", [&](uvcpp::uvcpp_web_ws_request& ws_req) { + uvcpp::uvcpp_ws_connection* c = ws_req.connection(); + rooms.join(c, *ws_req.param("room")); +}); + +// 从别的线程(例如定时任务)广播:用 app.post() 投回循环线程 +rooms.broadcast_text("lobby", msg.data(), msg.size()); +``` + +- **断线自动退订**:`join()` 会给会话挂一个终结观察者 + (`uvcpp_ws_connection::add_close_observer()`),对端 Close、异常断开、 + 协议错误、本端 `close()`、服务器停机 —— 任何一条终结路径都会把它从所有 + 房间摘掉。业务不需要再手写"on_close 清理"。 +- **慢客户端**:单条连接发送积压 > `uvcpp_ws_broadcast_options::max_queue_bytes` + (默认 1 MiB)时,按 `policy` 处理:`DROP`(跳过这一条,默认)或 + `CLOSE`(1001 关掉)。广播返回值 + `stats()` 里的 `dropped` / `closed_slow` + 如实记账;一条不读数据的连接拖不慢整场广播。 +- **只在 app 的循环线程上调用**(房间表没有锁);跨线程用 `app.post()`。 +- 只接 **h1** 会话;跨进程(Redis pub/sub)见 issue #74。用例: + `web_app_ws_rooms_func.cpp`。 + +--- + ## 可运行示例 `examples/webapp_demo.cpp` —— 默认**自校验**:起一个 app(路由 + 中间件 + 静态 + diff --git a/src/web/uvcpp_ws_connection.cpp b/src/web/uvcpp_ws_connection.cpp index db44dd8b..c0571148 100644 --- a/src/web/uvcpp_ws_connection.cpp +++ b/src/web/uvcpp_ws_connection.cpp @@ -1,4 +1,4 @@ -#include +#include #include #if UVCPP_WEB_ENABLE @@ -135,6 +135,17 @@ void uvcpp_ws_connection::notify_retired() { // 队列里的帧发不出去了,逐条结算 —— 不结算调用方会永远等下去。 if (!send_q_.empty()) fail_pending_sends(-1); + // 终结观察者:在属主回收**之前**跑,且必须是本对象还能安全访问的最后一段 + // 里的一步(回调里可能把本对象从房间表里摘掉,但不该再调本类别的发送方法)。 + if (!close_observers_.empty()) { + std::map> obs; + obs.swap(close_observers_); + for (std::map>::iterator it = obs.begin(); + it != obs.end(); ++it) { + if (it->second) it->second(); + } + } + // 上报属主。回调返回之后本对象随时可能被 delete,所以这必须是最后一步, // 并且先把回调搬出来(属主的 delete 会销毁 retire_fn_ 自己)。 retire_fn cb(std::move(retire_fn_)); @@ -706,6 +717,26 @@ void uvcpp_ws_connection::on_pong(std::function cb void uvcpp_ws_connection::on_close(std::function cb) { on_close_ = std::move(cb); } void uvcpp_ws_connection::on_error(std::function cb) { on_error_ = std::move(cb); } +int uvcpp_ws_connection::add_close_observer(std::function cb) { + if (!cb) return 0; + const int id = close_observer_next_id_++; + close_observers_[id] = std::move(cb); + return id; +} + +void uvcpp_ws_connection::remove_close_observer(int id) { + close_observers_.erase(id); +} + +size_t uvcpp_ws_connection::pending_send_bytes() const { + size_t n = 0; + for (std::deque::const_iterator it = send_q_.begin(); + it != send_q_.end(); ++it) { + n += it->bytes.size(); + } + return n; +} + void uvcpp_ws_connection::on_frame(std::function cb) { on_frame_ = std::move(cb); } diff --git a/src/web/uvcpp_ws_connection.h b/src/web/uvcpp_ws_connection.h index 708b6aad..2545ad20 100644 --- a/src/web/uvcpp_ws_connection.h +++ b/src/web/uvcpp_ws_connection.h @@ -33,6 +33,7 @@ #include #include #include +#include #include #include #include @@ -200,6 +201,29 @@ class UVCPP_API uvcpp_ws_connection { */ void on_close(std::function cb); + /** + * @brief 追加一个「会话终结」观察者。**可叠加**,与 `on_close` 不同。 + * + * `on_close` 只有一个槽,而且只在**对端**走人时报告;本方法在任何一条终结 + * 路径上(对端 Close、异常断开、本端 `close()`、协议错误、属主 `terminate()`) + * 都**恰好触发一次**。房间订阅表这类"必须精确摘除"的簿记靠它。 + * + * 回调在终结那一刻**同步**跑;返回之后不要再碰会话(它可能被回收)。 + * + * @return 观察者 id(`remove_close_observer()` 用);0 = 无效参数。 + */ + int add_close_observer(std::function cb); + + /// 摘掉一个观察者。会话已经终结时是空操作。 + void remove_close_observer(int id); + + /** + * @brief 发送队列里**还没写完**的字节数(含已在途的那一批)。 + * + * 广播的"慢客户端"策略用它判定——本层没有别的公开积压指标。 + */ + size_t pending_send_bytes() const; + /** * @brief 协议错误回调:`on_error(close_code, reason)`。 * @@ -371,6 +395,10 @@ class UVCPP_API uvcpp_ws_connection { bool close_notified_ = false; retire_fn retire_fn_; + /// 会话终结观察者;id → 回调。见 `add_close_observer()`。 + std::map> close_observers_; + int close_observer_next_id_ = 1; + /** * @brief 存活令牌(与 `uvcpp_tcp_client::alive_token_` 同一个手法)。 * diff --git a/src/webapp/uvcpp_ws_rooms.cpp b/src/webapp/uvcpp_ws_rooms.cpp new file mode 100644 index 00000000..18dfe5a9 --- /dev/null +++ b/src/webapp/uvcpp_ws_rooms.cpp @@ -0,0 +1,260 @@ +/** + * @file src/webapp/uvcpp_ws_rooms.cpp + * @brief 房间表与广播的实现。 + * @author zhuweiye + * @version 1.0.0 + */ + +#include "webapp/uvcpp_ws_rooms.h" + +#if UVCPP_WEB_ENABLE && UVCPP_WEB_WS_ENABLE + +#include +#include +#include +#include +#include + +#include +#include + +namespace uvcpp { + +uvcpp_ws_broadcast_options::uvcpp_ws_broadcast_options() + : max_queue_bytes(1024u * 1024u), + policy(uvcpp_ws_slow_client::DROP) {} + +struct uvcpp_ws_rooms::impl { + std::map > rooms; + /// 连接 → 它加入过的房间(摘除时不必扫全表)。 + std::map > conns; + /// 连接 → 终结观察者 id(析构时摘掉)。 + std::map obs_ids; + uvcpp_ws_room_stats s; + + void on_closed(uvcpp_ws_connection* c) { + // 终结路径上调用:只改自己的表,**不再碰会话**(它马上要被回收)。 + std::map >::iterator it = + conns.find(c); + if (it == conns.end()) return; + const std::set joined = it->second; + for (std::set::const_iterator r = joined.begin(); + r != joined.end(); ++r) { + std::map >::iterator rm = + rooms.find(*r); + if (rm == rooms.end()) continue; + std::vector& v = rm->second; + v.erase(std::remove(v.begin(), v.end(), c), v.end()); + if (v.empty()) rooms.erase(rm); + } + conns.erase(it); + obs_ids.erase(c); + } + + /// 会话已经没了(或正在关):先摘观察者再清表。 + /// + /// **摘观察者这一步不能省**:本函数还会在"连接还活着、只是发送失败/被策略 + /// 关掉"时调用。留着观察者的话,连接稍后终结会回调进本对象;如果那时本对象 + /// 已经析构,就是一次悬垂调用。 + void drop_conn(uvcpp_ws_connection* c) { + if (c != nullptr) { + std::map::iterator it = obs_ids.find(c); + if (it != obs_ids.end()) c->remove_close_observer(it->second); + } + on_closed(c); + } + + size_t broadcast(const std::string& room, const char* data, size_t len, + bool binary, const uvcpp_ws_broadcast_options& opts, + size_t* dropped_out) { + ++s.broadcasts; + size_t dropped = 0; + if (dropped_out != nullptr) *dropped_out = 0; + + std::map >::iterator it = + rooms.find(room); + if (it == rooms.end()) return 0; + + // 遍历副本:策略 CLOSE 会改表(`drop_conn`),而当场的发送**不会**同步 + // 跑用户回调(本类不传每条消息的 done),所以副本足够且最省心。 + const std::vector members = it->second; + size_t delivered = 0; + for (size_t i = 0; i < members.size(); ++i) { + uvcpp_ws_connection* c = members[i]; + if (c == nullptr || !c->is_open()) { + ++dropped; + drop_conn(c); + continue; + } + if (opts.max_queue_bytes > 0 && + c->pending_send_bytes() > opts.max_queue_bytes) { + if (opts.policy == uvcpp_ws_slow_client::CLOSE) { + ++s.closed_slow; + c->close(ws_close_code::GOING_AWAY, "slow client"); + drop_conn(c); + } + ++dropped; + continue; + } + const int rc = binary ? c->send_binary(data, len) + : c->send_text(data, len); + if (rc != 0) { + ++dropped; + drop_conn(c); + continue; + } + ++delivered; + } + s.delivered += delivered; + s.dropped += dropped; + if (dropped_out != nullptr) *dropped_out = dropped; + return delivered; + } +}; + +uvcpp_ws_rooms::uvcpp_ws_rooms() : impl_(new impl()) {} + +uvcpp_ws_rooms::~uvcpp_ws_rooms() { + // 摘掉自己挂的观察者:本对象先于连接析构时,连接终结时不该再回调到这里。 + for (std::map::iterator it = + impl_->obs_ids.begin(); + it != impl_->obs_ids.end(); ++it) { + if (it->first != nullptr) it->first->remove_close_observer(it->second); + } + impl_->obs_ids.clear(); + impl_->conns.clear(); + impl_->rooms.clear(); +} + +int uvcpp_ws_rooms::join(uvcpp_ws_connection* c, const std::string& room) { + if (c == nullptr || room.empty()) return UV_EINVAL; + std::set& joined = impl_->conns[c]; + if (joined.find(room) != joined.end()) return 0; // 幂等 + joined.insert(room); + std::vector& v = impl_->rooms[room]; + if (std::find(v.begin(), v.end(), c) == v.end()) v.push_back(c); + + if (impl_->obs_ids.find(c) == impl_->obs_ids.end()) { + // 终结观察者必须**每条连接只挂一个**:上面用 `conns[c]` 的默认构造建立 + // 了条目,观察者按"首次 join"决定。 + impl_->obs_ids[c] = c->add_close_observer([this, c] { impl_->on_closed(c); }); + } + return 0; +} + +int uvcpp_ws_rooms::leave(uvcpp_ws_connection* c, const std::string& room) { + if (c == nullptr) return UV_EINVAL; + std::map >::iterator it = + impl_->conns.find(c); + if (it == impl_->conns.end()) return 0; + if (it->second.erase(room) == 0) return 0; + + std::map >::iterator rm = + impl_->rooms.find(room); + if (rm != impl_->rooms.end()) { + std::vector& v = rm->second; + v.erase(std::remove(v.begin(), v.end(), c), v.end()); + if (v.empty()) impl_->rooms.erase(rm); + } + if (it->second.empty()) { + std::map::iterator o = impl_->obs_ids.find(c); + if (o != impl_->obs_ids.end()) { + c->remove_close_observer(o->second); + impl_->obs_ids.erase(o); + } + impl_->conns.erase(it); + } + return 0; +} + +size_t uvcpp_ws_rooms::leave_all(uvcpp_ws_connection* c) { + if (c == nullptr) return 0; + std::map >::iterator it = + impl_->conns.find(c); + if (it == impl_->conns.end()) return 0; + const size_t n = it->second.size(); + // 先摘观察者,再走通用清理(通用清理不再碰会话)。 + std::map::iterator o = impl_->obs_ids.find(c); + if (o != impl_->obs_ids.end()) { + c->remove_close_observer(o->second); + impl_->obs_ids.erase(o); + } + impl_->on_closed(c); + return n; +} + +size_t uvcpp_ws_rooms::room_size(const std::string& room) const { + std::map >::const_iterator it = + impl_->rooms.find(room); + return it == impl_->rooms.end() ? 0 : it->second.size(); +} + +size_t uvcpp_ws_rooms::room_count() const { return impl_->rooms.size(); } + +size_t uvcpp_ws_rooms::member_count() const { return impl_->conns.size(); } + +size_t uvcpp_ws_rooms::broadcast_text( + const std::string& room, const char* data, size_t len, + const uvcpp_ws_broadcast_options& opts, size_t* dropped_out) { + return impl_->broadcast(room, data, len, /*binary=*/false, opts, dropped_out); +} + +size_t uvcpp_ws_rooms::broadcast_binary( + const std::string& room, const void* data, size_t len, + const uvcpp_ws_broadcast_options& opts, size_t* dropped_out) { + return impl_->broadcast(room, static_cast(data), len, + /*binary=*/true, opts, dropped_out); +} + +size_t uvcpp_ws_rooms::broadcast_all_text( + const char* data, size_t len, const uvcpp_ws_broadcast_options& opts, + size_t* dropped_out) { + // 全量广播按"每个房间各发一次"会重复投递给多房间成员;按**成员去重**发。 + ++impl_->s.broadcasts; + size_t dropped = 0; + if (dropped_out != nullptr) *dropped_out = 0; + const std::map > snapshot = + impl_->conns; + size_t delivered = 0; + for (std::map >::const_iterator + it = snapshot.begin(); + it != snapshot.end(); ++it) { + uvcpp_ws_connection* c = it->first; + if (c == nullptr || !c->is_open()) { + ++dropped; + impl_->drop_conn(c); + continue; + } + if (opts.max_queue_bytes > 0 && + c->pending_send_bytes() > opts.max_queue_bytes) { + if (opts.policy == uvcpp_ws_slow_client::CLOSE) { + ++impl_->s.closed_slow; + c->close(ws_close_code::GOING_AWAY, "slow client"); + impl_->drop_conn(c); + } + ++dropped; + continue; + } + if (c->send_text(data, len) != 0) { + ++dropped; + impl_->drop_conn(c); + continue; + } + ++delivered; + } + impl_->s.delivered += delivered; + impl_->s.dropped += dropped; + if (dropped_out != nullptr) *dropped_out = dropped; + return delivered; +} + +uvcpp_ws_room_stats uvcpp_ws_rooms::stats() const { + uvcpp_ws_room_stats out = impl_->s; + out.rooms = impl_->rooms.size(); + out.members = impl_->conns.size(); + return out; +} + +} // namespace uvcpp + +#endif // UVCPP_WEB_ENABLE && UVCPP_WEB_WS_ENABLE diff --git a/src/webapp/uvcpp_ws_rooms.h b/src/webapp/uvcpp_ws_rooms.h new file mode 100644 index 00000000..df53476c --- /dev/null +++ b/src/webapp/uvcpp_ws_rooms.h @@ -0,0 +1,157 @@ +/** + * @file src/webapp/uvcpp_ws_rooms.h + * @brief WebSocket 房间与广播:join/leave、按房间群发、慢客户端策略。 + * @author zhuweiye + * @version 1.0.0 + * + * `uvcpp_web_app` 之前只有单条会话的 `send_text()`;群发要业务自己维护 + * `room → 会话` 的表,而"会话什么时候没了"没有可靠的摘除点(`on_close` 是 + * 单槽、且只在对端走人时报告)。本类把这三件事收在一起: + * + * ```cpp + * uvcpp::uvcpp_ws_rooms rooms; // 归 app 所有,活得比所有会话久 + * + * app.websocket("/chat/:room", [&](uvcpp::uvcpp_web_ws_request& ws_req) { + * uvcpp::uvcpp_ws_connection* c = ws_req.connection(); + * rooms.join(c, *ws_req.param("room")); + * c->on_text([&rooms](const std::string& msg) { + * rooms.broadcast_text("chat", msg.data(), msg.size()); // 示例:按房间广播 + * }); + * }); + * ``` + * + * ## 三条语义 + * + * 1. **成员资格随会话终结自动摘除。** 本类在 `join()` 时给会话挂一个 + * **终结观察者**(`uvcpp_ws_connection::add_close_observer()`,可叠加, + * 任何一条终结路径都恰好触发一次)——对端 Close、异常断开、协议错误、 + * 本端 `close()`、服务器停机,都会把这条会话从它加入过的所有房间摘掉。 + * 2. **广播不保证送达。** WebSocket 是可靠流,但本类的慢客户端策略可能 + * **主动丢弃**一条消息或**关闭**那条连接:一个不读数据、队列涨到上限的 + * 客户端不该拖着整场广播一起慢。 + * 3. **只在 app 的循环线程上调用。** 房间表没有锁;WS 回调本来就在那条线程 + * 上。要从别的线程广播,用 `app.post()` 投回来。 + * + * ## 不做的事(如实列出) + * + * - **跨进程**:只看得见本进程本对象里的会话(跨进程用 Redis pub/sub 另接, + * 见 issue #74); + * - **h2/h3 extended CONNECT 的会话**:那两条腿的会话类型是 + * `uvcpp_web_ws_session`,目前还没有同形的终结观察者接口,本类只接 h1; + * - **心跳 / ping-pong 保活**:`uvcpp_ws_connection` 已会自动回 PONG,主动探测 + * 留给业务(一个定时器即可); + * - **升级鉴权**:在 `websocket()` 的处理器里先判 Cookie / 头再做升级流程之外 + * 的事,不在本类里。 + */ + +#pragma once +#ifndef SRC_WEBAPP_UVCPP_WS_ROOMS_H +#define SRC_WEBAPP_UVCPP_WS_ROOMS_H + +#include +#include + +#if UVCPP_WEB_ENABLE && UVCPP_WEB_WS_ENABLE + +#include +#include +#include +#include + +namespace uvcpp { + +class uvcpp_ws_connection; + +/// 慢客户端的处置方式(队列超过 `max_queue_bytes` 时)。 +enum class uvcpp_ws_slow_client : int { + /// 跳过这一条消息(其他成员照常收)。默认 —— 最不具破坏性。 + DROP = 0, + /// 关掉这条连接(1001 GOING_AWAY)。适合"消息必须完整"的场合。 + CLOSE = 1, +}; + +/// 一次广播的旋钮。显式构造函数(C++11 聚合初始化资格)。 +struct UVCPP_API uvcpp_ws_broadcast_options { + uvcpp_ws_broadcast_options(); + + /** + * @brief 单条连接的发送积压上限(字节,含在途那批)。默认 **1 MiB**。 + * + * 超过它才触发 `policy`。设 0 = 不检查(**不建议**:慢客户端会把内存拖到 + * 无限,本类的意义就没了)。 + */ + size_t max_queue_bytes; + + uvcpp_ws_slow_client policy; +}; + +/// 累计观测(无锁快照;只在循环线程上读,没有并发问题)。 +struct UVCPP_API uvcpp_ws_room_stats { + uint64_t broadcasts = 0; ///< 调用广播的次数 + uint64_t delivered = 0; ///< 成功交给会话的次数(一条消息 × 一个成员) + uint64_t dropped = 0; ///< 因慢客户端 / 已关闭而跳过的次数 + uint64_t closed_slow = 0; ///< 因慢客户端被关掉的连接数 + size_t rooms = 0; ///< 当前房间数 + size_t members = 0; ///< 当前成员连接数(去重) +}; + +/** + * @brief 房间表 + 广播。见文件头。 + * + * **生命周期**:本对象必须活得比所有加入过它的会话久(析构时会摘掉自己挂的 + * 终结观察者;那时连接仍在也可以安全析构)。 + */ +class UVCPP_API uvcpp_ws_rooms { + public: + uvcpp_ws_rooms(); + ~uvcpp_ws_rooms(); + + uvcpp_ws_rooms(const uvcpp_ws_rooms&) = delete; + uvcpp_ws_rooms& operator=(const uvcpp_ws_rooms&) = delete; + + // ---- 房间 ---- + + /// 加入房间。重复加入是幂等成功。空房间名 / 空连接 → `UV_EINVAL`。 + int join(uvcpp_ws_connection* c, const std::string& room); + + /// 离开房间(不在里面也是成功)。 + int leave(uvcpp_ws_connection* c, const std::string& room); + + /// 离开所有房间,返回摘掉的房间数。 + size_t leave_all(uvcpp_ws_connection* c); + + size_t room_size(const std::string& room) const; + size_t room_count() const; + /// 成员连接数(同一条连接加入多个房间只算一次)。 + size_t member_count() const; + + // ---- 广播 ---- + + size_t broadcast_text(const std::string& room, const char* data, size_t len, + const uvcpp_ws_broadcast_options& opts = + uvcpp_ws_broadcast_options(), + size_t* dropped_out = nullptr); + + size_t broadcast_binary(const std::string& room, const void* data, + size_t len, + const uvcpp_ws_broadcast_options& opts = + uvcpp_ws_broadcast_options(), + size_t* dropped_out = nullptr); + + /// 向所有成员广播(不区分房间)。 + size_t broadcast_all_text(const char* data, size_t len, + const uvcpp_ws_broadcast_options& opts = + uvcpp_ws_broadcast_options(), + size_t* dropped_out = nullptr); + + uvcpp_ws_room_stats stats() const; + + private: + struct impl; + std::unique_ptr impl_; +}; + +} // namespace uvcpp + +#endif // UVCPP_WEB_ENABLE && UVCPP_WEB_WS_ENABLE +#endif // SRC_WEBAPP_UVCPP_WS_ROOMS_H diff --git a/tests/functional/web_app_ws_rooms_func.cpp b/tests/functional/web_app_ws_rooms_func.cpp new file mode 100644 index 00000000..2e127f9e --- /dev/null +++ b/tests/functional/web_app_ws_rooms_func.cpp @@ -0,0 +1,419 @@ +/** + * @file tests/functional/web_app_ws_rooms_func.cpp + * @brief WebSocket 房间与广播(`uvcpp_ws_rooms`)。 + * + * 判据(全部落在"客户端实际收到了什么"上): + * + * 1. **按房间隔离**:两个客户端进 `roomA`、一个进 `roomB`,向 `roomA` + * 广播 → 只有 A 的两个人收到; + * 2. **断线自动退订**:客户端断开后 `room_size()` 回到 0(房间被摘掉); + * 3. **慢客户端 · DROP**:单条连接的积压超过 `max_queue_bytes` 时跳过这一条, + * 其他消息照发;`stats().dropped` 涨、连接还活着; + * 4. **慢客户端 · CLOSE**:同一情形按策略关连接(1001),`stats().closed_slow` + * 涨; + * 5. **成员/房间计数**:`stats()` 与 `room_count()/member_count()` 对得上。 + * + * 装置:`uvcpp_web_app` 后台线程;HTTP 侧用阻塞 `uvcpp_http_client` 触发广播, + * WS 侧用**裸 TCP** 做握手与帧解析(需要区分"收到/没收到",现成的 ws 客户端 + * 没有这个观测点)。慢客户端故意**不读 socket**,让服务端发送积压涨起来。 + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#if UVCPP_WEBAPP_ENABLE && UVCPP_WEB_WS_ENABLE + +#include +#include +#include +#include +#include +#include +#include + +using namespace uvcpp; + +namespace { + +int g_fail = 0; + +void check(bool ok, const std::string& what) { + if (ok) { + std::cout << " [ ok ] " << what << std::endl; + } else { + ++g_fail; + std::cerr << " [FAIL] " << what << std::endl; + } +} + +long long ms_since(std::chrono::steady_clock::time_point t0) { + return std::chrono::duration_cast( + std::chrono::steady_clock::now() - t0) + .count(); +} + +// --------------------------------------------------------------------------- +// 裸 WebSocket 客户端(只认服务端→客户端方向) +// --------------------------------------------------------------------------- +struct ws_raw { + uvcpp_tcp_client c; + std::string buf; + std::vector texts; + bool closed = false; + + bool connect(int port) { + return c.connect_wait("127.0.0.1", port, 3000) == 0; + } + + bool handshake(const std::string& path) { + std::string req = "GET " + path + " HTTP/1.1\r\n"; + req += "Host: localhost\r\n"; + req += "Upgrade: websocket\r\n"; + req += "Connection: Upgrade\r\n"; + req += "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"; + req += "Sec-WebSocket-Version: 13\r\n\r\n"; + if (c.write_wait(req.data(), req.size(), 3000) != 0) return false; + + const std::chrono::steady_clock::time_point t0 = + std::chrono::steady_clock::now(); + while (buf.find("\r\n\r\n") == std::string::npos) { + if (ms_since(t0) > 3000) return false; + uvcpp_buf b; + if (c.read_wait(b, 50) == 0 && b.size() > 0 && + b.get_const_data() != nullptr) { + buf.append(b.get_const_data(), b.size()); + } + } + const size_t p = buf.find("\r\n\r\n") + 4; + const bool ok = buf.find("101") != std::string::npos; + buf.erase(0, p); // 多读到的字节属于后续帧 + parse(); + return ok; + } + + /// 解析缓冲里的完整服务端帧(不掩码)。 + void parse() { + for (;;) { + if (buf.size() < 2) return; + const unsigned char b0 = static_cast(buf[0]); + const unsigned char b1 = static_cast(buf[1]); + const int op = b0 & 0x0f; + if ((b1 & 0x80) != 0) { // 服务端帧不该带掩码 + closed = true; + buf.clear(); + return; + } + uint64_t len = b1 & 0x7f; + size_t off = 2; + if (len == 126) { + if (buf.size() < 4) return; + len = (static_cast(buf[2]) << 8) | + static_cast(buf[3]); + off = 4; + } else if (len == 127) { + if (buf.size() < 10) return; + len = 0; + for (int i = 0; i < 8; ++i) { + len = (len << 8) | static_cast(buf[2 + i]); + } + off = 10; + } + if (buf.size() < off + len) return; + const std::string payload = buf.substr(off, static_cast(len)); + buf.erase(0, off + static_cast(len)); + if (op == 0x1) { + texts.push_back(payload); + } else if (op == 0x8) { + closed = true; + } + } + } + + /// 读一会儿(最多 @p ms),返回是否读到了任何字节。 + bool pump(int ms) { + const std::chrono::steady_clock::time_point t0 = + std::chrono::steady_clock::now(); + bool got = false; + while (ms_since(t0) < ms) { + uvcpp_buf b; + const int rv = c.read_wait(b, 20); + if (rv == 0 && b.size() > 0 && b.get_const_data() != nullptr) { + buf.append(b.get_const_data(), b.size()); + got = true; + parse(); + } else if (rv != 0 && rv != UV_ETIMEDOUT) { + closed = true; + break; + } + } + return got; + } + + void close_socket() { c.close(); } +}; + +// --------------------------------------------------------------------------- +// 服务端 +// --------------------------------------------------------------------------- +struct TestApp { + uvcpp_ws_rooms rooms; // 先声明:后于 app 析构(app 停掉后会话不再回调) + uvcpp_web_app app; + + void build() { + app.set_host("127.0.0.1") + .set_port(0) + .set_access_log(false) + .set_log_level(log_level::WARN); + + app.websocket("/chat/:room", + [this](uvcpp_web_ws_request& ws_req) { + const std::string* room = ws_req.param("room"); + if (room == nullptr || ws_req.connection() == nullptr) { + return; + } + rooms.join(ws_req.connection(), *room); + }); + + // GET /bcast/:room?text=... → 按房间广播,body 里回 "delivered=N dropped=M" + app.get("/bcast/:room", + [this](uvcpp_web_request& req, uvcpp_web_response& resp, + uvcpp_web_next) { + const std::string* room = req.param("room"); + const std::string* text = req.query("text"); + size_t dropped = 0; + const size_t delivered = + room == nullptr + ? 0 + : rooms.broadcast_text(*room, text ? text->data() : "", + text ? text->size() : 0, + uvcpp_ws_broadcast_options(), + &dropped); + resp.text(std::string("delivered=") + std::to_string(delivered) + + " dropped=" + std::to_string(dropped)); + resp.end(); + }); + + // GET /bcast_twice/:room?policy=drop|close&cap=N + // 一条 200 KiB 的大消息连发两次:第一次把积压顶上去,第二次按策略处置。 + app.get("/bcast_twice/:room", + [this](uvcpp_web_request& req, uvcpp_web_response& resp, + uvcpp_web_next) { + const std::string* room = req.param("room"); + const std::string* pol = req.query("policy"); + const std::string* cap = req.query("cap"); + uvcpp_ws_broadcast_options o; + o.max_queue_bytes = cap != nullptr + ? static_cast(std::strtoul( + cap->c_str(), nullptr, 10)) + : 1024; + o.policy = (pol != nullptr && *pol == "close") + ? uvcpp_ws_slow_client::CLOSE + : uvcpp_ws_slow_client::DROP; + const std::string payload(200 * 1024, 'x'); + size_t d1 = 0, d2 = 0; + const size_t n1 = + room ? rooms.broadcast_text(*room, payload.data(), + payload.size(), o, &d1) + : 0; + const size_t n2 = + room ? rooms.broadcast_text(*room, payload.data(), + payload.size(), o, &d2) + : 0; + (void)n2; + resp.text(std::string("delivered=") + std::to_string(n1) + + " dropped=" + std::to_string(d1 + d2)); + resp.end(); + }); + + app.get("/room_size/:room", + [this](uvcpp_web_request& req, uvcpp_web_response& resp, + uvcpp_web_next) { + const std::string* room = req.param("room"); + resp.text(std::to_string(room ? rooms.room_size(*room) : 0)); + resp.end(); + }); + + app.get("/stats", + [this](uvcpp_web_request&, uvcpp_web_response& resp, + uvcpp_web_next) { + const uvcpp_ws_room_stats s = rooms.stats(); + resp.text("rooms=" + std::to_string(s.rooms) + " members=" + + std::to_string(s.members) + " dropped=" + + std::to_string(s.dropped) + " closed_slow=" + + std::to_string(s.closed_slow)); + resp.end(); + }); + } + + int start() { + if (app.start_background() != 0) return -1; + return app.bound_port(); + } + void shutdown() { + app.stop(); + app.join(); + } +}; + +std::string http_get(int port, const std::string& path) { + uvcpp_http_client c; + if (c.connect_wait("127.0.0.1", port, 3000) != 0) return std::string(); + uvcpp_http_response r; + if (c.send_wait(uvcpp_http_request::make_get(path), r, 3000) != 0) { + return std::string(); + } + return r.body.to_string(); +} + +bool wait_room_size(int port, const std::string& room, size_t want, + int deadline_ms = 3000) { + const std::chrono::steady_clock::time_point t0 = + std::chrono::steady_clock::now(); + for (;;) { + const std::string s = http_get(port, "/room_size/" + room); + if (s == std::to_string(want)) return true; + if (ms_since(t0) > deadline_ms) return false; + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + } +} + +// --------------------------------------------------------------------------- +// 用例 +// --------------------------------------------------------------------------- +void test_room_isolation_and_cleanup() { + std::cout << "-- 房间隔离 / 断线退订 --" << std::endl; + TestApp t; + t.build(); + const int port = t.start(); + check(port > 0, "app 起来了"); + if (port <= 0) { + t.shutdown(); + return; + } + + ws_raw a1, a2, b; + check(a1.connect(port) && a1.handshake("/chat/roomA"), "A1 升级成功"); + check(a2.connect(port) && a2.handshake("/chat/roomA"), "A2 升级成功"); + check(b.connect(port) && b.handshake("/chat/roomB"), "B 升级成功"); + check(wait_room_size(port, "roomA", 2), "roomA 有 2 个成员"); + check(wait_room_size(port, "roomB", 1), "roomB 有 1 个成员"); + + const std::string r = http_get(port, "/bcast/roomA?text=hi"); + check(r == "delivered=2 dropped=0", "广播回报 delivered=2(实际 " + r + ")"); + + a1.pump(500); + a2.pump(500); + b.pump(200); + check(a1.texts.size() == 1 && a1.texts[0] == "hi", "A1 收到 hi"); + check(a2.texts.size() == 1 && a2.texts[0] == "hi", "A2 收到 hi"); + check(b.texts.empty(), "roomB 的 B 没收到(按房间隔离)"); + + // 断线 → 自动退订 + a1.close_socket(); + check(wait_room_size(port, "roomA", 1), "A1 断开后 roomA 回到 1 个成员"); + + const std::string st = http_get(port, "/stats"); + check(st.find("rooms=2") != std::string::npos, "stats:还剩 2 个房间(" + st + ")"); + + a2.close_socket(); + b.close_socket(); + t.shutdown(); +} + +void test_slow_client_drop() { + std::cout << "-- 慢客户端:DROP --" << std::endl; + TestApp t; + t.build(); + const int port = t.start(); + if (port <= 0) { + check(false, "app 起来了"); + t.shutdown(); + return; + } + + ws_raw s; + check(s.connect(port) && s.handshake("/chat/slow"), "慢客户端升级成功"); + + // 连发两次 200 KiB:第一次入队/在途,第二次应因积压 > cap 被丢弃。 + const std::string r = + http_get(port, "/bcast_twice/slow?policy=drop&cap=1024"); + check(r.find("dropped=1") != std::string::npos, + "DROP:第二次被丢弃(实际 " + r + ")"); + const std::string st = http_get(port, "/stats"); + check(st.find("dropped=1") != std::string::npos || + st.find("dropped=2") != std::string::npos, + "stats().dropped 涨了(" + st + ")"); + check(!s.closed, "DROP 不关连接"); + + // 把 socket 读空:应当只看到第一条大消息。 + s.pump(1000); + check(s.texts.size() == 1, "慢客户端只收到第一条(实际 " + + std::to_string(s.texts.size()) + ")"); + + s.close_socket(); + t.shutdown(); +} + +void test_slow_client_close() { + std::cout << "-- 慢客户端:CLOSE --" << std::endl; + TestApp t; + t.build(); + const int port = t.start(); + if (port <= 0) { + check(false, "app 起来了"); + t.shutdown(); + return; + } + + ws_raw s; + check(s.connect(port) && s.handshake("/chat/slow2"), "慢客户端升级成功"); + const std::string r = + http_get(port, "/bcast_twice/slow2?policy=close&cap=1024"); + check(r.find("dropped=1") != std::string::npos, + "CLOSE:第二次被丢弃(实际 " + r + ")"); + + s.pump(1500); + check(s.closed, "连接被服务端关掉(收到 Close 或 EOF)"); + const std::string st = http_get(port, "/stats"); + check(st.find("closed_slow=1") != std::string::npos, + "stats().closed_slow=1(" + st + ")"); + + s.close_socket(); + t.shutdown(); +} + +} // namespace + +int main() { + std::cout << "[web_app_ws_rooms] start" << std::endl; + test_room_isolation_and_cleanup(); + test_slow_client_drop(); + test_slow_client_close(); + if (g_fail == 0) { + std::cout << "[web_app_ws_rooms] ALL PASS" << std::endl; + return 0; + } + std::cerr << "[web_app_ws_rooms] " << g_fail << " check(s) failed" + << std::endl; + return 1; +} + +#else // !(webapp && ws) + +int main() { + std::cout << "SKIP: webapp/ws disabled" << std::endl; + return 0; +} + +#endif diff --git a/tests/tools/doc_line_refs.lock b/tests/tools/doc_line_refs.lock index 1f7b6fc9..62b6e3d2 100644 --- a/tests/tools/doc_line_refs.lock +++ b/tests/tools/doc_line_refs.lock @@ -679,52 +679,52 @@ src/web/uvcpp_ws_client.h:70-70 03e2262722065fc7 03e2262722065fc7 - src/web/uvcpp_ws_connection.cpp:100-100 2f8ede1869abb20c 2f8ede1869abb20c - src/web/uvcpp_ws_connection.cpp:104-104 04148b7ca3e59957 04148b7ca3e59957 - src/web/uvcpp_ws_connection.cpp:109-109 b6ef97c9ef0602e3 b6ef97c9ef0602e3 - -src/web/uvcpp_ws_connection.cpp:115-143 ef9aee5c038a07aa c2b7df6201fdd336 b551ecd6117a0532 +src/web/uvcpp_ws_connection.cpp:115-154 7a9e9cde4d0d3a41 c2b7df6201fdd336 b551ecd6117a0532 src/web/uvcpp_ws_connection.cpp:133-133 7d53cf6aa6f39699 7d53cf6aa6f39699 - src/web/uvcpp_ws_connection.cpp:136-136 7bb2b4bec768fde7 7bb2b4bec768fde7 - -src/web/uvcpp_ws_connection.cpp:201-201 20fca471828474a1 20fca471828474a1 - -src/web/uvcpp_ws_connection.cpp:210-210 82a3ad57e6e08815 82a3ad57e6e08815 - -src/web/uvcpp_ws_connection.cpp:230-230 b9020b27773ad173 b9020b27773ad173 - -src/web/uvcpp_ws_connection.cpp:231-231 7247feb3b8cbf9dd 7247feb3b8cbf9dd - -src/web/uvcpp_ws_connection.cpp:244-244 84a81f9ef224510b 84a81f9ef224510b - -src/web/uvcpp_ws_connection.cpp:246-246 09d4b26468ba0ff5 09d4b26468ba0ff5 - -src/web/uvcpp_ws_connection.cpp:274-274 6cb613bd36fdc75f 6cb613bd36fdc75f - -src/web/uvcpp_ws_connection.cpp:293-293 240257f670e27e30 240257f670e27e30 - -src/web/uvcpp_ws_connection.cpp:319-319 d94d863619ae61d1 d94d863619ae61d1 - +src/web/uvcpp_ws_connection.cpp:212-212 20fca471828474a1 20fca471828474a1 - +src/web/uvcpp_ws_connection.cpp:221-221 82a3ad57e6e08815 82a3ad57e6e08815 - +src/web/uvcpp_ws_connection.cpp:241-241 b9020b27773ad173 b9020b27773ad173 - +src/web/uvcpp_ws_connection.cpp:242-242 7247feb3b8cbf9dd 7247feb3b8cbf9dd - +src/web/uvcpp_ws_connection.cpp:255-255 84a81f9ef224510b 84a81f9ef224510b - +src/web/uvcpp_ws_connection.cpp:257-257 09d4b26468ba0ff5 09d4b26468ba0ff5 - +src/web/uvcpp_ws_connection.cpp:285-285 6cb613bd36fdc75f 6cb613bd36fdc75f - +src/web/uvcpp_ws_connection.cpp:304-304 240257f670e27e30 240257f670e27e30 - src/web/uvcpp_ws_connection.cpp:32-32 946704a597a007c7 946704a597a007c7 - +src/web/uvcpp_ws_connection.cpp:330-330 d94d863619ae61d1 d94d863619ae61d1 - src/web/uvcpp_ws_connection.cpp:35-48 81cab6657d41722a c2b7df6201fdd336 7bb2b4bec768fde7 -src/web/uvcpp_ws_connection.cpp:395-395 44e0ca9841603a01 44e0ca9841603a01 - -src/web/uvcpp_ws_connection.cpp:411-411 423daf1fc38d0c35 423daf1fc38d0c35 - -src/web/uvcpp_ws_connection.cpp:425-425 a6a87cf16d8497bd a6a87cf16d8497bd - -src/web/uvcpp_ws_connection.cpp:428-428 b62e916881c14ee1 b62e916881c14ee1 - -src/web/uvcpp_ws_connection.cpp:457-457 360dfd4dcf56d559 360dfd4dcf56d559 - -src/web/uvcpp_ws_connection.cpp:463-463 4aa5b5ba916fcc56 4aa5b5ba916fcc56 - -src/web/uvcpp_ws_connection.cpp:597-597 66e618bcd39607fc 66e618bcd39607fc - -src/web/uvcpp_ws_connection.cpp:689-689 ed8a4998950deaff ed8a4998950deaff - -src/web/uvcpp_ws_connection.cpp:693-693 0dd6c9d40af8999f 0dd6c9d40af8999f - -src/web/uvcpp_ws_connection.cpp:695-695 f0cf56cbafd71286 f0cf56cbafd71286 - +src/web/uvcpp_ws_connection.cpp:406-406 44e0ca9841603a01 44e0ca9841603a01 - +src/web/uvcpp_ws_connection.cpp:422-422 423daf1fc38d0c35 423daf1fc38d0c35 - +src/web/uvcpp_ws_connection.cpp:430-436 8efe6ac51b54218a a6a87cf16d8497bd da39a3ee5e6b4b0d +src/web/uvcpp_ws_connection.cpp:439-439 b62e916881c14ee1 b62e916881c14ee1 - +src/web/uvcpp_ws_connection.cpp:468-468 360dfd4dcf56d559 360dfd4dcf56d559 - +src/web/uvcpp_ws_connection.cpp:474-474 4aa5b5ba916fcc56 4aa5b5ba916fcc56 - +src/web/uvcpp_ws_connection.cpp:608-608 66e618bcd39607fc 66e618bcd39607fc - +src/web/uvcpp_ws_connection.cpp:700-700 ed8a4998950deaff ed8a4998950deaff - +src/web/uvcpp_ws_connection.cpp:704-704 0dd6c9d40af8999f 0dd6c9d40af8999f - +src/web/uvcpp_ws_connection.cpp:706-706 f0cf56cbafd71286 f0cf56cbafd71286 - src/web/uvcpp_ws_connection.cpp:92-92 47adccde73eb2729 47adccde73eb2729 - src/web/uvcpp_ws_connection.h:10-23 3d813c4510f15690 c4d2345910e45855 d338759f69ca9599 -src/web/uvcpp_ws_connection.h:148-148 8e489eb219531ada 8e489eb219531ada - -src/web/uvcpp_ws_connection.h:150-150 d09f4b4b176afd28 d09f4b4b176afd28 - -src/web/uvcpp_ws_connection.h:156-156 1f76f3341ebccb19 1f76f3341ebccb19 - -src/web/uvcpp_ws_connection.h:165-165 d1f1a3954c2ba592 d1f1a3954c2ba592 - -src/web/uvcpp_ws_connection.h:170-170 adc0fc3aa01a60ed adc0fc3aa01a60ed - -src/web/uvcpp_ws_connection.h:171-171 a247d8cac4a3f401 a247d8cac4a3f401 - -src/web/uvcpp_ws_connection.h:172-172 3a2533aca97ff471 3a2533aca97ff471 - -src/web/uvcpp_ws_connection.h:173-173 993ab29edc85f0f2 993ab29edc85f0f2 - -src/web/uvcpp_ws_connection.h:174-174 9798b964ecd68dd5 9798b964ecd68dd5 - -src/web/uvcpp_ws_connection.h:181-181 4a05c91184cc6575 4a05c91184cc6575 - -src/web/uvcpp_ws_connection.h:186-186 1bbc1f52ccad6271 1bbc1f52ccad6271 - -src/web/uvcpp_ws_connection.h:188-188 d09f4b4b176afd28 d09f4b4b176afd28 - -src/web/uvcpp_ws_connection.h:261-261 ac0857b1ac601f69 ac0857b1ac601f69 - -src/web/uvcpp_ws_connection.h:271-271 81975903e254382a 81975903e254382a - -src/web/uvcpp_ws_connection.h:278-278 c52d1eaabbefc6b1 c52d1eaabbefc6b1 - -src/web/uvcpp_ws_connection.h:290-290 fe353d7a218c2385 fe353d7a218c2385 - -src/web/uvcpp_ws_connection.h:305-305 b4d07233c9813403 b4d07233c9813403 - -src/web/uvcpp_ws_connection.h:407-407 42632037db01ccb5 42632037db01ccb5 - -src/web/uvcpp_ws_connection.h:56-56 ff34c0eeef7c67e2 ff34c0eeef7c67e2 - -src/web/uvcpp_ws_connection.h:61-61 db0047ab00b5347b db0047ab00b5347b - +src/web/uvcpp_ws_connection.h:149-149 8e489eb219531ada 8e489eb219531ada - +src/web/uvcpp_ws_connection.h:151-151 d09f4b4b176afd28 d09f4b4b176afd28 - +src/web/uvcpp_ws_connection.h:157-157 1f76f3341ebccb19 1f76f3341ebccb19 - +src/web/uvcpp_ws_connection.h:166-166 d1f1a3954c2ba592 d1f1a3954c2ba592 - +src/web/uvcpp_ws_connection.h:171-171 adc0fc3aa01a60ed adc0fc3aa01a60ed - +src/web/uvcpp_ws_connection.h:172-172 a247d8cac4a3f401 a247d8cac4a3f401 - +src/web/uvcpp_ws_connection.h:173-173 3a2533aca97ff471 3a2533aca97ff471 - +src/web/uvcpp_ws_connection.h:174-174 993ab29edc85f0f2 993ab29edc85f0f2 - +src/web/uvcpp_ws_connection.h:175-175 9798b964ecd68dd5 9798b964ecd68dd5 - +src/web/uvcpp_ws_connection.h:182-182 4a05c91184cc6575 4a05c91184cc6575 - +src/web/uvcpp_ws_connection.h:187-187 1bbc1f52ccad6271 1bbc1f52ccad6271 - +src/web/uvcpp_ws_connection.h:189-189 d09f4b4b176afd28 d09f4b4b176afd28 - +src/web/uvcpp_ws_connection.h:285-285 ac0857b1ac601f69 ac0857b1ac601f69 - +src/web/uvcpp_ws_connection.h:295-295 81975903e254382a 81975903e254382a - +src/web/uvcpp_ws_connection.h:302-302 c52d1eaabbefc6b1 c52d1eaabbefc6b1 - +src/web/uvcpp_ws_connection.h:314-314 fe353d7a218c2385 fe353d7a218c2385 - +src/web/uvcpp_ws_connection.h:329-329 b4d07233c9813403 b4d07233c9813403 - +src/web/uvcpp_ws_connection.h:435-435 42632037db01ccb5 42632037db01ccb5 - +src/web/uvcpp_ws_connection.h:57-57 ff34c0eeef7c67e2 ff34c0eeef7c67e2 - +src/web/uvcpp_ws_connection.h:62-62 db0047ab00b5347b db0047ab00b5347b - src/web/uvcpp_ws_ext.h:110-110 f103385a69bdc617 f103385a69bdc617 - src/web/uvcpp_ws_ext.h:126-126 350a28f0b1fc8091 350a28f0b1fc8091 - src/web/uvcpp_ws_frame.h:41-41 c8903a3611d72aa0 c8903a3611d72aa0 -