@opensumi/ide-connection 2.27.3-next-1706520813.0 → 2.27.3-rc-1706687185.0

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

@@ -0,0 +1,62 @@
+import type net from 'net';
+
+import { IDisposable } from '@opensumi/ide-core-common';
+
+import { BaseConnection } from './base';
+import { StreamPacketDecoder, createStreamPacket } from './stream-decoder';
+
+export class NetSocketConnection extends BaseConnection<Uint8Array> {
+  protected decoder = new StreamPacketDecoder();
+
+  constructor(private socket: net.Socket) {
+    super();
+    this.socket.on('data', (chunk) => {
+      this.decoder.push(chunk);
+    });
+    this.socket.once('close', () => {
+      this.decoder.dispose();
+    });
+  }
+
+  isOpen(): boolean {
+    return this.socket.readyState === 'open';
+  }
+
+  send(data: Uint8Array): void {
+    this.socket.write(createStreamPacket(data));
+  }
+
+  onMessage(cb: (data: Uint8Array) => void): IDisposable {
+    const dispose = this.decoder.onData(cb);
+    return {
+      dispose,
+    };
+  }
+
+  onceClose(cb: () => void): IDisposable {
+    this.socket.once('close', cb);
+    return {
+      dispose: () => {
+        this.socket.off('close', cb);
+      },
+    };
+  }
+
+  onOpen(cb: () => void): IDisposable {
+    this.socket.on('connect', cb);
+    return {
+      dispose: () => {
+        this.socket.off('connect', cb);
+      },
+    };
+  }
+
+  onError(cb: (err: Error) => void): IDisposable {
+    this.socket.on('error', cb);
+    return {
+      dispose: () => {
+        this.socket.off('error', cb);
+      },
+    };
+  }
+}

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

