@opensumi/ide-connection 3.0.4-next-1716529130.0 → 3.0.4-next-1716962745.0

package/src/browser/ws-channel-handler.ts

@@ -1,9 +1,16 @@
 import { EventEmitter } from '@opensumi/events';
 import { Barrier, Deferred, DisposableStore, IReporterService, MultiMap, REPORT_NAME } from '@opensumi/ide-core-common';
 
+import { ChannelMessage } from '../common/channel/types';
 import { IRuntimeSocketConnection } from '../common/connection';
+import { IConnectionShape } from '../common/connection/types';
+import { ISerializer, furySerializer, wrapSerializer } from '../common/serializer';
 import { ConnectionInfo, WSCloseInfo } from '../common/types';
-import { ErrorMessageCode, WSChannel, parse, pingMessage } from '../common/ws-channel';
+import { WSChannel } from '../common/ws-channel';
+
+export interface WSChannelHandlerOptions {
+  serializer?: ISerializer<ChannelMessage, any>;
+}
 
 /**
  * Channel Handler in browser
@@ -12,6 +19,8 @@ export class WSChannelHandler {
   private _disposables = new DisposableStore();
 
   private _onChannelCreatedEmitter = this._disposables.add(new EventEmitter<Record<string, [WSChannel]>>());
+
+  wrappedConnection: IConnectionShape<ChannelMessage>;
   public onChannelCreated(path: string, listener: (channel: WSChannel) => void) {
     return this._onChannelCreatedEmitter.on(path, listener);
   }
@@ -30,10 +39,17 @@ export class WSChannelHandler {
 
   LOG_TAG: string;
 
-  constructor(public connection: IRuntimeSocketConnection<Uint8Array>, logger: any, clientId: string) {
+  constructor(
+    public connection: IRuntimeSocketConnection<Uint8Array>,
+    logger: any,
+    clientId: string,
+    options: WSChannelHandlerOptions = {},
+  ) {
     this.logger = logger || this.logger;
     this.clientId = clientId;
     this.LOG_TAG = `[WSChannelHandler] [client-id:${this.clientId}]`;
+    const serializer = options.serializer || furySerializer;
+    this.wrappedConnection = wrapSerializer(this.connection, serializer);
   }
   // 为解决建立连接之后，替换成可落盘的 logger
   replaceLogger(logger: any) {
@@ -49,37 +65,24 @@ export class WSChannelHandler {
       clearTimeout(this.heartbeatMessageTimer);
     }
     this.heartbeatMessageTimer = global.setTimeout(() => {
-      this.connection.send(pingMessage);
+      this.channelMap.forEach((channel) => {
+        channel.ping();
+      });
+
       this.heartbeatMessage();
     }, 10 * 1000);
   }
 
   public async initHandler() {
-    this.connection.onMessage((message) => {
+    this.wrappedConnection.onMessage((msg) => {
       // 一个心跳周期内如果有收到消息，则不需要再发送心跳
       this.heartbeatMessage();
 
-      const msg = parse(message);
-
       switch (msg.kind) {
         case 'pong':
-          // pong 没有 msg.id, 且不需要分发, 不处理
-          break;
-        case 'error':
-          this.logger.error(this.LOG_TAG, `receive error: id: ${msg.id}, code: ${msg.code}, error: ${msg.message}`);
-          switch (msg.code) {
-            case ErrorMessageCode.ChannelNotFound:
-              if (this.channelMap.has(msg.id)) {
-                // 如果远程报错 channel 不存在但是本机存在，则重新打开
-                const channel = this.channelMap.get(msg.id)!;
-                if (channel.channelPath) {
-                  channel.pause();
-                  channel.open(channel.channelPath, this.clientId);
-                }
-              }
-              break;
-          }
+          // pong 不需要分发, 不处理
           break;
+
         default: {
           const channel = this.channelMap.get(msg.id);
           if (channel) {
@@ -138,7 +141,7 @@ export class WSChannelHandler {
       this.logger.log(this.LOG_TAG, `channel ${key} already exists, dispose it`);
     }
 
-    const channel = new WSChannel(this.connection, {
+    const channel = new WSChannel(this.wrappedConnection, {
       id: key,
       logger: this.logger,
       ensureServerReady: true,

package/src/common/channel/index.ts

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

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 { BaseMessageIO, 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?: BaseMessageIO;
 }
 
 const chunkedResponseHeaders: IResponseHeaders = {
@@ -61,7 +61,7 @@ export class SumiConnection implements IDisposable {
 
   protected activeRequestPool = new Map<number, SumiReadableStream<any>>();
 
-  public io = new MessageIO();
+  public io: BaseMessageIO;
   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);
   }
@@ -193,35 +195,28 @@ 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();
+        const message = this.io.readMessage(data);
+        const opType = message.kind;
+        const requestId = message.requestId;
 
         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));
-          }
+          clearTimeout(this._timeoutHandles.get(requestId));
           this._timeoutHandles.delete(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;
 
             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 +225,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 +259,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 +303,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: Record<string, any>;
+  result: any;
+}
+
+export interface RPCErrorMessage {
+  kind: OperationType.Error;
+  requestId: number;
+  method: string;
+  headers: Record<string, any>;
+  error: any;
+}
+
+export interface RPCCancelMessage {
+  kind: OperationType.Cancel;
+  requestId: number;
+}
+
+export type RPCMessage =
+  | RPCRequestMessage
+  | RPCNotificationMessage
+  | RPCResponseMessage
+  | RPCErrorMessage
+  | RPCCancelMessage;
+
+export abstract class BaseMessageIO<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 readMessage(data: T): RPCMessage;
+}
+
+export class MessageIO extends BaseMessageIO<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,69 @@ 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();
   }
+
+  readMessage(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}`);
+    }
+  }
 }

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> {
@@ -57,12 +57,14 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
   protected readonly _locals: Map<string, any>;
   protected readonly _proxies: Map<string, any>;
   protected _knownProtocols: Record<string, TSumiProtocol>;
+  io: MessageIO;
 
   constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiMultiplexerConnectionOptions = {}) {
     super(socket, options);
     this._locals = new Map();
     this._proxies = new Map();
     this._knownProtocols = options.knownProtocols || {};
+    this.io = new MessageIO();
     this.io.setAnySerializer(new AnyProtocolSerializer(this.io.writer, this.io.reader, ExtObjectTransfer));
 
     this.onRequestNotFound((rpcName: string, args: any[]) => this.invoke(rpcName, args));

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/registry.ts

@@ -1,6 +1,6 @@
 import { DisposableStore, Emitter, IDisposable } from '@opensumi/ide-core-common';
 
-import { MessageIO, TSumiProtocol, TSumiProtocolMethod } from '../rpc';
+import { BaseMessageIO, TSumiProtocol, TSumiProtocolMethod } from '../rpc';
 import { RPCServiceMethod } from '../types';
 
 const skipMethods = new Set(['constructor']);
@@ -119,13 +119,21 @@ export class ProtocolRegistry {
     this.emitter.fire(serviceNames);
   }
 
-  applyTo(io: MessageIO) {
+  applyTo(io: BaseMessageIO) {
+    if (!io.loadProtocolMethod) {
+      return;
+    }
+
     for (const protocol of this.protocolMap.values()) {
       io.loadProtocolMethod(protocol);
     }
 
     this._disposables.add(
       this.onProtocolUpdate((methods) => {
+        if (!io.loadProtocolMethod) {
+          return;
+        }
+
         for (const method of methods) {
           const protocol = this.protocolMap.get(method);
           if (protocol) {

package/src/common/serializer/fury.ts

@@ -0,0 +1,61 @@
+import { Type } from '@furyjs/fury';
+
+import { ChannelMessage } from '../channel/types';
+import { oneOf } from '../fury-extends/one-of';
+
+import { ISerializer } from './types';
+
+export const PingProtocol = Type.object('ping', {
+  id: Type.string(),
+});
+
+export const PongProtocol = Type.object('pong', {
+  id: Type.string(),
+});
+
+export const OpenProtocol = Type.object('open', {
+  clientId: Type.string(),
+  id: Type.string(),
+  path: Type.string(),
+  connectionToken: Type.string(),
+});
+
+export const ServerReadyProtocol = Type.object('server-ready', {
+  id: Type.string(),
+  token: Type.string(),
+});
+
+export const ErrorProtocol = Type.object('error', {
+  id: Type.string(),
+  code: Type.uint16(),
+  message: Type.string(),
+});
+
+export const DataProtocol = Type.object('data', {
+  id: Type.string(),
+  content: Type.string(),
+});
+
+export const BinaryProtocol = Type.object('binary', {
+  id: Type.string(),
+  binary: Type.binary(),
+});
+
+export const CloseProtocol = Type.object('close', {
+  id: Type.string(),
+  code: Type.uint32(),
+  reason: Type.string(),
+});
+
+const serializer = oneOf([
+  PingProtocol,
+  PongProtocol,
+  OpenProtocol,
+  ServerReadyProtocol,
+  DataProtocol,
+  BinaryProtocol,
+  CloseProtocol,
+  ErrorProtocol,
+]);
+
+export const furySerializer: ISerializer<ChannelMessage, Uint8Array> = serializer;

package/src/common/serializer/index.ts

@@ -0,0 +1,23 @@
+import { IConnectionShape } from '../connection/types';
+
+import { ISerializer } from './types';
+
+export * from './fury';
+export * from './types';
+
+export const wrapSerializer = <FROM, TO>(
+  connection: IConnectionShape<TO>,
+  serializer: ISerializer<FROM, TO>,
+): IConnectionShape<FROM> => ({
+  onceClose(cb) {
+    return connection.onceClose(cb);
+  },
+  onMessage(cb) {
+    return connection.onMessage((data) => {
+      cb(serializer.deserialize(data));
+    });
+  },
+  send(data) {
+    connection.send(serializer.serialize(data));
+  },
+});