@opensumi/ide-debug 2.21.6 → 2.21.7-next-1670228715.0

package/src/browser/debug-progress.service.ts

@@ -0,0 +1,122 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Injectable, Autowired } from '@opensumi/di';
+import { Event, IDisposable } from '@opensumi/ide-core-browser';
+import { IProgressService } from '@opensumi/ide-core-browser/lib/progress';
+import { DisposableCollection, IProgress, IProgressStep } from '@opensumi/ide-core-common';
+import { ProgressLocation } from '@opensumi/ide-core-common';
+import { DebugProtocol } from '@opensumi/vscode-debugprotocol';
+
+import { IDebugProgress } from '../common/debug-progress';
+import { DebugState, IDebugSessionManager } from '../common/debug-session';
+
+import { DebugSession } from './debug-session';
+
+@Injectable()
+export class DebugProgressService implements IDebugProgress {
+  static DEBUG_PANEL_PROGRESS_ID = 'debug';
+
+  @Autowired(IProgressService)
+  protected readonly progressService: IProgressService;
+
+  private progressResolve: (() => void) | undefined;
+
+  private toDispose: IDisposable[] = [];
+
+  public async onDebugServiceStateChange(state: DebugState) {
+    if (this.progressResolve) {
+      this.progressResolve();
+      this.progressResolve = undefined;
+    }
+    if (
+      state === DebugState.Initializing &&
+      this.progressService.getIndicator(DebugProgressService.DEBUG_PANEL_PROGRESS_ID)
+    ) {
+      this.progressService.withProgress(
+        { location: DebugProgressService.DEBUG_PANEL_PROGRESS_ID },
+        (_progress) => new Promise<void>((resolve) => (this.progressResolve = resolve)),
+      );
+    }
+  }
+
+  public run(sessionsManager: IDebugSessionManager): void {
+    let progressListener: DisposableCollection | undefined;
+    const listenOnProgress = (session: DebugSession | undefined) => {
+      progressListener = new DisposableCollection();
+
+      if (session) {
+        progressListener?.push(session.onDidChangeState((state: DebugState) => this.onDebugServiceStateChange(state)));
+        progressListener?.push(
+          session.onDidProgressStart(async (progressStartEvent: DebugProtocol.ProgressStartEvent) => {
+            const promise = new Promise<void>((r) => {
+              const listener = Event.any(
+                Event.filter(session.onDidProgressEnd, (e) => e.body.progressId === progressStartEvent.body.progressId),
+                session.onDidExitAdapter as Event<any>,
+              )(() => {
+                listener.dispose();
+                r();
+              });
+            });
+
+            if (this.progressService.getIndicator(DebugProgressService.DEBUG_PANEL_PROGRESS_ID)) {
+              this.progressService.withProgress(
+                { location: DebugProgressService.DEBUG_PANEL_PROGRESS_ID },
+                () => promise,
+              );
+            }
+
+            this.progressService.withProgress(
+              {
+                location: ProgressLocation.Notification,
+                title: progressStartEvent.body.title,
+                cancellable: progressStartEvent.body.cancellable,
+                silent: true,
+                delay: 500,
+              },
+              (progressStep: IProgress<IProgressStep>) => {
+                let total = 0;
+                const reportProgress = (progress: { message?: string; percentage?: number }) => {
+                  let increment: undefined | number;
+                  if (typeof progress.percentage === 'number') {
+                    increment = progress.percentage - total;
+                    total += increment;
+                  }
+                  progressStep.report({
+                    message: progress.message,
+                    increment,
+                    total: typeof increment === 'number' ? 100 : undefined,
+                  });
+                };
+
+                if (progressStartEvent.body.message) {
+                  reportProgress(progressStartEvent.body);
+                }
+
+                const progressUpdateListener = session.onDidProgressUpdate((e) => {
+                  if (e.body.progressId === progressStartEvent.body.progressId) {
+                    reportProgress(e.body);
+                  }
+                });
+
+                return promise.then(() => progressUpdateListener.dispose());
+              },
+              () => session.cancel(progressStartEvent.body.progressId),
+            );
+          }),
+        );
+      }
+    };
+
+    this.toDispose.push(
+      sessionsManager.onDidChangeActiveDebugSession(({ current }) => {
+        if (progressListener) {
+          progressListener.dispose();
+        }
+        listenOnProgress(current);
+      }),
+    );
+    listenOnProgress(sessionsManager.currentSession);
+  }
+}

