(GH-459) Use new DebugAdapterDescriptionFactory API

This commit adds a new Debugging Feature class which is used to create
a DebugAdapterDescriptionFactory.  This factory is responsible for creating
the environment to start the Puppet Language Debug Server e.g. getting the
correct path and environment variables.

Author: glennsarti

src/configuration.ts

@@ -137,6 +137,10 @@ export class ConnectionConfiguration implements IConnectionConfiguration {
     return path.join('vendor', 'languageserver', 'puppet-languageserver');
   }
 
+  get debugServerPath(): string {
+    return path.join('vendor', 'languageserver', 'puppet-debugserver');
+  }
+
   get type(): ConnectionType {
     switch (this.settings.editorService.protocol) {
       case ProtocolType.TCP:

src/extension.ts

@@ -8,6 +8,7 @@ import { ConnectionHandler } from './handler';
 import { StdioConnectionHandler } from './handlers/stdio';
 import { TcpConnectionHandler } from './handlers/tcp';
 import { IFeature } from './feature';
+import { DebuggingFeature } from './feature/DebuggingFeature';
 import { DebugConfigurationFeature } from './feature/DebugConfigurationFeature';
 import { FormatDocumentFeature } from './feature/FormatDocumentFeature';
 import { NodeGraphFeature } from './feature/NodeGraphFeature';
@@ -22,6 +23,7 @@ import { Reporter, reporter } from './telemetry/telemetry';
 
 export const puppetLangID = 'puppet'; // don't change this
 export const puppetFileLangID = 'puppetfile'; // don't change this
+const debugType = 'Puppet';  // don't change this
 
 let extContext: vscode.ExtensionContext;
 let connectionHandler: ConnectionHandler;
@@ -72,7 +74,8 @@ export function activate(context: vscode.ExtensionContext) {
     new FormatDocumentFeature(puppetLangID, connectionHandler, settings, logger, extContext),
     new NodeGraphFeature(puppetLangID, connectionHandler, logger, extContext),
     new PDKFeature(extContext, logger),
-    new PuppetResourceFeature(extContext, connectionHandler, logger)
+    new PuppetResourceFeature(extContext, connectionHandler, logger),
+    new DebuggingFeature(debugType, settings, configSettings, extContext, logger)
   ];
 }
 

src/feature/DebuggingFeature.ts

@@ -0,0 +1,119 @@
+'use strict';
+
+import * as vscode from "vscode";
+import * as cp from 'child_process';
+
+import { IFeature } from "../feature";
+import { ILogger } from "../logging";
+import { CommandEnvironmentHelper } from "../helpers/commandHelper";
+import { IConnectionConfiguration } from '../interfaces';
+import { ISettings } from '../settings';
+
+// Socket vs Exec DebugAdapter types
+// https://github.com/Microsoft/vscode/blob/2808feeaf6b24feaaa6ba49fb91ea165c4d5fb06/src/vs/workbench/parts/debug/node/debugger.ts#L58-L61
+//
+// DebugAdapterExecutable uses stdin/stdout
+// https://github.com/Microsoft/vscode/blob/2808feeaf6b24feaaa6ba49fb91ea165c4d5fb06/src/vs/workbench/parts/debug/node/debugAdapter.ts#L305
+//
+// DebugAdapterServer uses tcp
+// https://github.com/Microsoft/vscode/blob/2808feeaf6b24feaaa6ba49fb91ea165c4d5fb06/src/vs/workbench/parts/debug/node/debugAdapter.ts#L256 
+
+export class DebugAdapterDescriptorFactory implements vscode.DebugAdapterDescriptorFactory, vscode.Disposable {
+  readonly Context: vscode.ExtensionContext;
+  readonly Settings: ISettings;
+  readonly Config: IConnectionConfiguration;
+  readonly Logger: ILogger;
+
+  public ChildProcesses: cp.ChildProcess[] = [];
+
+  constructor(
+    context: vscode.ExtensionContext,
+    settings: ISettings,
+    config: IConnectionConfiguration,
+    logger: ILogger
+  ) {
+    this.Context = context;
+    this.Settings = settings;
+    this.Config = config;
+    this.Logger = logger;
+  }
+
+  public createDebugAdapterDescriptor(session: vscode.DebugSession, executable: vscode.DebugAdapterExecutable): vscode.ProviderResult<vscode.DebugAdapterDescriptor> {
+    // Right now we don't care about session as we only have one type of adapter, which is launch.  When
+    // we add the ability to attach to a debugger remotely we'll need to switch scenarios based on `session`
+    let thisFactory = this;
+
+    return new Promise<vscode.DebugAdapterDescriptor>( function(resolve, reject) {
+      let debugServer = CommandEnvironmentHelper.getDebugServerRubyEnvFromConfiguration(
+        thisFactory.Context.asAbsolutePath(thisFactory.Config.debugServerPath),
+        thisFactory.Settings,
+        thisFactory.Config,
+      );
+  
+      let spawn_options: cp.SpawnOptions = {};
+      spawn_options.env = debugServer.options.env;
+      spawn_options.stdio = 'pipe';
+      if (process.platform !== 'win32') { spawn_options.shell = true; }
+  
+      thisFactory.Logger.verbose("Starting the Debug Server with " + debugServer.command + " " + debugServer.args.join(" "));
+      let debugServerProc = cp.spawn(debugServer.command, debugServer.args, spawn_options);
+      thisFactory.ChildProcesses.push(debugServerProc);
+  
+      let debugSessionRunning: boolean = false;
+      debugServerProc.stdout.on('data', (data) => {
+        thisFactory.Logger.debug("Debug Server STDOUT: " + data.toString());
+        // If the debug client isn't already running and it's sent the trigger text, start up a client
+        if ( !debugSessionRunning && (data.toString().match("DEBUG SERVER RUNNING") !== null) ) {
+          debugSessionRunning = true;
+
+          var p = data.toString().match(/DEBUG SERVER RUNNING (.*):(\d+)/);
+          if (p === null) {
+            reject("Debug Server started but unable to parse hostname and port");
+          } else {
+            thisFactory.Logger.debug("Starting Debug Client connection to " + p[1] + ":" + p[2]);
+            resolve(new vscode.DebugAdapterServer(Number(p[2]), p[1]));
+          }
+        }
+      });
+      debugServerProc.on('error', (data) => {
+        thisFactory.Logger.error("Debug Srver errored with " + data);
+        reject("Spawning Debug Server failed with " + data);
+      });
+      debugServerProc.on('close', (exitCode) => {
+        thisFactory.Logger.verbose("Debug Server exited with exitcode " + exitCode);
+      });
+    });
+  }
+
+  public dispose(): any {
+    this.ChildProcesses.forEach( (item) => {
+      item.kill('SIGHUP');
+    });
+    this.ChildProcesses = [];
+    return undefined;
+  }
+}
+
+export class DebuggingFeature implements IFeature {
+  private factory: DebugAdapterDescriptorFactory;
+
+  constructor(
+    debugType: string,
+    settings: ISettings,
+    config: IConnectionConfiguration,
+    context: vscode.ExtensionContext,
+    logger: ILogger
+  ) {
+    this.factory = new DebugAdapterDescriptorFactory(context, settings, config, logger);
+
+    logger.debug("Registered DebugAdapterDescriptorFactory for " + debugType);
+    context.subscriptions.push(vscode.debug.registerDebugAdapterDescriptorFactory(debugType, this.factory));
+  }
+
+  public dispose(): any {
+    if (this.factory !== null) {
+      this.factory.dispose();
+      this.factory = null;
+    }
+  }
+}

src/helpers/commandHelper.ts

@@ -21,6 +21,20 @@ export class CommandEnvironmentHelper {
     return exe;
   }
 
+  public static getDebugServerRubyEnvFromConfiguration(
+    debugServerpath: string,
+    settings: ISettings,
+    config: IConnectionConfiguration,
+  ): Executable {
+    let exe: Executable = {
+      command: this.buildExecutableCommand(settings, config),
+      args: this.buildDebugServerArguments(debugServerpath),
+      options: {},
+    };
+    this.applyRubyEnvFromConfiguration(exe, settings, config);
+    return exe;
+  }
+
   private static applyRubyEnvFromConfiguration(
     exe: Executable,
     settings: ISettings,
@@ -107,6 +121,22 @@ export class CommandEnvironmentHelper {
     return args;
   }
 
+  private static buildDebugServerArguments(
+    serverPath: string
+  ): string[] {
+    let args = [serverPath];
+
+    // The Debug Adapter always runs on TCP and IPv4 loopback
+    // Using localhost can have issues due to ruby and node differing on what address
+    // to use for localhost e.g Ruby may prefer 127.0.0.1 (IP4) and Node may prefer ::1 (IP6)
+    // and therefore won't connect.
+    args.push('--ip=127.0.0.1');
+
+    // TODO: Add additional command line args e.g. --debuglogfie
+
+    return args;
+  }
+
   private static buildPuppetEnvironment(exe: Executable, config: IConnectionConfiguration) {
     exe.options.env.RUBYOPT = 'rubygems';
     exe.options.env.SSL_CERT_FILE = config.sslCertFile;

src/interfaces.ts

@@ -31,6 +31,7 @@ export interface IConnectionConfiguration {
   puppetBaseDir: string;
   puppetDir: string;
   languageServerPath: string;
+  debugServerPath: string;
   rubydir: string;
   rubylib: string;
   environmentPath: string;