protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
Task.Run(async() =>
{
while (!stoppingToken.IsCancellationRequested)
{
var output = await DotNetInteractiveProcess.StandardOutput.ReadLineAsync();
if (!string.IsNullOrEmpty(output))
{
logger.LogDebug(output);
var eventEnvelope = KernelEventEnvelope.Deserialize(output);
var token = eventEnvelope.Event.Command?.GetToken();
if (token != null && pendingRequests.TryGetValue(token, out var tracker))
{
tracker(eventEnvelope.Event);
}
}
}
}, stoppingToken);
return(Task.CompletedTask);
}
public static void RegisterEventsAndCommands()
{
// register commands and event with serialization
var commandTypes = typeof(CSharpProjectKernel).Assembly.ExportedTypes
.Where(t => !t.IsAbstract && !t.IsInterface)
.Where(t => typeof(KernelCommand).IsAssignableFrom(t))
.OrderBy(t => t.Name)
.ToList();
var eventTypes = typeof(CSharpProjectKernel).Assembly.ExportedTypes
.Where(t => !t.IsAbstract && !t.IsInterface)
.Where(t => typeof(KernelEvent).IsAssignableFrom(t))
.OrderBy(t => t.Name)
.ToList();
foreach (var commandType in commandTypes)
{
KernelCommandEnvelope.RegisterCommand(commandType);
}
foreach (var eventType in eventTypes)
{
KernelEventEnvelope.RegisterEvent(eventType);
}
}
public async Task RouteAsync(RouteContext context)
{
if (context.HttpContext.Request.Method == HttpMethods.Post)
{
var segments =
context.HttpContext
.Request
.Path
.Value
.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Length == 1 && segments[0] == "publishEvent")
{
using var reader = new StreamReader(context.HttpContext.Request.Body);
var requestText = await reader.ReadToEndAsync();
var requestObject = JsonDocument.Parse(requestText).RootElement;
var commandToken = requestObject.GetPropertyFromPath("commandToken")?.GetString();
var eventEnvelopeText = requestObject.GetPropertyFromPath("eventEnvelope")?.GetRawText();
_frontendEnvironment.PublishEventFromCommand(commandToken, command =>
{
context.Handler = async httpContext =>
{
httpContext.Response.StatusCode = 200;
await httpContext.Response.CompleteAsync();
};
var eventEnvelope = KernelEventEnvelope.DeserializeWithCommand(eventEnvelopeText, command);
return(eventEnvelope.Event);
});
}
}
}
public async Task SendAsync(KernelEvent kernelEvent, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
_sender.WriteMessage(KernelEventEnvelope.Serialize(KernelEventEnvelope.Create(kernelEvent)));
await _sender.FlushAsync(cancellationToken);
}
public static TKernel UseVSCodeCommands <TKernel>(this TKernel kernel) where TKernel : Kernel
{
kernel.RegisterCommandType <GetInput>();
KernelCommandEnvelope.RegisterCommand <GetInput>();
KernelEventEnvelope.RegisterEvent <InputProduced>();
return(kernel);
}
public void Dispose()
{
KernelCommandEnvelope.ResetToDefaults();
KernelEventEnvelope.ResetToDefaults();
_host.Value.Dispose();
_host = null;
}
public CommandLineParserTests(ITestOutputHelper output)
{
KernelCommandEnvelope.ResetToDefaults();
KernelEventEnvelope.ResetToDefaults();
_output = output;
_serviceCollection = new ServiceCollection();
_parser = CommandLineParser.Create(
_serviceCollection,
startServer: (options, invocationContext) =>
{
_startOptions = options;
},
jupyter: (startupOptions, console, startServer, context) =>
{
_startOptions = startupOptions;
return(Task.FromResult(1));
},
startStdIO: (startupOptions, kernel, console) =>
{
_startOptions = startupOptions;
return(Task.FromResult(1));
},
startHttp: (startupOptions, console, startServer, context) =>
{
_startOptions = startupOptions;
return(Task.FromResult(1));
},
telemetry: new FakeTelemetry(),
firstTimeUseNoticeSentinel: new NopFirstTimeUseNoticeSentinel());
_connectionFile = new FileInfo(Path.GetTempFileName());
_kernelSpecInstallPath = new DirectoryInfo(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()));
}
public void All_event_types_are_round_trip_serializable(KernelEvent @event)
{
var originalEnvelope = KernelEventEnvelope.Create(@event);
var json = KernelEventEnvelope.Serialize(originalEnvelope);
_output.WriteLine($"{Environment.NewLine}{@event.GetType().Name}: {Environment.NewLine}{json}");
var deserializedEnvelope = KernelEventEnvelope.Deserialize(json);
// ignore these specific properties because they're not serialized
var ignoredProperties = new HashSet <string>
{
$"{nameof(CommandFailed)}.{nameof(CommandFailed.Exception)}",
$"{nameof(DisplayEvent)}.{nameof(DisplayEvent.Value)}"
};
deserializedEnvelope
.Should()
.BeEquivalentToRespectingRuntimeTypes(
originalEnvelope,
o => o.Excluding(envelope => envelope.Event.Command.Properties)
.Excluding(envelope => ignoredProperties.Contains($"{envelope.SelectedMemberInfo.DeclaringType.Name}.{envelope.SelectedMemberInfo.Name}"))
);
}
public async Task SendAsync(KernelEvent kernelEvent, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
await _writer.WriteAsync(KernelEventEnvelope.Serialize(KernelEventEnvelope.Create(kernelEvent)));
await _writer.WriteAsync(Delimiter);
await _writer.FlushAsync();
}
public static Task UseVSCodeHelpersAsync <TKernel>(this TKernel kernel, Kernel rootKernel) where TKernel : DotNetKernel
{
rootKernel.RegisterCommandType <GetInput>();
KernelEventEnvelope.RegisterEvent <InputProduced>();
var interactiveHost = new VSCodeInteractiveHost(rootKernel);
return(kernel.SetVariableAsync("InteractiveHost", interactiveHost, typeof(IInteractiveHost)));
}
public void Create_creates_envelope_of_the_correct_type()
{
IKernelEvent @event = new DisplayedValueProduced(
123,
new SubmitCode("display(123)"));
var envelope = KernelEventEnvelope.Create(@event);
envelope.Should().BeOfType <KernelEventEnvelope <DisplayedValueProduced> >();
}
public void Create_creates_envelope_with_reference_to_original_event()
{
IKernelEvent @event = new DisplayedValueProduced(
123,
new SubmitCode("display(123)"));
var envelope = KernelEventEnvelope.Create(@event);
envelope.Event.Should().BeSameAs(@event);
}
static CSharpProjectKernel()
{
// register commands and event with serialization
KernelCommandEnvelope.RegisterCommand <OpenProject>();
KernelCommandEnvelope.RegisterCommand <OpenDocument>();
KernelCommandEnvelope.RegisterCommand <CompileProject>();
KernelEventEnvelope.RegisterEvent <DocumentOpened>();
KernelEventEnvelope.RegisterEvent <AssemblyProduced>();
}
public async Task when_a_KernelEventEnvelope_is_received_it_publishes_the_event()
{
var kernelEvent = new CommandSucceeded(new SubmitCode("x=1"));
var message = KernelEventEnvelope.Serialize(KernelEventEnvelope.Create(kernelEvent));
using var stringReader = new StringReader(message);
var receiver = new KernelCommandAndEventTextReceiver(stringReader);
var d = await receiver.CommandsAndEventsAsync(CancellationToken.None).FirstAsync();
d.Event.Should().BeEquivalentTo(kernelEvent);
}
public void Event_contract_has_not_been_broken(KernelEvent @event)
{
var _configuration = new Configuration()
.UsingExtension($"{@event.GetType().Name}.json")
.SetInteractive(Debugger.IsAttached);
@event.Command?.SetToken("the-token");
var json = KernelEventEnvelope.Serialize(@event);
this.Assent(json, _configuration);
}
public SerializationTests(ITestOutputHelper output)
{
_output = output;
KernelCommandEnvelope.RegisterCommand <OpenProject>();
KernelCommandEnvelope.RegisterCommand <OpenDocument>();
KernelCommandEnvelope.RegisterCommand <CompileProject>();
KernelEventEnvelope.RegisterEvent <DocumentOpened>();
KernelEventEnvelope.RegisterEvent <AssemblyProduced>();
KernelCommandEnvelope.RegisterCommand <GetInput>();
KernelEventEnvelope.RegisterEvent <InputProduced>();
}
public async Task when_a_KernelEvent_is_sent_it_writes_a_KernelEventEnvelope()
{
var kernelEvent = new CommandSucceeded(new SubmitCode("x=1"));
var buffer = new StringBuilder();
var sender = new KernelCommandAndEventTextStreamSender(new StringWriter(buffer));
await sender.SendAsync(kernelEvent, CancellationToken.None);
var envelopeMessage = buffer.ToString();
envelopeMessage.Should()
.BeEquivalentTo(KernelEventEnvelope.Serialize(KernelEventEnvelope.Create(kernelEvent)) + KernelCommandAndEventTextStreamSender.Delimiter);
}
public void All_event_types_are_round_trip_serializable(IKernelEvent @event)
{
var originalEnvelope = KernelEventEnvelope.Create(@event);
var json = KernelEventEnvelope.Serialize(originalEnvelope);
_output.WriteLine($"{Environment.NewLine}{@event.GetType().Name}: {Environment.NewLine}{json}");
var deserializedEnvelope = KernelEventEnvelope.Deserialize(json);
deserializedEnvelope
.Should()
.BeEquivalentTo(originalEnvelope);
}
private void HandleLine(string line)
{
try
{
var eventEnvelope = KernelEventEnvelope.Deserialize(line);
if (eventEnvelope.Event is KernelReady)
{
_ready.SetResult(true);
}
_events.OnNext(eventEnvelope.Event);
}
catch (JsonReaderException)
{
}
}
private async Task PollEvents(string commandToken)
{
do
{
var message = await _clientStream.ReadMessageAsync();
var kernelEvent = KernelEventEnvelope.Deserialize(message).Event;
PublishEvent(kernelEvent);
if (kernelEvent is CommandSucceeded || kernelEvent is CommandFailed)
{
if (kernelEvent.Command.GetToken() == commandToken)
{
break;
}
}
} while (true);
}
public async IAsyncEnumerable <CommandOrEvent> CommandsOrEventsAsync([EnumeratorCancellation] CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
KernelCommand kernelCommand = null;
KernelEvent kernelEvent = null;
var message = await ReadMessageAsync(cancellationToken);
if (string.IsNullOrWhiteSpace(message))
{
continue;
}
var isParseError = false;
try
{
var jsonObject = JsonDocument.Parse(message).RootElement;
if (IsEventEnvelope(jsonObject))
{
var kernelEventEnvelope = KernelEventEnvelope.Deserialize(jsonObject);
kernelEvent = kernelEventEnvelope.Event;
}
else if (IsCommandEnvelope(jsonObject))
{
var kernelCommandEnvelope = KernelCommandEnvelope.Deserialize(jsonObject);
kernelCommand = kernelCommandEnvelope.Command;
}
else
{
kernelEvent = new DiagnosticLogEntryProduced(
$"Expected {nameof(KernelCommandEnvelope)} or {nameof(KernelEventEnvelope)} but received: \n{message}", KernelCommand.None);
isParseError = true;
}
}
catch (Exception ex)
{
kernelEvent = new DiagnosticLogEntryProduced(
$"Error while parsing Envelope: {message} \n{ex.Message}", KernelCommand.None);
isParseError = true;
}
yield return(kernelCommand is null ? new CommandOrEvent(kernelEvent, isParseError) : new CommandOrEvent(kernelCommand));
}
}
protected override async Task <CommandOrEvent> ReadCommandOrEventAsync(CancellationToken cancellationToken)
{
KernelCommand kernelCommand = null;
KernelEvent kernelEvent = null;
var message = await ReadMessageAsync(cancellationToken);
if (string.IsNullOrWhiteSpace(message))
{
return(null);
}
var isParseError = false;
try
{
var jsonObject = JsonDocument.Parse(message).RootElement;
if (IsEventEnvelope(jsonObject))
{
var kernelEventEnvelope = KernelEventEnvelope.Deserialize(jsonObject);
kernelEvent = kernelEventEnvelope.Event;
}
else if (IsCommandEnvelope(jsonObject))
{
var kernelCommandEnvelope = KernelCommandEnvelope.Deserialize(jsonObject);
kernelCommand = kernelCommandEnvelope.Command;
}
else
{
kernelEvent = new DiagnosticLogEntryProduced(
$"Expected {nameof(KernelCommandEnvelope)} or {nameof(KernelEventEnvelope)} but received: \n{message}", KernelCommand.None);
isParseError = true;
}
}
catch (Exception ex)
{
kernelEvent = new DiagnosticLogEntryProduced(
$"Error while parsing Envelope: {message} \n{ex.Message}", KernelCommand.None);
isParseError = true;
}
return(kernelCommand is null ? new CommandOrEvent(kernelEvent, isParseError) : new CommandOrEvent(kernelCommand));
}
public async Task KernelEvent(string kernelEventEnvelope)
{
var envelope = KernelEventEnvelope.Deserialize(kernelEventEnvelope);
await _connection.HandleKernelEventFromClientAsync(envelope);
}
public async Task SendAsync(KernelEvent kernelEvent, CancellationToken cancellationToken)
{
await _sender.SendAsync("kernelEventFromServer", KernelEventEnvelope.Serialize(KernelEventEnvelope.Create(kernelEvent)), cancellationToken : cancellationToken);
}
private async Task PublishEventToContext(IKernelEvent kernelEvent, IHubContext <KernelHub> hubContext)
{
var eventEnvelope = KernelEventEnvelope.Create(kernelEvent);
await hubContext.Clients.All.SendAsync("kernelEvent", KernelEventEnvelope.Serialize(eventEnvelope));
}
public Task SendAsync(KernelEvent kernelEvent, CancellationToken cancellationToken)
{
_onSendAsync?.Invoke(new CommandOrEvent(KernelEventEnvelope.Deserialize(KernelEventEnvelope.Serialize(kernelEvent)).Event));
return(Task.CompletedTask);
}