package/src/browser/debug-schema-updater.ts

@@ -0,0 +1,67 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { objects, IJSONSchema, IJSONSchemaRegistry } from '@opensumi/ide-core-browser';
+
+import { launchSchemaUri } from '../common';
+import { DebugServer, IDebugServer } from '../common/debug-service';
+
+import { DebugConfigurationManager } from './debug-configuration-manager';
+
+const { deepClone } = objects;
+
+@Injectable()
+export class DebugSchemaUpdater {
+  @Autowired(IDebugServer)
+  protected readonly debug: DebugServer;
+
+  @Autowired(IJSONSchemaRegistry)
+  private schemaRegistry: IJSONSchemaRegistry;
+
+  @Autowired(DebugConfigurationManager)
+  private config: DebugConfigurationManager;
+
+  async update(): Promise<void> {
+    const debuggers = this.config.getDebuggers();
+    const schema = { ...deepClone(launchSchema) };
+    const items = schema!.properties!.configurations.items as IJSONSchema;
+    const configurations = debuggers.map((dbg) => ({
+      attributes: Object.keys(dbg.configurationAttributes || {}).map((request) => {
+        const attributes: IJSONSchema = dbg.configurationAttributes[request];
+        return attributes;
+      }),
+      configurationSnippets: dbg.configurationSnippets,
+    }));
+    for (const { attributes, configurationSnippets } of configurations) {
+      if (attributes && items.oneOf) {
+        items.oneOf!.push(...attributes);
+      }
+      if (configurationSnippets && items.defaultSnippets) {
+        items.defaultSnippets.push(...configurationSnippets);
+      }
+    }
+    this.schemaRegistry.registerSchema(`${launchSchemaUri}/extension`, schema, ['launch.json']);
+  }
+}
+
+export const launchSchema: IJSONSchema = {
+  $id: launchSchemaUri,
+  type: 'object',
+  title: 'Launch',
+  required: [],
+  default: { version: '0.2.0', configurations: [] },
+  properties: {
+    version: {
+      type: 'string',
+      description: 'Version of this file format.',
+      default: '0.2.0',
+    },
+    configurations: {
+      type: 'array',
+      description: 'List of configurations. Add new configurations or edit existing ones by using IntelliSense.',
+      items: {
+        defaultSnippets: [],
+        type: 'object',
+        oneOf: [],
+      },
+    },
+  },
+};

package/src/browser/debug-service.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@opensumi/di';
+import { IJSONSchema, Event, Emitter } from '@opensumi/ide-core-browser';
+
+import { IDebugService, IDebugServiceContributionPoint } from '../common';
+
+@Injectable()
+export class DebugService implements IDebugService {
+  private onDidDebugContributionPointChangeEmitter: Emitter<IDebugServiceContributionPoint> =
+    new Emitter<IDebugServiceContributionPoint>();
+
+  private debugContributionPointsMap: Map<string, IJSONSchema[]> = new Map();
+
+  registerDebugContributionPoints(path: string, contributions: IJSONSchema[]) {
+    if (!this.debugContributionPointsMap.has(path)) {
+      this.debugContributionPointsMap.set(path, contributions);
+      this.onDidDebugContributionPointChangeEmitter.fire({
+        path,
+        contributions,
+      });
+    }
+  }
+
+  unregisterDebugContributionPoints(path: string) {
+    const contributions = this.debugContributionPointsMap.get(path);
+    if (contributions) {
+      this.debugContributionPointsMap.delete(path);
+      this.onDidDebugContributionPointChangeEmitter.fire({
+        path,
+        contributions,
+        removed: true,
+      });
+    }
+  }
+
+  get debugContributionPoints() {
+    return this.debugContributionPointsMap;
+  }
+
+  get onDidDebugContributionPointChange(): Event<IDebugServiceContributionPoint> {
+    return this.onDidDebugContributionPointChangeEmitter.event;
+  }
+}

package/src/browser/debug-session-connection.ts

