@opensumi/ide-connection 3.0.4 → 3.0.5-next-1717466130.0

package/src/common/channel/types.ts

@@ -0,0 +1,82 @@
+export type ChannelMessage =
+  | PingMessage
+  | PongMessage
+  | OpenMessage
+  | ServerReadyMessage
+  | DataMessage
+  | BinaryMessage
+  | CloseMessage
+  | ErrorMessage;
+
+/**
+ * `ping` and `pong` are used to detect whether the connection is alive.
+ */
+export interface PingMessage {
+  kind: 'ping';
+  id: string;
+}
+
+/**
+ * when server receive a `ping` message, it should reply a `pong` message, vice versa.
+ */
+export interface PongMessage {
+  kind: 'pong';
+  id: string;
+}
+
+/**
+ * `data` message indicate that the channel has received some data.
+ * the `content` field is the data, it should be a string.
+ */
+export interface DataMessage {
+  kind: 'data';
+  id: string;
+  content: string;
+}
+
+export interface BinaryMessage {
+  kind: 'binary';
+  id: string;
+  binary: Uint8Array;
+}
+
+export interface CloseMessage {
+  kind: 'close';
+  id: string;
+  code: number;
+  reason: string;
+}
+
+/**
+ * `open` message is used to open a new channel.
+ * `path` is used to identify which handler should be used to handle the channel.
+ * `clientId` is used to identify the client.
+ */
+export interface OpenMessage {
+  kind: 'open';
+  id: string;
+  path: string;
+  clientId: string;
+  connectionToken: string;
+}
+
+export enum ErrorMessageCode {
+  ChannelNotFound = 1,
+}
+
+export interface ErrorMessage {
+  kind: 'error';
+  id: string;
+  code: ErrorMessageCode;
+  message: string;
+}
+
+/**
+ * when server receive a `open` message, it should reply a `server-ready` message.
+ * this is indicate that the channel is ready to use.
+ */
+export interface ServerReadyMessage {
+  kind: 'server-ready';
+  id: string;
+  token: string;
+}

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

@@ -2,19 +2,19 @@ import { IDisposable } from '@opensumi/ide-core-common';
 
 import { BaseConnection } from './base';
 
