private void publishMessage(KernelFunctionality kernel, Message message, int executionCount) { for (Message msg : responses) { msg.setParentHeader(message.getHeader()); } kernel.publish(responses); }
public List<Message> handleMsg(Message message) { List<Message> messages = new ArrayList<>(); try { getPythonEntryPoint(); } catch (NoSuchKernelException e) { return messages; } pep.sendMessage(new ObjectMapper().valueToTree(message).toString()); try { messages = getIopubMessages(); } catch (IOException e) { e.printStackTrace(); } for (Message msg : messages) { msg.setParentHeader(message.getHeader()); } return messages; }
private void handleMsg(Message message) { logger.debug("Processing CommInfoHandler"); Message reply = new Message(new Header(COMM_INFO_REPLY, message.getHeader().getSession())); HashMap<String, Serializable> content = new HashMap<>(); content.put(COMMS, new HashMap<String, Serializable>()); String target = getMessageTarget(message); kernel.getCommHashSet().stream() .map(hash -> kernel.getComm(hash)) .filter(comm -> target == null || target.isEmpty() || comm.getTargetName().equals(target)) .forEach(comm -> { HashMap<String, Serializable> commRepDetails = new HashMap<>(); commRepDetails.put(TARGET_NAME, comm.getTargetName()); ((HashMap<String, Serializable>) content.get(COMMS)).put(comm.getCommId(), commRepDetails); }); reply.setContent(content); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); send(reply); }
private Message createMsg(Message message, int cursorPos, AutocompleteResult autocomplete) { Message reply = new Message(new Header(COMPLETE_REPLY, message.getHeader().getSession())); reply.setIdentities(message.getIdentities()); reply.setParentHeader(message.getHeader()); Map<String, Serializable> content = new HashMap<>(); content.put(STATUS, "ok"); content.put(MATCHES, autocomplete.getMatches().toArray()); content.put(CURSOR_END, cursorPos); content.put(CURSOR_START, autocomplete.getStartIndex()); reply.setContent(content); return reply; } }
private void announceTheCode(Message message, String code) { Message reply = new Message(new Header(EXECUTE_INPUT, message.getHeader().getSession())); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); Map<String, Serializable> map1 = new HashMap<>(2); map1.put("execution_count", executionCount); map1.put("code", code); reply.setContent(map1); kernel.publish(singletonList(reply)); }
private Message createMsg(Message message, InspectResult inspectResult) { Message reply = new Message(new Header(INSPECT_REPLY, message.getHeader().getSession())); reply.setIdentities(message.getIdentities()); reply.setParentHeader(message.getHeader()); Map<String, Serializable> content = new HashMap<>(); content.put(STATUS, "ok"); content.put(DATA, inspectResult.getData()); //content.put(METADATA, {}); content.put(FOUND, inspectResult.getFound()); reply.setContent(content); return reply; } }
private void handleMsg(Message message) { logger.debug("Processing is complete request"); Message reply = new Message(new Header(IS_COMPLETE_REPLY, message.getHeader().getSession())); HashMap<String, Serializable> map = new HashMap<>(); map.put("status", "complete"); reply.setContent(map); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); send(reply); } }
public static void initMessage(Message message) { message.getIdentities().add("identityStr".getBytes()); message.setParentHeader(message.getHeader()); message.setMetadata(new LinkedHashMap<>()); message.setContent(new LinkedHashMap<>()); }
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 void close() { Message parentMessage = getParentMessage(); if (this.getCloseCallbackList() != null && !this.getCloseCallbackList().isEmpty()) { for (Handler<Message> handler : getCloseCallbackList()) { handler.handle(parentMessage); } } Message message = new Message(new Header(COMM_CLOSE, parentMessage.getHeader().getSession())); if (parentMessage != null) { message.setParentHeader(parentMessage.getHeader()); } HashMap<String, Serializable> map = new HashMap<>(); map.put(COMM_ID, getCommId()); map.put(DATA, new HashMap<>()); map.put(METADATA, new HashMap<>()); message.setContent(map); message.setMetadata(buildMetadata()); kernel.removeComm(getCommId()); kernel.publish(singletonList(message)); }
private void doOpen(Message parentMessage, Buffer buffer) { Preconditions.checkNotNull(parentMessage, "parent message can not be null"); Message message = new Message(new Header(COMM_OPEN, parentMessage.getHeader().getSession())); message.setParentHeader(parentMessage.getHeader()); HashMap<String, Serializable> map = new HashMap<>(); map.put(COMM_ID, getCommId()); map.put(TARGET_NAME, getTargetName()); HashMap<String, Serializable> state = new HashMap<>(); state.put(STATE, data.getData()); state.put(METHOD, (Serializable) data.getData().get(METHOD)); if (!buffer.isEmpty()) { state.put(BUFFER_PATHS, buffer.getBufferPaths()); message.setBuffers(buffer.getBuffers()); } map.put(DATA, state); map.put(METADATA, metadata); map.put(TARGET_MODULE, getTargetModule()); message.setContent(map); message.setMetadata(buildMetadata()); kernel.publish(singletonList(message)); kernel.addComm(getCommId(), this); }
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 void handleMsg(Message message) { logger.debug("Processing CommCloseHandler"); Map<String, Serializable> commMap = message.getContent(); String targetName = (kernel.getComm(getString(commMap, COMM_ID)) != null) ? kernel.getComm(getString(commMap, COMM_ID)).getTargetName() : ""; kernel.removeComm(getString(commMap, COMM_ID)); Message reply = new Message(new Header(COMM_CLOSE, message.getHeader().getSession())); HashMap<String, Serializable> map = new HashMap<>(); map.put(DATA, new HashMap<>()); reply.setContent(map); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); send(reply); logger.debug("Comm closed, target name = " + targetName); } }
private void handleMsg(Message message) { logger.debug("Processing kernel info request"); Message reply = new Message(new Header(KERNEL_INFO_REPLY, message.getHeader().getSession())); reply.setContent(content()); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); send(reply); }
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 void handleMsg(Message message) { logger.debug("Processing CommOpenHandler"); Message reply = null; HashMap<String, Serializable> map = new HashMap<>(6); Map<String, Serializable> commMap = message.getContent(); Comm newComm = null; if (isValidMessage(commMap)) { newComm = readComm(commMap, message); reply = new Message(new Header(COMM_OPEN, message.getHeader().getSession())); map.put(COMM_ID, newComm.getCommId()); map.put(TARGET_NAME, newComm.getTargetName()); map.put(DATA, new HashMap<>()); map.put(TARGET_MODULE, newComm.getTargetModule()); } else { reply = new Message(new Header(COMM_CLOSE, message.getHeader().getSession())); map.put(DATA, new HashMap<>()); } if (newComm != null) { logger.debug("Comm opened, target name = " + newComm.getTargetName()); for (Handler<Message> handler : getKernelControlChanelHandlers(newComm.getTargetName())) { newComm.addMsgCallbackList(handler); } kernel.addComm(newComm.getCommId(), newComm); } reply.setContent(map); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); send(reply); }
private void handleControlMsg() { Message message = readMessage(controlSocket); JupyterMessages type = message.getHeader().getTypeEnum(); if (type.equals(SHUTDOWN_REQUEST)) { Message reply = new Message(new Header(SHUTDOWN_REPLY, message.getHeader().getSession())); reply.setParentHeader(message.getHeader()); reply.setContent(message.getContent()); sendMsg(controlSocket, Collections.singletonList(reply)); shutdown(); } }
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 Message readMessage(ZMQ.Socket socket) { ZMsg zmsg = null; Message message = null; try { zmsg = ZMsg.recvMsg(socket); ZFrame[] parts = new ZFrame[zmsg.size()]; zmsg.toArray(parts); byte[] uuid = parts[MessageParts.UUID].getData(); byte[] header = parts[MessageParts.HEADER].getData(); byte[] parent = parts[MessageParts.PARENT].getData(); byte[] metadata = parts[MessageParts.METADATA].getData(); byte[] content = parts[MessageParts.CONTENT].getData(); byte[] expectedSig = parts[MessageParts.HMAC].getData(); verifyDelim(parts[MessageParts.DELIM]); verifySignatures(expectedSig, header, parent, metadata, content); message = new Message(parse(header, Header.class)); if (uuid != null) { message.getIdentities().add(uuid); } message.setParentHeader(parse(parent, Header.class)); message.setMetadata(parse(metadata, LinkedHashMap.class)); message.setContent(parse(content, LinkedHashMap.class)); } finally { if (zmsg != null) { zmsg.destroy(); } } return message; }
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; }