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

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/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);
     });
   }