@opensumi/ide-process 2.21.9-rc-1671176957.0 → 2.21.9

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@opensumi/ide-process",
-  "version": "2.21.9-rc-1671176957.0",
+  "version": "2.21.9",
   "files": [
-    "lib",
-    "src"
+    "lib"
   ],
   "license": "MIT",
   "main": "lib/index.js",
@@ -17,11 +16,11 @@
     "url": "git@github.com:opensumi/core.git"
   },
   "dependencies": {
-    "@opensumi/ide-core-common": "2.21.9-rc-1671176957.0",
-    "@opensumi/ide-core-node": "2.21.9-rc-1671176957.0"
+    "@opensumi/ide-core-common": "2.21.9",
+    "@opensumi/ide-core-node": "2.21.9"
   },
   "devDependencies": {
     "@opensumi/ide-dev-tool": "^1.3.1"
   },
-  "gitHead": "81fe16f43c329c633bd8b2eeb737363c8f4e7110"
+  "gitHead": "6038a6faa5ad85bfb5acb721c1d39190fe674555"
 }

package/src/common/index.ts

@@ -1,68 +0,0 @@
-import { ChildProcess } from 'child_process';
-import stream from 'stream';
-
-import { Event } from '@opensumi/ide-core-common';
-
-export const IProcessFactory = Symbol('IProcessFactory');
-export const IProcessManage = Symbol('IProcessManage');
-export const processManageServicePath = 'ProcessManageService';
-
-export interface IProcess {
-  readonly process: ChildProcess | undefined;
-  readonly outputStream: stream.Readable;
-  readonly errorStream: stream.Readable;
-  readonly inputStream: stream.Writable;
-  readonly processManage: IProcessManage;
-  pid: number | null;
-  onStart: Event<unknown>;
-  onExit: Event<IProcessExitEvent>;
-  onError: Event<ProcessErrorEvent>;
-  killed: boolean;
-  dispose(signal?: string);
-}
-
-export interface IProcessFactory {
-  create(options: ProcessOptions | ForkOptions): IProcess;
-}
-
-export interface IProcessManage {
-  register(process: IProcess): boolean;
-  unregister(process: IProcess): void;
-  get(id: number): IProcess | undefined;
-  onUnregister: Event<number>;
-  dispose(): void;
-}
-
-export interface ProcessOptions<T = string> {
-  readonly command: string;
-  args?: T[];
-  options?: {
-    [key: string]: any;
-  };
-}
-
-export interface ForkOptions {
-  readonly modulePath: string;
-  args?: string[];
-  options?: object;
-}
-
-export interface IProcessExitEvent {
-  // Exactly one of code and signal will be set.
-  readonly code?: number;
-  readonly signal?: string;
-}
-
-/**
- * Data emitted when a process has been successfully started.
- */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface IProcessStartEvent {}
-
-/**
- * Data emitted when a process has failed to start.
- */
-export interface ProcessErrorEvent extends Error {
-  /** An errno-like error string (e.g. ENOENT).  */
-  code: string;
-}

package/src/index.ts

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

package/src/node/dev-null-stream.ts

@@ -1,16 +0,0 @@
-import stream = require('stream');
-
-/**
- * A Node stream like `/dev/null`.
- *
- * Writing goes to a black hole, reading returns `EOF`.
- */
-export class DevNullStream extends stream.Duplex {
-  _write(chunk: any, encoding: string, callback: (err?: Error) => void): void {
-    callback();
-  }
-
-  _read(size: number): void {
-    this.push(null);
-  }
-}

package/src/node/index.ts

@@ -1,25 +0,0 @@
-import { Provider, Injectable } from '@opensumi/di';
-import { NodeModule } from '@opensumi/ide-core-node';
-
-import { IProcessManage, processManageServicePath, IProcessFactory } from '../common/';
-
-import { ProcessFactory } from './process';
-import { ProcessManage } from './process-manager';
-
-@Injectable()
-export class ProcessModule extends NodeModule {
-  providers: Provider[] = [
-    { token: IProcessManage, useClass: ProcessManage },
-    { token: IProcessFactory, useClass: ProcessFactory },
-  ];
-
-  backServices = [
-    {
-      servicePath: processManageServicePath,
-      token: IProcessManage,
-    },
-  ];
-}
-
-export * from './process';
-export * from './process-manager';

package/src/node/process-manager.ts

@@ -1,64 +0,0 @@
-import { Injectable } from '@opensumi/di';
-import { Disposable, getDebugLogger, Emitter, Event } from '@opensumi/ide-core-common';
-
-import { IProcessManage } from '../common/index';
-
-import { Process } from './process';
-
-const logger = getDebugLogger();
-
-@Injectable()
-export class ProcessManage extends Disposable implements IProcessManage {
-  protected readonly processes: Map<number, Process>;
-  protected readonly unregisterEmitter: Emitter<number>;
-
-  constructor() {
-    super();
-    this.processes = new Map();
-    this.unregisterEmitter = new Emitter<number>();
-  }
-
-  register(process: Process) {
-    const id = process.pid;
-
-    if (!id) {
-      logger.error('The Process launch failed!');
-      return false;
-    }
-    this.processes.set(id, process);
-    process.onExit(() => this.unregister(process));
-    process.onError(() => this.unregister(process));
-    return true;
-  }
-
-  unregister(process: Process) {
-    const id = process.pid;
-    if (!process.killed) {
-      process.dispose();
-    }
-    if (id && this.processes.delete(id)) {
-      this.unregisterEmitter.fire(id);
-      // logger.log(`The process was successfully unregistered. ${id}`);
-    } else {
-      logger.warn(`This process was not registered or was already unregistered. ${id || ''}`);
-    }
-  }
-
-  get(id: number): Process | undefined {
-    return this.processes.get(id);
-  }
-
-  get onUnregister(): Event<number> {
-    return this.unregisterEmitter.event;
-  }
-
-  dispose() {
-    this.processes.forEach((process, id) => {
-      try {
-        this.unregister(process);
-      } catch (e) {
-        logger.error(`Error occurred when unregistering process. ${id}`, e);
-      }
-    });
-  }
-}