-export class SimpleConnection extends BaseConnection<Uint8Array> {
+export class SimpleConnection<T = Uint8Array> extends BaseConnection<T> {
   constructor(
     public options: {
-      send?: (data: Uint8Array) => void;
-      onMessage?: (cb: (data: Uint8Array) => void) => IDisposable;
+      send?: (data: T) => void;
+      onMessage?: (cb: (data: T) => void) => IDisposable;
     } = {},
   ) {
     super();
   }
-  send(data: Uint8Array): void {
+  send(data: T): void {
     this.options.send?.(data);
   }
-  onMessage(cb: (data: Uint8Array) => void): IDisposable {
+  onMessage(cb: (data: T) => void): IDisposable {
     if (this.options.onMessage) {
       return this.options.onMessage(cb);
     }

package/src/common/index.ts

@@ -1,7 +1,11 @@
 export * from './rpc-service/proxy';
+export * from './rpc-service';
 export * from './rpc/multiplexer';
 export * from './rpcProtocol';
 export * from './capturer';
 export * from './ws-channel';
 export * from './connect';
 export * from './types';
+export * from './connection';
+export * from './serializer';
+export * from './channel';

package/src/common/rpc/connection.ts

@@ -5,7 +5,6 @@ import {
   DisposableStore,
   IDisposable,
   canceled,
-  parseError,
 } from '@opensumi/ide-utils';
 import { SumiReadableStream, isReadableStream, listenReadable } from '@opensumi/ide-utils/lib/stream';
 
@@ -15,9 +14,8 @@ import { METHOD_NOT_REGISTERED } from '../constants';
 import { ILogger } from '../types';
 
 import { MethodTimeoutError } from './errors';
-import { MessageIO, OperationType, Status } from './message-io';
+import { IMessageIO, MessageIO, OperationType, RPCErrorMessage, RPCResponseMessage } from './message-io';
 import {
-  IRequestHeaders,
   IResponseHeaders,
   TGenericNotificationHandler,
   TGenericRequestHandler,
@@ -38,6 +36,8 @@ export interface ISumiConnectionOptions {
    * The name of the connection, used for debugging(and can see in opensumi-devtools).
    */
   name?: string;
+
+  io?: IMessageIO;
 }
 
 const chunkedResponseHeaders: IResponseHeaders = {
@@ -55,13 +55,13 @@ export class SumiConnection implements IDisposable {
   private _requestId = 0;
   private _callbacks = new Map<number, TRequestCallback>();
 
-  private readonly _timeoutHandles = new Map<number, NodeJS.Timeout | number>();
+  private readonly _reqTimeoutHandles = new Map<number, NodeJS.Timeout | number>();
   private readonly _cancellationTokenSources = new Map<number, CancellationTokenSource>();
   private readonly _knownCanceledRequests = new Set<number>();
 
   protected activeRequestPool = new Map<number, SumiReadableStream<any>>();
 
-  public io = new MessageIO();
+  public io: IMessageIO;
   protected logger: ILogger;
 
   protected capturer: Capturer;
@@ -73,6 +73,8 @@ export class SumiConnection implements IDisposable {
       this.logger = getDebugLogger();
     }
 
+    this.io = options.io || new MessageIO();
+
     this.capturer = new Capturer(options.name || 'sumi');
     this.disposable.add(this.capturer);
   }
@@ -113,7 +115,7 @@ export class SumiConnection implements IDisposable {
         const timeoutHandle = setTimeout(() => {
           this._handleTimeout(method, requestId);
         }, this.options.timeout);
-        this._timeoutHandles.set(requestId, timeoutHandle);
+        this._reqTimeoutHandles.set(requestId, timeoutHandle);
       }
 
       const cancellationToken: CancellationToken | undefined =
@@ -146,13 +148,13 @@ export class SumiConnection implements IDisposable {
   }
 
   private _handleTimeout(method: string, requestId: number) {
-    if (!this._callbacks.has(requestId) || !this._timeoutHandles.has(requestId)) {
+    if (!this._callbacks.has(requestId) || !this._reqTimeoutHandles.has(requestId)) {
       return;
     }
 
     const callback = this._callbacks.get(requestId)!;
     this._callbacks.delete(requestId);
-    this._timeoutHandles.delete(requestId);
+    this._reqTimeoutHandles.delete(requestId);
     callback(nullHeaders, new MethodTimeoutError(method));
   }
 
@@ -193,35 +195,29 @@ export class SumiConnection implements IDisposable {
   }
 
   listen() {
-    const { reader } = this.io;
-
     this.disposable.add(
       this.socket.onMessage((data) => {
-        reader.reset(data);
-        // skip version, currently only have version 1
-        reader.skip(1);
-
-        const opType = reader.uint8() as OperationType;
-        const requestId = reader.uint32();
-
-        if (this._timeoutHandles.has(requestId)) {
-          // Ignore some jest test scenarios where clearTimeout is not defined.
-          if (typeof clearTimeout === 'function') {
-            // @ts-ignore
-            clearTimeout(this._timeoutHandles.get(requestId));
-          }
-          this._timeoutHandles.delete(requestId);
-        }
+        const message = this.io.parse(data);
+
+        const opType = message.kind;
+        const requestId = message.requestId;
 
         switch (opType) {
+          case OperationType.Error:
           case OperationType.Response: {
-            const method = reader.stringOfVarUInt32();
-            const status = reader.uint16();
+            const { headers, method } = message;
+            const err = (message as RPCErrorMessage).error;
+            const result = (message as RPCResponseMessage).result;
+
+            if (this._reqTimeoutHandles.has(requestId)) {
+              clearTimeout(this._reqTimeoutHandles.get(requestId));
+              this._reqTimeoutHandles.delete(requestId);
+            }
 
             const runCallback = (headers: IResponseHeaders, error?: any, result?: any) => {
               const callback = this._callbacks.get(requestId);
               if (!callback) {
-                this.logger.error(`Cannot find callback for request ${requestId}: ${method}, status: ${status}`);
+                this.logger.error(`Cannot find callback for request ${requestId}: ${method}`);
                 return;
               }
 
@@ -230,17 +226,6 @@ export class SumiConnection implements IDisposable {
               callback(headers, error, result);
             };
 
-            const headers = this.io.responseHeadersSerializer.read();
-            let err: any;
-            let result: any;
-            if (status === Status.Err) {
-              // todo: move to processor
-              const content = reader.stringOfVarUInt32();
-              err = parseError(content);
-            } else {
-              result = this.io.getProcessor(method).readResponse();
-            }
-
             if (headers && headers.chunked) {
               let activeReq: SumiReadableStream<any>;
               if (this.activeRequestPool.has(requestId)) {
@@ -275,9 +260,7 @@ export class SumiConnection implements IDisposable {
           case OperationType.Notification:
           // fall through
           case OperationType.Request: {
-            const method = reader.stringOfVarUInt32();
-            const headers = this.io.requestHeadersSerializer.read() as IRequestHeaders;
-            const args = this.io.getProcessor(method).readRequest();
+            const { method, headers, args } = message;
 
             if (headers.cancelable) {
               const tokenSource = new CancellationTokenSource();
@@ -321,16 +304,17 @@ export class SumiConnection implements IDisposable {
                       },
                       onEnd: () => {
                         this.socket.send(this.io.Response(requestId, method, chunkedResponseHeaders, null));
+                        this._cancellationTokenSources.delete(requestId);
                       },
                       onError: (err) => {
                         this.socket.send(this.io.Error(requestId, method, chunkedResponseHeaders, err));
+                        this._cancellationTokenSources.delete(requestId);
                       },
                     });
                   } else {
                     this.socket.send(this.io.Response(requestId, method, nullHeaders, result));
+                    this._cancellationTokenSources.delete(requestId);
                   }
-
-                  this._cancellationTokenSources.delete(requestId);
                 };
 
                 const onError = (err: Error) => {

package/src/common/rpc/message-io.ts

@@ -1,8 +1,9 @@
 import Fury, { Serializer, Type, TypeDescription } from '@furyjs/fury';
 import { generateSerializer } from '@furyjs/fury/dist/lib/gen';
+import { PlatformBuffer } from '@furyjs/fury/dist/lib/platformBuffer';
 import { BinaryReader, BinaryWriter } from '@furyjs/fury/dist/lib/type';
 
-import { stringifyError } from '@opensumi/ide-core-common/lib/utils';
+import { parseError, stringifyError } from '@opensumi/ide-core-common/lib/utils';
 
 import { AnySerializer, IObjectTransfer } from '../fury-extends/any';
 import { furyFactory } from '../fury-extends/shared';
@@ -24,11 +25,7 @@ export enum OperationType {
   Notification,
   Response,
   Cancel,
-}
-
-export enum Status {
-  OK,
-  Err,
+  Error,
 }
 
 export const HeadersProto = {
@@ -45,6 +42,7 @@ const PacketPrefix = {
   Notification: (OperationType.Notification << 8) | ProtoVersionV1,
   Response: (OperationType.Response << 8) | ProtoVersionV1,
   Cancel: (OperationType.Cancel << 8) | ProtoVersionV1,
+  Error: (OperationType.Error << 8) | ProtoVersionV1,
 } as const;
 
 class SumiProtocolSerializer implements IProtocolSerializer {
@@ -105,7 +103,66 @@ export class AnyProtocolSerializer implements IProtocolSerializer {
   }
 }
 
-export class MessageIO {
+export interface RPCRequestMessage {
+  kind: OperationType.Request;
+  requestId: number;
+  method: string;
+  headers: IRequestHeaders;
+  args: any[];
+}
+
+export interface RPCNotificationMessage {
+  kind: OperationType.Notification;
+  requestId: number;
+  method: string;
+  headers: IRequestHeaders;
+  args: any[];
+}
+
+export interface RPCResponseMessage {
+  kind: OperationType.Response;
+  requestId: number;
+  method: string;
+  headers: IResponseHeaders;
+  result: any;
+}
+
+export interface RPCErrorMessage {
+  kind: OperationType.Error;
+  requestId: number;
+  method: string;
+  headers: IResponseHeaders;
+  error: any;
+}
+
+export interface RPCCancelMessage {
+  kind: OperationType.Cancel;
+  requestId: number;
+}
+
+export type RPCMessage =
+  | RPCRequestMessage
+  | RPCNotificationMessage
+  | RPCResponseMessage
+  | RPCErrorMessage
+  | RPCCancelMessage;
+
+export abstract class IMessageIO<T = any> {
+  abstract loadProtocolMethod?(
+    methodProtocol: TSumiProtocolMethod,
+    options?: { nameConverter?: (str: string) => string },
+  ): void;
+
+  abstract Request(requestId: number, method: string, headers: IRequestHeaders, args: any[]): T;
+  abstract Notification(requestId: number, method: string, headers: IRequestHeaders, args: any[]): T;
+  abstract Cancel(requestId: number): T;
+  abstract Response(requestId: number, method: string, headers: Record<string, any>, result: any): T;
+  abstract Error(requestId: number, method: string, headers: Record<string, any>, error: any): T;
+
+  abstract parse(data: T): RPCMessage;
+}
+
+export class MessageIO extends IMessageIO<PlatformBuffer> {
   fury: Fury;
   reader: BinaryReader;
   writer: BinaryWriter;
@@ -118,6 +175,7 @@ export class MessageIO {
   responseHeadersSerializer: Serializer<IResponseHeaders, IRequestHeaders>;
 
   constructor() {
+    super();
     const fury = furyFactory();
     this.fury = fury.fury;
     this.reader = fury.reader;
@@ -216,7 +274,6 @@ export class MessageIO {
     writer.uint16(PacketPrefix.Response);
     writer.uint32(requestId);
     writer.stringOfVarUInt32(method);
-    writer.uint16(Status.OK);
     this.responseHeadersSerializer.write(headers);
     this.getProcessor(method).writeResponse(result);
 
@@ -227,13 +284,118 @@ export class MessageIO {
     const { writer } = this;
     writer.reset();
 
-    writer.uint16(PacketPrefix.Response);
+    writer.uint16(PacketPrefix.Error);
     writer.uint32(requestId);
     writer.stringOfVarUInt32(method);
-    writer.uint16(Status.Err);
     this.responseHeadersSerializer.write(headers);
     writer.stringOfVarUInt32(stringifyError(error));
 
     return writer.dump();
   }
+
+  parse(data: PlatformBuffer): RPCMessage {
+    const { reader } = this;
+    reader.reset(data);
+
+    // skip version, currently only have version 1
+    reader.skip(1);
+    const opType = reader.uint8() as OperationType;
+    const requestId = reader.uint32();
+
+    switch (opType) {
+      case OperationType.Request:
+      case OperationType.Notification: {
+        const method = reader.stringOfVarUInt32();
+        const headers = this.requestHeadersSerializer.read() as IRequestHeaders;
+        const args = this.getProcessor(method).readRequest();
+        return {
+          kind: opType,
+          requestId,
+          method,
+          headers,
+          args,
+        };
+      }
+      case OperationType.Error: {
+        const method = reader.stringOfVarUInt32();
+        const headers = this.responseHeadersSerializer.read() as IResponseHeaders;
+        const error = parseError(reader.stringOfVarUInt32());
+        return {
+          kind: OperationType.Error,
+          requestId,
+          method,
+          headers,
+          error,
+        };
+      }
+      case OperationType.Response: {
+        const method = reader.stringOfVarUInt32();
+        const headers = this.responseHeadersSerializer.read() as IResponseHeaders;
+        const result = this.getProcessor(method).readResponse();
+        return {
+          kind: OperationType.Response,
+          requestId,
+          method,
+          headers,
+          result,
+        };
+      }
+      case OperationType.Cancel:
+        return {
+          kind: OperationType.Cancel,
+          requestId,
+        };
+      default:
+        throw new Error(`Unknown message type: ${opType}`);
+    }
+  }
+}
+
+export class RawMessageIO implements IMessageIO<RPCMessage> {
+  Request(requestId: number, method: string, headers: IRequestHeaders, args: any[]): RPCRequestMessage {
+    return {
+      kind: OperationType.Request,
+      requestId,
+      method,
+      headers,
+      args,
+    };
+  }
+  Notification(requestId: number, method: string, headers: IRequestHeaders, args: any[]): RPCNotificationMessage {
+    return {
+      kind: OperationType.Notification,
+      requestId,
+      method,
+      headers,
+      args,
+    };
+  }
+  Cancel(requestId: number): RPCCancelMessage {
+    return {
+      kind: OperationType.Cancel,
+      requestId,
+    };
+  }
+  Response(requestId: number, method: string, headers: Record<string, any>, result: any): RPCResponseMessage {
+    return {
+      kind: OperationType.Response,
+      requestId,
+      headers,
+      method,
+      result,
+    };
+  }
+  Error(requestId: number, method: string, headers: Record<string, any>, error: any): RPCErrorMessage {
+    return {
+      kind: OperationType.Error,
+      requestId,
+      method,
+      headers,
+      error,
+    };
+  }
+
+  parse(data: any): RPCMessage {
+    return data;
+  }
 }

package/src/common/rpc/multiplexer.ts

@@ -2,7 +2,7 @@ import { BaseConnection } from '../connection';
 import { ExtObjectTransfer } from '../fury-extends/any';
 
 import { ISumiConnectionOptions, SumiConnection } from './connection';
-import { AnyProtocolSerializer } from './message-io';
+import { AnyProtocolSerializer, MessageIO } from './message-io';
 import { TSumiProtocol } from './types';
 
 export class ProxyIdentifier<T = any> {
@@ -20,13 +20,6 @@ export class ProxyIdentifier<T = any> {
   }
 }
 
-export interface ISumiMultiplexerConnectionOptions extends ISumiConnectionOptions {
-  /**
-   * Known protocols that will be loaded automatically when a proxy is created.
-   */
-  knownProtocols?: Record<string, TSumiProtocol>;
-}
-
 export const IRPCProtocol = Symbol('IRPCProtocol');
 export interface IRPCProtocol {
   getProxy<T>(proxyId: ProxyIdentifier<T>): T;
@@ -34,6 +27,24 @@ export interface IRPCProtocol {
   get<T>(identifier: ProxyIdentifier<T>): T;
 }
 
+/**
+ *
+ * @param protocols Known protocols that will be loaded automatically when a proxy is created.
+ * @returns
+ */
+export function createExtMessageIO(protocols?: Map<ProxyIdentifier<any>, TSumiProtocol>) {
+  const io = new MessageIO();
+  io.setAnySerializer(new AnyProtocolSerializer(io.writer, io.reader, ExtObjectTransfer));
+
+  protocols?.forEach((protocol, proxyId) => {
+    io.loadProtocol(protocol, {
+      nameConverter: (str: string) => SumiConnectionMultiplexer.getRPCName(proxyId.serviceId, str),
+    });
+  });
+
+  return io;
+}
+
 /**
  * A connection multiplexer that allows to register multiple local RPC services and to create proxies for them.
  */
@@ -41,7 +52,7 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
   protected static SEP = '/';
   protected static SEP_LENGTH = SumiConnectionMultiplexer.SEP.length;
 
-  protected static getRPCName(serviceId: string, methodName: string) {
+  static getRPCName(serviceId: string, methodName: string) {
     return `${serviceId}${SumiConnectionMultiplexer.SEP}${methodName}`;
   }
 
@@ -56,14 +67,16 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
 
   protected readonly _locals: Map<string, any>;
   protected readonly _proxies: Map<string, any>;
-  protected _knownProtocols: Record<string, TSumiProtocol>;
 
-  constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiMultiplexerConnectionOptions = {}) {
-    super(socket, options);
+  io: MessageIO;
+
+  constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiConnectionOptions = {}) {
+    super(socket, {
+      ...options,
+      io: options.io || createExtMessageIO(),
+    });
     this._locals = new Map();
     this._proxies = new Map();
-    this._knownProtocols = options.knownProtocols || {};
-    this.io.setAnySerializer(new AnyProtocolSerializer(this.io.writer, this.io.reader, ExtObjectTransfer));
 
     this.onRequestNotFound((rpcName: string, args: any[]) => this.invoke(rpcName, args));
 
@@ -75,10 +88,6 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
   public set<T>(identifier: ProxyIdentifier<T>, instance: any) {
     const id = SumiConnectionMultiplexer.normalizeServiceId(identifier.serviceId);
     this._locals.set(id, instance);
-    const protocol = this._knownProtocols[identifier.serviceId];
-    if (protocol) {
-      this.loadProtocol(id, protocol);
-    }
 
     return instance;
   }
@@ -87,21 +96,10 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
     return this._locals.get(SumiConnectionMultiplexer.normalizeServiceId(identifier.serviceId));
   }
 
-  protected loadProtocol(rpcId: string, protocol: TSumiProtocol) {
-    this.io.loadProtocol(protocol, {
-      nameConverter: (str: string) => SumiConnectionMultiplexer.getRPCName(rpcId, str),
-    });
-  }
-
   public getProxy<T>(proxyId: ProxyIdentifier<T>) {
     const serviceId = SumiConnectionMultiplexer.normalizeServiceId(proxyId.serviceId);
 
     if (!this._proxies.has(serviceId)) {
-      const protocol = this._knownProtocols[proxyId.serviceId];
-      if (protocol) {
-        this.loadProtocol(serviceId, protocol);
-      }
-
       this._proxies.set(serviceId, this._createProxy(serviceId));
     }
 

package/src/common/rpc-service/index.ts

@@ -1,5 +1,6 @@
 export * from './stub';
 export * from './center';
+export * from './registry';
 
 export abstract class RPCService<T = any> {
   rpcClient?: T[];

package/src/common/rpc-service/proxy/json.ts

@@ -127,16 +127,18 @@ export class ProxyJson extends ProxyBase<MessageConnection> {
   listen(connection: MessageConnection): void {
     super.listen(connection);
 
-    connection.onRequest((method) => {
-      if (!this.registry.has(method)) {
-        const requestId = this.nextRequestId();
-        this.capturer.captureOnRequest(requestId, method, []);
-        const result = {
-          data: METHOD_NOT_REGISTERED,
-        };
-        this.capturer.captureOnRequestFail(requestId, method, result.data);
-        return result;
-      }
-    });
+    this._disposables.add(
+      connection.onRequest((method) => {
+        if (!this.registry.has(method)) {
+          const requestId = this.nextRequestId();
+          this.capturer.captureOnRequest(requestId, method, []);
+          const result = {
+            data: METHOD_NOT_REGISTERED,
+          };
+          this.capturer.captureOnRequestFail(requestId, method, result.data);
+          return result;
+        }
+      }),
+    );
   }
 }

package/src/common/rpc-service/proxy/sumi.ts

@@ -35,8 +35,10 @@ export class ProxySumi extends ProxyBase<SumiConnection> {
 
   listen(connection: SumiConnection): void {
     super.listen(connection);
-    connection.onRequestNotFound(() => {
-      throw METHOD_NOT_REGISTERED;
-    });
+    this._disposables.add(
+      connection.onRequestNotFound(() => {
+        throw METHOD_NOT_REGISTERED;
+      }),
+    );
   }
 }