@@ -0,0 +1,196 @@
+import { BinaryReader } from '@furyjs/fury/dist/lib/reader';
+import { BinaryWriter } from '@furyjs/fury/dist/lib/writer';
+
+import { EventEmitter } from '@opensumi/events';
+
+import { Buffers } from '../buffers';
+
+/**
+ * You can use `Buffer.from('Sumi')` to get this magic number
+ */
+export const kMagicNumber = 0x53756d69;
+
+const writer = BinaryWriter({});
+
+/**
+ * When we send data through net.Socket, the data is not guaranteed to be sent as a whole.
+ *
+ * So we need to add a header to the data, so that the receiver can know the length of the data,
+ * The header is 4 bytes, the first 4 bytes is a magic number, which is `Sumi` in little endian.
+ * use magic number can help us to detect the start of the packet in the stream.
+ *
+ * The next 4 bytes is a varUInt32, which means the length of the following data, and
+ * the following data is the content.
+ */
+export function createStreamPacket(content: Uint8Array) {
+  writer.reset();
+  writer.uint32(kMagicNumber);
+  writer.varUInt32(content.byteLength);
+  writer.buffer(content);
+  return writer.dump();
+}
+
+export class StreamPacketDecoder {
+  protected emitter = new EventEmitter<{
+    data: [Uint8Array];
+  }>();
+
+  protected buffers = new Buffers();
+  protected cursor = this.buffers.cursor();
+
+  protected reader = BinaryReader({});
+
+  protected state = 0;
+  protected contentLength = 0;
+
+  reset() {
+    this.state = 0;
+    this.contentLength = 0;
+
+    this.cursor.reset();
+  }
+
+  push(chunk: Uint8Array): void {
+    this.buffers.push(chunk);
+    let done = false;
+
+    while (!done) {
+      done = this.readPacket();
+    }
+  }
+
+  protected readPacket(): boolean {
+    const found = this.readHeader();
+
+    if (found) {
+      const start = this.cursor.offset;
+      const end = start + this.contentLength;
+
+      const binary = this.buffers.slice(start, end);
+
+      this.emitter.emit('data', binary);
+
+      if (this.buffers.byteLength > end) {
+        this.cursor.moveTo(end);
+        this.state = 0;
+        this.contentLength = 0;
+        // has more data, continue to parse
+        return false;
+      }
+
+      // delete used buffers
+      this.buffers.splice(0, end);
+      this.reset();
+    }
+
+    return true;
+  }
+
+  /**
+   * First we read the first 4 bytes, if it is not magic 4 bytes
+   * discard it and continue to read the next byte until we get magic 4 bytes
+   * Then read the next byte, this is a varUint32, which means the length of the following data
+   * Then read the following data, until we get the length of varUint32, then return this data and continue to read the next packet
+   */
+  protected readHeader() {
+    if (this.buffers.byteLength === 0) {
+      return false;
+    }
+
+    if (this.state !== 4) {
+      this.readMagicNumber();
+    }
+
+    if (this.state !== 4) {
+      // Not enough data yet, wait for more data
+      return false;
+    }
+
+    if (this.cursor.offset + 4 > this.buffers.byteLength) {
+      // Not enough data yet, wait for more data
+      return false;
+    }
+
+    if (!this.contentLength) {
+      // read the content length
+      const buffers = this.buffers.slice(this.cursor.offset, this.cursor.offset + 4);
+      this.reader.reset(buffers);
+      this.contentLength = this.reader.varUInt32();
+      this.cursor.move(this.reader.getCursor());
+    }
+
+    if (this.cursor.offset + this.contentLength > this.buffers.byteLength) {
+      // Not enough data yet, wait for more data
+      return false;
+    }
+
+    return true;
+  }
+
+  protected readMagicNumber() {
+    const iter = this.cursor.iterator();
+
+    let result = iter.next();
+    while (!result.done) {
+      // Fury use little endian to store data
+      switch (result.value) {
+        case 0x69:
+          switch (this.state) {
+            case 0:
+              this.state = 1;
+              break;
+            default:
+              this.state = 0;
+              break;
+          }
+          break;
+        case 0x6d:
+          switch (this.state) {
+            case 1:
+              this.state = 2;
+              break;
+            default:
+              this.state = 0;
+              break;
+          }
+          break;
+        case 0x75:
+          switch (this.state) {
+            case 2:
+              this.state = 3;
+              break;
+            default:
+              this.state = 0;
+              break;
+          }
+          break;
+        case 0x53:
+          switch (this.state) {
+            case 3:
+              this.state = 4;
+              iter.return();
+              break;
+            default:
+              this.state = 0;
+              break;
+          }
+          break;
+        default:
+          this.state = 0;
+          break;
+      }
+      result = iter.next();
+    }
+  }
+
+  onData(cb: (data: Uint8Array) => void) {
+    return this.emitter.on('data', cb);
+  }
+
+  dispose() {
+    this.reader = BinaryReader({});
+    this.emitter.dispose();
+    this.buffers.dispose();
+    this.cursor.dispose();
+  }
+}

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

@@ -0,0 +1,52 @@
+import { Emitter } from '@opensumi/ide-core-common';
+
+import { IConnectionShape } from '../types';
+
+export class EventQueue<T> {
+  emitter = new Emitter<T>();
+
+  queue: T[] = [];
+
+  isOpened = false;
+  open() {
+    this.isOpened = true;
+    this.queue.forEach((data) => {
+      this.emitter.fire(data);
+    });
+    this.queue = [];
+  }
+
+  push(data: T) {
+    if (this.isOpened) {
+      this.emitter.fire(data);
+    } else {
+      this.queue.push(data);
+    }
+  }
+
+  on(cb: (data: T) => void) {
+    const disposable = this.emitter.event(cb);
+
+    if (!this.isOpened) {
+      this.open();
+    }
+
+    return disposable;
+  }
+}
+
+export const createQueue = <T>(socket: IConnectionShape<T>): IConnectionShape<T> => {
+  const queue = new EventQueue<T>();
+
+  socket.onMessage((data) => {
+    queue.push(data);
+  });
+
+  return {
+    send: (data) => {
+      socket.send(data);
+    },
+    onMessage: (cb) => queue.on(cb),
+    onceClose: (cb) => socket.onceClose(cb),
+  };
+};

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

