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);