Java Code Examples for com.twosigma.beakerx.message.Message#getContent()

private void handleMsg(Message message) {
  Map<String, Serializable> commMap = message.getContent();
  String commId = getString(commMap, COMM_ID);
  Comm comm = kernel.getComm(commId);
  logger.debug("Comm message handling, target name: " + (comm != null ? comm.getTargetName() : "undefined"));
  if (comm != null) {
    comm.handleMsg(message);
  } else {
    MagicKernelManager magicKernelManager = kernel.getManagerByCommId(commId);
    if (magicKernelManager != null) {
      List<Message> messages = magicKernelManager.handleMsg(message);
      if (!messages.isEmpty()) {
        kernel.publish(messages);
        return;
      }
    }
    logger.warn("No such comm: " + getString(commMap, COMM_ID));
  }
}
 

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

@SuppressWarnings("unchecked")
public static Optional<Object> getSyncDataValue(Message msg) {
  Optional<Object> ret = Optional.empty();
  if (msg != null && msg.getContent() != null && msg.getContent().containsKey(DATA)) {
    Map<String, Serializable> data = (Map<String, Serializable>) msg.getContent().get(DATA);
    if (data.containsKey(SYNC_DATA)) {
      Map<String, Serializable> sync_data = (Map<String, Serializable>) data.get(SYNC_DATA);
      if (sync_data.containsKey(VALUE)) {
        ret = Optional.of(sync_data.get(VALUE));
      } else if (sync_data.containsKey(INDEX)) {
        ret = Optional.of(sync_data.get(INDEX));
      } else if (sync_data.containsKey("outputs")) {
        ret = Optional.of(sync_data.get("outputs"));
      }
    }
  }
  return ret;
}
 

static void runCommEvent(Message message, CommActions action, Widget.ActionPerformed handlerAction) {
  if (message.getContent() != null) {
    Serializable data = message.getContent().get("data");
    if (data != null && data instanceof LinkedHashMap) {
      Object contentObject = ((LinkedHashMap) data).get("content");
      if (contentObject instanceof LinkedHashMap) {
        HashMap content = (LinkedHashMap) contentObject;
        if (handlerAction != null) {
          final SimpleEvaluationObject seo = initOutput(message);
          handlerAction.executeAction(content, message);
          seo.clrOutputHandler();
        }
      }
    }
  }
}
 

@Test
public void handle_sentMessageHasLanguageInfo() throws Exception {
  //when
  handler.handle(message);
  //then
  Message sentMessage = kernel.getSentMessages().get(0);
  Map<String, Serializable> map = sentMessage.getContent();
  Assertions.assertThat(map).isNotNull();
  Assertions.assertThat(map.get("language_info")).isNotNull();
}
 

protected Map<String, T> getData(Message message) {
  Map<String, T> ret = null;
  if (message != null) {
    Map<String, Serializable> commMap = message.getContent();
    ret = (HashMap<String, T>) commMap.get(DATA);
  } else {
    logger.info("Comm message contend is null");
  }
  return ret;
}
 

private boolean isWidget(Message message, String viewNameValue) {
  if (message.getContent() != null) {
    Map<String, Serializable> data = getState(message);
    if (data != null) {
      Serializable easyForm = data.get(Widget.VIEW_NAME);
      if (easyForm != null) {
        return easyForm.equals(viewNameValue);
      }
    }
  }
  return false;
}
 

@Test
public void handle_messageContentHasGroovyLabel() throws Exception {
  //when
  handler.handle(message);
  //then
  Message sentMessage = kernel.getSentMessages().get(0);
  Map<String, Serializable> map = sentMessage.getContent();
  Assertions.assertThat(map).isNotNull();
  Assertions.assertThat(map.get("implementation")).isEqualTo("groovy");
}
 