@@ -0,0 +1,31 @@
+import type WebSocket from 'ws';
+
+import { IDisposable } from '@opensumi/ide-core-common';
+
+import { BaseConnection } from './base';
+
+export class WSWebSocketConnection extends BaseConnection<Uint8Array> {
+  constructor(public socket: WebSocket) {
+    super();
+  }
+  send(data: Uint8Array): void {
+    this.socket.send(data);
+  }
+
+  onMessage(cb: (data: Uint8Array) => void): IDisposable {
+    this.socket.on('message', cb);
+    return {
+      dispose: () => {
+        this.socket.off('message', cb);
+      },
+    };
+  }
+  onceClose(cb: () => void): IDisposable {
+    this.socket.once('close', cb);
+    return {
+      dispose: () => {
+        this.socket.off('close', cb);
+      },
+    };
+  }
+}

package/src/common/connection/index.ts

@@ -0,0 +1 @@
+export * from './drivers';

package/src/common/connection/types.ts

@@ -0,0 +1,7 @@
+import { IDisposable } from '@opensumi/ide-core-common';
+
+export interface IConnectionShape<T> {
+  send(data: T): void;
+  onMessage: (cb: (data: T) => void) => IDisposable;
+  onceClose: (cb: () => void) => IDisposable;
+}

package/src/common/constants.ts

@@ -0,0 +1 @@
+export const METHOD_NOT_REGISTERED = '$$METHOD_NOT_REGISTERED';

package/src/common/{rpcProtocol.ts → ext-rpc-protocol.ts}

@@ -1,4 +1,17 @@
-import { CancellationToken, CancellationTokenSource, Deferred, Event, Uri } from '@opensumi/ide-core-common';
+import {
+  CancellationToken,
+  CancellationTokenSource,
+  Deferred,
+  Emitter,
+  Event,
+  SerializedError,
+  Uri,
+  transformErrorForSerialization,
+} from '@opensumi/ide-core-common';
+
+import { ILogger } from './types';
+import { WSChannel } from './ws-channel';
+
 // Uri: vscode 中的 uri
 // URI: 在 vscode 中的 uri 基础上包装了一些基础方法
 
@@ -7,30 +20,6 @@ export enum RPCProtocolEnv {
   EXT,
 }
 
-export interface SerializedError {
-  readonly $isError: true;
-  readonly name: string;
-  readonly message: string;
-  readonly stack: string;
-}
-
-export function transformErrorForSerialization(error: Error): SerializedError;
-export function transformErrorForSerialization(error: any): any;
-export function transformErrorForSerialization(error: any): any {
-  if (error instanceof Error) {
-    const { name, message } = error;
-    const stack: string = (error as any).stacktrace || (error as any).stack;
-    return {
-      $isError: true,
-      name,
-      message,
-      stack,
-    };
-  }
-
-  return error;
-}
-
 export interface IProxyIdentifier {
   serviceId: string;
   countId: number;
@@ -56,7 +45,7 @@ export function createMainContextProxyIdentifier<T>(identifier: string): ProxyId
   return result;
 }
 export interface IMessagePassingProtocol {
-  send(msg): void;
+  send(msg: string): void;
   onMessage: Event<string>;
   timeout?: number;
 }
