dotnet · colombod · Sep 3, 2019 · Aug 23, 2019 · Aug 23, 2019 · Aug 23, 2019
diff --git a/FSharpWorkspaceShim/FSharpWorkspaceShim.fsproj b/FSharpWorkspaceShim/FSharpWorkspaceShim.fsproj
@@ -9,9 +9,7 @@
   <PropertyGroup Condition="$(TargetFramework.StartsWith('netstandard')) AND '$(OS)' == 'Windows_NT'">
     <!-- the 2.1.503 F# compiler can produce PDBs that can't properly be converted, see https://github.com/Microsoft/visualfsharp/issues/5976 -->
     <PublishWindowsPdb>false</PublishWindowsPdb>
-  </PropertyGroup>
-
-
+  </PropertyGroup> 
 
 
   <ItemGroup>

diff --git a/MLS.Agent/CommandLine/KernelServerCommand.cs b/MLS.Agent/CommandLine/KernelServerCommand.cs
@@ -5,7 +5,6 @@
 using System.CommandLine;
 using System.Threading.Tasks;
 using Microsoft.DotNet.Interactive;
-using WorkspaceServer.Kernel;
 
 namespace MLS.Agent.CommandLine
 {

diff --git a/Microsoft.DotNet.Interactive.FSharp/FSharpKernel.fs b/Microsoft.DotNet.Interactive.FSharp/FSharpKernel.fs
@@ -35,10 +35,19 @@ type FSharpKernel() =
             context.Publish(CodeSubmissionEvaluated(codeSubmission))
             context.Complete()
         }
+
+    let handleCancelCurrentCommand (cancelCurrentCommand: CancelCurrentCommand) (context: KernelInvocationContext) =
+        async {
+            let reply = CurrentCommandCancelled(cancelCurrentCommand)           
+            context.Publish(reply)
+            context.Complete()
+        }
+
     override __.HandleAsync(command: IKernelCommand, _context: KernelInvocationContext): Task =
         async {
             match command with
             | :? SubmitCode as submitCode -> submitCode.Handler <- fun invocationContext -> (handleSubmitCode submitCode invocationContext) |> Async.StartAsTask :> Task
+            | :? CancelCurrentCommand as cancelCurrentCommand -> cancelCurrentCommand.Handler <- fun invocationContext -> (handleCancelCurrentCommand cancelCurrentCommand invocationContext) |> Async.StartAsTask :> Task
             | _ -> ()
         } |> Async.StartAsTask :> Task
 
