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

package/src/common/connect.ts

@@ -1,212 +1,26 @@
-import { MessageConnection } from '@opensumi/vscode-jsonrpc/lib/common/connection';
-
-import { RPCProxy, NOTREGISTERMETHOD, ILogger } from './proxy';
-
-export type RPCServiceMethod = (...args: any[]) => any;
-export type ServiceProxy = any;
-
-export enum ServiceType {
-  Service,
-  Stub,
-}
-
-export class RPCServiceStub {
-  constructor(private serviceName: string, private center: RPCServiceCenter, private type: ServiceType) {
-    if (this.type === ServiceType.Service) {
-      this.center.registerService(serviceName, this.type);
-    }
-  }
-
-  async ready() {
-    return this.center.when();
-  }
-  getNotificationName(name: string) {
-    return `on:${this.serviceName}:${name}`;
-  }
-  getRequestName(name: string) {
-    return `${this.serviceName}:${name}`;
-  }
-  // 服务方
-  on(name: string, method: RPCServiceMethod) {
-    this.onRequest(name, method);
-  }
-  getServiceMethod(service): string[] {
-    let props: any[] = [];
-
-    if (/^\s*class/.test(service.constructor.toString())) {
-      let obj = service;
-      do {
-        props = props.concat(Object.getOwnPropertyNames(obj));
-      } while ((obj = Object.getPrototypeOf(obj)));
-      props = props.sort().filter((e, i, arr) => e !== arr[i + 1] && typeof service[e] === 'function');
-    } else {
-      for (const prop in service) {
-        if (service[prop] && typeof service[prop] === 'function') {
-          props.push(prop);
-        }
-      }
-    }
-
-    return props;
-  }
-  onRequestService(service: any) {
-    const methods = this.getServiceMethod(service);
-    for (const method of methods) {
-      this.onRequest(method, service[method].bind(service));
-    }
-  }
-
-  onRequest(name: string, method: RPCServiceMethod) {
-    this.center.onRequest(this.getMethodName(name), method);
-  }
-  broadcast(name: string, ...args): Promise<any> {
-    return this.center.broadcast(this.getMethodName(name), ...args);
-  }
-
-  getMethodName(name: string) {
-    return name.startsWith('on') ? this.getNotificationName(name) : this.getRequestName(name);
-  }
-  getProxy = <T>() =>
-    new Proxy<RPCServiceStub & T>(this as any, {
-      // 调用方
-      get: (target, prop: string) => {
-        if (!target[prop]) {
-          if (typeof prop === 'symbol') {
-            return Promise.resolve();
-          } else {
-            return (...args) => this.ready().then(() => this.broadcast(prop, ...args));
-          }
-        } else {
-          return target[prop];
-        }
-      },
-    });
-}
+import { RPCServiceCenter, RPCServiceStub } from './rpc-service';
+import { ServiceType } from './types';
 
 export function initRPCService<T = void>(center: RPCServiceCenter) {
   return {
     createRPCService: (name: string, service?: any) => {
-      const proxy = new RPCServiceStub(name, center, ServiceType.Service).getProxy<T>();
+      const proxy = createRPCService<T>(name, center);
       if (service) {
         proxy.onRequestService(service);
       }
 
       return proxy;
     },
-    getRPCService: (name: string) => new RPCServiceStub(name, center, ServiceType.Stub).getProxy<T>(),
+    getRPCService: (name: string) => getRPCService<T>(name, center),
   };
 }
 
