@opensumi/ide-connection 3.8.3-next-1741917543.0 → 3.8.3-next-1741920696.0

package/src/common/connection/drivers/reconnecting-websocket.ts

@@ -1,20 +1,74 @@
+/* eslint-disable no-console */
 import { IDisposable } from '@opensumi/ide-core-common';
 import ReconnectingWebSocket, {
   Options as ReconnectingWebSocketOptions,
   UrlProvider,
 } from '@opensumi/reconnecting-websocket';
 
+import { chunkSize } from '../../constants';
+
 import { BaseConnection } from './base';
+import { LengthFieldBasedFrameDecoder } from './frame-decoder';
 
 import type { ErrorEvent } from '@opensumi/reconnecting-websocket';
 
 export class ReconnectingWebSocketConnection extends BaseConnection<Uint8Array> {
-  constructor(private socket: ReconnectingWebSocket) {
+  protected decoder = new LengthFieldBasedFrameDecoder();
+  private sendQueue: Array<{ data: Uint8Array; resolve: () => void; reject: (error: Error) => void }> = [];
+  private sending = false;
+
+  protected constructor(private socket: ReconnectingWebSocket) {
     super();
+
+    if (socket.binaryType === 'arraybuffer') {
+      this.socket.addEventListener('message', this.arrayBufferHandler);
+    } else if (socket.binaryType === 'blob') {
+      throw new Error('blob is not implemented');
+    }
   }
 
-  send(data: Uint8Array): void {
-    this.socket.send(data);
+  private async processSendQueue() {
+    if (this.sending) {
+      return;
+    }
+    this.sending = true;
+
+    while (this.sendQueue.length > 0) {
+      const { data, resolve, reject } = this.sendQueue[0];
+      let handle: { get: () => Uint8Array; dispose: () => void } | null = null;
+
+      try {
+        handle = LengthFieldBasedFrameDecoder.construct(data).dumpAndOwn();
+        const packet = handle.get();
+
+        for (let i = 0; i < packet.byteLength; i += chunkSize) {
+          await new Promise<void>((resolve) => {
+            const chunk = packet.subarray(i, Math.min(i + chunkSize, packet.byteLength));
+            this.socket.send(chunk);
+            resolve();
+          });
+        }
+
+        resolve();
+      } catch (error) {
+        console.error('[ReconnectingWebSocket] Error sending data:', error);
+        reject(error);
+      } finally {
+        if (handle) {
+          handle.dispose();
+        }
+      }
+      this.sendQueue.shift();
+    }
+
+    this.sending = false;
+  }
+
+  send(data: Uint8Array): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.sendQueue.push({ data, resolve, reject });
+      this.processSendQueue();
+    });
   }
 
   isOpen(): boolean {
@@ -29,29 +83,8 @@ export class ReconnectingWebSocketConnection extends BaseConnection<Uint8Array>
       },
     };
   }
-
   onMessage(cb: (data: Uint8Array) => void): IDisposable {
-    const handler = (e: MessageEvent) => {
-      let buffer: Promise<ArrayBuffer>;
-      if (e.data instanceof Blob) {
-        buffer = e.data.arrayBuffer();
-      } else if (e.data instanceof ArrayBuffer) {
-        buffer = Promise.resolve(e.data);
-      } else if (e.data?.constructor?.name === 'Buffer') {
-        // Compatibility with nodejs Buffer in test environment
-        buffer = Promise.resolve(e.data);
-      } else {
-        throw new Error('unknown message type, expect Blob or ArrayBuffer, received: ' + typeof e.data);
-      }
-      buffer.then((v) => cb(new Uint8Array(v, 0, v.byteLength)));
-    };
-
-    this.socket.addEventListener('message', handler);
-    return {
-      dispose: () => {
-        this.socket.removeEventListener('message', handler);
-      },
-    };
+    return this.decoder.onData(cb);
   }
   onceClose(cb: (code?: number, reason?: string) => void): IDisposable {
     const disposable = this.onClose(wrapper);
@@ -91,8 +124,15 @@ export class ReconnectingWebSocketConnection extends BaseConnection<Uint8Array>
     };
   }
 