diff --git a/Microsoft.DotNet.Interactive.Jupyter.Tests/InterruptRequestHandlerTests.cs b/Microsoft.DotNet.Interactive.Jupyter.Tests/InterruptRequestHandlerTests.cs
@@ -0,0 +1,66 @@
+// 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.Linq;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.DotNet.Interactive.Jupyter.Protocol;
+using Recipes;
+using WorkspaceServer.Kernel;
+using Xunit;
+
+namespace Microsoft.DotNet.Interactive.Jupyter.Tests
+{
+    public class InterruptRequestHandlerTests
+    {
+        private readonly MessageSender _ioPubChannel;
+        private readonly MessageSender _serverChannel;
+        private readonly RecordingSocket _serverRecordingSocket;
+        private readonly RecordingSocket _ioRecordingSocket;
+        private readonly KernelStatus _kernelStatus;
+
+        public InterruptRequestHandlerTests()
+        {
+            var signatureValidator = new SignatureValidator("key", "HMACSHA256");
+            _serverRecordingSocket = new RecordingSocket();
+            _serverChannel = new MessageSender(_serverRecordingSocket, signatureValidator);
+            _ioRecordingSocket = new RecordingSocket();
+            _ioPubChannel = new MessageSender(_ioRecordingSocket, signatureValidator);
+            _kernelStatus = new KernelStatus();
+        }
+
+        [Fact]
+        public void cannot_handle_requests_that_are_not_InterruptRequest()
+        {
+            var kernel = new CSharpKernel();
+            var handler = new InterruptRequestHandler(kernel);
+            var request = Message.Create(new DisplayData(), null);
+            Func<Task> messageHandling = () => handler.Handle(new JupyterRequestContext(_serverChannel, _ioPubChannel, request, _kernelStatus));
+            messageHandling.Should().ThrowExactly<InvalidOperationException>();
+        }
+
+        [Fact]
+        public async Task handles_InterruptRequest()
+        {
+            var kernel = new CSharpKernel();
+            var handler = new InterruptRequestHandler(kernel);
+            var request = Message.Create(new InterruptRequest(), null);
+            await handler.Handle(new JupyterRequestContext(_serverChannel, _ioPubChannel, request, _kernelStatus));
+        }
+
+        [Fact]
+        public async Task sends_InterruptReply()
+        {
+            var kernel = new CSharpKernel();
+            var handler = new InterruptRequestHandler(kernel);
+            var request = Message.Create(new InterruptRequest(), null);
+            await handler.Handle(new JupyterRequestContext(_serverChannel, _ioPubChannel, request, _kernelStatus));
+
+            _serverRecordingSocket.DecodedMessages.SingleOrDefault(message =>
+                    message.Contains(MessageTypeValues.InterruptReply))
+                .Should()
+                .NotBeNullOrWhiteSpace();
+        }
+    }
+}
diff --git a/Microsoft.DotNet.Interactive.Jupyter/InterruptRequestHandler.cs b/Microsoft.DotNet.Interactive.Jupyter/InterruptRequestHandler.cs
@@ -0,0 +1,64 @@
+// 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.Reactive.Concurrency;
+using System.Threading.Tasks;
+using Microsoft.DotNet.Interactive.Commands;
+using Microsoft.DotNet.Interactive.Events;
+using Microsoft.DotNet.Interactive.Jupyter.Protocol;
+
+namespace Microsoft.DotNet.Interactive.Jupyter
+{
+    public class InterruptRequestHandler : RequestHandlerBase<InterruptRequest>
+    {
+
+        public InterruptRequestHandler(IKernel kernel, IScheduler scheduler = null)
+            : base(kernel, scheduler ?? CurrentThreadScheduler.Instance)
+        {
+
+        }
+
+        protected override void OnKernelEvent(IKernelEvent @event)
+        {
+            switch (@event)
+            {
+                case CurrentCommandCancelled kernelInterrupted:
+                    OnExecutionInterrupted(kernelInterrupted);
+                    break;
+            }
+        }
+
+        private void OnExecutionInterrupted(CurrentCommandCancelled currentCommandCancelled)
+        {
+            if (InFlightRequests.TryRemove(currentCommandCancelled.Command, out var openRequest))
+            {
+                // reply 
+                var interruptReplyPayload = new InterruptReply();
+
+                // send to server
+                var interruptReply = Message.CreateResponse(
+                    interruptReplyPayload,
+                    openRequest.Context.Request);
+
+                openRequest.Context.ServerChannel.Send(interruptReply);
+                openRequest.Context.RequestHandlerStatus.SetAsIdle();
+                openRequest.Dispose();
+            }
+        }
+
+        public async Task Handle(JupyterRequestContext context)
+        {
+            var interruptRequest = GetJupyterRequest(context);
+
+            context.RequestHandlerStatus.SetAsBusy();
+
+            var command = new CancelCurrentCommand();
+
+            var openRequest = new InflightRequest(context, interruptRequest, 0);
+
+            InFlightRequests[command] = openRequest;
+
+            await Kernel.SendAsync(command);
+        }
+    }
+}
diff --git a/Microsoft.DotNet.Interactive.Jupyter/IsCompleteRequestHandler.cs b/Microsoft.DotNet.Interactive.Jupyter/IsCompleteRequestHandler.cs
@@ -63,7 +63,5 @@ private void OnKernelEvent(IKernelEvent @event, bool isComplete)
                 openRequest.Dispose();
             }
         }
-
-
     }
 }
diff --git a/Microsoft.DotNet.Interactive.Jupyter/JupyterRequestContextHandler.cs b/Microsoft.DotNet.Interactive.Jupyter/JupyterRequestContextHandler.cs
@@ -15,7 +15,8 @@ public class JupyterRequestContextHandler : ICommandHandler<JupyterRequestContex
 
         private readonly ExecuteRequestHandler _executeHandler;
         private readonly CompleteRequestHandler _completeHandler;
-        private IsCompleteRequestHandler _isCompleteHandler;
+        private readonly InterruptRequestHandler _interruptHandler;
+        private readonly IsCompleteRequestHandler _isCompleteHandler;
 
         public JupyterRequestContextHandler(
             IKernel kernel)
@@ -28,6 +29,7 @@ public JupyterRequestContextHandler(
 
             _executeHandler = new ExecuteRequestHandler(kernel, scheduler);
             _completeHandler = new CompleteRequestHandler(kernel, scheduler);
+            _interruptHandler = new InterruptRequestHandler(kernel, scheduler);
             _isCompleteHandler = new IsCompleteRequestHandler(kernel, scheduler);
 
         }
@@ -43,6 +45,9 @@ public async Task<ICommandDeliveryResult> Handle(
                 case MessageTypeValues.CompleteRequest:
                     await _completeHandler.Handle(delivery.Command);
                     break;
+                case MessageTypeValues.InterruptRequest:
+                    await _interruptHandler.Handle(delivery.Command);
+                    break;
             }
 
             return delivery.Complete();