package/src/node/process.ts

@@ -1,134 +0,0 @@
-import { ChildProcess, spawn, fork } from 'child_process';
-import stream from 'stream';
-
-import { Injectable, Autowired } from '@opensumi/di';
-import { Disposable, Emitter } from '@opensumi/ide-core-common';
-
-import {
-  ProcessOptions,
-  ForkOptions,
-  IProcessStartEvent,
-  IProcessExitEvent,
-  ProcessErrorEvent,
-  IProcessManage,
-  IProcess,
-} from '../common/index';
-
-import { DevNullStream } from './dev-null-stream';
-import { ProcessManage } from './process-manager';
-
-@Injectable()
-export class ProcessFactory {
-  constructor() {}
-
-  @Autowired(IProcessManage)
-  private readonly processManage: ProcessManage;
-
-  create(options: ProcessOptions | ForkOptions): IProcess {
-    return new Process(options, this.processManage);
-  }
-}
-
-export class Process extends Disposable implements IProcess {
-  readonly process: ChildProcess | undefined;
-  readonly outputStream: stream.Readable;
-  readonly errorStream: stream.Readable;
-  readonly inputStream: stream.Writable;
-  protected _killed = false;
-
-  protected readonly startEmitter: Emitter<IProcessStartEvent> = new Emitter<IProcessStartEvent>();
-  protected readonly exitEmitter: Emitter<IProcessExitEvent> = new Emitter<IProcessExitEvent>();
-  protected readonly errorEmitter: Emitter<ProcessErrorEvent> = new Emitter<ProcessErrorEvent>();
-
-  constructor(options: ProcessOptions | ForkOptions, readonly processManage: ProcessManage) {
-    super();
-    // About catching errors: spawn will sometimes throw directly
-    // (EACCES on Linux), sometimes return a Process object with the pid
-    // property undefined (ENOENT on Linux) and then emit an 'error' event.
-    // For now, we try to normalize that into always emitting an 'error'
-    // event.
-    try {
-      if (this.isForkOptions(options)) {
-        this.process = fork(options.modulePath, options.args, options.options);
-      } else {
-        this.process = spawn(options.command, options.args, options.options);
-      }
-
-      this.process.on('error', (error: NodeJS.ErrnoException) => {
-        error.code = error.code || 'Unknown error';
-        this.errorEmitter.fire(error as ProcessErrorEvent);
-      });
-      this.process.on('exit', (exitCode: number, signal: string) => {
-        // node's child_process exit sets the unused parameter to null,
-        // but we want it to be undefined instead.
-        this.emitOnExit({
-          code: exitCode !== null ? exitCode : undefined,
-          signal: signal !== null ? signal : undefined,
-        });
-      });
-
-      this.outputStream = this.process.stdout || new DevNullStream();
-      this.inputStream = this.process.stdin || new DevNullStream();
-      this.errorStream = this.process.stderr || new DevNullStream();
-
-      if (this.process.pid !== undefined) {
-        this.processManage.register(this);
-        process.nextTick(this.emitOnStart.bind(this));
-      }
-    } catch (error) {
-      /* When an error is thrown, set up some fake streams, so the client
-         code doesn't break because these field are undefined.  */
-      this.outputStream = new DevNullStream();
-      this.inputStream = new DevNullStream();
-      this.errorStream = new DevNullStream();
-
-      /* Call the client error handler, but first give them a chance to register it.  */
-      process.nextTick(this.emitOnError.bind(this), error);
-    }
-  }
-
-  protected isForkOptions(options: any): options is ForkOptions {
-    return !!options && !!options.modulePath;
-  }
-
-  protected emitOnStart() {
-    this.startEmitter.fire({});
-  }
-
-  protected emitOnError(err: ProcessErrorEvent) {
-    this._killed = true;
-    this.errorEmitter.fire(err);
-  }
-
-  protected emitOnExit(event: IProcessExitEvent) {
-    this._killed = true;
-    this.exitEmitter.fire(event);
-  }
-
-  get pid(): number | null {
-    return this.process ? this.process.pid : null;
-  }
-
-  get onStart() {
-    return this.startEmitter.event;
-  }
-
-  get onExit() {
-    return this.exitEmitter.event;
-  }
-
-  get onError() {
-    return this.errorEmitter.event;
-  }
-
-  get killed() {
-    return this._killed;
-  }
-
-  dispose(signal?: string) {
-    if (this.process && this.killed === false) {
-      // TODO test window is work
-      this.process.kill(signal);
-    }
-  }
-}