public static IKernelEventEnvelope Create(IKernelEvent @event)
{
var factory = _envelopeFactories.GetOrAdd(
@event.GetType(),
eventType =>
{
var genericType = _envelopeTypesByEventTypeName[@event.GetType().Name];
var constructor = genericType.GetConstructors().Single();
var eventParameter = Expression.Parameter(
typeof(IKernelEvent),
"e");
var newExpression = Expression.New(
constructor,
Expression.Convert(eventParameter, eventType));
var expression = Expression.Lambda <Func <IKernelEvent, IKernelEventEnvelope> >(
newExpression,
eventParameter);
return(expression.Compile());
});
return(factory(@event));
}
void OnKernelResultEvent(IKernelEvent value)
{
switch (value)
{
case ValueProduced valueProduced:
OnValueProduced(valueProduced, InFlightRequests);
break;
case CodeSubmissionEvaluated codeSubmissionEvaluated:
OnCodeSubmissionEvaluated(codeSubmissionEvaluated, InFlightRequests);
break;
case CodeSubmissionEvaluationFailed codeSubmissionEvaluationFailed:
OnCodeSubmissionEvaluatedFailed(codeSubmissionEvaluationFailed, InFlightRequests);
break;
case CodeSubmissionReceived _:
case IncompleteCodeSubmissionReceived _:
case CompleteCodeSubmissionReceived _:
break;
default:
throw new NotSupportedException();
}
}
void OnKernelResultEvent(IKernelEvent value)
{
switch (value)
{
case ValueProduced valueProduced:
OnValueProduced(valueProduced, OpenRequests, _renderingEngine);
break;
case CodeSubmissionEvaluated codeSubmissionEvaluated:
OnCodeSubmissionEvaluated(codeSubmissionEvaluated, OpenRequests);
break;
case CodeSubmissionEvaluationFailed codeSubmissionEvaluationFailed:
OnCodeSubmissionEvaluatedFailed(codeSubmissionEvaluationFailed, OpenRequests);
break;
case CodeSubmissionReceived _:
case IncompleteCodeSubmissionReceived _:
case CompleteCodeSubmissionReceived _:
break;
default:
throw new NotImplementedException();
}
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case DisplayEventBase displayEvent:
OnDisplayEvent(displayEvent, context.JupyterRequestMessageEnvelope, context.JupyterMessageSender);
break;
case DiagnosticLogEntryProduced logEvent:
OnLogEvent(logEvent, context.JupyterRequestMessageEnvelope, context.JupyterMessageSender);
break;
case CommandHandled _:
OnCommandHandled(context.JupyterMessageSender);
break;
case CommandFailed commandFailed:
OnCommandFailed(commandFailed, context.JupyterMessageSender);
break;
case InputRequested inputRequested:
OnInputRequested(context, inputRequested);
break;
case PasswordRequested passwordRequested:
OnPasswordRequested(context, passwordRequested);
break;
}
}
protected void PublishEvent(IKernelEvent kernelEvent)
{
if (kernelEvent == null)
{
throw new ArgumentNullException(nameof(kernelEvent));
}
_channel.OnNext(kernelEvent);
}
protected override void OnKernelEvent(IKernelEvent @event)
{
switch (@event)
{
case CurrentCommandCancelled kernelInterrupted:
OnExecutionInterrupted(kernelInterrupted);
break;
}
}
public static StreamKernelEvent ToStreamKernelEvent(IKernelEvent kernelEvent, int correlationId)
{
return(new StreamKernelEvent
{
Id = correlationId,
EventType = kernelEvent.GetType().Name,
Event = kernelEvent
});
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CurrentCommandCancelled kernelInterrupted:
OnExecutionInterrupted(kernelInterrupted, context.Request, context.ServerChannel);
break;
}
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CurrentCommandCancelled _:
OnExecutionInterrupted(context.JupyterMessageSender);
break;
}
}
public void Publish(IKernelEvent @event)
{
var command = @event.Command;
if (command == null ||
Command == command ||
_childCommands.Contains(command))
{
_events.OnNext(@event);
}
}
public void Publish(IKernelEvent @event)
{
if (_parentContext != null)
{
_parentContext.Publish(@event);
}
else
{
_events.OnNext(@event);
}
}
protected override void OnKernelEvent(IKernelEvent @event)
{
switch (@event)
{
case CompletionRequestCompleted completionRequestCompleted:
OnCompletionRequestCompleted(completionRequestCompleted, InFlightRequests);
break;
case CompletionRequestReceived _:
break;
}
}
private void Write(IKernelEvent e, int id)
{
var wrapper = new StreamKernelEvent
{
Id = id,
Event = e,
EventType = e.GetType().Name
};
var serialized = wrapper.Serialize();
_output.Write(serialized);
}
protected override void OnKernelEvent(IKernelEvent @event)
{
switch (@event)
{
case CompleteCodeSubmissionReceived completeCodeSubmissionReceived:
OnKernelEvent(completeCodeSubmissionReceived, true);
break;
case IncompleteCodeSubmissionReceived incompleteCodeSubmissionReceived:
OnKernelEvent(incompleteCodeSubmissionReceived, false);
break;
}
}
private void WriteEventToOutput(IKernelEvent kernelEvent)
{
if (kernelEvent is ReturnValueProduced rvp && rvp.Value is DisplayedValue)
{
return;
}
var envelope = KernelEventEnvelope.Create(kernelEvent);
var serialized = KernelEventEnvelope.Serialize(envelope);
_output.Write(serialized);
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CompletionRequestCompleted completionRequestCompleted:
OnCompletionRequestCompleted(
completionRequestCompleted,
context.JupyterMessageSender);
break;
}
}
private void Write(IKernelEvent e, int id)
{
var wrapper = new StreamKernelEvent
{
Id = id,
Event = e,
EventType = e.GetType().Name
};
var serialized = JsonConvert.SerializeObject(wrapper, _jsonSerializerSettings);
_output.WriteLine(serialized);
_output.Flush();
}
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);
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CompletionRequestCompleted completionRequestCompleted:
OnCompletionRequestCompleted(
completionRequestCompleted,
context.Request,
context.ServerChannel);
break;
}
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CompleteCodeSubmissionReceived completeCodeSubmissionReceived:
Reply(true, context.JupyterRequestMessageEnvelope, context.JupyterMessageSender);
break;
case IncompleteCodeSubmissionReceived incompleteCodeSubmissionReceived:
Reply(false, context.JupyterRequestMessageEnvelope, context.JupyterMessageSender);
break;
}
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CompleteCodeSubmissionReceived completeCodeSubmissionReceived:
Reply(true, context.Request, context.ServerChannel);
break;
case IncompleteCodeSubmissionReceived incompleteCodeSubmissionReceived:
Reply(false, context.Request, context.ServerChannel);
break;
}
}
void OnKernelResultEvent(IKernelEvent value)
{
switch (value)
{
case CompletionRequestCompleted completionRequestCompleted:
OnCompletionRequestCompleted(completionRequestCompleted, InFlightRequests);
break;
case CompletionRequestReceived _:
break;
default:
throw new NotSupportedException();
}
}
public void Publish(IKernelEvent @event)
{
if (IsComplete)
{
return;
}
var command = @event.Command as KernelCommandBase;
if (command == null ||
Command == command ||
_childCommands.Contains(command))
{
_events.OnNext(@event);
}
}
public static IKernelCommand GetRootCommand(this IKernelEvent kernelEvent)
{
if (kernelEvent == null)
{
throw new ArgumentNullException(nameof(kernelEvent));
}
var root = kernelEvent.Command;
while (root is KernelCommandBase kb && kb.Parent != null)
{
root = kb.Parent;
}
return(root);
}
private void Write(IKernelEvent kernelEvent, int correlationId)
{
if (kernelEvent is ReturnValueProduced rvp && rvp.Value is DisplayedValue)
{
return;
}
var wrapper = new StreamKernelEvent
{
Id = correlationId,
Event = kernelEvent,
EventType = kernelEvent.GetType().Name
};
var serialized = wrapper.Serialize();
_output.Write(serialized);
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case DisplayEventBase displayEvent:
OnDisplayEvent(displayEvent, context.Request, context.JupyterMessageSender);
break;
case CommandHandled _:
OnCommandHandled(context.JupyterMessageSender);
break;
case CommandFailed commandFailed:
OnCommandFailed(commandFailed, context.JupyterMessageSender);
break;
}
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case DisplayEventBase displayEvent:
OnDisplayEvent(displayEvent, context.Request, context.IoPubChannel);
break;
case CommandHandled commandHandled:
OnCommandHandled(commandHandled, context.Request, context.ServerChannel);
break;
case CommandFailed commandFailed:
OnCommandFailed(commandFailed, context.Request, context.ServerChannel, context.IoPubChannel);
break;
}
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case ValueProducedEventBase valueProduced:
OnValueProduced(valueProduced, context.Request, context.IoPubChannel);
break;
case CommandHandled commandHandled:
OnCommandHandled(commandHandled, context.Request, context.ServerChannel);
break;
case CommandFailed commandFailed:
OnCommandFailed(commandFailed, context.Request, context.ServerChannel, context.IoPubChannel);
break;
}
}
private void OnKernelEvent(IKernelEvent @event, bool isComplete)
{
if (InFlightRequests.TryRemove(@event.Command, out var openRequest))
{
var status = isComplete ? "complete" : "incomplete";
var indent = isComplete ? string.Empty : "*";
// reply
var isCompleteReplyPayload = new IsCompleteReply(indent: indent, status: status);
// send to server
var executeReply = Message.CreateResponse(
isCompleteReplyPayload,
openRequest.Context.Request);
openRequest.Context.ServerChannel.Send(executeReply);
openRequest.Context.RequestHandlerStatus.SetAsIdle();
openRequest.Dispose();
}
}
private void WriteEventToOutput(IKernelEvent kernelEvent)
{
if (kernelEvent is ReturnValueProduced rvp && rvp.Value is DisplayedValue)
{
return;
}
if (kernelEvent.Command is {} command)
{
if (command.Properties.Count == 0)
{
}
}
var envelope = KernelEventEnvelope.Create(kernelEvent);
var serialized = KernelEventEnvelope.Serialize(envelope);
_output.Write(serialized);
}
