grpc-libp2p-client 0.0.21 → 0.0.23

package/dist/dc-http2/parser.cjs.js

@@ -6,6 +6,7 @@ const FRAME_TYPES = {
     RST_STREAM: 0x3, // 终止流  
     SETTINGS: 0x4, // 设置连接参数  
     PING: 0x6, // 测量RTT和活性检查  
+    GOAWAY: 0x7, // 优雅地关闭连接  
     WINDOW_UPDATE: 0x8};
 const FRAME_FLAGS = {
     ACK: 0x1,
@@ -1515,18 +1516,25 @@ function _createPayload(settings) {
 }
 
 class HTTP2Parser {
-    constructor(writer) {
+    constructor(writer, options) {
         this.buffer = new Uint8Array(0);
         this.settingsAckReceived = false;
+        this.peerSettingsReceived = false;
         // 初始化连接级别的流控制窗口大小（默认值：65,535）
         this.connectionWindowSize = 4 << 20;
         // 存储流的Map
         this.streams = new Map();
         // 默认的流级别初始窗口大小
         this.defaultStreamWindowSize = 4 << 20;
+        // 发送方向窗口（对端接收窗口）默认均为 65535
+        this.sendConnWindow = 65535;
+        this.sendStreamWindows = new Map();
+        this.peerInitialStreamWindow = 65535;
+        this.sendWindowWaiters = [];
         // 结束标志
         this.endFlag = false;
         this.writer = writer;
+        this.compatibilityMode = options?.compatibilityMode ?? false;
     }
     // 持续处理流数据
     async processStream(stream) {
@@ -1567,6 +1575,17 @@ class HTTP2Parser {
             console.error("Error processing stream:", error);
             throw error;
         }
+        finally {
+            if (!this.compatibilityMode && !this.endFlag) {
+                this.endFlag = true;
+                try {
+                    this.onEnd?.();
+                }
+                catch (err) {
+                    console.error("Error during onEnd callback:", err);
+                }
+            }
+        }
     }
     isHttp2Preface(buffer) {
         const PREFACE = new TextEncoder().encode("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
@@ -1598,6 +1617,102 @@ class HTTP2Parser {
             }, 30000);
         });
     }
+    // 等待接收来自对端的 SETTINGS（非 ACK）
+    waitForPeerSettings(timeoutMs = 30000) {
+        return new Promise((resolve, reject) => {
+            if (this.peerSettingsReceived) {
+                resolve();
+                return;
+            }
+            const interval = setInterval(() => {
+                if (this.peerSettingsReceived) {
+                    clearInterval(interval);
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            }, 100);
+            const timeout = setTimeout(() => {
+                clearInterval(interval);
+                reject(new Error("Peer SETTINGS timeout"));
+            }, timeoutMs);
+        });
+    }
+    // 注册我们要发送数据的出站流（用于初始化该流的对端窗口）
+    registerOutboundStream(streamId) {
+        if (!this.sendStreamWindows.has(streamId)) {
+            this.sendStreamWindows.set(streamId, this.peerInitialStreamWindow);
+        }
+    }
+    // 获取发送窗口
+    getSendWindows(streamId) {
+        const s = this.sendStreamWindows.get(streamId) ?? 0;
+        return { conn: this.sendConnWindow, stream: s };
+    }
+    // 消耗发送窗口（成功写入 DATA 之后调用）
+    consumeSendWindow(streamId, bytes) {
+        this.sendConnWindow = Math.max(0, this.sendConnWindow - bytes);
+        const cur = this.sendStreamWindows.get(streamId) ?? 0;
+        this.sendStreamWindows.set(streamId, Math.max(0, cur - bytes));
+    }
+    // 非标准兜底：在对端未及时发送 WINDOW_UPDATE 时，手动回填窗口额度以避免阻塞
+    unsafeForceExtendSendWindow(streamId, bytes) {
+        if (this.compatibilityMode)
+            return;
+        if (bytes <= 0)
+            return;
+        this.sendConnWindow = Math.min(0x7fffffff, this.sendConnWindow + bytes);
+        const cur = this.sendStreamWindows.get(streamId) ?? 0;
+        this.sendStreamWindows.set(streamId, Math.min(0x7fffffff, cur + bytes));
+    }
+    // 等待可用发送窗口（两个窗口都需要 >0）
+    async waitForSendWindow(streamId, minBytes = 1, timeoutMs = 30000) {
+        const start = Date.now();
+        return new Promise((resolve, reject) => {
+            let interval = null;
+            let settled = false;
+            const check = () => {
+                const { conn, stream } = this.getSendWindows(streamId);
+                if (conn >= minBytes && stream >= minBytes) {
+                    if (!settled) {
+                        settled = true;
+                        if (interval) {
+                            clearInterval(interval);
+                            interval = null;
+                        }
+                        resolve();
+                    }
+                    return true;
+                }
+                if (Date.now() - start > timeoutMs) {
+                    if (!settled) {
+                        settled = true;
+                        if (interval) {
+                            clearInterval(interval);
+                            interval = null;
+                        }
+                        reject(new Error('Send window wait timeout'));
+                    }
+                    return true;
+                }
+                return false;
+            };
+            if (check())
+                return;
+            const tick = () => {
+                if (!check()) ;
+            };
+            const wake = () => { tick(); };
+            // 简单的等待模型：依赖 WINDOW_UPDATE 到达时调用 wake
+            this.sendWindowWaiters.push(wake);
+            // 同时做一个轻微的轮询，防止错过唤醒
+            interval = setInterval(() => {
+                if (check() && interval) {
+                    clearInterval(interval);
+                    interval = null;
+                }
+            }, 50);
+        });
+    }
     // 处理单个帧
     async _handleFrame(frameHeader, frameData) {
         switch (frameHeader.type) {
@@ -1608,6 +1723,8 @@ class HTTP2Parser {
                 else {
                     //接收到Setting请求,进行解析
                     const settingsPayload = frameData.slice(9);
+                    let initialWindowDelta = 0;
+                    let maxConcurrentStreams;
                     for (let i = 0; i < settingsPayload.length; i += 6) {
                         // 正确解析：2字节ID + 4字节值
                         const id = (settingsPayload[i] << 8) | settingsPayload[i + 1];
@@ -1617,13 +1734,48 @@ class HTTP2Parser {
                             settingsPayload[i + 5];
                         if (id === 4) {
                             // SETTINGS_INITIAL_WINDOW_SIZE
-                            this.defaultStreamWindowSize = value;
+                            this.defaultStreamWindowSize = value; // 我方接收窗口（入站）
+                            initialWindowDelta = value - this.peerInitialStreamWindow;
+                            this.peerInitialStreamWindow = value; // 对端接收窗口（我方发送）
+                        }
+                        else if (id === 3) {
+                            // SETTINGS_MAX_CONCURRENT_STREAMS
+                            maxConcurrentStreams = value;
                         }
                     }
+                    if (!this.compatibilityMode && initialWindowDelta !== 0) {
+                        for (const [sid, current] of this.sendStreamWindows.entries()) {
+                            const updated = Math.max(0, current + initialWindowDelta);
+                            this.sendStreamWindows.set(sid, updated);
+                        }
+                    }
+                    try {
+                        if (this.onSettingsParsed && (maxConcurrentStreams !== undefined || initialWindowDelta !== 0)) {
+                            const payload = {};
+                            if (maxConcurrentStreams !== undefined) {
+                                payload.maxConcurrentStreams = maxConcurrentStreams;
+                            }
+                            if (initialWindowDelta !== 0) {
+                                payload.initialWindowSize = this.peerInitialStreamWindow;
+                            }
+                            this.onSettingsParsed(payload);
+                        }
+                    }
+                    catch (err) {
+                        console.error('Error handling parsed SETTINGS callback:', err);
+                    }
                     //发送ACK
                     if (this.onSettings) {
                         this.onSettings(frameHeader);
                     }
+                    // 标记已收到对端 SETTINGS
+                    this.peerSettingsReceived = true;
+                    // 唤醒等待窗口（以防部分实现通过 SETTINGS 改变有效窗口）
+                    const waiters = this.sendWindowWaiters.splice(0);
+                    waiters.forEach(fn => { try {
+                        fn();
+                    }
+                    catch { } });
                 }
                 break;
             case FRAME_TYPES.DATA:
@@ -1673,11 +1825,60 @@ class HTTP2Parser {
             case FRAME_TYPES.WINDOW_UPDATE:
                 // 处理窗口更新帧
                 this.handleWindowUpdateFrame(frameHeader, frameData, frameHeader.streamId);
+                // 更新发送窗口（对端接收窗口）
+                try {
+                    const inc = this.parseWindowUpdateFrame(frameData, frameHeader).windowSizeIncrement;
+                    if (frameHeader.streamId === 0) {
+                        this.sendConnWindow += inc;
+                    }
+                    else {
+                        const cur = this.sendStreamWindows.get(frameHeader.streamId) ?? this.peerInitialStreamWindow;
+                        this.sendStreamWindows.set(frameHeader.streamId, cur + inc);
+                    }
+                    const waiters = this.sendWindowWaiters.splice(0);
+                    waiters.forEach(fn => { try {
+                        fn();
+                    }
+                    catch { } });
+                }
+                catch (e) { }
                 break;
             case FRAME_TYPES.PING:
                 // 处理PING帧
                 this._handlePingFrame(frameHeader, frameData);
                 break;
+            case FRAME_TYPES.GOAWAY: {
+                let info;
+                try {
+                    const body = frameData.subarray(9);
+                    if (body.length >= 8) {
+                        const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+                        const lastStreamId = view.getUint32(0, false) & 0x7fffffff;
+                        const errorCode = view.getUint32(4, false);
+                        info = { lastStreamId, errorCode };
+                        console.warn('[HTTP2] GOAWAY received', info);
+                    }
+                    else {
+                        console.warn('[HTTP2] GOAWAY received');
+                        info = {};
+                    }
+                }
+                catch { }
+                try {
+                    this.onGoaway?.(info ?? {});
+                }
+                catch (err) {
+                    console.error('Error during GOAWAY callback:', err);
+                }
+                this.endFlag = true;
+                try {
+                    this.onEnd?.();
+                }
+                catch (err) {
+                    console.error('Error during GOAWAY onEnd callback:', err);
+                }
+                break;
+            }
             // case FRAME_TYPES.PUSH_PROMISE:
             //     // 处理服务器推送承诺帧
             //     this.handlePushPromiseFrame(frameHeader, frameData);