private void OnCommandHandled(IJupyterMessageSender jupyterMessageSender) { // reply ok var executeReplyPayload = new ExecuteReplyOk(executionCount: _executionCount); // send to server jupyterMessageSender.Send(executeReplyPayload); }
public async void Process(Message <T> message) { object result = null; try { var displayDataHandler = new Action <DisplayData>((data) => { _ioPub.Send(message, data, MessageType.DisplayData); }); DisplayDataEmitter.DisplayDataHandler = displayDataHandler; using (var consoleProxy = CreateConsoleProxy(displayDataHandler)) { consoleProxy.StartRedirect(); result = await _scriptEngine.ExecuteAsync(message.Content.Code); } } catch (Exception e) { _logger.LogError(e, "Failed to run the code: " + message.Content.Code); var error = e.Message + Environment.NewLine + e.StackTrace; _ioPub.Send(message, new DisplayData(error, $"<p style=\"color:red;\">{error}</p>"), MessageType.DisplayData); return; } finally { DisplayDataEmitter.DisplayDataHandler = null; } if (result == null) { return; } _ioPub.Send(message, result, MessageType.DisplayData); // send execute reply to shell socket var executeReply = new ExecuteReplyOk { ExecutionCount = _executionCount++, Payload = new List <Dictionary <string, string> >(), UserExpressions = new Dictionary <string, string>() }; _shell.Send(message, executeReply, MessageType.ExecuteReply); }
private void OnCommandHandled( CommandHandled commandHandled, Message request, IMessageSender serverChannel) { // reply ok var executeReplyPayload = new ExecuteReplyOk(executionCount: _executionCount); // send to server var executeReply = Message.CreateResponse( executeReplyPayload, request); serverChannel.Send(executeReply); }
public void SendExecuteReplyMessage(Message message, RouterSocket shellSocket) { ExecuteReplyOk executeReply = new ExecuteReplyOk() { ExecutionCount = this.executionCount, Payload = new List <Dictionary <string, string> >(), UserExpressions = new Dictionary <string, string>() }; Message executeReplyMessage = MessageBuilder.CreateMessage(MessageTypeValues.ExecuteReply, JsonSerializer.Serialize(executeReply), message.Header); this.logger.Info(string.Format("Sending message to Shell {0}", JsonSerializer.Serialize(executeReplyMessage))); MessageSender.Send(executeReplyMessage, shellSocket); }
private static void OnCodeSubmissionEvaluated(CodeSubmissionEvaluated codeSubmissionEvaluated, ConcurrentDictionary <Guid, OpenRequest> openRequests) { var openRequest = openRequests[codeSubmissionEvaluated.ParentId]; // reply ok var executeReplyPayload = new ExecuteReplyOk(executionCount: openRequest.ExecutionCount); // send to server var executeReply = Message.CreateResponse( executeReplyPayload, openRequest.Context.Request); openRequest.Context.ServerChannel.Send(executeReply); openRequest.Context.RequestHandlerStatus.SetAsIdle(); }
private static void OnCodeSubmissionEvaluated(CodeSubmissionEvaluated codeSubmissionEvaluated, ConcurrentDictionary <IKernelCommand, InflightRequest> openRequests) { openRequests.TryRemove(codeSubmissionEvaluated.Command, out var openRequest); // reply ok var executeReplyPayload = new ExecuteReplyOk(executionCount: openRequest.ExecutionCount); // send to server var executeReply = Message.CreateResponse( executeReplyPayload, openRequest.Context.Request); openRequest.Context.ServerChannel.Send(executeReply); openRequest.Context.RequestHandlerStatus.SetAsIdle(); openRequest.Dispose(); }
public void SendExecuteReplyOkMessage(Message message, RouterSocket shellSocket) { ExecuteReplyOk executeReply = new ExecuteReplyOk() { ExecutionCount = this.executionCount, Payload = new List <Dictionary <string, string> >(), UserExpressions = new Dictionary <string, string>() }; Message executeReplyMessage = MessageBuilder.CreateMessage(MessageTypeValues.ExecuteReply, JObject.FromObject(executeReply), message.Header); // Stick the original identifiers on the message so they'll be sent first // Necessary since the shell socket is a ROUTER socket executeReplyMessage.Identifiers = message.Identifiers; this.logger.Info(string.Format("Sending message to Shell {0}", JsonSerializer.Serialize(executeReplyMessage))); this.messageSender.Send(executeReplyMessage, shellSocket); }
private void OnCommandHandled(CommandHandled commandHandled) { if (!InFlightRequests.TryRemove(commandHandled.GetRootCommand(), out var openRequest)) { return; } // reply ok var executeReplyPayload = new ExecuteReplyOk(executionCount: openRequest.ExecutionCount); // send to server var executeReply = Message.CreateResponse( executeReplyPayload, openRequest.Context.Request); openRequest.Context.ServerChannel.Send(executeReply); openRequest.Context.RequestHandlerStatus.SetAsIdle(); openRequest.Dispose(); }
public async Task <ICommandDeliveryResult> Handle( ICommandDelivery <JupyterRequestContext> delivery) { switch (delivery.Command.Request.Header.MessageType) { case MessageTypeValues.ExecuteRequest: var transient = new Dictionary <string, object> { { "display_id", Guid.NewGuid().ToString() } }; var jObject = (JObject)delivery.Command.Request.Content; var executeRequest = jObject.ToObject <ExecuteRequest>(); var code = executeRequest.Code; var workspace = new Workspace( files: new[] { new File("Program.cs", Scaffold()) }, buffers: new[] { new Buffer(new BufferId("Program.cs", "main"), code), }, workspaceType: "console"); var workspaceRequest = new WorkspaceRequest(workspace); var server = new WorkspaceServerMultiplexer(new PackageRegistry()); var result = await server.Run(workspaceRequest); var messageBuilder = delivery.Command.Builder; var ioPubChannel = delivery.Command.IoPubChannel; var serverChannel = delivery.Command.ServerChannel; if (!executeRequest.Silent) { _executionCount++; var executeInput = messageBuilder.CreateMessage( MessageTypeValues.ExecuteInput, new ExecuteInput { Code = code, ExecutionCount = _executionCount }, delivery.Command.Request.Header); ioPubChannel.Send(executeInput); } // execute result var output = string.Join("\n", result.Output); // executeResult data var executeResultData = new ExecuteResult() { Data = new JObject { { "text/html", output }, { "text/plain", output } }, Transient = transient, ExecutionCount = _executionCount }; var resultSucceeded = result.Succeeded && result.Exception == null; if (resultSucceeded) { // reply ok var executeReplyPayload = new ExecuteReplyOk { ExecutionCount = _executionCount }; // send to server var executeReply = messageBuilder.CreateMessage( MessageTypeValues.ExecuteReply, executeReplyPayload, delivery.Command.Request.Header); executeReply.Identifiers = delivery.Command.Request.Identifiers; serverChannel.Send(executeReply); } else { var errorContent = new Error { EName = string.IsNullOrWhiteSpace(result.Exception) ? "Compile Error" : "Unhandled Exception", EValue = output, Traceback = new List <string>() }; // reply Error var executeReplyPayload = new ExecuteReplyError(errorContent) { ExecutionCount = _executionCount }; // send to server var executeReply = messageBuilder.CreateMessage( MessageTypeValues.ExecuteReply, executeReplyPayload, delivery.Command.Request.Header); executeReply.Identifiers = delivery.Command.Request.Identifiers; serverChannel.Send(executeReply); if (!executeRequest.Silent) { // send on io var error = messageBuilder.CreateMessage( MessageTypeValues.Error, errorContent, delivery.Command.Request.Header); ioPubChannel.Send(error); // send on stderr var stdErr = new StdErrStream { Text = errorContent.EValue }; var stream = messageBuilder.CreateMessage( MessageTypeValues.Stream, stdErr, delivery.Command.Request.Header); ioPubChannel.Send(stream); } } if (!executeRequest.Silent && resultSucceeded) { // send on io var executeResultMessage = messageBuilder.CreateMessage( MessageTypeValues.ExecuteResult, executeResultData, delivery.Command.Request.Header); ioPubChannel.Send(executeResultMessage); } break; } return(delivery.Complete()); }
private async Task HandleExecuteRequest(ICommandDelivery <JupyterRequestContext> delivery) { var ioPubChannel = delivery.Command.IoPubChannel; var serverChannel = delivery.Command.ServerChannel; var transient = new Dictionary <string, object> { { "display_id", Guid.NewGuid().ToString() } }; var executeRequest = delivery.Command.GetRequestContent <ExecuteRequest>(); var code = executeRequest.Code; var workspace = CreateScaffoldWorkspace(code); var workspaceRequest = new WorkspaceRequest(workspace); var result = await _server.Run(workspaceRequest); if (!executeRequest.Silent) { _executionCount++; var executeInput = Message.Create( new ExecuteInput(code: code, executionCount: _executionCount), delivery.Command.Request.Header); ioPubChannel.Send(executeInput); } // execute result var output = string.Join("\n", result.Output); // executeResult data var executeResultData = new ExecuteResult( _executionCount, transient: transient, data: new Dictionary <string, object> { { "text/html", output }, { "text/plain", output } }); var resultSucceeded = result.Succeeded && result.Exception == null; if (resultSucceeded) { // reply ok var executeReplyPayload = new ExecuteReplyOk(executionCount: _executionCount); // send to server var executeReply = Message.CreateResponse( executeReplyPayload, delivery.Command.Request); serverChannel.Send(executeReply); } else { var errorContent = new Error( eName: string.IsNullOrWhiteSpace(result.Exception) ? "Compile Error" : "Unhandled Exception", eValue: output ); // reply Error var executeReplyPayload = new ExecuteReplyError(errorContent, executionCount: _executionCount); // send to server var executeReply = Message.CreateResponse( executeReplyPayload, delivery.Command.Request); serverChannel.Send(executeReply); if (!executeRequest.Silent) { // send on io var error = Message.Create( errorContent, delivery.Command.Request.Header); ioPubChannel.Send(error); // send on stderr var stdErr = new StdErrStream(errorContent.EValue); var stream = Message.Create( stdErr, delivery.Command.Request.Header); ioPubChannel.Send(stream); } } if (!executeRequest.Silent && resultSucceeded) { // send on io var executeResultMessage = Message.Create( executeResultData, delivery.Command.Request.Header); ioPubChannel.Send(executeResultMessage); } }
internal void executeRequest(KernelMessage msg, ExecuteRequest content) { Evaluation.sbOut.Clear(); Evaluation.sbErr.Clear(); Evaluation.sbPrint.Clear(); payload.Clear(); if (!content.silent) { executionCount++; } // sending busy sendStateBusy(msg); sendMessage(ioSocket, msg, "pyin", new Pyin() { code = content.code, execution_count = executionCount }); // preprocess var newCode = preprocessCode(content.code); if (!String.IsNullOrEmpty(newCode)) { // evaluate try { (var value, var errors) = Evaluation.EvalInteractionNonThrowing(newCode); if (errors.Length > 0) { var sb = errors.Aggregate(new StringBuilder(), (ag, n) => ag.AppendLine(n)); sendError(sb.ToString(), msg); } var executeReply = new ExecuteReplyOk() { status = "ok", execution_count = executionCount, payload = payload.ToArray(), user_variables = new Dictionary <string, object>(), user_expressions = new Dictionary <string, object>() }; sendMessage(shellSocket, msg, "execute_reply", executeReply); // send all the data if (!content.silent) { var lastExpression = Evaluation.GetLastExpression(); if (lastExpression != null) { var printedResult = Printers.PrintVariable(lastExpression); sendDisplayData(printedResult.ContentType, printedResult.Data, "pyout"); } } } catch (AggregateException ae) { var esb = new StringBuilder(); esb.AppendLine(ae.Message); foreach (var e in ae.InnerExceptions) { esb.AppendLine(e.Message); } sendError(esb.ToString(), msg); } catch (Exception ex) { var error = $"Expression evaluation failed: {ex.Message}\r\n {ex.StackTrace}"; sendError(error, msg); } } if (Evaluation.sbPrint.Length > 0) { sendDisplayData("text/plain", Evaluation.sbPrint.ToString(), "display_data"); } sendStateIdle(msg); }