Make ExecuteCommandAsync cancellable

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>();

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

@@ -72,7 +72,8 @@ public async Task<Unit> Handle(ShowHelpParams request, CancellationToken cancell
 
             // TODO: Rather than print the help in the console, we should send the string back
             //       to VSCode to display in a help pop-up (or similar)
-            await _powerShellContextService.ExecuteCommandAsync<PSObject>(checkHelpPSCommand, sendOutputToHost: true).ConfigureAwait(false);
+            await _powerShellContextService.ExecuteCommandAsync<PSObject>(
+                checkHelpPSCommand, sendOutputToHost: true, cancellationToken: cancellationToken).ConfigureAwait(false);
             return Unit.Value;
         }
     }

src/PowerShellEditorServices/Services/PowerShellContext/PowerShellContextService.cs

@@ -519,9 +519,11 @@ public Task<RunspaceHandle> GetRunspaceHandleAsync(CancellationToken cancellatio
         public Task<IEnumerable<TResult>> ExecuteCommandAsync<TResult>(
             PSCommand psCommand,
             bool sendOutputToHost = false,
-            bool sendErrorToHost = true)
+            bool sendErrorToHost = true,
+            CancellationToken cancellationToken = default)
         {
-            return ExecuteCommandAsync<TResult>(psCommand, errorMessages: null, sendOutputToHost, sendErrorToHost);
+            return this.ExecuteCommandAsync<TResult>(
+                psCommand, errorMessages: null, sendOutputToHost, sendErrorToHost, cancellationToken: cancellationToken);
         }
 
         /// <summary>
@@ -549,7 +551,8 @@ public Task<IEnumerable<TResult>> ExecuteCommandAsync<TResult>(
             StringBuilder errorMessages,
             bool sendOutputToHost = false,
             bool sendErrorToHost = true,
-            bool addToHistory = false)
+            bool addToHistory = false,
+            CancellationToken cancellationToken = default)
         {
             return
                 this.ExecuteCommandAsync<TResult>(
@@ -560,7 +563,8 @@ public Task<IEnumerable<TResult>> ExecuteCommandAsync<TResult>(
                         WriteOutputToHost = sendOutputToHost,
                         WriteErrorsToHost = sendErrorToHost,
                         AddToHistory = addToHistory
-                    });
+                    },
+                    cancellationToken);
         }
 
 
@@ -581,7 +585,8 @@ public Task<IEnumerable<TResult>> ExecuteCommandAsync<TResult>(
         public async Task<IEnumerable<TResult>> ExecuteCommandAsync<TResult>(
             PSCommand psCommand,
             StringBuilder errorMessages,
-            ExecutionOptions executionOptions)
+            ExecutionOptions executionOptions,
+            CancellationToken cancellationToken = default)
         {
             Validate.IsNotNull(nameof(psCommand), psCommand);
             Validate.IsNotNull(nameof(executionOptions), executionOptions);
@@ -759,8 +764,11 @@ public async Task<IEnumerable<TResult>> ExecuteCommandAsync<TResult>(
                         return shell.Invoke<TResult>(null, invocationSettings);
                     }
 
-                    // May need a cancellation token here
-                    return await Task.Run<IEnumerable<TResult>>(() => shell.Invoke<TResult>(input: null, invocationSettings), CancellationToken.None).ConfigureAwait(false);
+                    // This is the primary reason that ExecuteCommandAsync takes a CancellationToken
+                    cancellationToken.Register(() => shell.Stop());
+                    return await Task.Run<IEnumerable<TResult>>(
+                        () => shell.Invoke<TResult>(input: null, invocationSettings), cancellationToken)
+                        .ConfigureAwait(false);
                 }
                 finally
                 {
@@ -872,7 +880,7 @@ public async Task<IEnumerable<TResult>> ExecuteCommandAsync<TResult>(
                         // will exist already so we need to create one and then use it
                         if (runspaceHandle == null)
                         {
-                            runspaceHandle = await this.GetRunspaceHandleAsync().ConfigureAwait(false);
+                            runspaceHandle = await this.GetRunspaceHandleAsync(cancellationToken).ConfigureAwait(false);
                         }
 
                         sessionDetails = this.GetSessionDetailsInRunspace(runspaceHandle.Runspace);

src/PowerShellEditorServices/Services/PowerShellContext/Session/Host/EditorServicesPSHostUserInterface.cs

@@ -731,7 +731,8 @@ private async Task WritePromptStringToHostAsync(CancellationToken cancellationTo
 
             cancellationToken.ThrowIfCancellationRequested();
             string promptString =
-                (await this.powerShellContext.ExecuteCommandAsync<PSObject>(promptCommand, false, false).ConfigureAwait(false))
+                (await this.powerShellContext.ExecuteCommandAsync<PSObject>(
+                    promptCommand, false, false, cancellationToken).ConfigureAwait(false))
                     .Select(pso => pso.BaseObject)
                     .OfType<string>()
                     .FirstOrDefault() ?? "PS> ";

src/PowerShellEditorServices/Services/PowerShellContext/Session/PSReadLinePromptContext.cs

@@ -143,7 +143,8 @@ public async Task<string> InvokeReadLineAsync(bool isCommandLine, CancellationTo
             IEnumerable<string> readLineResults = await _powerShellContext.ExecuteCommandAsync<string>(
                 readLineCommand,
                 errorMessages: null,
-                s_psrlExecutionOptions).ConfigureAwait(false);
+                s_psrlExecutionOptions,
+                cancellationToken).ConfigureAwait(false);
 
             string line = readLineResults.FirstOrDefault();