@Test
public void handle_sentMessageHasLanguageInfo() throws Exception {
  //when
  handler.handle(message);
  //then
  Message sentMessage = kernel.getSentMessages().get(0);
  Map<String, Serializable> map = sentMessage.getContent();
  Assertions.assertThat(map).isNotNull();
  Assertions.assertThat(map.get("language_info")).isNotNull();
}
 

@Test
public void handle_sentMessageHasLanguageInfo() throws Exception {
  //when
  handler.handle(message);
  //then
  Message sentMessage = kernel.getSentMessages().get(0);
  Map<String, Serializable> map = sentMessage.getContent();
  Assertions.assertThat(map).isNotNull();
  Assertions.assertThat(map.get("language_info")).isNotNull();
}
 

@Test
public void createBusyMessage_messageHasExecutionStateIsBusy() {
  //when
  Message message = MessageCreator.createBusyMessage(commMsg());
  //then
  Map data = message.getContent();
  assertThat(data.get(MessageCreator.EXECUTION_STATE)).isEqualTo(MessageCreator.BUSY);
}
 

@Test
public void createIdleMessage_messageHasExecutionStateIsIdle() {
  //when
  Message message = MessageCreator.createIdleMessage(commMsg());
  //then
  Map data = message.getContent();
  assertThat(data.get(MessageCreator.EXECUTION_STATE)).isEqualTo(MessageCreator.IDLE);
}
 

@Test
public void handle_messageContentHasKotlinLabel() throws Exception {
  //when
  handler.handle(message);
  //then
  Message sentMessage = kernel.getSentMessages().get(0);
  Map<String, Serializable> map = sentMessage.getContent();
  Assertions.assertThat(map).isNotNull();
  Assertions.assertThat(map.get("implementation")).isEqualTo("kotlin");
}
 

@Override
public void handle(Message message) {
  if (message.getContent()!= null && message.getContent().containsKey("data")) {
    Map data = (Map) message.getContent().get("data");
    if (data.containsKey("method")) {
      String method = (String) data.get("method");
      if (method.equals("request_state")) {
        action.execute();
      }
    }
  }
}
 

public Optional<Property> getSyncDataValue(Message msg) {
  Optional<Property> ret = Optional.empty();
  if (msg != null && msg.getContent() != null && msg.getContent().containsKey("data")) {
    Map<String, Serializable> data = (Map<String, Serializable>) msg.getContent().get("data");
    if (data.containsKey("state")) {
      Map<String, Serializable> sync_data = (Map<String, Serializable>) data.get("state");
      if (sync_data.containsKey("loadMoreRows")) {
        ret = Optional.of(new Property("loadMoreRows", sync_data.get("loadMoreRows")));
      }
    }
  }
  return ret;
}
 

private void verifyAutocompleteMsg(Message reply, int expectedCursorStart, int expectedCursorEnd) {
  Map<String, Serializable> content = reply.getContent();
  int cursorStart = (int) content.get(CompleteHandler.CURSOR_START);
  assertThat(cursorStart).isEqualTo(expectedCursorStart);
  int cursorEnd = (int) content.get(CompleteHandler.CURSOR_END);
  assertThat(cursorEnd).isEqualTo(expectedCursorEnd);
  Object[] matches = (Object[]) content.get(CompleteHandler.MATCHES);
  assertThat(matches).isNotEmpty();
}
 

@Test
public void handle_messageContentHasClojureLabel() throws Exception {
  //when
  handler.handle(message);
  //then
  Message sentMessage = kernel.getSentMessages().get(0);
  Map<String, Serializable> map = sentMessage.getContent();
  Assertions.assertThat(map).isNotNull();
  Assertions.assertThat(map.get("implementation")).isEqualTo("clojure");
}
 

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 boolean isIdleMessage(Message message) {
  return message.getContent() != null &&
          message.getContent().get("execution_state") != null &&
          message.getContent().get("execution_state").equals("idle");
}
 

public static boolean isBusyMessage(Message message) {
  return  message.getContent() != null &&
          message.getContent().get("execution_state") != null &&
          message.getContent().get("execution_state").equals("busy");
}