+  private arrayBufferHandler = (e: MessageEvent<ArrayBuffer>) => {
+    const buffer: ArrayBuffer = e.data;
+    this.decoder.push(new Uint8Array(buffer, 0, buffer.byteLength));
+  };
+
   dispose(): void {
-    // do nothing
+    this.socket.removeEventListener('message', this.arrayBufferHandler);
+    this.sendQueue = [];
+    this.sending = false;
   }
 
   static forURL(url: UrlProvider, protocols?: string | string[], options?: ReconnectingWebSocketOptions) {

package/src/common/connection/drivers/stream.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import { IDisposable } from '@opensumi/ide-core-common';
 
 import { BaseConnection } from './base';
@@ -21,10 +22,16 @@ export class StreamConnection extends BaseConnection<Uint8Array> {
   }
 
   send(data: Uint8Array): void {
-    const result = LengthFieldBasedFrameDecoder.construct(data);
-    this.writable.write(result, () => {
-      // TODO: logger error
-    });
+    const handle = LengthFieldBasedFrameDecoder.construct(data).dumpAndOwn();
+    try {
+      this.writable.write(handle.get(), (error) => {
+        if (error) {
+          console.error('Failed to write data:', error);
+        }
+      });
+    } finally {
+      handle.dispose();
+    }
   }
 
   onMessage(cb: (data: Uint8Array) => void): IDisposable {

package/src/common/connection/drivers/ws-websocket.ts

@@ -1,24 +1,102 @@
+/* eslint-disable no-console */
 import { IDisposable } from '@opensumi/ide-core-common';
 
+import { chunkSize } from '../../constants';
+
 import { BaseConnection } from './base';
+import { LengthFieldBasedFrameDecoder } from './frame-decoder';
 
 import type WebSocket from 'ws';
 
+interface SendQueueItem {
+  data: Uint8Array;
+  resolve: () => void;
+  reject: (error: Error) => void;
+}
+
 export class WSWebSocketConnection extends BaseConnection<Uint8Array> {
+  protected decoder = new LengthFieldBasedFrameDecoder();
+  private static readonly MAX_QUEUE_SIZE = 1000; // 限制队列长度
+
+  private sendQueue: SendQueueItem[] = [];
+  private pendingSize = 0;
+  private sending = false;
+
   constructor(public socket: WebSocket) {
     super();
+    this.socket.on('message', (data: Buffer) => {
+      this.decoder.push(data);
+    });
   }
-  send(data: Uint8Array): void {
-    this.socket.send(data);
+
+  private async processSendQueue() {
+    if (this.sending) {
+      return;
+    }
+    this.sending = true;
+
+    while (this.sendQueue.length > 0) {
+      const { data, resolve, reject } = this.sendQueue[0];
+      let handle: { get: () => Uint8Array; dispose: () => void } | null = null;
+
+      try {
+        handle = LengthFieldBasedFrameDecoder.construct(data).dumpAndOwn();
+        const packet = handle.get();
+
+        for (let i = 0; i < packet.byteLength; i += chunkSize) {
+          if (!this.isOpen()) {
+            throw new Error('Connection closed while sending');
+          }
+
+          await new Promise<void>((resolve, reject) => {
+            const chunk = packet.subarray(i, Math.min(i + chunkSize, packet.byteLength));
+            this.socket.send(chunk, { binary: true }, (error?: Error) => {
+              if (error) {
+                reject(error);
+              } else {
+                resolve();
+              }
+            });
+          });
+        }
+
+        resolve();
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      } finally {
+        if (handle) {
+          try {
+            handle.dispose();
+          } catch (error) {
+            console.warn('[WSWebSocket] Error disposing handle:', error);
+          }
+        }
+        this.pendingSize -= this.sendQueue[0].data.byteLength;
+        this.sendQueue.shift();
+      }
+    }
+
+    this.sending = false;
+  }
+
+  send(data: Uint8Array): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      // 检查队列大小限制
+      if (this.sendQueue.length >= WSWebSocketConnection.MAX_QUEUE_SIZE) {
+        reject(new Error('Send queue full'));
+        return;
+      }
+
+      this.pendingSize += data.byteLength;
+      this.sendQueue.push({ data, resolve, reject });
+      this.processSendQueue().catch((error) => {
+        console.error('[WSWebSocket] Error processing queue:', error);
+      });
+    });
   }
 
   onMessage(cb: (data: Uint8Array) => void): IDisposable {
-    this.socket.on('message', cb);
-    return {
-      dispose: () => {
-        this.socket.off('message', cb);
-      },
-    };
+    return this.decoder.onData(cb);
   }
   onceClose(cb: () => void): IDisposable {
     this.socket.once('close', cb);
@@ -35,5 +113,12 @@ export class WSWebSocketConnection extends BaseConnection<Uint8Array> {
 
   dispose(): void {
     this.socket.removeAllListeners();
+    // 拒绝所有待发送的消息
+    while (this.sendQueue.length > 0) {
+      const { reject } = this.sendQueue.shift()!;
+      reject(new Error('Connection disposed'));
+    }
+    this.pendingSize = 0;
+    this.sending = false;
   }
 }

package/src/common/constants.ts

@@ -1 +1,6 @@
 export const METHOD_NOT_REGISTERED = '$$METHOD_NOT_REGISTERED';
+
+/**
+ * 分片大小, 1MB
+ */
+export const chunkSize = 1 * 1024 * 1024;

package/src/common/fury-extends/one-of.ts

@@ -68,6 +68,9 @@ export const oneOf = (
       case 7:
         v = serializers[7].read();
         break;
+      default: {
+        throw new Error('unknown index: ' + idx);
+      }
     }
 
     v.kind = kinds[idx];

package/src/node/common-channel-handler.ts

@@ -42,8 +42,7 @@ export class CommonChannelHandler extends BaseCommonChannelHandler implements We
       ...this.options.wsServerOptions,
     });
     this.wsServer.on('connection', (connection: WebSocket) => {
-      const wsConnection = new WSWebSocketConnection(connection);
-      this.receiveConnection(wsConnection);
+      this.receiveConnection(new WSWebSocketConnection(connection));
     });
   }