@@ -0,0 +1,331 @@
+import { Injectable, Optional, Autowired } from '@opensumi/di';
+import { IWebSocket } from '@opensumi/ide-connection';
+import {
+  Event,
+  Emitter,
+  DisposableCollection,
+  Disposable,
+  IDisposable,
+  Deferred,
+  getDebugLogger,
+} from '@opensumi/ide-core-browser';
+import { CancellationToken } from '@opensumi/ide-core-common';
+import { OutputChannel } from '@opensumi/ide-output/lib/browser/output.channel';
+import { DebugProtocol } from '@opensumi/vscode-debugprotocol';
+
+import {
+  DebugConfiguration,
+  DebugEventTypes,
+  DebugExitEvent,
+  DebugRequestTypes,
+  DEBUG_REPORT_NAME,
+  getSequenceId,
+  IDebugSessionManager,
+} from '../common';
+
+import { DebugSessionManager } from './debug-session-manager';
+
+export type DebugRequestHandler = (request: DebugProtocol.Request) => any;
+
+const standardDebugEvents = new Set<Required<keyof DebugEventTypes>>([
+  'breakpoint',
+  'capabilities',
+  'continued',
+  'exited',
+  'initialized',
+  'loadedSource',
+  'module',
+  'output',
+  'process',
+  'stopped',
+  'terminated',
+  'thread',
+  'progressStart',
+  'progressUpdate',
+  'progressEnd',
+  'invalidated',
+]);
+
+@Injectable({ multiple: true })
+export class DebugSessionConnection implements IDisposable {
+  @Autowired(IDebugSessionManager)
+  protected readonly manager: DebugSessionManager;
+
+  protected readonly pendingRequests = new Map<number, (response: DebugProtocol.Response) => void>();
+  protected readonly connection: Promise<IWebSocket>;
+
+  protected readonly requestHandlers = new Map<string, DebugRequestHandler>();
+
+  protected readonly onDidCustomEventEmitter = new Emitter<DebugProtocol.Event>();
+  readonly onDidCustomEvent: Event<DebugProtocol.Event> = this.onDidCustomEventEmitter.event;
+
+  protected readonly toDispose = new DisposableCollection(
+    this.onDidCustomEventEmitter,
+    Disposable.create(() => this.pendingRequests.clear()),
+    Disposable.create(() => this.emitters.clear()),
+  );
+
+  constructor(
+    @Optional() readonly sessionId: string,
+    @Optional() protected readonly connectionFactory: (sessionId: string) => Promise<IWebSocket>,
+    @Optional() protected readonly traceOutputChannel: OutputChannel | undefined,
+  ) {
+    this.connection = this.createConnection();
+  }
+
+  get disposed(): boolean {
+    return this.toDispose.disposed;
+  }
+
+  dispose(): void {
+    this.toDispose.dispose();
+  }
+
+  /**
+   * 通过 Connection 模块创建可与 Node 进程通信的链接
+   * @returns IWebSocket
+   */
+  protected async createConnection(): Promise<IWebSocket> {
+    if (this.disposed) {
+      throw new Error('Connection has been already disposed.');
+    } else {
+      const connection = await this.connectionFactory(this.sessionId);
+      connection.onClose((code, reason) => {
+        this.fire('exited', { code, reason });
+      });
+
+      connection.onMessage((data) => this.handleMessage(data));
+
+      this.toDispose.push(
+        Disposable.create(() => {
+          connection.close();
+        }),
+      );
+      return connection;
+    }
+  }
+
+  protected allThreadsContinued = true;
+
+  protected sessionAdapterID: DebugProtocol.InitializeRequestArguments['adapterID'];
+
+  async sendRequest<K extends keyof DebugRequestTypes>(
+    command: K,
+    args: DebugRequestTypes[K][0],
+    configuration: DebugConfiguration,
+    token?: CancellationToken,
+  ): Promise<DebugRequestTypes[K][1]> {
+    /**
+     * 在接收到 initialize 请求的时候记录当前的 session 适配器类型
+     */
+    if (command === 'initialize') {
+      this.sessionAdapterID = (args as DebugProtocol.InitializeRequestArguments).adapterID;
+    }
+
+    const reportDAP = this.manager.reportTime(DEBUG_REPORT_NAME.DEBUG_ADAPTER_PROTOCOL_TIME, {
+      sessionId: this.sessionId,
+      threadId: (args && (args as DebugProtocol.ThreadsArguments).threadId) || this.manager.currentThread?.raw.id,
+    });
+    const result = await this.doSendRequest(command, args, token);
+
+    /*
+     * 对 threads 请求增加 数量 统计
+     */
+    const reportExtra: any = {
+      adapterID: this.sessionAdapterID,
+      request: configuration.request,
+    };
+
+    if (command === 'threads') {
+      reportExtra.amount = (result as DebugProtocol.ThreadsResponse).body.threads.length;
+    }
+
+    reportDAP(command, reportExtra);
+
+    if (
+      command === 'next' ||
+      command === 'stepIn' ||
+      command === 'stepOut' ||
+      command === 'stepBack' ||
+      command === 'reverseContinue' ||
+      command === 'restartFrame'
+    ) {
+      this.fireContinuedEvent((args as any).threadId);
+    }
+    if (command === 'continue') {
+      const response = result as DebugProtocol.ContinueResponse;
+      const allThreadsContinued = response && response.body && response.body.allThreadsContinued;
+      if (allThreadsContinued !== undefined) {
+        this.allThreadsContinued = result.body.allThreadsContinued;
+      }
+      this.fireContinuedEvent((args as any).threadId, this.allThreadsContinued);
+      return result;
+    }
+    return result;
+  }
+
+  async sendCustomRequest<T extends DebugProtocol.Response>(command: string, args?: any): Promise<T> {
+    return (await this.doSendRequest<T>(command, args))?.body;
+  }
+
+  protected async doSendRequest<K extends DebugProtocol.Response>(
+    command: string,
+    args: any = null,
+    token?: CancellationToken,
+  ): Promise<K> {
+    const result = new Deferred<K>();
+
+    const request: DebugProtocol.Request = {
+      seq: getSequenceId(),
+      type: 'request',
+      command,
+    };
+
+    let cancelationListener: IDisposable;
+    if (args && Object.keys(args).length > 0) {
+      request.arguments = args;
+    }
+
+    this.pendingRequests.set(request.seq, (response: any) => {
+      if (cancelationListener) {
+        cancelationListener.dispose();
+      }
+      if (!response.success) {
+        result.reject(response);
+      } else {
+        result.resolve(response);
+      }
+    });
+
+    if (token) {
+      cancelationListener = token.onCancellationRequested(async () => {
+        cancelationListener.dispose();
+        const session = this.manager.getSession(this.sessionId);
+        if (session && session.capabilities.supportsCancelRequest) {
+          session.sendRequest('cancel', {
+            requestId: request.seq,
+          });
+        }
+      });
+    }
+
+    await this.send(request);
+    return result.promise;
+  }
+
+  protected async send(message: DebugProtocol.ProtocolMessage): Promise<void> {
+    const connection = await this.connection;
+    const messageStr = JSON.stringify(message);
+    if (this.traceOutputChannel) {
+      this.traceOutputChannel.appendLine(`${this.sessionId.substring(0, 8)} [UI -> adapter]: ${messageStr}`);
+    }
+    connection.send(messageStr);
+  }
+
+  protected handleMessage(data: string) {
+    if (this.traceOutputChannel) {
+      this.traceOutputChannel.appendLine(`${this.sessionId.substring(0, 8)} [adapter -> UI ]: ${data}`);
+    }
+    const message: DebugProtocol.ProtocolMessage = JSON.parse(data);
+    if (message.type === 'request') {
+      this.handleRequest(message as DebugProtocol.Request);
+    } else if (message.type === 'response') {
+      this.handleResponse(message as DebugProtocol.Response);
+    } else if (message.type === 'event') {
+      this.handleEvent(message as DebugProtocol.Event);
+    }
+  }
+
+  protected handleResponse(response: DebugProtocol.Response): void {
+    const callback = this.pendingRequests.get(response.request_seq);
+    if (callback) {
+      this.pendingRequests.delete(response.request_seq);
+      callback(response);
+    }
+  }
+
+  onRequest(command: string, handler: DebugRequestHandler): void {
+    this.requestHandlers.set(command, handler);
+  }
+
+  protected async handleRequest(request: DebugProtocol.Request): Promise<void> {
+    const response: DebugProtocol.Response = {
+      type: 'response',
+      seq: getSequenceId(),
+      command: request.command,
+      request_seq: request.seq,
+      success: true,
+    };
+    const handler = this.requestHandlers.get(request.command);
+    if (handler) {
+      try {
+        response.body = handler(request);
+      } catch (error) {
+        response.success = false;
+        response.message = error.message;
+      }
+    } else {
+      getDebugLogger().error('Unhandled request', request);
+    }
+    await this.send(response);
+  }
+
+  protected handleEvent(event: DebugProtocol.Event): void {
+    if ('event' in event) {
+      if (event.event === 'continued') {
+        this.allThreadsContinued =
+          (event as DebugProtocol.ContinuedEvent).body.allThreadsContinued === false ? false : true;
+      }
+      if (standardDebugEvents.has(event.event as keyof DebugEventTypes)) {
+        this.doFire(event.event, event);
+      } else {
+        this.onDidCustomEventEmitter.fire(event);
+      }
+    } else {
+      this.fire('exited', event as DebugEventTypes['exited']);
+    }
+  }
+
+  protected readonly emitters = new Map<string, Emitter<DebugProtocol.Event | DebugExitEvent>>();
+  on<K extends keyof DebugEventTypes>(kind: K, listener: (e: DebugEventTypes[K]) => any): IDisposable {
+    if (this.disposed) {
+      return Disposable.create(() => {});
+    }
+    return this.getEmitter(kind).event(listener);
+  }
+
+  public fire<K extends keyof DebugEventTypes>(kind: K, e: DebugEventTypes[K]): void {
+    this.doFire(kind, e);
+  }
+
+  protected doFire(kind: string, e: DebugProtocol.Event | DebugExitEvent): void {
+    if (this.disposed) {
+      return;
+    }
+    this.getEmitter(kind).fire(e);
+  }
+
+  protected getEmitter(kind: string): Emitter<DebugProtocol.Event | DebugExitEvent> {
+    const emitter = this.emitters.get(kind) || this.newEmitter();
+    this.emitters.set(kind, emitter);
+    return emitter;
+  }
+
+  protected newEmitter(): Emitter<DebugProtocol.Event | DebugExitEvent> {
+    const emitter = new Emitter<DebugProtocol.Event | DebugExitEvent>();
+    this.toDispose.push(emitter);
+    return emitter;
+  }
+
+  protected fireContinuedEvent(threadId: number, allThreadsContinued = false): void {
+    this.fire('continued', {
+      type: 'event',
+      event: 'continued',
+      body: {
+        threadId,
+        allThreadsContinued,
+      },
+      seq: getSequenceId(),
+    });
+  }
+}

