@Override
  public boolean process(String type, String message, Object object) {
    Applications applications = (Applications) object;

    if (GroupInstanceTerminatingEvent.class.getName().equals(type)) {
      // Return if applications has not been initialized
      if (!applications.isInitialized()) return false;

      // Parse complete message and build event
      GroupInstanceTerminatingEvent event =
          (GroupInstanceTerminatingEvent)
              MessagingUtil.jsonToObject(message, GroupInstanceTerminatingEvent.class);

      ApplicationsUpdater.acquireWriteLockForApplication(event.getAppId());

      try {
        return doProcess(event, applications);

      } finally {
        ApplicationsUpdater.releaseWriteLockForApplication(event.getAppId());
      }

    } else {
      if (nextProcessor != null) {
        // ask the next processor to take care of the message.
        return nextProcessor.process(type, message, applications);
      } else {
        throw new RuntimeException(
            String.format(
                "Failed to process message using available message processors: [type] %s [body] %s",
                type, message));
      }
    }
  }
  @Override
  public boolean process(String type, String message, Object object) {
    Topology topology = (Topology) object;

    if (MemberMaintenanceModeEvent.class.getName().equals(type)) {
      // Return if topology has not been initialized
      if (!TopologyManager.isInitialized()) return false;

      // Parse complete message and build event
      MemberMaintenanceModeEvent event =
          (MemberMaintenanceModeEvent)
              MessagingUtil.jsonToObject(message, MemberMaintenanceModeEvent.class);

      TopologyUpdater.acquireWriteLockForCluster(event.getServiceName(), event.getClusterId());
      try {
        return doProcess(event, topology);

      } finally {
        TopologyUpdater.releaseWriteLockForCluster(event.getServiceName(), event.getClusterId());
      }

    } else {
      if (nextProcessor != null) {
        // ask the next processor to take care of the message.
        return nextProcessor.process(type, message, topology);
      } else {
        throw new RuntimeException(
            String.format(
                "Failed to process message using available message processors: [type] %s [body] %s",
                type, message));
      }
    }
  }
  @Override
  public boolean process(String type, String message, Object object) {
    if (CompleteTopologyRequestEvent.class.getName().equals(type)) {
      // Parse complete message and build event
      CompleteTopologyRequestEvent event =
          (CompleteTopologyRequestEvent)
              MessagingUtil.jsonToObject(message, CompleteTopologyRequestEvent.class);

      // Notify event listeners
      notifyEventListeners(event);
      return true;
    } else {
      if (nextProcessor != null) {
        // ask the next processor to take care of the message.
        return nextProcessor.process(type, message, object);
      } else {
        throw new RuntimeException(
            String.format(
                "Failed to process message using available message processors: [type] %s [body] %s",
                type, message));
      }
    }
  }