diff --git a/Microsoft.DotNet.Interactive.Jupyter/Protocol/InterruptReply.cs b/Microsoft.DotNet.Interactive.Jupyter/Protocol/InterruptReply.cs
@@ -0,0 +1,11 @@
+// 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.
+
+namespace Microsoft.DotNet.Interactive.Jupyter.Protocol
+{
+    [JupyterMessageType(MessageTypeValues.InterruptReply)]
+    public class InterruptReply : JupyterMessageContent
+    {
+
+    }
+}
diff --git a/Microsoft.DotNet.Interactive.Jupyter/Protocol/InterruptRequest.cs b/Microsoft.DotNet.Interactive.Jupyter/Protocol/InterruptRequest.cs
@@ -0,0 +1,11 @@
+// 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.
+
+namespace Microsoft.DotNet.Interactive.Jupyter.Protocol
+{
+    [JupyterMessageType(MessageTypeValues.InterruptRequest)]
+    public class InterruptRequest : JupyterMessageContent
+    {
+
+    }
+}
diff --git a/Microsoft.DotNet.Interactive.Jupyter/Protocol/MessageTypeValues.cs b/Microsoft.DotNet.Interactive.Jupyter/Protocol/MessageTypeValues.cs
@@ -62,5 +62,9 @@ public class MessageTypeValues
         public const string CommInfoRequest = "comm_info_request";
 
         public const string CommInfoReply = "comm_info_reply";
+
+        public const string InterruptRequest = "interrupt_request";
+
+        public const string InterruptReply = "interrupt_reply";
     }
 }
diff --git a/Microsoft.DotNet.Interactive/Commands/CancelCurrentCommand.cs b/Microsoft.DotNet.Interactive/Commands/CancelCurrentCommand.cs
@@ -0,0 +1,10 @@
+// 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.
+
+namespace Microsoft.DotNet.Interactive.Commands
+{
+    public class CancelCurrentCommand : KernelCommandBase
+    {
+
+    }
+}
diff --git a/Microsoft.DotNet.Interactive/Commands/RequestCompletion.cs b/Microsoft.DotNet.Interactive/Commands/RequestCompletion.cs
@@ -1,7 +1,5 @@
 // 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.
-// 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;
 

diff --git a/Microsoft.DotNet.Interactive/Commands/SubmitCode.cs b/Microsoft.DotNet.Interactive/Commands/SubmitCode.cs
@@ -20,6 +20,7 @@ public SubmitCode(
         public string Code { get; set; }
 
         public string TargetKernelName { get; set; }
+
         public SubmissionType SubmissionType { get; }
 
         public override string ToString() => $"{base.ToString()}: {Code.TruncateForDisplay()}";

diff --git a/Microsoft.DotNet.Interactive/Events/CurrentCommandCancelled.cs b/Microsoft.DotNet.Interactive/Events/CurrentCommandCancelled.cs
@@ -0,0 +1,15 @@
+// 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 Microsoft.DotNet.Interactive.Commands;
+
+namespace Microsoft.DotNet.Interactive.Events
+{
+    public class CurrentCommandCancelled:KernelEventBase
+    {
+        public CurrentCommandCancelled(IKernelCommand command) : base(command)
+        {
+
+        }
+    }
+}
diff --git a/Microsoft.DotNet.Interactive/KernelStreamClient.cs b/Microsoft.DotNet.Interactive/KernelStreamClient.cs
@@ -18,6 +18,7 @@ public class KernelStreamClient
         private readonly TextReader _input;
         private readonly TextWriter _output;
         private readonly CommandDeserializer _deserializer = new CommandDeserializer();
+
         private readonly JsonSerializerSettings _jsonSerializerSettings = new JsonSerializerSettings
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver()

diff --git a/WorkspaceServer.Tests/Kernel/CSharpKernelTests.cs b/WorkspaceServer.Tests/Kernel/CSharpKernelTests.cs
@@ -203,6 +203,28 @@ public async Task it_produces_values_when_executing_Console_output()
                     new DisplayedValueProduced("value three", kernelCommand,  new[] { new FormattedValue("text/plain", "value three"), }));
         }
 
+        [Fact]
+        public async Task it_can_cancel_execution()
+        {
+            var kernel = CreateKernel();
+
+            var submitCodeCommand = new SubmitCode(@"System.Threading.Thread.Sleep(90000000);");
+            var codeSubmission = kernel.SendAsync(submitCodeCommand);
+            var interruptionCommand = new CancelCurrentCommand();
+            await kernel.SendAsync(interruptionCommand);
+            await codeSubmission;
+
+            KernelEvents
+                .ValuesOnly()
+                .Single(e => e is CurrentCommandCancelled);
+
+            KernelEvents
+                .ValuesOnly()
+                .OfType<CommandFailed>()
+                .Should()
+                .BeEquivalentTo(new CommandFailed(null, interruptionCommand, "Command cancelled"));
+        }
+
         [Fact]
         public async Task it_produces_a_final_value_if_the_code_expression_evaluates()
         {
-Original file line number
+Diff line change
@@ Expand Up @@
                     openRequest.Dispose();
                 }
             }
         }
     }