@opensumi/ide-connection 2.27.3-rc-1706857131.0 → 2.27.3-rc-1708222409.0

package/src/common/fury-extends/any.ts

@@ -0,0 +1,144 @@
+import { Uri } from '@opensumi/ide-core-common';
+
+import { furyFactory } from './shared';
+
+const { reader, writer } = furyFactory();
+
+export enum ProtocolType {
+  String,
+  Buffer,
+  Number,
+  Int32,
+  JSONObject,
+  BigInt,
+  Array,
+  Union,
+  Object,
+  Undefined,
+  Boolean,
+}
+
+function serializeWorker(data: unknown) {
+  if (typeof data === 'undefined') {
+    writer.uint8(ProtocolType.Undefined);
+  } else if (Array.isArray(data)) {
+    writer.uint8(ProtocolType.Array);
+    writer.varUInt32(data.length);
+    for (const element of data) {
+      serializeWorker(element);
+    }
+  } else if (typeof data === 'boolean') {
+    writer.uint8(ProtocolType.Boolean);
+    writer.uint8(data ? 1 : 0);
+  } else if (typeof data === 'number') {
+    if ((data | 0) === data) {
+      writer.uint8(ProtocolType.Int32);
+      writer.int32(data);
+    } else {
+      writer.uint8(ProtocolType.Number);
+      writer.double(data);
+    }
+  } else if (typeof data === 'string') {
+    writer.uint8(ProtocolType.String);
+    writer.stringOfVarUInt32(data);
+  } else if (data instanceof Uint8Array) {
+    writer.uint8(ProtocolType.Buffer);
+    writer.varUInt32(data.byteLength);
+    writer.buffer(data);
+  } else if (typeof data === 'bigint') {
+    writer.uint8(ProtocolType.BigInt);
+    writer.int64(data);
+  } else if (typeof data === 'object') {
+    writer.uint8(ProtocolType.JSONObject);
+    writer.stringOfVarUInt32(JSON.stringify(data, ObjectTransfer.replacer));
+  } else {
+    throw new Error(`Unknown type ${typeof data}`);
+  }
+}
+
+function deserializeWorker() {
+  const type = reader.uint8();
+  switch (type) {
+    case ProtocolType.Undefined:
+      return undefined;
+    case ProtocolType.String:
+      return reader.stringOfVarUInt32();
+    case ProtocolType.Buffer: {
+      const length = reader.varUInt32();
+      return reader.buffer(length);
+    }
+    case ProtocolType.Int32:
+      return reader.int32();
+    case ProtocolType.Number:
+      return reader.double();
+    case ProtocolType.JSONObject: {
+      const json = reader.stringOfVarUInt32();
+      return JSON.parse(json, ObjectTransfer.reviver);
+    }
+    case ProtocolType.BigInt:
+      return reader.int64();
+    case ProtocolType.Array: {
+      const length = reader.varUInt32();
+      const data = [] as unknown[];
+      for (let i = 0; i < length; i++) {
+        data.push(deserializeWorker());
+      }
+      return data;
+    }
+    case ProtocolType.Boolean:
+      return reader.uint8() === 1;
+    default:
+      throw new Error(`Unknown type ${type}`);
+  }
+}
+
+const deserialize = (bytes: Uint8Array) => {
+  reader.reset(bytes);
+
+  return deserializeWorker();
+};
+
+const serializeVolatile = (v: any) => {
+  writer.reset();
+
+  serializeWorker(v);
+
+  return writer.dumpAndOwn();
+};
+
+const serialize = (v: any) => {
+  writer.reset();
+  serializeWorker(v);
+
+  return writer.dump();
+};
+
+export const anySerializer = {
+  deserialize,
+  serialize,
+  serializeVolatile,
+};
+
+class ObjectTransfer {
+  static replacer(key: string | undefined, value: any) {
+    if (value) {
+      if (value.$mid === 1) {
+        const uri = Uri.revive(value);
+        return {
+          $type: 'VSCODE_URI',
+          data: uri.toString(),
+        };
+      }
+    }
+
+    return value;
+  }
+  static reviver(key: string | undefined, value: any) {
+    if (value && value.$type !== undefined && value.data !== undefined) {
+      if (value.$type === 'VSCODE_URI') {
+        return Uri.parse(value.data);
+      }
+    }
+    return value;
+  }
+}

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

