grpc-libp2p-client 0.0.6 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grpc-libp2p-client",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "description": "grpc-libp2p-client",
   "main": "./dist/index.cjs.js",

package/src/dc-http2/frame.ts

@@ -45,22 +45,78 @@ export class Http2Frame {
         return FrameEncoder.encodeSettingsAckFrame();  
     }  
 
+    /**
+ * 创建 WINDOW_UPDATE 帧
+ * @param streamId 流ID，0表示连接级别的窗口更新
+ * @param increment 窗口大小增量（必须为正数）
+ * @returns 编码好的 WINDOW_UPDATE 帧
+ */
+static createWindowUpdateFrame(streamId: number, increment: number): Uint8Array {
+    // 验证窗口增量
+    if (increment <= 0 || increment > 2147483647) { // 2^31 - 1
+        throw new Error('Window size increment must be between 1 and 2^31-1');
+    }
+    
+    // 创建4字节的payload
+    const payload = new Uint8Array(4);
+    
+    // 写入窗口大小增量 (31位无符号整数，最高位保留为0)
+    payload[0] = (increment >> 24) & 0x7F; // 只用低7位，确保最高位为0
+    payload[1] = (increment >> 16) & 0xFF;
+    payload[2] = (increment >> 8) & 0xFF;
+    payload[3] = increment & 0xFF;
+    
+    // 创建帧，类型0x8表示WINDOW_UPDATE
+    return Http2Frame.createFrame(0x8, 0x0, streamId, payload);
+}
+
 
