Adding cancel execution command

src/Microsoft.DotNet.Interactive.CSharp/CSharpKernel.cs

@@ -254,13 +254,16 @@ await RunAsync(
                 // Publish the compilation diagnostics. This doesn't include the exception.
                 var kernelDiagnostics = diagnostics.Select(Diagnostic.FromCodeAnalysisDiagnostic).ToImmutableArray();
 
-                var formattedDiagnostics =
-                    diagnostics
-                        .Select(d => d.ToString())
-                        .Select(text => new FormattedValue(PlainTextFormatter.MimeType, text))
-                        .ToImmutableArray();
+                if (kernelDiagnostics.Length > 0)
+                {
+                    var formattedDiagnostics =
+                        diagnostics
+                            .Select(d => d.ToString())
+                            .Select(text => new FormattedValue(PlainTextFormatter.MimeType, text))
+                            .ToImmutableArray();
 
-                context.Publish(new DiagnosticsProduced(kernelDiagnostics, submitCode, formattedDiagnostics));
+                    context.Publish(new DiagnosticsProduced(kernelDiagnostics, submitCode, formattedDiagnostics));
+                }
 
                 // Report the compilation failure or exception
                 if (exception != null)

src/Microsoft.DotNet.Interactive.ExtensionLab/RecordTranscriptExtension.cs

@@ -1,9 +1,11 @@
-using System;
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
 using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.IO;
-using System.Linq;
 using System.Threading.Tasks;
+
 using Microsoft.DotNet.Interactive.Server;
 
 namespace Microsoft.DotNet.Interactive.ExtensionLab

src/Microsoft.DotNet.Interactive.Js/src/dotnet-interactive/contracts.ts

@@ -6,10 +6,12 @@
 // --------------------------------------------- Kernel Commands
 
 export const AddPackageType = "AddPackage";
+export const CancelType = "Cancel";
 export const ChangeWorkingDirectoryType = "ChangeWorkingDirectory";
 export const DisplayErrorType = "DisplayError";
 export const DisplayValueType = "DisplayValue";
 export const ParseNotebookType = "ParseNotebook";
+export const QuitType = "Quit";
 export const RequestCompletionsType = "RequestCompletions";
 export const RequestDiagnosticsType = "RequestDiagnostics";
 export const RequestHoverTextType = "RequestHoverText";
@@ -20,10 +22,12 @@ export const UpdateDisplayedValueType = "UpdateDisplayedValue";
 
 export type KernelCommandType =
       typeof AddPackageType
+    | typeof CancelType
     | typeof ChangeWorkingDirectoryType
     | typeof DisplayErrorType
     | typeof DisplayValueType
     | typeof ParseNotebookType
+    | typeof QuitType
     | typeof RequestCompletionsType
     | typeof RequestDiagnosticsType
     | typeof RequestHoverTextType
@@ -40,6 +44,9 @@ export interface KernelCommand {
     targetKernelName?: string;
 }
 
+export interface Cancel extends KernelCommand {
+}
+
 export interface ChangeWorkingDirectory extends KernelCommand {
     workingDirectory: string;
 }
@@ -58,6 +65,9 @@ export interface ParseNotebook extends KernelCommand {
     rawData: Uint8Array;
 }
 
+export interface Quit extends Cancel {
+}
+
 export interface RequestCompletions extends LanguageServiceCommand {
 }
 

src/Microsoft.DotNet.Interactive.Tests/CancelCommandTests.cs

@@ -0,0 +1,203 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Threading.Tasks;
+
+using FluentAssertions;
+using FluentAssertions.Execution;
+
+using Microsoft.DotNet.Interactive.Commands;
+using Microsoft.DotNet.Interactive.Events;
+using Microsoft.DotNet.Interactive.Tests.Utility;
+
+using Xunit;
+using Xunit.Abstractions;
+
+
+namespace Microsoft.DotNet.Interactive.Tests
+{
+    public class CancelCommandTests : LanguageKernelTestBase
+    {
+        public CancelCommandTests(ITestOutputHelper output) : base(output)
+        {
+        }
+
+        [Fact]
+        public async Task cancel_command_cancels_all_deferred_commands_on_composite_kernel()
+        {
+            var deferredCommandExecuted = false;
+
+            var kernel = CreateKernel();
+
+            var deferred = new SubmitCode("placeholder")
+            {
+                Handler = (command, context) =>
+                {
+                    deferredCommandExecuted = true;
+                    return Task.CompletedTask;
+                }
+            };
+
+            var cancelCommand = new Cancel();
+
+            kernel.DeferCommand(deferred);
+
+            var events = kernel.KernelEvents.ToSubscribedList();
+
+            await kernel.SendAsync(cancelCommand);
+
+            using var _ = new AssertionScope();
+
+            deferredCommandExecuted.Should().BeFalse();
+
+            events
+                .Should().ContainSingle<CommandSucceeded>()
+                .Which
+                .Command
+                .Should()
+                .Be(cancelCommand);
+        }
+
+        [Theory]
+        [InlineData(Language.CSharp, Skip = "requires scheduler working")]
+        [InlineData(Language.FSharp, Skip = "requires scheduler working")]
+        [InlineData(Language.PowerShell, Skip = "requires scheduler working")]
+        public async Task cancel_command_cancels_all_deferred_commands_on_subkernels(Language language)
+        {
+
+            var kernel = CreateKernel(language);
+
+            var deferred = new CancellableCommand();
+
+            var cancelCommand = new Cancel();
+
+            foreach (var subkernel in kernel.ChildKernels)
+            {
+                subkernel.DeferCommand(deferred);
+            }
+
+            await kernel.SendAsync(cancelCommand);
+
+            using var _ = new AssertionScope();
+
+            deferred.HasRun.Should().BeFalse();
+
+            KernelEvents
+                .Should().ContainSingle<CommandSucceeded>()
+                .Which
+                .Command
+                .Should()
+                .Be(cancelCommand);
+        }
+
+        [Theory]
+        [InlineData(Language.CSharp, Skip = "requires scheduler working")]
+        [InlineData(Language.FSharp, Skip = "requires scheduler working")]
+        [InlineData(Language.PowerShell, Skip = "to address later")]
+        public void cancel_command_cancels_the_running_command(Language language)
+        {
+
+            var kernel = CreateKernel(language);
+
+            var cancelCommand = new Cancel();
+
+            var submitCodeCommand = new CancellableCommand();
+
+            Task.WhenAll(
+                    Task.Run(async () =>
+                    {
+                        await kernel.SendAsync(submitCodeCommand);
+                    }),
+                    Task.Run(async () =>
+                    {
+                        await Task.Delay(100);
+                        await kernel.SendAsync(cancelCommand);
+                    }))
+                .Wait(TimeSpan.FromSeconds(20));
+
+
+            using var _ = new AssertionScope();
+
+            submitCodeCommand.HasRun.Should().BeTrue();
+            submitCodeCommand.HasBeenCancelled.Should().BeTrue();
+
+            KernelEvents
+                .Should()
+                .ContainSingle<CommandFailed>(c => c.Command == submitCodeCommand)
+                .Which
+                .Exception
+                .Should()
+                .BeOfType<OperationCanceledException>();
+        }
+
+        [Theory]
+        [InlineData(Language.CSharp, Skip = "requires scheduler working")]
+        [InlineData(Language.FSharp, Skip = "requires scheduler working")]
+        [InlineData(Language.PowerShell, Skip = "to address later")]
+        public async Task commands_issued_after_cancel_command_are_executed(Language language)
+        {
+
+            var kernel = CreateKernel(language);
+
+            var cancelCommand = new Cancel();
+
+            var commandToCancel = new CancellableCommand( );
+
+            var commandToRun = new SubmitCode("1");
+
+            var _ = kernel.SendAsync(commandToCancel);
+            await Task.Delay(4000);
+            await kernel.SendAsync(cancelCommand);
+            await kernel.SendAsync(commandToRun);
+
+           // using var _ = new AssertionScope();
+
+            commandToCancel.HasRun.Should().BeTrue();
+            commandToCancel.HasBeenCancelled.Should().BeTrue();
+
+            KernelEvents
+                .Should()
+                .ContainSingle<CommandFailed>(c => c.Command == commandToCancel)
+                .Which
+                .Exception
+                .Should()
+                .BeOfType<OperationCanceledException>();
+        }
+
+
+        [Theory]
+        [InlineData(Language.CSharp, @"while(true){
+    if(Microsoft.DotNet.Interactive.KernelInvocationContext.Current.CancellationToken.IsCancellationRequested)
+    {
+        Console.WriteLine(""done c#"");
+        break;
+    }
+} 
+", "done c#", Skip = "requires scheduler working")]
+        [InlineData(Language.FSharp, @"
+System.Threading.Thread.Sleep(3000)
+Console.WriteLine(""done c#"")", "done f#", Skip = "for the moment")]
+        public async Task user_code_can_react_to_cancel_command_using_cancellation_token(Language language, string code, string expectedValue)
+        {
+            var kernel = CreateKernel(language);
+            var cancelCommand = new Cancel();
+            var submitCodeCommand = new SubmitCode(code);
+
+            var _ = kernel.SendAsync(submitCodeCommand);
+            await Task.Delay(4000);
+            await kernel.SendAsync(cancelCommand);
+
+            KernelEvents
+                .Should()
+                .ContainSingle<StandardOutputValueProduced>()
+                .Which
+                .Value
+                .Should()
+                .Be(expectedValue);
+
+        }
+    }
+
+
+}

src/Microsoft.DotNet.Interactive.Tests/CompositeKernelTests.cs

@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using FluentAssertions;
+using FluentAssertions.Execution;
 using Microsoft.DotNet.Interactive.Commands;
 using Microsoft.DotNet.Interactive.CSharp;
 using Microsoft.DotNet.Interactive.Events;
@@ -21,7 +22,7 @@ namespace Microsoft.DotNet.Interactive.Tests
 {
     public class CompositeKernelTests : IDisposable
     {
-        private readonly CompositeDisposable _disposables = new CompositeDisposable();
+        private readonly CompositeDisposable _disposables = new();
 
         public CompositeKernelTests(ITestOutputHelper output)
         {
@@ -424,6 +425,7 @@ public async Task Deferred_commands_on_composite_kernel_are_execute_on_first_sub
                     typeof(CompleteCodeSubmissionReceived),
                     typeof(CommandSucceeded));
         }
+
 
         [Fact]
         public async Task Deferred_commands_on_composite_kernel_can_use_directives()