@@ -0,0 +1,61 @@
+import { ObjectTypeDescription, Serializer, TypeDescription } from '@furyjs/fury';
+import { generateSerializer } from '@furyjs/fury/dist/lib/gen';
+
+import { furyFactory } from './shared';
+const { fury, reader, writer } = furyFactory();
+
+type Writable = Record<string, any> & { kind: string };
+
+export const oneOf = (schemas: TypeDescription[]) => {
+  const registry = new Map<string, Serializer>();
+
+  schemas.forEach((schema) => {
+    registry.set((schema as ObjectTypeDescription).options.tag, generateSerializer(fury, schema));
+  });
+
+  const deserialize = (bytes: Uint8Array) => {
+    reader.reset(bytes);
+    const kind = reader.stringOfVarUInt32();
+    const serializer = registry.get(kind);
+    if (!serializer) {
+      throw new Error(`Unknown kind: ${kind}`);
+    }
+
+    const v = serializer.read();
+    v.kind = kind;
+
+    return v;
+  };
+
+  const serializeVolatile = (v: Writable) => {
+    const serializer = registry.get(v.kind);
+    if (!serializer) {
+      throw new Error(`Unknown kind: ${v.kind}`);
+    }
+
+    writer.reset();
+    writer.stringOfVarUInt32(v.kind);
+    serializer.write(v);
+
+    return writer.dumpAndOwn();
+  };
+
+  const serialize = (v: Writable) => {
+    const serializer = registry.get(v.kind);
+    if (!serializer) {
+      throw new Error(`Unknown kind: ${v.kind}`);
+    }
+
+    writer.reset();
+    writer.stringOfVarUInt32(v.kind);
+    serializer.write(v);
+
+    return writer.dump();
+  };
+
+  return {
+    deserialize,
+    serialize,
+    serializeVolatile,
+  };
+};

package/src/common/fury-extends/shared.ts

@@ -0,0 +1,15 @@
+import Fury from '@furyjs/fury/dist/lib/fury';
+
+export const furyFactory = () => {
+  const fury = Fury({});
+  const reader = fury.binaryReader;
+  const writer = fury.binaryWriter;
+
+  return {
+    fury,
+    reader,
+    writer,
+  };
+};
+
+export type FuryFactoryReturn = ReturnType<typeof furyFactory>;

package/src/common/index.ts

@@ -1,5 +1,6 @@
 export * from './message';
-export * from './proxy';
+export * from './rpc-service/proxy';
+export * from './rpc/multiplexer';
 export * from './ext-rpc-protocol';
 export * from './utils';
 export * from './ws-channel';

package/src/common/protocols/common-server.ts

@@ -0,0 +1,18 @@
+import { Type } from '@furyjs/fury';
+
+import { CommonServerPath } from '@opensumi/ide-core-common';
+
+import type { TSumiProtocol } from '../rpc';
+
+export const CommonServerProtocol = {
+  name: CommonServerPath,
+  methods: [
+    {
+      method: 'getBackendOS',
+      request: [],
+      response: {
+        type: Type.uint16(),
+      },
+    },
+  ],
+} as TSumiProtocol;

package/src/common/protocols/common.ts

@@ -0,0 +1,9 @@
+import { Type } from '@furyjs/fury';
+
+export const UriComponentsProto = Type.object('uri-components', {
+  scheme: Type.string(),
+  authority: Type.string(),
+  path: Type.string(),
+  query: Type.string(),
+  fragment: Type.string(),
+});

