Fixing some issues with debugging

Author: daviwil

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -25,6 +25,7 @@ public class DebugAdapter : DebugAdapterBase
         private EditorSession editorSession;
 
         private bool noDebug;
+        private bool isAttachSession;
         private bool waitingForAttach;
         private string scriptToLaunch;
         private bool ownsEditorSession;
@@ -187,8 +188,12 @@ protected async Task HandleLaunchRequest(
 #endif
             }
 
-            editorSession.PowerShellContext.SetWorkingDirectory(workingDir);
-            Logger.Write(LogLevel.Verbose, "Working dir set to: " + workingDir);
+            // TODO: What's the right approach here?
+            if (this.editorSession.PowerShellContext.CurrentRunspace.Location == RunspaceLocation.Local)
+            {
+                editorSession.PowerShellContext.SetWorkingDirectory(workingDir);
+                Logger.Write(LogLevel.Verbose, "Working dir set to: " + workingDir);
+            }
 
             // Prepare arguments to the script - if specified
             string arguments = null;
@@ -205,6 +210,16 @@ protected async Task HandleLaunchRequest(
 #pragma warning restore 618
             this.arguments = arguments;
 
+            // If the current session is remote, map the script path to the remote
+            // machine if necessary
+            if (this.editorSession.PowerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote)
+            {
+                this.scriptPathToLaunch =
+                    this.editorSession.RemoteFileManager.GetMappedPath(
+                        this.scriptPathToLaunch,
+                        this.editorSession.PowerShellContext.CurrentRunspace);
+            }
+
             await requestContext.SendResult(null);
 
             // If no script is being launched, execute an empty script to
@@ -226,6 +241,8 @@ protected async Task HandleAttachRequest(
             AttachRequestArguments attachParams,
             RequestContext<object> requestContext)
         {
+            this.isAttachSession = true;
+
             // If there are no host processes to attach to or the user cancels selection, we get a null for the process id.
             // This is not an error, just a request to stop the original "attach to" request.
             // Testing against "undefined" is a HACK because I don't know how to make "Cancel" on quick pick loading
@@ -270,8 +287,7 @@ await requestContext.SendError(
                 }
             }
 
-            int processId;
-            if (int.TryParse(attachParams.ProcessId, out processId) && (processId > 0))
+            if (int.TryParse(attachParams.ProcessId, out int processId) && (processId > 0))
             {
                 PowerShellVersionDetails runspaceVersion =
                     this.editorSession.PowerShellContext.CurrentRunspace.PowerShellVersion;
@@ -296,6 +312,10 @@ await requestContext.SendError(
                     return;
                 }
 
+                // Stop the current read loop because the debugger
+                // will start its own
+                //this.editorSession.ConsoleService.CancelReadLoop();
+
                 // Execute the Debug-Runspace command but don't await it because it
                 // will block the debug adapter initialization process.  The
                 // InitializedEvent will be sent as soon as the RunspaceChanged
@@ -327,13 +347,27 @@ protected async Task HandleDisconnectRequest(
         {
             EventHandler<SessionStateChangedEventArgs> handler = null;
 
+            // Define a handler that encapsulates the RequestContext so
+            // that it can be completed once the executed script is
+            // shutting down.
             handler =
                 async (o, e) =>
                 {
                     if (e.NewSessionState == PowerShellContextState.Ready)
                     {
                         await requestContext.SendResult(null);
                         this.editorSession.PowerShellContext.SessionStateChanged -= handler;
+
+                        if (this.isAttachSession)
+                        {
+                            // Start up the read loop again if this is a shared session
+                            if (!this.ownsEditorSession)
+                            {
+                                this.editorSession.ConsoleService.StartReadLoop();
+                            }
+
+                            await this.Stop();
+                        }
                     }
                 };
 
@@ -741,7 +775,10 @@ async void powerShellContext_RunspaceChanged(object sender, RunspaceChangedEvent
                 this.waitingForAttach = false;
                 await this.SendEvent(InitializedEvent.Type, null);
             }
-            else if (e.ChangeAction == RunspaceChangeAction.Exit && this.editorSession.PowerShellContext.IsDebuggerStopped)
+            else if (
+                e.ChangeAction == RunspaceChangeAction.Exit && 
+                (this.editorSession == null ||
+                 this.editorSession.PowerShellContext.IsDebuggerStopped))
             {
                 // Exited the session while the debugger is stopped,
                 // send a ContinuedEvent so that the client changes the

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -78,6 +78,8 @@ public LanguageServer(HostDetails hostDetails, ProfilePaths profilePaths, Channe
                     this.editorSession,
                     this);
 
+            this.editorSession.StartDebugService(this.editorOperations);
+
             // Always send console prompts through the UI in the language service
             // TODO: This will change later once we have a general REPL available
             // in VS Code.

src/PowerShellEditorServices/Console/ConsoleReadLine.cs

@@ -210,13 +210,14 @@ public async Task<string> ReadCommandLine(CancellationToken cancellationToken)
                     {
                         historyIndex = -1;
 
-                        using (RunspaceHandle runspaceHandle = await this.powerShellContext.GetRunspaceHandle())
-                        using (PowerShell powerShell = PowerShell.Create())
-                        {
-                            powerShell.Runspace = runspaceHandle.Runspace;
-                            powerShell.AddCommand("Get-History");
-                            currentHistory = powerShell.Invoke();
-                        }
+                        PSCommand command = new PSCommand();
+                        command.AddCommand("Get-History");
+
+                        currentHistory =
+                            await this.powerShellContext.ExecuteCommand<PSObject>(
+                                command,
+                                false,
+                                false) as Collection<PSObject>;
 
                         if (currentHistory != null)
                         {

src/PowerShellEditorServices/Console/ConsoleService.cs

@@ -119,6 +119,18 @@ public void StartReadLoop()
                     TaskScheduler.Default);
         }
 
+        /// <summary>
+        /// Cancels an active read loop.
+        /// </summary>
+        public void CancelReadLoop()
+        {
+            if (this.readLineCancellationToken != null)
+            {
+                this.readLineCancellationToken.Cancel();
+                this.readLineCancellationToken = null;
+            }
+        }
+
         /// <summary>
         /// Stops the current terminal-based interactive console.
         /// </summary>
@@ -141,6 +153,8 @@ public void StopInteractiveConsole()
         /// <param name="echoToConsole">If true, the input will be echoed to the console.</param>
         public void ExecuteCommand(string inputString, bool echoToConsole)
         {
+            this.CancelReadLoop();
+
             if (this.activePromptHandler != null)
             {
                 if (echoToConsole)
@@ -321,15 +335,6 @@ await this.powerShellContext.ExecuteScriptString(
             while (!cancellationToken.IsCancellationRequested);
         }
 
-        private void CancelReadLoop()
-        {
-            if (this.readLineCancellationToken != null)
-            {
-                this.readLineCancellationToken.Cancel();
-                this.readLineCancellationToken = null;
-            }
-        }
-
         #endregion
 
         #region Events
@@ -427,6 +432,9 @@ private void activePromptHandler_PromptCancelled(object sender, EventArgs e)
 
         private void PowerShellContext_DebuggerStop(object sender, System.Management.Automation.DebuggerStopEventArgs e)
         {
+            // Cancel any existing prompt first
+            this.CancelReadLoop();
+
             this.WriteDebuggerBanner(e);
             this.StartReadLoop();
         }

src/PowerShellEditorServices/Session/EditorSession.cs

@@ -60,6 +60,11 @@ public class EditorSession
         /// </summary>
         public TemplateService TemplateService { get; private set; }
 
+        /// <summary>
+        /// Gets the RemoteFileManager instance for this session.
+        /// </summary>
+        public RemoteFileManager RemoteFileManager { get; private set; }
+
         #endregion
 
         #region Public Methods
@@ -74,12 +79,13 @@ public class EditorSession
         /// <param name="profilePaths">
         /// An object containing the profile paths for the session.
         /// </param>
-        public void StartSession(HostDetails hostDetails, ProfilePaths profilePaths)
+        public void StartSession(
+            HostDetails hostDetails,
+            ProfilePaths profilePaths)
         {
             // Initialize all services
             this.PowerShellContext = new PowerShellContext(hostDetails, profilePaths);
             this.LanguageService = new LanguageService(this.PowerShellContext);
-            this.DebugService = new DebugService(this.PowerShellContext);
             this.ConsoleService = new ConsoleService(this.PowerShellContext);
             this.ExtensionService = new ExtensionService(this.PowerShellContext);
             this.TemplateService = new TemplateService(this.PowerShellContext);
@@ -111,15 +117,28 @@ public void StartDebugSession(
             // Initialize all services
             this.PowerShellContext = new PowerShellContext(hostDetails, profilePaths);
             this.ConsoleService = new ConsoleService(this.PowerShellContext);
-            this.DebugService =
-                new DebugService(
-                    this.PowerShellContext,
-                    new RemoteFileManager(this.PowerShellContext, editorOperations));
+            this.RemoteFileManager = new RemoteFileManager(this.PowerShellContext, editorOperations);
+            this.DebugService = new DebugService(this.PowerShellContext, this.RemoteFileManager);
 
             // Create a workspace to contain open files
             this.Workspace = new Workspace(this.PowerShellContext.LocalPowerShellVersion.Version);
         }
 
+        /// <summary>
+        /// Starts the DebugService if it's not already strated
+        /// </summary>
+        /// <param name="editorOperations">
+        /// An IEditorOperations implementation used to interact with the editor.
+        /// </param>
+        public void StartDebugService(IEditorOperations editorOperations)
+        {
+            if (this.DebugService == null)
+            {
+                this.RemoteFileManager = new RemoteFileManager(this.PowerShellContext, editorOperations);
+                this.DebugService = new DebugService(this.PowerShellContext, this.RemoteFileManager);
+            }
+        }
+
         internal void InstantiateAnalysisService(string settingsPath = null)
         {
             // AnalysisService will throw FileNotFoundException if

src/PowerShellEditorServices/Session/PowerShellContext.cs

@@ -22,6 +22,7 @@ namespace Microsoft.PowerShell.EditorServices
     using System.Management.Automation;
     using System.Management.Automation.Host;
     using System.Management.Automation.Runspaces;
+    using Microsoft.PowerShell.EditorServices.Session.Capabilities;
 
     /// <summary>
     /// Manages the lifetime and usage of a PowerShell session.
@@ -771,10 +772,10 @@ public void AbortExecution()
                 {
                     this.ResumeDebugger(DebuggerResumeAction.Stop);
                 }
-                else
-                {
+                //else
+                //{
                     this.powerShell.BeginStop(null, null);
-                }
+                //}
 
                 this.SessionState = PowerShellContextState.Aborting;
             }
@@ -1499,6 +1500,24 @@ private void OnDebuggerStop(object sender, DebuggerStopEventArgs e)
                     // Notify listeners that the debugger has resumed
                     this.DebuggerResumed?.Invoke(this, e.ResumeAction);
 
+                    // Pop the current RunspaceDetails if we were attached
+                    // to a runspace and the resume action is Stop
+                    if (this.CurrentRunspace.Context == RunspaceContext.DebuggedRunspace &&
+                        e.ResumeAction == DebuggerResumeAction.Stop)
+                    {
+                        this.PopRunspace();
+                    }
+                    else if (e.ResumeAction != DebuggerResumeAction.Stop)
+                    {
+                        // Update the session state
+                        this.OnSessionStateChanged(
+                            this,
+                            new SessionStateChangedEventArgs(
+                                PowerShellContextState.Running,
+                                PowerShellExecutionResult.NotFinished,
+                                null));
+                    }
+
                     break;
                 }
                 else if (taskIndex == 1)

src/PowerShellEditorServices/Session/RunspaceDetails.cs

@@ -193,6 +193,7 @@ internal static RunspaceDetails CreateFromRunspace(
 
             var runspaceId = runspace.InstanceId;
             var runspaceLocation = RunspaceLocation.Local;
+            var runspaceContext = RunspaceContext.Original;
             var versionDetails = PowerShellVersionDetails.GetVersionDetails(runspace);
 
             string connectionString = null;
@@ -207,6 +208,7 @@ internal static RunspaceDetails CreateFromRunspace(
                     if (connectionInfo.ProcessId != null)
                     {
                         connectionString = connectionInfo.ProcessId.ToString();
+                        runspaceContext = RunspaceContext.EnteredProcess;
                     }
                 }
                 catch (RuntimeBinderException)
@@ -234,7 +236,7 @@ internal static RunspaceDetails CreateFromRunspace(
                     sessionDetails,
                     versionDetails,
                     runspaceLocation,
-                    RunspaceContext.Original,
+                    runspaceContext,
                     connectionString);
         }