Merge pull request #1532 from PowerShell/andschwa/debugger

Make `ExecuteCommandAsync` cancellable

Author: andyleejordan

src/PowerShellEditorServices/Server/PsesDebugServer.cs

@@ -137,6 +137,7 @@ public async Task StartAsync()
         public void Dispose()
         {
             _powerShellContextService.IsDebugServerActive = false;
+            // TODO: If the debugger has stopped, should we clear the breakpoints?
             _debugAdapterServer.Dispose();
             _inputStream.Dispose();
             _outputStream.Dispose();

src/PowerShellEditorServices/Services/DebugAdapter/BreakpointService.cs

@@ -135,7 +135,8 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc
                 IEnumerable<Breakpoint> setBreakpoints =
                     await _powerShellContextService.ExecuteCommandAsync<Breakpoint>(psCommand).ConfigureAwait(false);
                 configuredBreakpoints.AddRange(
-                    setBreakpoints.Select(BreakpointDetails.Create));
+                    setBreakpoints.Select((breakpoint) => BreakpointDetails.Create(breakpoint))
+                );
             }
 
             return configuredBreakpoints;

src/PowerShellEditorServices/Services/DebugAdapter/DebugEventHandlerService.cs

@@ -81,6 +81,7 @@ e.OriginalEvent.Breakpoints[0] is CommandBreakpoint
                 new StoppedEvent
                 {
                     ThreadId = 1,
+                    AllThreadsStopped = true,
                     Reason = debuggerStoppedReason
                 });
         }
@@ -117,59 +118,47 @@ private void PowerShellContext_DebuggerResumed(object sender, DebuggerResumeActi
             _debugAdapterServer.SendNotification(EventNames.Continued,
                 new ContinuedEvent
                 {
-                    AllThreadsContinued = true,
-                    ThreadId = 1
+                    ThreadId = 1,
+                    AllThreadsContinued = true
                 });
         }
 
         private void DebugService_BreakpointUpdated(object sender, BreakpointUpdatedEventArgs e)
         {
-            string reason = "changed";
-
+            // Don't send breakpoint update notifications when setting
+            // breakpoints on behalf of the client.
             if (_debugStateService.IsSetBreakpointInProgress)
             {
-                // Don't send breakpoint update notifications when setting
-                // breakpoints on behalf of the client.
                 return;
             }
 
-            switch (e.UpdateType)
-            {
-                case BreakpointUpdateType.Set:
-                    reason = "new";
-                    break;
-
-                case BreakpointUpdateType.Removed:
-                    reason = "removed";
-                    break;
-            }
-
-            var breakpoint = new OmniSharp.Extensions.DebugAdapter.Protocol.Models.Breakpoint
-            {
-                Verified = e.UpdateType != BreakpointUpdateType.Disabled
-            };
-
             if (e.Breakpoint is LineBreakpoint)
             {
-                breakpoint = LspDebugUtils.CreateBreakpoint(BreakpointDetails.Create(e.Breakpoint));
+                var breakpoint = LspDebugUtils.CreateBreakpoint(
+                    BreakpointDetails.Create(e.Breakpoint, e.UpdateType)
+                );
+
+                string reason = (e.UpdateType) switch {
+                    BreakpointUpdateType.Set => BreakpointEventReason.New,
+                    BreakpointUpdateType.Removed => BreakpointEventReason.Removed,
+                    BreakpointUpdateType.Enabled => BreakpointEventReason.Changed,
+                    BreakpointUpdateType.Disabled => BreakpointEventReason.Changed,
+                    _ => "InvalidBreakpointUpdateTypeEnum"
+                };
+
+                _debugAdapterServer.SendNotification(
+                    EventNames.Breakpoint,
+                    new BreakpointEvent { Breakpoint = breakpoint, Reason = reason }
+                );
             }
             else if (e.Breakpoint is CommandBreakpoint)
             {
                 _logger.LogTrace("Function breakpoint updated event is not supported yet");
-                return;
             }
             else
             {
                 _logger.LogError($"Unrecognized breakpoint type {e.Breakpoint.GetType().FullName}");
-                return;
             }
-
-            _debugAdapterServer.SendNotification(EventNames.Breakpoint,
-                new BreakpointEvent
-                {
-                    Reason = reason,
-                    Breakpoint = breakpoint
-                });
         }
 
         #endregion

src/PowerShellEditorServices/Services/DebugAdapter/Debugging/BreakpointDetails.cs

