Check if experimental debugger is used and prompt to repair (microsoft#2482)

* Check if experimental debugger is used and prompt to repair * Touch up Markdown in news entry * Fix code review comments * Fix formatting * Fix tests

Author: DonJayamanne

news/2 Fixes/2478.md

@@ -0,0 +1 @@
+Upgrade `pythonExperimental` to `python` in `launch.json`.

src/client/application/diagnostics/applicationDiagnostics.ts

@@ -9,19 +9,20 @@ import { STANDARD_OUTPUT_CHANNEL } from '../../common/constants';
 import { ILogger, IOutputChannel } from '../../common/types';
 import { IServiceContainer } from '../../ioc/types';
 import { IApplicationDiagnostics } from '../types';
-import { EnvironmentPathVariableDiagnosticsServiceId } from './checks/envPathVariable';
 import { IDiagnostic, IDiagnosticsService } from './types';
 
 @injectable()
 export class ApplicationDiagnostics implements IApplicationDiagnostics {
  constructor(@inject(IServiceContainer) private readonly serviceContainer: IServiceContainer) { }
  public async performPreStartupHealthCheck(): Promise<void> {
- const envHealthCheck = this.serviceContainer.get<IDiagnosticsService>(IDiagnosticsService, EnvironmentPathVariableDiagnosticsServiceId);
- const diagnostics = await envHealthCheck.diagnose();
- this.log(diagnostics);
- if (diagnostics.length > 0) {
- await envHealthCheck.handle(diagnostics);
- }
+ const diagnosticsServices = this.serviceContainer.getAll<IDiagnosticsService>(IDiagnosticsService);
+ await Promise.all(diagnosticsServices.map(async diagnosticsService => {
+ const diagnostics = await diagnosticsService.diagnose();
+ this.log(diagnostics);
+ if (diagnostics.length > 0) {
+ await diagnosticsService.handle(diagnostics);
+ }
+ }));
  }
  private log(diagnostics: IDiagnostic[]): void {
  const logger = this.serviceContainer.get<ILogger>(ILogger);

src/client/application/diagnostics/checks/invalidDebuggerType.ts

@@ -0,0 +1,115 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import * as path from 'path';
+import { DiagnosticSeverity, WorkspaceFolder } from 'vscode';
+import { ICommandManager, IWorkspaceService } from '../../../common/application/types';
+import '../../../common/extensions';
+import { IFileSystem } from '../../../common/platform/types';
+import { IServiceContainer } from '../../../ioc/types';
+import { BaseDiagnostic, BaseDiagnosticsService } from '../base';
+import { IDiagnosticsCommandFactory } from '../commands/types';
+import { DiagnosticCodes } from '../constants';
+import { DiagnosticCommandPromptHandlerServiceId, MessageCommandPrompt } from '../promptHandler';
+import { DiagnosticScope, IDiagnostic, IDiagnosticHandlerService } from '../types';
+
+const InvalidDebuggerTypeMessage = 'Your launch.json file needs to be updated to change the "pythonExperimental" debug ' +
+ 'configurations to use the "python" debugger type, otherwise Python debugging may ' +
+ 'not work. Would you like to automatically update your launch.json file now?';
+
+export class InvalidDebuggerTypeDiagnostic extends BaseDiagnostic {
+ constructor(message) {
+ super(DiagnosticCodes.InvalidDebuggerTypeDiagnostic,
+ message, DiagnosticSeverity.Error, DiagnosticScope.WorkspaceFolder);
+ }
+}
+
+export const InvalidDebuggerTypeDiagnosticsServiceId = 'InvalidDebuggerTypeDiagnosticsServiceId';
+
+const CommandName = 'python.debugger.replaceExperimental';
+
+@injectable()
+export class InvalidDebuggerTypeDiagnosticsService extends BaseDiagnosticsService {
+ protected readonly messageService: IDiagnosticHandlerService<MessageCommandPrompt>;
+ protected readonly fs: IFileSystem;
+ constructor(@inject(IServiceContainer) serviceContainer: IServiceContainer) {
+ super([DiagnosticCodes.InvalidEnvironmentPathVariableDiagnostic], serviceContainer);
+ this.messageService = serviceContainer.get<IDiagnosticHandlerService<MessageCommandPrompt>>(IDiagnosticHandlerService, DiagnosticCommandPromptHandlerServiceId);
+ const cmdManager = serviceContainer.get<ICommandManager>(ICommandManager);
+ this.fs = this.serviceContainer.get<IFileSystem>(IFileSystem);
+ cmdManager.registerCommand(CommandName, this.fixLaunchJson, this);
+ }
+ public async diagnose(): Promise<IDiagnostic[]> {
+ if (await this.isExperimentalDebuggerUsed()) {
+ return [new InvalidDebuggerTypeDiagnostic(InvalidDebuggerTypeMessage)];
+ } else {
+ return [];
+ }
+ }
+ public async handle(diagnostics: IDiagnostic[]): Promise<void> {
+ // This class can only handle one type of diagnostic, hence just use first item in list.
+ if (diagnostics.length === 0 || !this.canHandle(diagnostics[0])) {
+ return;
+ }
+ const diagnostic = diagnostics[0];
+ const commandFactory = this.serviceContainer.get<IDiagnosticsCommandFactory>(IDiagnosticsCommandFactory);
+ const options = [
+ {
+ prompt: 'Yes, update launch.json',
+ command: commandFactory.createCommand(diagnostic, { type: 'executeVSCCommand', options: 'python.debugger.replaceExperimental' })
+ },
+ {
+ prompt: 'No, I will do it later'
+ }
+ ];
+
+ await this.messageService.handle(diagnostic, { commandPrompts: options });
+ }
+ private async isExperimentalDebuggerUsed() {
+ const workspaceService = this.serviceContainer.get<IWorkspaceService>(IWorkspaceService);
+ if (!workspaceService.hasWorkspaceFolders) {
+ return false;
+ }
+
+ const results = await Promise.all(workspaceService.workspaceFolders!.map(workspaceFolder => this.isExperimentalDebuggerUsedInWorkspace(workspaceFolder)));
+ return results.filter(used => used === true).length > 0;
+ }
+ private getLaunchJsonFile(workspaceFolder: WorkspaceFolder) {
+ return path.join(workspaceFolder.uri.fsPath, '.vscode', 'launch.json');
+ }
+ private async isExperimentalDebuggerUsedInWorkspace(workspaceFolder: WorkspaceFolder) {
+ const launchJson = this.getLaunchJsonFile(workspaceFolder);
+ if (!await this.fs.fileExists(launchJson)) {
+ return false;
+ }
+
+ const fileContents = await this.fs.readFile(launchJson);
+ return fileContents.indexOf('"pythonExperimental"') > 0;
+ }
+ private async fixLaunchJson() {
+ const workspaceService = this.serviceContainer.get<IWorkspaceService>(IWorkspaceService);
+ if (!workspaceService.hasWorkspaceFolders) {
+ return false;
+ }
+
+ await Promise.all(workspaceService.workspaceFolders!.map(workspaceFolder => this.fixLaunchJsonInWorkspace(workspaceFolder)));
+ }
+ private async fixLaunchJsonInWorkspace(workspaceFolder: WorkspaceFolder) {
+ if (!await this.isExperimentalDebuggerUsedInWorkspace(workspaceFolder)) {
+ return;
+ }
+
+ const launchJson = this.getLaunchJsonFile(workspaceFolder);
+ let fileContents = await this.fs.readFile(launchJson);
+ const debuggerType = new RegExp('"pythonExperimental"', 'g');
+ const debuggerLabel = new RegExp('"Python Experimental:', 'g');
+
+ fileContents = fileContents.replace(debuggerType, '"python"');
+ fileContents = fileContents.replace(debuggerLabel, '"Python:');
+
+ await this.fs.writeFile(launchJson, fileContents);
+ }
+}

src/client/application/diagnostics/commands/execVSCCommand.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { ICommandManager } from '../../../common/application/types';
+import { IServiceContainer } from '../../../ioc/types';
+import { IDiagnostic } from '../types';
+import { BaseDiagnosticCommand } from './base';
+
+export class ExecuteVSCCommand extends BaseDiagnosticCommand {
+ constructor(diagnostic: IDiagnostic, private serviceContainer: IServiceContainer, private commandName: string) {
+ super(diagnostic);
+ }
+ public async invoke(): Promise<void> {
+ const cmdManager = this.serviceContainer.get<ICommandManager>(ICommandManager);
+ return cmdManager.executeCommand(this.commandName).then(() => undefined);
+ }
+}

src/client/application/diagnostics/commands/factory.ts

@@ -6,6 +6,7 @@
 import { inject, injectable } from 'inversify';
 import { IServiceContainer } from '../../../ioc/types';
 import { IDiagnostic, IDiagnosticCommand } from '../types';
+import { ExecuteVSCCommand } from './execVSCCommand';
 import { IgnoreDiagnosticCommand } from './ignore';
 import { LaunchBrowserCommand } from './launchBrowser';
 import { CommandOptions, IDiagnosticsCommandFactory } from './types';
@@ -22,6 +23,9 @@ export class DiagnosticsCommandFactory implements IDiagnosticsCommandFactory {
  case 'launch': {
  return new LaunchBrowserCommand(diagnostic, this.serviceContainer, options.options);
  }
+ case 'executeVSCCommand': {
+ return new ExecuteVSCCommand(diagnostic, this.serviceContainer, options.options);
+ }
  default: {
  throw new Error(`Unknown Diagnostic command commandType '${commandType}'`);
  }

src/client/application/diagnostics/commands/types.ts

@@ -8,7 +8,8 @@ import { DiagnosticScope, IDiagnostic, IDiagnosticCommand } from '../types';
 export type CommandOption<Type, Option> = { type: Type; options: Option };
 export type LaunchBrowserOption = CommandOption<'launch', string>;
 export type IgnoreDiagnostOption = CommandOption<'ignore', DiagnosticScope>;
-export type CommandOptions = LaunchBrowserOption | IgnoreDiagnostOption;
+export type ExecuteVSCCommandOption = CommandOption<'executeVSCCommand', string>;
+export type CommandOptions = LaunchBrowserOption | IgnoreDiagnostOption | ExecuteVSCCommandOption;
 
 export const IDiagnosticsCommandFactory = Symbol('IDiagnosticsCommandFactory');
 

src/client/application/diagnostics/constants.ts

@@ -4,5 +4,6 @@
 'use strict';
 
 export enum DiagnosticCodes {
- InvalidEnvironmentPathVariableDiagnostic = 'InvalidEnvironmentPathVariableDiagnostic'
+ InvalidEnvironmentPathVariableDiagnostic = 'InvalidEnvironmentPathVariableDiagnostic',
+ InvalidDebuggerTypeDiagnostic = 'InvalidDebuggerTypeDiagnostic'
 }

src/client/application/diagnostics/serviceRegistry.ts

@@ -5,6 +5,7 @@
 
 import { IServiceManager } from '../../ioc/types';
 import { EnvironmentPathVariableDiagnosticsService, EnvironmentPathVariableDiagnosticsServiceId } from './checks/envPathVariable';
+import { InvalidDebuggerTypeDiagnosticsService, InvalidDebuggerTypeDiagnosticsServiceId } from './checks/invalidDebuggerType';
 import { DiagnosticsCommandFactory } from './commands/factory';
 import { IDiagnosticsCommandFactory } from './commands/types';
 import { DiagnosticFilterService } from './filter';
@@ -15,5 +16,6 @@ export function registerTypes(serviceManager: IServiceManager) {
  serviceManager.addSingleton<IDiagnosticFilterService>(IDiagnosticFilterService, DiagnosticFilterService);
  serviceManager.addSingleton<IDiagnosticHandlerService<MessageCommandPrompt>>(IDiagnosticHandlerService, DiagnosticCommandPromptHandlerService, DiagnosticCommandPromptHandlerServiceId);
  serviceManager.addSingleton<IDiagnosticsService>(IDiagnosticsService, EnvironmentPathVariableDiagnosticsService, EnvironmentPathVariableDiagnosticsServiceId);
+ serviceManager.addSingleton<IDiagnosticsService>(IDiagnosticsService, InvalidDebuggerTypeDiagnosticsService, InvalidDebuggerTypeDiagnosticsServiceId);
  serviceManager.addSingleton<IDiagnosticsCommandFactory>(IDiagnosticsCommandFactory, DiagnosticsCommandFactory);
 }

src/client/common/platform/fileSystem.ts

@@ -168,4 +168,8 @@ export class FileSystem implements IFileSystem {
  });
  });
  }
+
+ public writeFile(filePath: string, data: {}): Promise<void> {
+ return fs.writeFile(filePath, data);
+ }
 }

src/client/common/platform/types.ts

@@ -78,6 +78,7 @@ export interface IFileSystem {
  getSubDirectories(rootDir: string): Promise<string[]>;
  arePathsSame(path1: string, path2: string): boolean;
  readFile(filePath: string): Promise<string>;
+ writeFile(filePath: string, data: {}): Promise<void>;
  appendFileSync(filename: string, data: {}, encoding: string): void;
  appendFileSync(filename: string, data: {}, options?: { encoding?: string; mode?: number; flag?: string }): void;
  // tslint:disable-next-line:unified-signatures