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 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 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 Task SendAsync(KernelEvent kernelEvent, CancellationToken cancellationToken)
{
_onSendAsync?.Invoke(new CommandOrEvent(KernelEventEnvelope.Deserialize(KernelEventEnvelope.Serialize(kernelEvent)).Event));
return(Task.CompletedTask);
}