private static Message initMessage(JupyterMessages type, Message message) { Message reply = new Message(new Header(type, message.getHeader().getSession())); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); return reply; }
private static Message copyMessage(Message origin) { String header = toJson(origin.getHeader()); Message copy = new Message(parse(header, Header.class)); for (byte[] list : origin.getIdentities()) { copy.getIdentities().add(list.clone()); } String parent = toJson(origin.getParentHeader()); String metadata = toJson(origin.getMetadata()); String content = toJson(origin.getContent()); copy.setParentHeader(parse(parent, Header.class)); copy.setMetadata(parse(metadata, LinkedHashMap.class)); copy.setContent(parse(content, LinkedHashMap.class)); return copy; }
private void verifyIfStreamMsgIsEarlierThanResult() { List<Message> publishedMessages = kernelSocketsService.getKernelSockets().getPublishedMessages(); List<Message> collect = publishedMessages.stream() .filter(x -> (x.type().equals(JupyterMessages.STREAM) || x.type().equals(JupyterMessages.EXECUTE_RESULT))) .collect(Collectors.toList()); assertThat(collect.get(0).type()).isEqualTo(JupyterMessages.STREAM); assertThat(collect.get(1).type()).isEqualTo(JupyterMessages.STREAM); assertThat(collect.get(2).type()).isEqualTo(JupyterMessages.EXECUTE_RESULT); }
private Message parseMessage(String stringJson) throws IOException { ObjectMapper mapper = new ObjectMapper(); JsonNode json = mapper.readTree(stringJson); Message msg = new Message(mapper.convertValue(json.get("header"), Header.class)); msg.setContent(mapper.convertValue(json.get("content"), Map.class)); msg.setMetadata(mapper.convertValue(json.get("metadata"), Map.class)); msg.setBuffers(mapper.convertValue(json.get("buffers"), List.class)); List<byte[]> identities = mapper.convertValue(json.get("comm_id"), List.class); msg.setIdentities(identities == null ? new ArrayList<>() : identities); return msg; }
protected Message createReplyMessage(Message message, Serializable responceData) { Message ret = null; if (message != null) { ret = new Message(new Header(COMM_MSG, message.getHeader().getSession())); Map<String, Serializable> commMap = message.getContent(); HashMap<String, Serializable> map = new HashMap<>(); map.put(COMM_ID, getString(commMap, COMM_ID)); map.put(DATA, responceData); ret.setContent(map); } return ret; }
@Test public void commCreatedWithoutParentMessageShouldAlwaysSendHeaderFromMessageGivenFromInternalVariable() throws NoSuchAlgorithmException { // code from first execution Message message1 = submitCodeToExecution(); comm.open(); assertThat(kernel.getPublishedMessages().get(0).getParentHeader()).isEqualTo(message1.getHeader()); kernel.clearPublishedMessages(); // code from second execution Message message2 = submitCodeToExecution(); comm.send(COMM_MSG, Comm.Buffer.EMPTY, comm.getData()); assertThat(kernel.getPublishedMessages().get(0).getParentHeader()).isEqualTo(message2.getHeader()); }
private synchronized void sendMsg(ZMQ.Socket socket, List<Message> messages) { if (!isShutdown()) { messages.forEach(message -> { String header = toJson(message.getHeader()); String parent = toJson(message.getParentHeader()); String meta = toJson(message.getMetadata()); String content = toJson(message.getContent()); String digest = hmac.sign(Arrays.asList(header, parent, meta, content)); ZMsg newZmsg = new ZMsg(); message.getIdentities().forEach(newZmsg::add); newZmsg.add(DELIM); newZmsg.add(digest.getBytes(StandardCharsets.UTF_8)); newZmsg.add(header.getBytes(StandardCharsets.UTF_8)); newZmsg.add(parent.getBytes(StandardCharsets.UTF_8)); newZmsg.add(meta.getBytes(StandardCharsets.UTF_8)); newZmsg.add(content.getBytes(StandardCharsets.UTF_8)); message.getBuffers().forEach(x -> newZmsg.add(x)); newZmsg.send(socket); }); } }
public static Message messageMessage(JupyterMessages type, Buffer buffer, Map<String, Serializable> content, Message parentMessage) { Message message = new Message(new Header(type, parentMessage.getHeader().getSession())); checkNotNull(parentMessage); message.setParentHeader(parentMessage.getHeader()); message.setContent(content); message.setMetadata(buildMetadata()); if (!buffer.isEmpty()) { message.setBuffers(buffer.getBuffers()); } return message; }
private static boolean isStderr(Message message) { return message.getContent() != null && message.getContent().get("name") != null && message.getContent().get("name").equals("stderr") && message.getContent().get("text") != null; }
public static void initMessage(Message message) { message.getIdentities().add("identityStr".getBytes()); message.setParentHeader(message.getHeader()); message.setMetadata(new LinkedHashMap<>()); message.setContent(new LinkedHashMap<>()); }
@Test public void handleMessageWithoutCommId_shouldSendCloseCommMessage() throws Exception { //given message.getContent().remove(COMM_ID); //when commOpenHandler.handle(message); //then Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_CLOSE.getName()); }
public static Message createMessage() { Header header = new Header(JupyterMessages.COMM_MSG, "session1"); Message message = new Message(header); message.getIdentities().add("identityStr".getBytes()); message.setParentHeader(header); message.setMetadata(new LinkedHashMap<>()); message.setContent(new LinkedHashMap<>()); return message; }
private TryResult initSparkContextInShell(KernelFunctionality kernel, Message parent) { String addSc = String.format(("import com.twosigma.beakerx.widget.SparkVariable\n" + "val %s = SparkVariable.getSparkSession()\n" + "val %s = %s.sparkContext\n" + "import org.apache.spark.SparkContext._\n" + "import %s.implicits._\n" + "import %s.sql\n" + "import org.apache.spark.sql.functions._\n"), SPARK_SESSION_NAME, SPARK_CONTEXT_NAME, SPARK_SESSION_NAME, SPARK_SESSION_NAME, SPARK_SESSION_NAME); SimpleEvaluationObject seo = createSimpleEvaluationObject(addSc, kernel, new Message(new Header(JupyterMessages.COMM_MSG, parent.getHeader().getSession())), 1); return kernel.executeCode(addSc, seo); }
public static Message initCommMessage(Map<String, Serializable> content) { Message message = new Message(initHeader(JupyterMessages.COMM_MSG)); message.setIdentities(Arrays.asList("identities".getBytes())); message.setContent(content); return message; }
private synchronized void send(boolean isError, String text) { List<Message> list = new ArrayList<>(); list.add(getComm().createUpdateMessage(MSG_ID, getComm().getParentMessage().getHeader().getId())); Map<String, Serializable> asMap = addOutput(isError, text); list.add(getComm().createOutputContent(asMap)); list.add(getComm().createUpdateMessage(MSG_ID, "")); getComm().publish(list); }
private static Message executeRequestMessage() { Message message = new Message(initHeader(JupyterMessages.EXECUTE_REQUEST)); message.setIdentities(Arrays.asList("identities".getBytes())); message.setParentHeader(null); message.setMetadata(new LinkedHashMap<>()); return message; }
public static Message buildMessage(Message message, List<MIMEContainer> mimes, int executionCount) { Message reply = initMessage(EXECUTE_RESULT, message); reply.setContent(new HashMap<>()); reply.getContent().put("execution_count", executionCount); HashMap<String, Object> map3 = new HashMap<>(); mimes.forEach(mimeItem -> map3.put(mimeItem.getMime().asString(), mimeItem.getData())); reply.getContent().put("data", map3); reply.getContent().put("metadata", new HashMap<>()); return reply; }
private static Optional<Message> getIdleMessage(List<Message> messages) { return messages.stream(). filter(x -> (x.type().equals(JupyterMessages.STATUS)) && (x.getContent().get("execution_state").equals("idle"))).findFirst(); }
public static Message getExecuteRequestMessage(String code) { Header header = new Header(JupyterMessages.COMM_MSG,"session1"); Message message = new Message(header); header.setTypeEnum(JupyterMessages.EXECUTE_REQUEST); HashMap<String, Serializable> content = new HashMap<>(); content.put("code", code); message.setContent(content); return message; }
public static Message initInfoMessage() { Message message = new Message(initHeader(JupyterMessages.COMM_INFO_REQUEST)); message.setIdentities(Arrays.asList("identities".getBytes())); return message; }