-interface IBench {
-  registerService: (service: string) => void;
-}
-
-export interface RPCMessageConnection extends MessageConnection {
-  uid?: string;
-  writer?: any;
-  reader?: any;
-}
-
-export function createRPCService<T = void>(name: string, center: RPCServiceCenter): any {
+export function createRPCService<T = void>(name: string, center: RPCServiceCenter) {
   return new RPCServiceStub(name, center, ServiceType.Service).getProxy<T>();
 }
 
-export function getRPCService<T = void>(name: string, center: RPCServiceCenter): any {
+export function getRPCService<T = void>(name: string, center: RPCServiceCenter) {
   return new RPCServiceStub(name, center, ServiceType.Stub).getProxy<T>();
 }
 
-export class RPCServiceCenter {
-  public uid: string;
-  public rpcProxy: RPCProxy[] = [];
-  public serviceProxy: ServiceProxy[] = [];
-  private connection: Array<MessageConnection> = [];
-  private serviceMethodMap = { client: undefined };
-
-  private createService: string[] = [];
-  private getService: string[] = [];
-
-  private connectionPromise: Promise<void>;
-  private connectionPromiseResolve: () => void;
-  private logger: ILogger;
-
-  constructor(private bench?: IBench, logger?: ILogger) {
-    this.uid = 'RPCServiceCenter:' + process.pid;
-    this.connectionPromise = new Promise((resolve) => {
-      this.connectionPromiseResolve = resolve;
-    });
-    this.logger = logger || console;
-  }
-
-  registerService(serviceName: string, type: ServiceType): void {
-    if (type === ServiceType.Service) {
-      this.createService.push(serviceName);
-      if (this.bench) {
-        this.bench.registerService(serviceName);
-      }
-    } else if (type === ServiceType.Stub) {
-      this.getService.push(serviceName);
-    }
-  }
-
-  when() {
-    return this.connectionPromise;
-  }
-
-  setConnection(connection: MessageConnection) {
-    if (!this.connection.length) {
-      this.connectionPromiseResolve();
-    }
-    this.connection.push(connection);
-
-    const rpcProxy = new RPCProxy(this.serviceMethodMap, this.logger);
-    rpcProxy.listen(connection);
-    this.rpcProxy.push(rpcProxy);
-
-    const serviceProxy = rpcProxy.createProxy();
-    this.serviceProxy.push(serviceProxy);
-  }
-
-  removeConnection(connection: MessageConnection) {
-    const removeIndex = this.connection.indexOf(connection);
-    if (removeIndex !== -1) {
-      this.connection.splice(removeIndex, 1);
-      this.rpcProxy.splice(removeIndex, 1);
-      this.serviceProxy.splice(removeIndex, 1);
-    }
-
-    return removeIndex !== -1;
-  }
-  onRequest(name: string, method: RPCServiceMethod) {
-    if (!this.connection.length) {
-      this.serviceMethodMap[name] = method;
-    } else {
-      this.rpcProxy.forEach((proxy) => {
-        proxy.listenService({ [name]: method });
-      });
-    }
-  }
-  async broadcast(name: string, ...args): Promise<any> {
-    const broadcastResult = this.serviceProxy.map((proxy) => proxy[name](...args));
-    if (!broadcastResult || broadcastResult.length === 0) {
-      throw new Error(`broadcast rpc \`${name}\` error: no remote service can handle this call`);
-    }
-
-    const doubtfulResult = [] as any[];
-    const result = [] as any[];
-    for (const i of broadcastResult) {
-      if (i === NOTREGISTERMETHOD) {
-        doubtfulResult.push(i);
-      } else {
-        result.push(i);
-      }
-    }
-
-    if (doubtfulResult.length > 0) {
-      this.logger.warn(`broadcast rpc \`${name}\` getting doubtful responses: ${doubtfulResult.join(',')}`);
-    }
-    // FIXME: this is an unreasonable design, if remote service only returned doubtful result, we will return an empty array.
-    //        but actually we should throw an error to tell user that no remote service can handle this call.
-    //        or just return `undefined`.
-    return result.length === 1 ? result[0] : result;
-  }
-}
+export * from './rpc-service';

package/src/common/connection/buffers.ts

@@ -0,0 +1,284 @@
+/**
+ * Treat a collection of Buffers as a single contiguous partially mutable Buffer.
+ *
+ * Where possible, operations execute without creating a new Buffer and copying everything over.
+ */
+
+const emptyBuffer = new Uint8Array(0);
+
+export function copy(
+  source: Uint8Array,
+  target: Uint8Array,
+  targetStart?: number,
+  sourceStart?: number,
+  sourceEnd?: number,
+) {
+  target.set(source.subarray(sourceStart, sourceEnd), targetStart);
+}
+
+export class Buffers {
+  buffers = [] as Uint8Array[];
+  protected size = 0;
+
+  get byteLength() {
+    return this.size;
+  }
+
+  push(buffer: Uint8Array) {
+    this.buffers.push(buffer);
+    this.size += buffer.length;
+  }
+
+  unshift(buffer: Uint8Array) {
+    this.buffers.unshift(buffer);
+    this.size += buffer.length;
+  }
+
+  slice(start?: number, end?: number) {
+    const buffers = this.buffers;
+    if (end === undefined) {
+      end = this.size;
+    }
+    if (start === undefined) {
+      start = 0;
+    }
+
+    if (end > this.size) {
+      end = this.size;
+    }
+
+    if (start >= end) {
+      return emptyBuffer;
+    }
+
+    let startBytes = 0;
+    let si = 0;
+    for (; si < buffers.length && startBytes + buffers[si].length <= start; si++) {
+      startBytes += buffers[si].length;
+    }
+
+    const target = new Uint8Array(end - start);
+
+    let ti = 0;
+    for (let ii = si; ti < end - start && ii < buffers.length; ii++) {
+      const len = buffers[ii].length;
+
+      const _start = ti === 0 ? start - startBytes : 0;
+      const _end = ti + len >= end - start ? Math.min(_start + (end - start) - ti, len) : len;
+      copy(buffers[ii], target, ti, _start, _end);
+      ti += _end - _start;
+    }
+
+    return target;
+  }
+
+  pos(i: number): { buf: number; offset: number } {
+    if (i < 0 || i >= this.size) {
+      throw new Error(`out of range, ${i} not in [0, ${this.size})`);
+    }
+    let l = i;
+    let bi = 0;
+    let bu: Uint8Array | null = null;
+    for (;;) {
+      bu = this.buffers[bi];
+      if (l < bu.length) {
+        return { buf: bi, offset: l };
+      } else {
+        l -= bu.length;
+      }
+      bi++;
+    }
+  }
+
+  copy(target: Uint8Array, targetStart = 0, sourceStart = 0, sourceEnd = this.size) {
+    return copy(this.slice(sourceStart, sourceEnd), target, targetStart, 0, sourceEnd - sourceStart);
+  }
+
+  splice(start: number, deleteCount: number, ...reps: Uint8Array[]) {
+    const buffers = this.buffers;
+    const index = start >= 0 ? start : this.size - start;
+
+    if (deleteCount === undefined) {
+      deleteCount = this.size - index;
+    } else if (deleteCount > this.size - index) {
+      deleteCount = this.size - index;
+    }
+
+    for (const i of reps) {
+      this.size += i.length;
+    }
+
+    const removed = new Buffers();
+
+    let startBytes = 0;
+    let ii = 0;
+    for (; ii < buffers.length && startBytes + buffers[ii].length < index; ii++) {
+      startBytes += buffers[ii].length;
+    }
+
+    if (index - startBytes > 0) {
+      const start = index - startBytes;
+
+      if (start + deleteCount < buffers[ii].length) {
+        removed.push(buffers[ii].slice(start, start + deleteCount));
+
+        const orig = buffers[ii];
+        const buf0 = new Uint8Array(start);
+        for (let i = 0; i < start; i++) {
+          buf0[i] = orig[i];
+        }
+
+        const buf1 = new Uint8Array(orig.length - start - deleteCount);
+        for (let i = start + deleteCount; i < orig.length; i++) {
+          buf1[i - deleteCount - start] = orig[i];
+        }
+
+        if (reps.length > 0) {
+          const reps_ = reps.slice();
+          reps_.unshift(buf0);
+          reps_.push(buf1);
+          buffers.splice.apply(buffers, [ii, 1, ...reps_]);
+          ii += reps_.length;
+          reps = [];
+        } else {
+          buffers.splice(ii, 1, buf0, buf1);
+          ii += 2;
+        }
+      } else {
+        removed.push(buffers[ii].slice(start));
+        buffers[ii] = buffers[ii].slice(0, start);
+        ii++;
+      }
+    }
+
+    if (reps.length > 0) {
+      buffers.splice.apply(buffers, [ii, 0, ...reps]);
+      ii += reps.length;
+    }
+
+    while (removed.byteLength < deleteCount) {
+      const buf = buffers[ii];
+      const len = buf.length;
+      const take = Math.min(len, deleteCount - removed.byteLength);
+
+      if (take === len) {
+        removed.push(buf);
+        buffers.splice(ii, 1);
+      } else {
+        removed.push(buf.slice(0, take));
+        buffers[ii] = buffers[ii].slice(take);
+      }
+    }
+
+    this.size -= removed.byteLength;
+
+    return removed;
+  }
+
+  get(i: number) {
+    const { buf, offset } = this.pos(i);
+    return this.buffers[buf][offset];
+  }
+
+  set(i: number, v: number) {
+    const { buf, offset } = this.pos(i);
+    this.buffers[buf][offset] = v;
+  }
+
+  cursor(offset = 0) {
+    return new Cursor(this, offset);
+  }
+
+  dispose() {
+    this.buffers = [];
+    this.size = 0;
+  }
+}
+
+/**
+ * Remember the current position in a Buffers.
+ *
+ * The cursor will always point to the next byte to be read.
+ *
+ * The cursor is not safe to use after the Buffers is modified.
+ */
+export class Cursor {
+  protected chunkIndex = 0;
+  protected chunkOffset = 0;
+
+  constructor(protected buffers: Buffers, public offset = 0) {
+    this.updatePosition();
+  }
+
+  protected updatePosition() {
+    if (this.offset === 0) {
+      this.chunkIndex = 0;
+      this.chunkOffset = 0;
+      return;
+    }
+
+    const { buf, offset } = this.buffers.pos(this.offset);
+    this.chunkIndex = buf;
+    this.chunkOffset = offset;
+  }
+
+  /**
+   * Return this cursor's current line number.
+   */
+  get line() {
+    return this.chunkIndex;
+  }
+
+  get lineWidth() {
+    return this.buffers.buffers[this.chunkIndex].byteLength;
+  }
+
+  get value() {
+    return this.buffers.buffers[this.chunkIndex][this.chunkOffset];
+  }
+
+  /**
+   * Return the cursor offset in the current line.
+   */
+  get lineOffset() {
+    return this.chunkOffset;
+  }
+
+  *iterator() {
+    while (this.chunkIndex < this.buffers.buffers.length) {
+      const chunk = this.buffers.buffers[this.chunkIndex];
+      const chunkLength = chunk.byteLength;
+
+      while (this.chunkOffset < chunkLength) {
+        const num = chunk[this.chunkOffset];
+        this.chunkOffset++;
+        this.offset++;
+
+        yield num;
+      }
+      this.chunkOffset = 0;
+      this.chunkIndex++;
+    }
+  }
+
+  move(n: number) {
+    this.offset += n;
+    this.updatePosition();
+  }
+
+  moveTo(n: number) {
+    this.offset = n;
+    this.updatePosition();
+  }
+
+  dispose() {
+    this.buffers = null as any;
+    this.offset = 0;
+  }
+
+  reset() {
+    this.offset = 0;
+    this.chunkIndex = 0;
+    this.chunkOffset = 0;
+  }
+}

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

@@ -0,0 +1,15 @@
+import { IDisposable } from '@opensumi/ide-core-common';
+
+import { IConnectionShape } from '../types';
+
+import { createQueue } from './utils';
+
+export abstract class BaseConnection<T> implements IConnectionShape<T> {
+  abstract send(data: T): void;
+  abstract onMessage(cb: (data: T) => void): IDisposable;
+  abstract onceClose(cb: () => void): IDisposable;
+
+  createQueue(): IConnectionShape<T> {
+    return createQueue(this);
+  }
+}

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

@@ -0,0 +1,19 @@
+import { IDisposable } from '@opensumi/ide-core-common';
+
+import { BaseConnection } from './base';
+
+export class EmptyConnection extends BaseConnection<Uint8Array> {
+  send(data: Uint8Array): void {
+    // do nothing
+  }
+  onMessage(cb: (data: Uint8Array) => void): IDisposable {
+    return {
+      dispose: () => {},
+    };
+  }
+  onceClose(cb: () => void): IDisposable {
+    return {
+      dispose: () => {},
+    };
+  }
+}

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

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './utils';
+export * from './node-message-port';
+export * from './socket';
+export * from './ws-websocket';

package/src/common/connection/drivers/node-message-port.ts

@@ -0,0 +1,33 @@
+import type { MessagePort } from 'worker_threads';
+
+import { IDisposable } from '@opensumi/ide-core-common';
+
+import { BaseConnection } from './base';
+
+export class NodeMessagePortConnection extends BaseConnection<Uint8Array> {
+  constructor(private port: MessagePort) {
+    super();
+  }
+
+  send(data: Uint8Array): void {
+    this.port.postMessage(data);
+  }
+
+  onMessage(cb: (data: Uint8Array) => void): IDisposable {
+    this.port.on('message', cb);
+    return {
+      dispose: () => {
+        this.port.off('message', cb);
+      },
+    };
+  }
+
+  onceClose(cb: () => void): IDisposable {
+    this.port.once('close', cb);
+    return {
+      dispose: () => {
+        this.port.off('close', cb);
+      },
+    };
+  }
+}

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

@@ -0,0 +1,86 @@
+import ReconnectingWebSocket, { Options as ReconnectingWebSocketOptions, UrlProvider } from 'reconnecting-websocket';
+import type { ErrorEvent } from 'reconnecting-websocket';
+
+import { IDisposable } from '@opensumi/ide-core-common';
+
+import { BaseConnection } from './base';
+
+export class ReconnectingWebSocketConnection extends BaseConnection<Uint8Array> {
+  constructor(private socket: ReconnectingWebSocket) {
+    super();
+  }
+
+  send(data: Uint8Array): void {
+    this.socket.send(data);
+  }
+
+  isOpen(): boolean {
+    return this.socket.readyState === this.socket.OPEN;
+  }
+
+  onOpen(cb: () => void): IDisposable {
+    this.socket.addEventListener('open', cb);
+    return {
+      dispose: () => {
+        this.socket.removeEventListener('open', cb);
+      },
+    };
+  }
+
+  onMessage(cb: (data: Uint8Array) => void): IDisposable {
+    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)));
+    };
+
+    this.socket.addEventListener('message', handler);
+    return {
+      dispose: () => {
+        this.socket.removeEventListener('message', handler);
+      },
+    };
+  }
+  onceClose(cb: (code?: number, reason?: string) => void): IDisposable {
+    const handler = (e: CloseEvent) => {
+      cb(e.code, e.reason);
+      this.socket.removeEventListener('close', handler);
+    };
+
+    this.socket.addEventListener('close', handler);
+    return {
+      dispose: () => {
+        this.socket.removeEventListener('close', handler);
+      },
+    };
+  }
+  onError(cb: (e: Error) => void): IDisposable {
+    const handler = (e: ErrorEvent) => {
+      cb(e.error);
+    };
+
+    this.socket.addEventListener('error', handler);
+    return {
+      dispose: () => {
+        this.socket.removeEventListener('error', handler);
+      },
+    };
+  }
+
+  static forURL(url: UrlProvider, protocols?: string | string[], options?: ReconnectingWebSocketOptions) {
+    const rawConnection = new ReconnectingWebSocket(url, protocols, options);
+    rawConnection.binaryType = 'arraybuffer';
+    const connection = new ReconnectingWebSocketConnection(rawConnection);
+
+    return connection;
+  }
+}