package/src/browser/debug-session-contribution.ts

@@ -0,0 +1,57 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { ContributionProvider } from '@opensumi/ide-core-browser';
+
+import { DebugSessionOptions } from '../common';
+
+import { DebugSession } from './debug-session';
+
+export const DebugSessionContribution = Symbol('DebugSessionContribution');
+
+export interface DebugSessionContribution {
+  /**
+   * 调试类型，如node2
+   */
+  debugType: string;
+
+  /**
+   * 生成DebugSession的工厂函数.
+   */
+  debugSessionFactory(): DebugSessionFactory;
+}
+
+export const DebugSessionContributionRegistry = Symbol('DebugSessionContributionRegistry');
+
+export interface DebugSessionContributionRegistry {
+  get(debugType: string): DebugSessionContribution | undefined;
+}
+
+@Injectable()
+export class DebugSessionContributionRegistryImpl implements DebugSessionContributionRegistry {
+  protected readonly contribs = new Map<string, DebugSessionContribution>();
+
+  @Autowired(DebugSessionContribution)
+  protected readonly contributions: ContributionProvider<DebugSessionContribution>;
+
+  constructor() {
+    this.init();
+  }
+
+  protected init(): void {
+    for (const contrib of this.contributions.getContributions()) {
+      this.contribs.set(contrib.debugType, contrib);
+    }
+  }
+
+  get(debugType: string): DebugSessionContribution | undefined {
+    return this.contribs.get(debugType);
+  }
+}
+
+export const DebugSessionFactory = Symbol('DebugSessionFactory');
+
+/**
+ * 生成DebugSession的工厂函数.
+ */
+export interface DebugSessionFactory {
+  get(sessionId: string, options: DebugSessionOptions): DebugSession;
+}