@@ -212,9 +201,9 @@ export class RPCProtocol implements IRPCProtocol {
   private readonly _timeoutHandles: Map<string, NodeJS.Timeout | number>;
   private _lastMessageId: number;
   private _pendingRPCReplies: Map<string, Deferred<any>>;
-  private logger;
+  private logger: ILogger;
 
-  constructor(connection: IMessagePassingProtocol, logger?: any) {
+  constructor(connection: IMessagePassingProtocol, logger?: ILogger) {
     this._protocol = connection;
     this._locals = new Map();
     this._proxies = new Map();
@@ -290,8 +279,8 @@ export class RPCProtocol implements IRPCProtocol {
     return result.promise;
   }
 
-  private _receiveOneMessage(rawmsg: string): void {
-    const msg = JSON.parse(rawmsg, ObjectTransfer.reviver);
+  private _receiveOneMessage(rawMsg: string): void {
+    const msg = JSON.parse(rawMsg, ObjectTransfer.reviver);
 
     if (this._timeoutHandles.has(msg.id)) {
       // 忽略一些 jest 测试场景 clearTimeout not defined 的问题
@@ -410,6 +399,29 @@ export class RPCProtocol implements IRPCProtocol {
     this._pendingRPCReplies.delete(callId);
     this._timeoutHandles.delete(callId);
 
-    pendingReply.reject(new Error('RPC Timeout: '+ callId));
+    pendingReply.reject(new Error('RPC Timeout: ' + callId));
   }
 }
+
+interface RPCProtocolCreateOptions {
+  timeout?: number;
+}
+
+export function createRPCProtocol(channel: WSChannel, options: RPCProtocolCreateOptions = {}): RPCProtocol {
+  const onMessageEmitter = new Emitter<string>();
+  channel.onMessage((msg: string) => {
+    onMessageEmitter.fire(msg);
+  });
+
+  const onMessage = onMessageEmitter.event;
+  const send = (msg: string) => {
+    channel.send(msg);
+  };
+
+  const mainThreadProtocol = new RPCProtocol({
+    onMessage,
+    send,
+    timeout: options.timeout,
+  });
+  return mainThreadProtocol;
+}

package/src/common/index.ts

@@ -1,6 +1,7 @@
 export * from './message';
 export * from './proxy';
-export * from './rpcProtocol';
+export * from './ext-rpc-protocol';
 export * from './utils';
 export * from './ws-channel';
 export * from './connect';
+export * from './types';

package/src/common/proxy/base.ts

@@ -0,0 +1,67 @@
+import { Deferred, isDefined } from '@opensumi/ide-core-common';
+
+import { ILogger, IRPCServiceMap } from '../types';
+import { ICapturedMessage, getCapturer, getServiceMethods } from '../utils';
+
+interface IBaseConnection {
+  listen(): void;
+}
+
+export abstract class ProxyBase<T extends IBaseConnection> {
+  protected proxyService: any = {};
+
+  protected logger: ILogger;
+  protected connection: T;
+
+  protected connectionPromise: Deferred<void> = new Deferred<void>();
+
+  protected abstract engine: 'legacy';
+
+  constructor(public target?: IRPCServiceMap, logger?: ILogger) {
+    this.logger = logger || console;
+  }
+
+  // capture messages for opensumi devtools
+  protected capture(message: ICapturedMessage): void {
+    const capturer = getCapturer();
+    if (isDefined(capturer)) {
+      capturer({
+        ...message,
+        engine: this.engine,
+      });
+    }
+  }
+
+  listen(connection: T): void {
+    this.connection = connection;
+
+    if (this.target) {
+      this.listenService(this.target);
+    }
+
+    connection.listen();
+    this.connectionPromise.resolve();
+  }
+
+  public listenService(service: IRPCServiceMap) {
+    if (this.connection) {
+      this.bindOnRequest(service, (service, prop) => {
+        this.proxyService[prop] = service[prop].bind(service);
+      });
+    } else {
+      if (!this.target) {
+        this.target = {} as any;
+      }
+
+      const methods = getServiceMethods(service);
+      for (const method of methods) {
+        // `getServiceMethods` ensure that method is a function
+        (this.target as any)[method] = service[method]!.bind(service);
+      }
+    }
+  }
+
+  abstract getInvokeProxy(): any;
+
+  protected abstract bindOnRequest(service: IRPCServiceMap, cb: (service: IRPCServiceMap, prop: string) => void): void;
+}

package/src/common/proxy/index.ts

@@ -0,0 +1,10 @@
+export * from './legacy';
+
+export abstract class RPCService<T = any> {
+  rpcClient?: T[];
+  rpcRegistered?: boolean;
+  register?(): () => Promise<T>;
+  get client() {
+    return this.rpcClient ? this.rpcClient[0] : undefined;
+  }
+}