protected async Task SendTheThingAndWaitForTheStuff(
JupyterRequestContext context,
IKernelCommand command)
{
var sub = Kernel.KernelEvents.Subscribe(e => OnKernelEventReceived(e, context));
await((KernelBase)Kernel).SendAsync(
command,
CancellationToken.None,
onDone: () => sub.Dispose());
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CurrentCommandCancelled kernelInterrupted:
OnExecutionInterrupted(kernelInterrupted, context.Request, context.ServerChannel);
break;
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_shell.Bind(_shellAddress);
_ioPubSocket.Bind(_ioPubAddress);
_stdIn.Bind(_stdInAddress);
_control.Bind(_controlAddress);
var id = Guid.NewGuid().ToString();
using (var activity = Log.OnEnterAndExit())
{
SetStarting();
while (!cancellationToken.IsCancellationRequested)
{
var message = _shell.GetMessage();
activity.Info("Received: {message}", message.ToJson());
SetBusy();
switch (message.Header.MessageType)
{
case JupyterMessageContentTypes.KernelInfoRequest:
id = Encoding.Unicode.GetString(message.Identifiers[0].ToArray());
HandleKernelInfoRequest(message);
SetIdle();
break;
case JupyterMessageContentTypes.KernelShutdownRequest:
SetIdle();
break;
default:
var context = new JupyterRequestContext(
_shellSender,
_ioPubSender,
message, id);
await _scheduler.Schedule(context);
await context.Done();
SetIdle();
break;
}
}
void SetBusy() => _ioPubSender.Send(Message.Create(new Status(StatusValues.Busy), identifiers: new [] { Message.Topic("status", id) }));
void SetIdle() => _ioPubSender.Send(Message.Create(new Status(StatusValues.Idle), identifiers: new[] { Message.Topic("status", id) }));
void SetStarting() => _ioPubSender.Send(Message.Create(new Status(StatusValues.Starting), identifiers: new[] { Message.Topic("status", id) }));
}
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CurrentCommandCancelled _:
OnExecutionInterrupted(context.JupyterMessageSender);
break;
}
}
public async Task Handle(JupyterRequestContext context)
{
var executeRequest = GetJupyterRequest(context);
context.RequestHandlerStatus.SetAsBusy();
var executionCount = executeRequest.Silent ? _executionCount : Interlocked.Increment(ref _executionCount);
var command = new SubmitCode(executeRequest.Code, "csharp");
var openRequest = new InflightRequest(context, executeRequest, executionCount);
InFlightRequests[command] = openRequest;
try
{
await Kernel.SendAsync(command);
}
catch (Exception e)
{
InFlightRequests.TryRemove(command, out _);
var errorContent = new Error(
eName: "Unhandled Exception",
eValue: $"{e.Message}"
);
if (!executeRequest.Silent)
{
// send on io
var error = Message.Create(
errorContent,
context.Request.Header);
context.IoPubChannel.Send(error);
// send on stderr
var stdErr = new StdErrStream(errorContent.EValue);
var stream = Message.Create(
stdErr,
context.Request.Header);
context.IoPubChannel.Send(stream);
}
// reply Error
var executeReplyPayload = new ExecuteReplyError(errorContent, executionCount: executionCount);
// send to server
var executeReply = Message.CreateResponse(
executeReplyPayload,
context.Request);
context.ServerChannel.Send(executeReply);
context.RequestHandlerStatus.SetAsIdle();
}
}
public async Task Schedule(JupyterRequestContext context)
{
try
{
JupyterRequestContext.Current = context;
await handle(context);
}
finally
{
JupyterRequestContext.Current = null;
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
using var activity = Log.OnEnterAndExit();
SetupDefaultMimeTypes();
_shell.Bind(_shellAddress);
_ioPubSocket.Bind(_ioPubAddress);
_stdIn.Bind(_stdInAddress);
_control.Bind(_controlAddress);
var kernelIdentity = Guid.NewGuid().ToString();
while (!cancellationToken.IsCancellationRequested)
{
var request = _shell.GetMessage();
activity.Info("Received: {message}", request.ToJson());
SetBusy(request);
switch (request.Header.MessageType)
{
case JupyterMessageContentTypes.KernelInfoRequest:
kernelIdentity = Encoding.Unicode.GetString(request.Identifiers[0].ToArray());
HandleKernelInfoRequest(request);
SetIdle(request);
break;
case JupyterMessageContentTypes.KernelShutdownRequest:
SetIdle(request);
break;
default:
var context = new JupyterRequestContext(
_shellChannel,
_ioPubChannel,
_stdInChannel,
request,
kernelIdentity);
await _scheduler.Schedule(context);
await context.Done();
SetIdle(request);
break;
}
}
void SetBusy(ZeroMQMessage request) => _ioPubChannel.Publish(new Status(StatusValues.Busy), request, kernelIdentity);
void SetIdle(ZeroMQMessage request) => _ioPubChannel.Publish(new Status(StatusValues.Idle), request, kernelIdentity);
}
protected override void OnKernelEventReceived(
KernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CompletionsProduced completionRequestCompleted:
OnCompletionRequestCompleted(
completionRequestCompleted,
context.JupyterMessageSender);
break;
}
}
public Task Handle(JupyterRequestContext context)
{
KernelInvocationContext.Current?.Fail(
new OperationCanceledException());
// reply
var interruptReplyPayload = new InterruptReply();
// send to server
context.JupyterMessageSender.Send(interruptReplyPayload);
return(Task.CompletedTask);
}
protected override void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CompletionRequestCompleted completionRequestCompleted:
OnCompletionRequestCompleted(
completionRequestCompleted,
context.Request,
context.ServerChannel);
break;
}
}
public async Task Handle(JupyterRequestContext context)
{
var completeRequest = GetJupyterRequest(context);
context.RequestHandlerStatus.SetAsBusy();
var command = new RequestCompletion(completeRequest.Code, completeRequest.CursorPosition);
var openRequest = new InflightRequest(context, completeRequest, 0);
InFlightRequests[command] = openRequest;
await Kernel.SendAsync(command);
}
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);
}
public async Task Handle(JupyterRequestContext context)
{
var executeRequest = GetJupyterRequest(context);
_executionCount = executeRequest.Silent ? _executionCount : Interlocked.Increment(ref _executionCount);
var executeInputPayload = new ExecuteInput(executeRequest.Code, _executionCount);
context.JupyterMessageSender.Send(executeInputPayload);
var command = new SubmitCode(executeRequest.Code);
await SendAsync(context, command);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_shell.Bind(_shellAddress);
_ioPubSocket.Bind(_ioPubAddress);
_stdIn.Bind(_stdInAddress);
_control.Bind(_controlAddress);
using (var activity = Log.OnEnterAndExit())
{
while (!cancellationToken.IsCancellationRequested)
{
var message = _shell.GetMessage();
activity.Info("Received: {message}", message.ToJson());
SetBusy();
switch (message.Header.MessageType)
{
case JupyterMessageContentTypes.KernelInfoRequest:
HandleKernelInfoRequest(message);
SetIdle();
break;
case JupyterMessageContentTypes.KernelShutdownRequest:
SetIdle();
break;
default:
var context = new JupyterRequestContext(
_shellSender,
_ioPubSender,
message);
await _scheduler.Schedule(context);
await context.Done();
SetIdle();
break;
}
void SetBusy() => _shellSender.Send(Message.Create(new Status(StatusValues.Busy), message.Header));
void SetIdle() => _shellSender.Send(Message.Create(new Status(StatusValues.Busy), message.Header));
}
}
}
protected override void OnKernelEventReceived(
KernelEvent @event,
JupyterRequestContext context)
{
switch (@event)
{
case CompleteCodeSubmissionReceived _:
Reply(true, context.JupyterRequestMessageEnvelope, context.JupyterMessageSender);
break;
case 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;
}
}
public async Task Handle(JupyterRequestContext context)
{
var executeRequest = GetJupyterRequest(context);
_executionCount = executeRequest.Silent ? _executionCount : Interlocked.Increment(ref _executionCount);
var executeInputPayload = new ExecuteInput(executeRequest.Code, _executionCount);
var executeReply = Message.Create(executeInputPayload, context.Request.Header, identifiers: new [] { Message.Topic("execute_input", context.KernelIdent) });
context.IoPubChannel.Send(executeReply);
var command = new SubmitCode(executeRequest.Code);
await SendTheThingAndWaitForTheStuff(context, command);
}
protected async Task SendAsync(
JupyterRequestContext context,
IKernelCommand command)
{
command.SetToken(context.Token);
var sub = Kernel.KernelEvents
.Where(e => e.Command?.GetToken() == context.Token)
.Subscribe(e => OnKernelEventReceived(e, context));
await((KernelBase)Kernel).SendAsync(
command,
CancellationToken.None,
onDone: () => sub.Dispose());
}
public async Task Handle(JupyterRequestContext context)
{
var completeRequest = GetJupyterRequest(context);
context.RequestHandlerStatus.SetAsBusy();
var command = new RequestCompletion(completeRequest.Code, completeRequest.CursorPosition);
var openRequest = new InflightRequest(context, completeRequest, 0, null);
InFlightRequests[command] = openRequest;
var kernelResult = await Kernel.SendAsync(command);
openRequest.AddDisposable(kernelResult.KernelEvents.Subscribe(OnKernelResultEvent));
}
public async Task Handle(JupyterRequestContext context)
{
var executeRequest = GetJupyterRequest(context);
string targetKernelName = context.GetLanguage();
_executionCount = executeRequest.Silent ? _executionCount : Interlocked.Increment(ref _executionCount);
FrontendEnvironment.AllowStandardInput = executeRequest.AllowStdin;
var executeInputPayload = new ExecuteInput(executeRequest.Code, _executionCount);
context.JupyterMessageSender.Send(executeInputPayload);
var command = new SubmitCode(executeRequest.Code, targetKernelName);
await SendAsync(context, command);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_shell.Bind(_shellAddress);
_ioPubSocket.Bind(_ioPubAddress);
_stdIn.Bind(_stdInAddress);
_control.Bind(_controlAddress);
using (var activity = Logger <Shell> .Log.OnEnterAndExit())
{
while (!cancellationToken.IsCancellationRequested)
{
var message = _shell.GetMessage();
activity.Info("Received: {message}", message.ToJson());
var status = new RequestHandlerStatus(message.Header, new MessageSender(_ioPubSocket, _signatureValidator));
switch (message.Header.MessageType)
{
case MessageTypeValues.KernelInfoRequest:
status.SetAsBusy();
HandleKernelInfoRequest(message);
status.SetAsIdle();
break;
case MessageTypeValues.KernelShutdownRequest:
status.SetAsBusy();
status.SetAsIdle();
break;
default:
var context = new JupyterRequestContext(
_shellSender,
_ioPubSender,
message,
new RequestHandlerStatus(message.Header, _shellSender));
await _scheduler.Schedule(context);
break;
}
}
}
}
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 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;
}
}
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 async Task SendAsync(
JupyterRequestContext context,
IKernelCommand command)
{
command.SetToken(context.Token);
using var sub = Kernel
.KernelEvents
.Where(ShouldForward)
.Subscribe(e => OnKernelEventReceived(e, context));
await((KernelBase)Kernel).SendAsync(
command,
CancellationToken.None);
bool ShouldForward(IKernelEvent e)
{
return((e.Command?.GetToken() == context.Token) || e.Command.ShouldPublishInternalEvents());
}
}
private void OnDiagnosticsProduced(JupyterRequestContext context,
ZeroMQMessage request,
DiagnosticsProduced diagnosticsProduced)
{
// Space out the diagnostics and send them to stderr
if (diagnosticsProduced.FormattedDiagnostics.Count() > 0)
{
var output =
Environment.NewLine +
string.Join(Environment.NewLine + Environment.NewLine, diagnosticsProduced.FormattedDiagnostics.Select(v => v.Value)) +
Environment.NewLine +
Environment.NewLine;
var dataMessage = Stream.StdErr(output);
var isSilent = ((ExecuteRequest)request.Content).Silent;
if (!isSilent)
{
// send on io
context.JupyterMessageSender.Send(dataMessage);
}
}
}
public async Task Handle(JupyterRequestContext context)
{
var executeRequest = GetJupyterRequest(context);
context.RequestHandlerStatus.SetAsBusy();
var executionCount = executeRequest.Silent ? _executionCount : Interlocked.Increment(ref _executionCount);
var command = new SubmitCode(executeRequest.Code);
var openRequest = new InflightRequest(context, executeRequest, executionCount);
InFlightRequests[command] = openRequest;
try
{
await Kernel.SendAsync(command);
}
catch (Exception e)
{
OnCommandFailed(new CommandFailed(e, command));
}
}
protected override void OnKernelEventReceived(KernelEvent @event, JupyterRequestContext context)
{
}
private void OnInputRequested(JupyterRequestContext context, InputRequested inputRequested)
{
var inputReq = new InputRequest(inputRequested.Prompt, password: false);
inputRequested.Content = context.JupyterMessageSender.Send(inputReq);
}
protected abstract void OnKernelEventReceived(
IKernelEvent @event,
JupyterRequestContext context);