-    static createDataFrames(streamId: number, data: Uint8Array,shouldEnd: boolean = false, maxFrameSize: number = 16384): Uint8Array[] {
-        const frames: Uint8Array[] = [];
-        let offset = 0;
+    static createDataFrames(streamId: number, data: Uint8Array, shouldEnd: boolean = false, maxFrameSize: number = 16384): Uint8Array[] {
+    const frames: Uint8Array[] = [];
     
-        while (offset < data.length) {
-            const chunkSize = Math.min(maxFrameSize, data.length - offset);
-            const chunk = data.slice(offset, offset + chunkSize);
-            let isEndStream = shouldEnd && (offset + chunkSize >= data.length); // 最后一帧设置 END_STREAM
-            const frame = Http2Frame.createDataFrame(streamId, chunk, isEndStream);
-            frames.push(frame);
-            offset += chunkSize;
-        }
+    // 首先构建完整的 gRPC 消息
+    // 格式: Compressed-Flag(1) + Message-Length(4) + Message-Data
+    const messageLength = data.length;
+    const grpcMessage = new Uint8Array(5 + messageLength);
+    
+    // Compressed-Flag (0 = 不压缩)
+    grpcMessage[0] = 0;
     
-        return frames;
+    // Message-Length (4 bytes) - 整个消息的长度
+    grpcMessage[1] = (messageLength >> 24) & 0xFF;
+    grpcMessage[2] = (messageLength >> 16) & 0xFF;
+    grpcMessage[3] = (messageLength >> 8) & 0xFF;
+    grpcMessage[4] = messageLength & 0xFF;
+    
+    // Message-Data
+    grpcMessage.set(data, 5);
+    
+    // 然后将完整的 gRPC 消息分割成多个 HTTP/2 DATA 帧
+    // HTTP/2 帧头为 9 字节
+    const maxDataPerFrame = maxFrameSize - 9;
+    
+    for (let offset = 0; offset < grpcMessage.length; offset += maxDataPerFrame) {
+        const remaining = grpcMessage.length - offset;
+        const chunkSize = Math.min(maxDataPerFrame, remaining);
+        const chunk = grpcMessage.slice(offset, offset + chunkSize);
+        
+        // 判断是否是最后一个数据块
+        const isLastChunk = (offset + chunkSize) >= grpcMessage.length;
+        const endStream = isLastChunk && shouldEnd;
+        
+        // 创建 HTTP/2 DATA 帧
+        const frame = Http2Frame.createFrame(
+            0x0, // DATA 帧类型
+            endStream ? 0x01 : 0x0, // 只在最后一块且需要结束流时设置 END_STREAM
+            streamId,
+            chunk
+        );
+        
+        frames.push(frame);
     }
+    
+    return frames;
+}
 
    static createDataFrame( streamId:number,data:Uint8Array,endStream:boolean = true):Uint8Array {  
         // gRPC 消息格式: 压缩标志(1字节) + 消息长度(4字节) + 消息内容  
@@ -101,7 +157,6 @@ export class Http2Frame {
         // 将 headers 编码为 HPACK 格式  
         const hpack = new HPACK();
         const encodedHeaders = hpack.encode(headersList);
-        console.log('Encoded:', encodedHeaders);
         // HEADERS frame flags: END_HEADERS | END_STREAM  
         const flags = endHeaders ? 0x04 : 0x00  
         return Http2Frame.createFrame(0x01, flags, streamId, encodedHeaders)  
@@ -111,7 +166,6 @@ export class Http2Frame {
         // 将 headers 编码为 HPACK 格式  
         const hpack = new HPACK();
         const encodedHeaders = hpack.encode(headersList);
-        console.log('Encoded:', encodedHeaders);
         // HEADERS frame flags: END_HEADERS | END_STREAM  
         const flags = endHeaders ? 0x04 : 0x00  
         return Http2Frame.createFrame(0x01, flags, streamId, encodedHeaders)  

package/src/dc-http2/parser.ts

@@ -47,7 +47,6 @@ export class HTTP2Parser {
         while (this.buffer.length >= 9) {
           // 判断是否有HTTP/2前导
           if (this.buffer.length >= 24 && this.isHttp2Preface(this.buffer)) {
-            console.log("HTTP/2 preface detected");
             this.buffer = this.buffer.slice(24);
             // 发送SETTINGS帧
             const settingFrme = Http2Frame.createSettingsFrame();
@@ -114,7 +113,6 @@ export class HTTP2Parser {
       case FRAME_TYPES.SETTINGS:
         if ((frameHeader.flags & FRAME_FLAGS.ACK) === FRAME_FLAGS.ACK) {
           this.settingsAckReceived = true;
-          console.log("Received SETTINGS ACK");
         } else {
           //接收到Setting请求,进行解析
           const settingsPayload = frameData.slice(9);
@@ -127,7 +125,6 @@ export class HTTP2Parser {
               settingsPayload[i + 3];
             settings[id] = value;
           }
-          console.log("Received SETTINGS:", settings);
 
           //发送ACK
           if (this.onSettings) {
@@ -141,6 +138,23 @@ export class HTTP2Parser {
         if (this.onData) {
           this.onData(frameData.slice(9), frameHeader); // 跳过帧头
         }
+         // 更新流窗口和连接窗口
+    try {
+        // 更新流级别的窗口
+        if (frameHeader.streamId !== 0) {
+            const streamWindowUpdate = Http2Frame.createWindowUpdateFrame(
+                frameHeader.streamId, 
+                frameHeader.length
+            );
+            this.writer.write(streamWindowUpdate);
+        }
+        
+        // 更新连接级别的窗口
+        const connWindowUpdate = Http2Frame.createWindowUpdateFrame(0, frameHeader.length);
+        this.writer.write(connWindowUpdate);
+    } catch (err) {
+        console.error("[HTTP2] Error sending window update:", err);
+    }
         //判断是否是最后一个帧
         if (
           (frameHeader.flags & FRAME_FLAGS.END_STREAM) ===
@@ -286,7 +300,8 @@ export class HTTP2Parser {
     }
 
     // 确保frameBuffer是Uint8Array类型
-    const buffer = new Uint8Array(frameBuffer);
+  //  const buffer = new Uint8Array(frameBuffer);
+   const buffer = new Uint8Array(frameBuffer.slice(9));
 
     // 读取window size increment (4字节，大端序)
     // 手动计算32位无符号整数，确保最高位为0
@@ -316,7 +331,6 @@ export class HTTP2Parser {
       const windowUpdate = this.parseWindowUpdateFrame(payload, frameHeader);
      
       this.connectionWindowSize += windowUpdate.windowSizeIncrement;
-      console.log(`Connection window size increased by ${windowUpdate.windowSizeIncrement}`);
 
       return windowUpdate;
     } catch (error) {

package/src/index.ts

@@ -55,6 +55,7 @@ export class Libp2pGrpcClient {
     let stream:Stream|null = null
     let responseData: Uint8Array | null = null
     let responseBuffer: Uint8Array[] = [] // 添加缓冲区来累积数据
+    let responseDataExpectedLength = -1 // 当前响应的期望长度
     const hpack = new HPACK()
     let exitFlag = false
     let errMsg = ''
@@ -69,13 +70,52 @@ export class Libp2pGrpcClient {
         const streamId = this.steamManager.getNextAppLevelStreamId()
         const writer = new StreamWriter(stream.sink)  
         const parser = new HTTP2Parser(writer);  
-        
+        responseDataExpectedLength  = -1 // 重置期望长度
+        responseBuffer = [] // 重置缓冲区
         parser.onData = (payload,frameHeader) => {//接收数据
-            const grpcData = payload.subarray(5) // 移除 gRPC 长度前缀
-            responseBuffer.push(grpcData)
-            
+            if (responseDataExpectedLength === -1) {//grpc消息头部未读取
+              //提取gRPC消息头部
+              if (payload.length < 5) {
+                return
+              }
+              const compressionFlag = payload[0] // 压缩标志
+              const lengthBytes = payload.slice(1, 5) // 消息长度的4字节
+              responseDataExpectedLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false) // big-endian
+              if (responseDataExpectedLength < 0) {
+                throw new Error('Invalid gRPC message length')
+              }
+              if (responseDataExpectedLength + 5 >  payload.length) {
+                // 如果当前 payload 不足以包含完整的 gRPC 消息，缓存数据
+                const grpcData = payload.subarray(5) 
+                responseBuffer.push(grpcData)
+                responseDataExpectedLength -= grpcData.length // 更新期望长度
+                return
+              }else {
+                // 如果当前 payload 足以包含完整的 gRPC 消息，重置缓冲区
+                const grpcData = payload.subarray(5)  // 提取完整的 gRPC 消息
+                responseBuffer.push(grpcData)
+                responseData = grpcData
+                isResponseComplete = true
+                responseDataExpectedLength = -1 // 重置期望长度
+              }
+            }else if (responseDataExpectedLength > 0) {//grpc消息头部已读取
+              responseBuffer.push(payload) // 将数据添加到缓冲区
+              responseDataExpectedLength -= payload.length // 更新期望长度
+              if (responseDataExpectedLength <= 0) {
+                // 如果缓冲区中的数据已经完全处理，重置缓冲区
+                responseData = new Uint8Array(responseBuffer.reduce((sum, chunk) => sum + chunk.length, 0))
+                let offset = 0
+                for (const chunk of responseBuffer) {
+                    responseData.set(chunk, offset)
+                    offset += chunk.length
+
+                }
+                responseDataExpectedLength = -1
+                isResponseComplete = true // 设置响应完成标志
+              }
+            }
             // 检查是否是流的最后一个帧（END_STREAM 标志）
-            if (frameHeader && (frameHeader.flags & 0x1)) { // END_STREAM flag
+            if (frameHeader && (frameHeader.flags & 0x1) && !isResponseComplete) { // END_STREAM flag
                 // 合并所有缓冲的数据
                 const totalLength = responseBuffer.reduce((sum, chunk) => sum + chunk.length, 0)
                 responseData = new Uint8Array(totalLength)
@@ -87,16 +127,31 @@ export class Libp2pGrpcClient {
                 isResponseComplete = true
             }
         }
+        parser.onEnd = () => {//接收结束
+          if (!isResponseComplete) {
+            isResponseComplete = true // 设置响应完成标志
+            if (responseBuffer.length === 0) {
+                responseData = new Uint8Array() // 如果没有数据，返回空数组
+            }else{
+                // 合并所有缓冲的数据
+                const totalLength = responseBuffer.reduce((sum, chunk) => sum + chunk.length, 0)
+                responseData = new Uint8Array(totalLength)
+                let offset = 0
+                for (const chunk of responseBuffer) {
+                    responseData.set(chunk, offset)
+                    offset += chunk.length
+                }
+                isResponseComplete = true
+            }
+          }
+        }
         parser.onSettings = () => {//接收settings,反馈ack
-            console.log('Settings received')
             const ackSettingFrame = Http2Frame.createSettingsAckFrame()
             writer.write(ackSettingFrame)
         }
         parser.onHeaders = (headers,header) => {
             const plainHeaders = hpack.decodeHeaderFields(headers)
-            console.log('Received headers:', plainHeaders);
             if (plainHeaders.get('grpc-status') === '0') {
-                console.log('gRPC call success')
             } else if (plainHeaders.get('grpc-status') !== undefined) {
                 exitFlag = true
                 errMsg = plainHeaders.get('grpc-message') || 'gRPC call failed'
@@ -225,15 +280,12 @@ export class Libp2pGrpcClient {
         };  
         
         parser.onSettings = () => {//接收settings,反馈ack
-            console.log('Settings received')
             const ackSettingFrame = Http2Frame.createSettingsAckFrame()
             writer.write(ackSettingFrame)
         }
         parser.onHeaders = (headers,header) => {
             const plainHeaders = hpack.decodeHeaderFields(headers)
-            console.log('Received headers:', plainHeaders);
             if (plainHeaders.get('grpc-status') === '0') {
-                console.log('gRPC call success')
             } else if (plainHeaders.get('grpc-status') !== undefined) {
                 const errMsg = plainHeaders.get('grpc-message') || 'gRPC call failed'
                 const err  = new Error(errMsg)