@opensumi/ide-connection 3.7.2-next-1740448398.0 → 3.7.2-next-1741226843.0

package/src/common/connection/drivers/frame-decoder.ts

@@ -1,7 +1,6 @@
-/* eslint-disable no-console */
 import { BinaryWriter } from '@furyjs/fury/dist/lib/writer';
 
-import { MaybeNull, readUInt32LE } from '@opensumi/ide-core-common';
+import { Emitter, readUInt32LE } from '@opensumi/ide-core-common';
 
 import { Buffers } from '../../buffers/buffers';
 
@@ -10,40 +9,30 @@ import { Buffers } from '../../buffers/buffers';
  */
 export const indicator = new Uint8Array([0x0d, 0x0a, 0x0d, 0x0a]);
 
-/**
- * The number of bytes in the length field.
- *
- * How many bytes are used to represent data length.
- *
- * For example, if the length field is 4 bytes, then the maximum length of the data is 2^32 = 4GB
- */
-const lengthFieldLength = 4;
-
 /**
  * sticky packet unpacking problems are generally problems at the transport layer.
  * we use a length field to represent the length of the data, and then read the data according to the length
  */
 export class LengthFieldBasedFrameDecoder {
-  private static readonly MAX_ITERATIONS = 50;
-
-  private _onDataListener: MaybeNull<(data: Uint8Array) => void>;
-  onData(listener: (data: Uint8Array) => void) {
-    this._onDataListener = listener;
-    return {
-      dispose: () => {
-        this._onDataListener = null;
-      },
-    };
-  }
+  protected dataEmitter = new Emitter<Uint8Array>();
+  onData = this.dataEmitter.event;
 
   protected buffers = new Buffers();
   protected cursor = this.buffers.cursor();
-  private processingPromise: Promise<void> | null = null;
 
   protected contentLength = -1;
 
   protected state = 0;
 
+  /**
+   * The number of bytes in the length field.
+   *
+   * How many bytes are used to represent data length.
+   *
+   * For example, if the length field is 4 bytes, then the maximum length of the data is 2^32 = 4GB
+   */
+  lengthFieldLength = 4;
+
   reset() {
     this.contentLength = -1;
     this.state = 0;
@@ -52,81 +41,38 @@ export class LengthFieldBasedFrameDecoder {
 
   push(chunk: Uint8Array): void {
     this.buffers.push(chunk);
+    let done = false;
 
-    // 确保同一时间只有一个处理过程
-    if (!this.processingPromise) {
-      this.processingPromise = this.processBuffers().finally(() => {
-        this.processingPromise = null;
-      });
+    while (!done) {
+      done = this.readFrame();
     }
   }
 
-  private async processBuffers(): Promise<void> {
-    let iterations = 0;
-    let hasMoreData = false;
-
-    do {
-      hasMoreData = false;
-      while (iterations < LengthFieldBasedFrameDecoder.MAX_ITERATIONS) {
-        if (this.buffers.byteLength === 0) {
-          break;
-        }
-
-        const result = await this.readFrame();
-        if (result === true) {
-          break;
-        }
-
-        iterations++;
-        if (iterations % 10 === 0) {
-          await new Promise((resolve) => setTimeout(resolve, 0));
-        }
-      }
-
-      // 检查剩余数据
-      if (this.buffers.byteLength > 0) {
-        hasMoreData = true;
-        // 异步继续处理，避免阻塞
-        await new Promise((resolve) => setImmediate(resolve));
-        iterations = 0; // 重置迭代计数器
-      }
-    } while (hasMoreData);
-  }
-
-  protected async readFrame(): Promise<boolean> {
-    try {
-      const found = this.readLengthField();
-      if (!found) {
-        return true;
-      }
+  protected readFrame(): boolean {
+    const found = this.readLengthField();
 
+    if (found) {
       const start = this.cursor.offset;
       const end = start + this.contentLength;
 
-      if (end > this.buffers.byteLength) {
-        return true;
-      }
-
       const binary = this.buffers.slice(start, end);
 
-      // 立即清理已处理的数据
-      this.buffers.splice(0, end);
-      this.reset();
+      this.dataEmitter.fire(binary);
 
-      if (this._onDataListener) {
-        try {
-          await Promise.resolve().then(() => this._onDataListener?.(binary));
-        } catch (error) {
-          console.error('[Frame Decoder] Error in data listener:', error);
-        }
+      if (this.buffers.byteLength > end) {
+        this.contentLength = -1;
+        this.state = 0;
+        this.cursor.moveTo(end);
+        // has more data, continue to parse
+        return false;
       }
 
-      return false;
-    } catch (error) {
-      console.error('[Frame Decoder] Error processing frame:', error);
+      // delete used buffers
+      this.buffers.splice(0, end);
       this.reset();
-      return true;
     }
+
+    return true;
   }
 
   protected readLengthField() {
@@ -147,13 +93,13 @@ export class LengthFieldBasedFrameDecoder {
     }
 
     if (this.contentLength === -1) {
-      if (this.cursor.offset + lengthFieldLength > bufferLength) {
+      if (this.cursor.offset + this.lengthFieldLength > bufferLength) {
         // Not enough data yet, wait for more data
         return false;
       }
 
       // read the content length
-      const buf = this.cursor.read4();
+      const buf = this.cursor.read(this.lengthFieldLength);
       // fury writer use little endian
       this.contentLength = readUInt32LE(buf, 0);
     }
@@ -172,12 +118,12 @@ export class LengthFieldBasedFrameDecoder {
     let result = iter.next();
     while (!result.done) {
       switch (result.value) {
-        case 0x0d: // \r
+        case 0x0d:
           switch (this.state) {
             case 0:
               this.state = 1;
               break;
-            case 2: // 第二个 \r
+            case 2:
               this.state = 3;
               break;
             default:
@@ -185,12 +131,12 @@ export class LengthFieldBasedFrameDecoder {
               break;
           }
           break;
-        case 0x0a: // \n
+        case 0x0a:
           switch (this.state) {
             case 1:
               this.state = 2;
               break;
-            case 3: // 第二个 \n
+            case 3:
               this.state = 4;
               iter.return();
               break;
@@ -208,23 +154,17 @@ export class LengthFieldBasedFrameDecoder {
   }
 
   dispose() {
-    this._onDataListener = null;
+    this.dataEmitter.dispose();
     this.buffers.dispose();
-    this.reset();
   }
 
+  static writer = BinaryWriter({});
+
   static construct(content: Uint8Array) {
-    // 每次都创建新的 writer，避免所有权问题
-    const writer = BinaryWriter({});
-
-    try {
-      writer.buffer(indicator);
-      writer.uint32(content.byteLength);
-      writer.buffer(content);
-      return writer;
-    } catch (error) {
-      console.warn('[Frame Decoder] Error constructing frame:', error);
-      throw error;
-    }
+    LengthFieldBasedFrameDecoder.writer.reset();
+    LengthFieldBasedFrameDecoder.writer.buffer(indicator);
+    LengthFieldBasedFrameDecoder.writer.uint32(content.byteLength);
+    LengthFieldBasedFrameDecoder.writer.buffer(content);
+    return LengthFieldBasedFrameDecoder.writer.dump();
   }
 }

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

@@ -1,74 +1,20 @@
-/* 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> {
-  protected decoder = new LengthFieldBasedFrameDecoder();
-  private sendQueue: Array<{ data: Uint8Array; resolve: () => void; reject: (error: Error) => void }> = [];
-  private sending = false;
-
-  protected constructor(private socket: ReconnectingWebSocket) {
+  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');
-    }
   }
 
-  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();
-    });
+  send(data: Uint8Array): void {
+    this.socket.send(data);
   }
 
   isOpen(): boolean {
@@ -83,8 +29,29 @@ export class ReconnectingWebSocketConnection extends BaseConnection<Uint8Array>
       },
     };
   }
+
   onMessage(cb: (data: Uint8Array) => void): IDisposable {
-    return this.decoder.onData(cb);
+    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);
+      },
+    };
   }
   onceClose(cb: (code?: number, reason?: string) => void): IDisposable {
     const disposable = this.onClose(wrapper);
@@ -124,15 +91,8 @@ 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 {
-    this.socket.removeEventListener('message', this.arrayBufferHandler);
-    this.sendQueue = [];
-    this.sending = false;
+    // do nothing
   }
 
   static forURL(url: UrlProvider, protocols?: string | string[], options?: ReconnectingWebSocketOptions) {

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

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

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

@@ -1,102 +1,24 @@
-/* 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);
-    });
   }
-
-  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);
-      });
-    });
+  send(data: Uint8Array): void {
+    this.socket.send(data);
   }
 
   onMessage(cb: (data: Uint8Array) => void): IDisposable {
-    return this.decoder.onData(cb);
+    this.socket.on('message', cb);
+    return {
+      dispose: () => {
+        this.socket.off('message', cb);
+      },
+    };
   }
   onceClose(cb: () => void): IDisposable {
     this.socket.once('close', cb);
@@ -113,12 +35,5 @@ 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,6 +1 @@
 export const METHOD_NOT_REGISTERED = '$$METHOD_NOT_REGISTERED';
-
-/**
- * 分片大小, 1MB
- */
-export const chunkSize = 1 * 1024 * 1024;

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

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

package/src/common/rpc/connection.ts

@@ -202,12 +202,6 @@ export class SumiConnection implements IDisposable {
         const opType = message.kind;
         const requestId = message.requestId;
 
-        if (opType === OperationType.Error) {
-          this.logger.warn(
-            `[${message.requestId}] Error received from server method ${message.method}: ${message.error}`,
-          );
-        }
-
         switch (opType) {
           case OperationType.Error:
           case OperationType.Response: {

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

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