@@ -77,8 +77,11 @@ internal static BreakpointDetails Create(
         /// PowerShell Breakpoint object.
         /// </summary>
         /// <param name="breakpoint">The Breakpoint instance from which details will be taken.</param>
+        /// <param name="updateType">The BreakpointUpdateType to determine if the breakpoint is verified.</param>
         /// <returns>A new instance of the BreakpointDetails class.</returns>
-        internal static BreakpointDetails Create(Breakpoint breakpoint)
+        internal static BreakpointDetails Create(
+            Breakpoint breakpoint,
+            BreakpointUpdateType updateType = BreakpointUpdateType.Set)
         {
             Validate.IsNotNull("breakpoint", breakpoint);
 
@@ -91,7 +94,7 @@ internal static BreakpointDetails Create(Breakpoint breakpoint)
             var breakpointDetails = new BreakpointDetails
             {
                 Id = breakpoint.Id,
-                Verified = true,
+                Verified = updateType != BreakpointUpdateType.Disabled,
                 Source = lineBreakpoint.Script,
                 LineNumber = lineBreakpoint.Line,
                 ColumnNumber = lineBreakpoint.Column,

src/PowerShellEditorServices/Services/DebugAdapter/Handlers/LaunchAndAttachHandler.cs

@@ -303,11 +303,13 @@ await _powerShellContextService.ExecuteScriptStringAsync(
             string debugRunspaceCmd;
             if (request.RunspaceName != null)
             {
-                IEnumerable<int?> ids = await _powerShellContextService.ExecuteCommandAsync<int?>(new PSCommand()
-                    .AddCommand("Microsoft.PowerShell.Utility\\Get-Runspace")
-                    .AddParameter("Name", request.RunspaceName)
-                    .AddCommand("Microsoft.PowerShell.Utility\\Select-Object")
-                    .AddParameter("ExpandProperty", "Id")).ConfigureAwait(false);
+                IEnumerable<int?> ids = await _powerShellContextService.ExecuteCommandAsync<int?>(
+                    new PSCommand()
+                        .AddCommand("Microsoft.PowerShell.Utility\\Get-Runspace")
+                        .AddParameter("Name", request.RunspaceName)
+                        .AddCommand("Microsoft.PowerShell.Utility\\Select-Object")
+                        .AddParameter("ExpandProperty", "Id"), cancellationToken: cancellationToken).ConfigureAwait(false);
+
                 foreach (var id in ids)
                 {
                     _debugStateService.RunspaceId = id;

src/PowerShellEditorServices/Services/DebugAdapter/Handlers/ThreadsHandler.cs

@@ -20,7 +20,7 @@ public Task<ThreadsResponse> Handle(ThreadsArguments request, CancellationToken
             {
                 // TODO: OmniSharp supports multithreaded debugging (where
                 // multiple threads can be debugged at once), but we don't. This
-                // means we always need to set AllThreadsStoppped and
+                // means we always need to set AllThreadsStopped and
                 // AllThreadsContinued in our events. But if we one day support
                 // multithreaded debugging, we'd need a way to associate
                 // debugged runspaces with .NET threads in a consistent way.

src/PowerShellEditorServices/Services/PowerShellContext/Console/ConsoleReadLine.cs

@@ -208,9 +208,8 @@ internal async Task<string> InvokeLegacyReadLineAsync(bool isCommandLine, Cancel
                                 command.AddParameter("CursorColumn", currentCursorIndex);
                                 command.AddParameter("Options", null);
 
-                                var results = await this.powerShellContext
-                                    .ExecuteCommandAsync<CommandCompletion>(command, sendOutputToHost: false, sendErrorToHost: false)
-                                    .ConfigureAwait(false);
+                                var results = await this.powerShellContext.ExecuteCommandAsync<CommandCompletion>(
+                                    command, sendOutputToHost: false, sendErrorToHost: false, cancellationToken).ConfigureAwait(false);
 
                                 currentCompletion = results.FirstOrDefault();
                             }
@@ -327,8 +326,8 @@ internal async Task<string> InvokeLegacyReadLineAsync(bool isCommandLine, Cancel
                             PSCommand command = new PSCommand();
                             command.AddCommand("Get-History");
 
-                            currentHistory = await this.powerShellContext.ExecuteCommandAsync<PSObject>(command, sendOutputToHost: false, sendErrorToHost: false)
-                                .ConfigureAwait(false)
+                            currentHistory = await this.powerShellContext.ExecuteCommandAsync<PSObject>(
+                                command, sendOutputToHost: false, sendErrorToHost: false, cancellationToken).ConfigureAwait(false)
                                 as Collection<PSObject>;
 
                             if (currentHistory != null)

src/PowerShellEditorServices/Services/PowerShellContext/Handlers/ExpandAliasHandler.cs

@@ -69,7 +69,8 @@ function __Expand-Alias {
                 .AddStatement()
                 .AddCommand("__Expand-Alias")
                 .AddArgument(request.Text);
-            var result = await _powerShellContextService.ExecuteCommandAsync<string>(psCommand).ConfigureAwait(false);
+            var result = await _powerShellContextService.ExecuteCommandAsync<string>(
+                psCommand, cancellationToken: cancellationToken).ConfigureAwait(false);
 
             return new ExpandAliasResult
             {

src/PowerShellEditorServices/Services/PowerShellContext/Handlers/GetCommandHandler.cs

@@ -53,7 +53,8 @@ public async Task<List<PSCommandMessage>> Handle(GetCommandParams request, Cance
                 .AddCommand("Microsoft.PowerShell.Utility\\Sort-Object")
                     .AddParameter("Property", "Name");
 
-            IEnumerable<CommandInfo> result = await _powerShellContextService.ExecuteCommandAsync<CommandInfo>(psCommand).ConfigureAwait(false);
+            IEnumerable<CommandInfo> result = await _powerShellContextService.ExecuteCommandAsync<CommandInfo>(
+                psCommand, cancellationToken: cancellationToken).ConfigureAwait(false);
 
             var commandList = new List<PSCommandMessage>();
             if (result != null)

src/PowerShellEditorServices/Services/PowerShellContext/Handlers/PSHostProcessAndRunspaceHandlers.cs

@@ -87,7 +87,8 @@ public async Task<RunspaceResponse[]> Handle(GetRunspaceParams request, Cancella
                 var psCommand = new PSCommand().AddCommand("Microsoft.PowerShell.Utility\\Get-Runspace");
                 var sb = new StringBuilder();
                 // returns (not deserialized) Runspaces. For simpler code, we use PSObject and rely on dynamic later.
-                runspaces = await _powerShellContextService.ExecuteCommandAsync<PSObject>(psCommand, sb).ConfigureAwait(false);
+                runspaces = await _powerShellContextService.ExecuteCommandAsync<PSObject>(
+                    psCommand, sb, cancellationToken: cancellationToken).ConfigureAwait(false);
             }
 
             var runspaceResponses = new List<RunspaceResponse>();