package/src/common/rpc/connection.ts

@@ -0,0 +1,345 @@
+import type net from 'net';
+
+import type { WebSocket } from 'ws';
+
+import { EventEmitter } from '@opensumi/events';
+import {
+  DisposableCollection,
+  IDisposable,
+  parseError,
+  CancellationToken,
+  canceled,
+  CancellationTokenSource,
+  isPromise,
+} from '@opensumi/ide-utils';
+
+import { BaseConnection, NetSocketConnection, WSWebSocketConnection } from '../connection';
+import { METHOD_NOT_REGISTERED } from '../constants';
+import { ILogger } from '../types';
+
+import { MethodTimeoutError } from './errors';
+import {
+  BodyCodec,
+  ErrorCode,
+  OperationType,
+  MessageIO,
+  requestHeadersSerializer,
+  reader,
+  IRequestHeaders,
+} from './packet';
+import { ProtocolRepository } from './protocol-repository';
+import {
+  TGenericNotificationHandler,
+  TGenericRequestHandler,
+  TOnNotificationNotFoundHandler,
+  TOnRequestNotFoundHandler,
+  TRequestCallback,
+} from './types';
+import { assert } from './utils';
+
+const nullHeaders = {};
+
+const star = '*';
+
+export interface ISumiConnectionOptions {
+  timeout?: number;
+  logger?: ILogger;
+}
+
+export class SumiConnection implements IDisposable {
+  protected disposable = new DisposableCollection();
+
+  private _requestEmitter = new EventEmitter<{
+    [key: string]: [requestId: number, method: string, headers: Record<string, any>, args: any[]];
+  }>();
+  private _notificationEmitter = new EventEmitter<{
+    [key: string]: [requestId: number, method: string, headers: Record<string, any>, args: any[]];
+  }>();
+
+  private _requestId = 0;
+  private _callbacks = new Map<number, TRequestCallback>();
+
+  private readonly _timeoutHandles = new Map<number, NodeJS.Timeout | number>();
+  private readonly _cancellationTokenSources = new Map<number, CancellationTokenSource>();
+  private readonly _knownCanceledRequests = new Set<number>();
+
+  public protocolRepository = new ProtocolRepository();
+  protected logger: ILogger = console;
+
+  constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiConnectionOptions = {}) {
+    if (options.logger) {
+      this.logger = options.logger;
+    }
+  }
+
+  sendNotification(method: string, ...args: any[]) {
+    const processor = this.protocolRepository.getProcessor(method);
+    const payload = processor.serializeRequest(args);
+    this.socket.send(MessageIO.Request(this._requestId++, OperationType.Notification, method, nullHeaders, payload));
+  }
+
+  sendRequest(method: string, ...args: any[]) {
+    return new Promise<any>((resolve, reject) => {
+      const requestId = this._requestId++;
+
+      const processor = this.protocolRepository.getProcessor(method);
+
+      this._callbacks.set(requestId, (headers, error, buffer) => {
+        if (error) {
+          if (error === METHOD_NOT_REGISTERED) {
+            resolve(error);
+            return;
+          }
+
+          reject(error);
+          return;
+        }
+
+        const result = processor.deserializeResult(buffer);
+        resolve(result);
+      });
+
+      // Set timeout callback, -1 means no timeout configuration is set.
+      if (this.options.timeout && this.options.timeout !== -1) {
+        const timeoutHandle = setTimeout(() => {
+          this._handleTimeout(method, requestId);
+        }, this.options.timeout);
+        this._timeoutHandles.set(requestId, timeoutHandle);
+      }
+
+      const cancellationToken: CancellationToken | undefined =
+        args.length && CancellationToken.isCancellationToken(args[args.length - 1]) ? args.pop() : undefined;
+      if (cancellationToken && cancellationToken.isCancellationRequested) {
+        return Promise.reject(canceled());
+      }
+
+      if (cancellationToken) {
+        cancellationToken.onCancellationRequested(() => this.cancelRequest(requestId));
+      }
+
+      const payload = processor.serializeRequest(args);
+      this.socket.send(
+        MessageIO.Request(
+          requestId,
+          OperationType.Request,
+          method,
+          {
+            cancelable: cancellationToken ? true : false,
+          },
+          payload,
+        ),
+      );
+    });
+  }
+
+  onNotification(method: string, handler: TGenericNotificationHandler): IDisposable {
+    const handlerWrapper = (requestId: number, method: string, headers: Record<string, any>, args: any[]) => {
+      handler(...args);
+    };
+    return this._notificationEmitter.on(method, handlerWrapper);
+  }
+
+  onNotificationNotFound(handler: TOnNotificationNotFoundHandler): IDisposable {
+    const handlerWrapper = (requestId: number, method: string, headers: Record<string, any>, args: any[]) => {
+      handler(method, args);
+    };
+    return this._notificationEmitter.on(star, handlerWrapper);
+  }
+
+  cancelRequest(requestId: number) {
+    this.socket.send(MessageIO.Cancel(requestId));
+  }
+
+  private _handleTimeout(method: string, requestId: number) {
+    if (!this._callbacks.has(requestId) || !this._timeoutHandles.has(requestId)) {
+      return;
+    }
+
+    const callback = this._callbacks.get(requestId)!;
+    this._callbacks.delete(requestId);
+    this._timeoutHandles.delete(requestId);
+    callback(nullHeaders, new MethodTimeoutError(method));
+  }
+
+  private runRequestHandler<T extends (...args: any[]) => any>(
+    requestId: number,
+    method: string,
+    args: any[],
+    handler: T,
+  ) {
+    let result: any;
+    let error: Error | undefined;
+    const processor = this.protocolRepository.getProcessor(method);
+
+    try {
+      result = handler(...args);
+    } catch (err) {
+      error = err;
+    }
+
+    if (error) {
+      this.socket.send(MessageIO.Error(requestId, ErrorCode.Err, nullHeaders, error));
+      this._cancellationTokenSources.delete(requestId);
+    } else if (isPromise(result)) {
+      result
+        .then((result) => {
+          const payload = processor.serializeResult(result);
+          this.socket.send(MessageIO.Response(requestId, nullHeaders, payload));
+          this._cancellationTokenSources.delete(requestId);
+        })
+        .catch((err) => {
+          this.socket.send(MessageIO.Error(requestId, ErrorCode.Err, nullHeaders, err));
+          this._cancellationTokenSources.delete(requestId);
+        });
+    } else {
+      const payload = processor.serializeResult(result);
+      this.socket.send(MessageIO.Response(requestId, nullHeaders, payload));
+      this._cancellationTokenSources.delete(requestId);
+    }
+  }
+
+  onRequest<T = any>(method: string, handler: TGenericRequestHandler<T>): IDisposable {
+    const handlerWrapper = (requestId: number, method: string, headers: Record<string, any>, args: any[]) => {
+      this.runRequestHandler(requestId, method, args, handler);
+    };
+    return this._requestEmitter.on(method, handlerWrapper);
+  }
+
+  onRequestNotFound(handler: TOnRequestNotFoundHandler): IDisposable {
+    const handlerWrapper = (requestId: number, method: string, headers: Record<string, any>, args: any[]) => {
+      this.runRequestHandler(requestId, method, [method, args], handler);
+    };
+
+    return this._requestEmitter.on(star, handlerWrapper);
+  }
+
+  setProtocolRepository(protocolRepository: ProtocolRepository) {
+    this.protocolRepository = protocolRepository;
+  }
+
+  listen() {
+    const toDispose = this.socket.onMessage((data) => {
+      reader.reset(data);
+      // skip version, currently only have version 1
+      reader.skip(1);
+
+      const rpcType = reader.uint8();
+
+      const requestId = reader.uint32();
+      const codec = reader.uint8();
+
+      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);
+      }
+
+      switch (rpcType) {
+        case OperationType.Response: {
+          const callback = this._callbacks.get(requestId);
+          if (!callback) {
+            this.logger.error(`Cannot find callback for request ${requestId}`);
+            return;
+          }
+
+          this._callbacks.delete(requestId);
+
+          const status = reader.uint16();
+          // const headers = headerSerializer.read();
+
+          // if error code is not 0, it's an error
+          if (status === ErrorCode.Err) {
+            // TODO: use binary codec
+            assert(codec === BodyCodec.JSON, 'Error response should be JSON encoded');
+            const content = reader.stringOfVarUInt32();
+            const error = parseError(content);
+            callback(nullHeaders, error);
+            return;
+          }
+
+          if (codec === BodyCodec.Binary) {
+            const contentLen = reader.varUInt32();
+            const buffer = reader.buffer(contentLen);
+            callback(nullHeaders, undefined, buffer);
+            return;
+          }
+
+          const content = reader.stringOfVarUInt32();
+          if (codec === BodyCodec.JSON) {
+            callback(nullHeaders, undefined, JSON.parse(content));
+          } else {
+            callback(nullHeaders, undefined, content);
+          }
+          break;
+        }
+        case OperationType.Notification:
+        // fall through
+        case OperationType.Request: {
+          const method = reader.stringOfVarUInt32();
+          const headers = requestHeadersSerializer.read() as IRequestHeaders;
+
+          const contentLen = reader.varUInt32();
+          const content = reader.buffer(contentLen);
+          const processor = this.protocolRepository.getProcessor(method);
+
+          const args = processor.deserializeRequest(content);
+
+          this._receiveRequest(rpcType, requestId, method, headers, args);
+          break;
+        }
+        case OperationType.Cancel: {
+          const cancellationTokenSource = this._cancellationTokenSources.get(requestId);
+          if (cancellationTokenSource) {
+            cancellationTokenSource.cancel();
+          } else {
+            this._knownCanceledRequests.add(requestId);
+          }
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+    });
+    if (toDispose) {
+      this.disposable.push(toDispose);
+    }
+  }
+
+  dispose(): void {
+    this.disposable.dispose();
+  }
+
+  protected _receiveRequest(rpcType: number, requestId: number, method: string, headers: IRequestHeaders, args: any[]) {
+    const cancelable = headers.cancelable;
+    if (cancelable) {
+      const tokenSource = new CancellationTokenSource();
+      this._cancellationTokenSources.set(requestId, tokenSource);
+      args.push(tokenSource.token);
+
+      if (this._knownCanceledRequests.has(requestId)) {
+        tokenSource.cancel();
+        this._knownCanceledRequests.delete(requestId);
+      }
+    }
+
+    if (rpcType === OperationType.Request) {
+      const eventName = this._requestEmitter.hasListener(method) ? method : star;
+      this._requestEmitter.emit(eventName, requestId, method, headers, args);
+    } else {
+      const eventName = this._notificationEmitter.hasListener(method) ? method : star;
+      this._notificationEmitter.emit(eventName, requestId, method, headers, args);
+    }
+  }
+
+  static forWSWebSocket(socket: WebSocket, options: ISumiConnectionOptions = {}) {
+    return new SumiConnection(new WSWebSocketConnection(socket), options);
+  }
+
+  static forNetSocket(socket: net.Socket, options: ISumiConnectionOptions = {}) {
+    return new SumiConnection(new NetSocketConnection(socket), options);
+  }
+}

package/src/common/rpc/errors.ts

@@ -0,0 +1,5 @@
+export class MethodTimeoutError extends Error {
+  constructor(method: string) {
+    super(`method ${method} timeout`);
+  }
+}

package/src/common/rpc/index.ts

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