コード例 #1
0
  /**
   * Start topology event receiver thread.
   *
   * @param executorService executor service instance
   * @param topologyProvider topology provider instance
   */
  private void startTopologyEventReceiver(
      ExecutorService executorService, TopologyProvider topologyProvider) {
    // Enforcing the listener order in order execute extension listener later
    topologyEventReceiver = new LoadBalancerCommonTopologyEventReceiver(topologyProvider, false);
    // Add load-balancer extension event listener
    addTopologyEventListeners(topologyEventReceiver);
    // Add default topology provider event listeners
    topologyEventReceiver.addEventListeners();
    topologyEventReceiver.setExecutorService(executorService);
    topologyEventReceiver.execute();
    if (log.isInfoEnabled()) {
      log.info("Topology receiver thread started");
    }

    if (log.isInfoEnabled()) {
      if (TopologyServiceFilter.getInstance().isActive()) {
        log.info(
            String.format(
                "Service filter activated: [filter] %s",
                TopologyServiceFilter.getInstance().toString()));
      }

      if (TopologyClusterFilter.getInstance().isActive()) {
        log.info(
            String.format(
                "Cluster filter activated: [filter] %s",
                TopologyClusterFilter.getInstance().toString()));
      }

      if (TopologyMemberFilter.getInstance().isActive()) {
        log.info(
            String.format(
                "Member filter activated: [filter] %s",
                TopologyMemberFilter.getInstance().toString()));
      }
    }
  }
コード例 #2
0
  private boolean doProcess(ClusterCreatedEvent event, Topology topology) {
    Cluster cluster = event.getCluster();
    String applicationId = cluster.getAppId();
    String serviceName = cluster.getServiceName();
    String clusterId = cluster.getClusterId();

    // Apply application filter
    if (TopologyApplicationFilter.apply(applicationId)) {
      return false;
    }

    // Apply service filter
    if (TopologyServiceFilter.apply(serviceName)) {
      return false;
    }

    // Apply cluster filter
    if (TopologyClusterFilter.apply(clusterId)) {
      return false;
    }

    // Validate event against the existing topology
    Service service = topology.getService(serviceName);
    if (service == null) {
      if (log.isWarnEnabled()) {
        log.warn(String.format("Service does not exist: [service] %s", serviceName));
      }
      return false;
    }
    if (service.clusterExists(clusterId)) {
      if (log.isDebugEnabled()) {
        log.debug(
            String.format(
                "Cluster already exists in service: [service] %s " + "[cluster] %s",
                serviceName, clusterId));
      }
    } else {

      // Apply changes to the topology
      service.addCluster(cluster);
      if (log.isInfoEnabled()) {
        log.info(String.format("Cluster created: %s", cluster.toString()));
      }
    }

    // Notify event listeners
    notifyEventListeners(event);
    return true;
  }
  @Override
  public boolean process(String type, String message, Object object) {
    Topology topology = (Topology) object;

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

      // Parse complete message and build event
      MemberTerminatedEvent event =
          (MemberTerminatedEvent) Util.jsonToObject(message, MemberTerminatedEvent.class);

      // Apply service filter
      if (TopologyServiceFilter.getInstance().isActive()) {
        if (TopologyServiceFilter.getInstance().serviceNameExcluded(event.getServiceName())) {
          // Service is excluded, do not update topology or fire event
          if (log.isDebugEnabled()) {
            log.debug(String.format("Service is excluded: [service] %s", event.getServiceName()));
          }
          return false;
        }
      }

      // Apply cluster filter
      if (TopologyClusterFilter.getInstance().isActive()) {
        if (TopologyClusterFilter.getInstance().clusterIdExcluded(event.getClusterId())) {
          // Cluster is excluded, do not update topology or fire event
          if (log.isDebugEnabled()) {
            log.debug(String.format("Cluster is excluded: [cluster] %s", event.getClusterId()));
          }
          return false;
        }
      }

      // Validate event against the existing topology
      Service service = topology.getService(event.getServiceName());
      if (service == null) {
        if (log.isWarnEnabled()) {
          log.warn(String.format("Service does not exist: [service] %s", event.getServiceName()));
        }
        return false;
      }
      Cluster cluster = service.getCluster(event.getClusterId());
      if (cluster == null) {
        if (log.isWarnEnabled()) {
          log.warn(
              String.format(
                  "Cluster does not exist: [service] %s [cluster] %s",
                  event.getServiceName(), event.getClusterId()));
        }
        return false;
      }
      Member member = cluster.getMember(event.getMemberId());
      if (member == null) {
        if (log.isWarnEnabled()) {
          log.warn(
              String.format(
                  "Member does not exist: [service] %s [cluster] %s [member] %s",
                  event.getServiceName(), event.getClusterId(), event.getMemberId()));
        }
        return false;
      }

      // Apply member filter
      if (TopologyMemberFilter.getInstance().isActive()) {
        if (TopologyMemberFilter.getInstance().lbClusterIdExcluded(member.getLbClusterId())) {
          if (log.isDebugEnabled()) {
            log.debug(
                String.format("Member is excluded: [lb-cluster-id] %s", member.getLbClusterId()));
          }
          return false;
        }
      }

      if (member.getStatus() == MemberStatus.Terminated) {
        if (log.isWarnEnabled()) {
          log.warn(
              String.format(
                  "Member already terminated: [service] %s [cluster] %s [member] %s",
                  event.getServiceName(), event.getClusterId(), event.getMemberId()));
        }
      } else {

        // Apply changes to the topology
        member.setStatus(MemberStatus.Terminated);
        // removing the member from the cluster
        cluster.removeMember(member);

        if (log.isInfoEnabled()) {
          log.info(
              String.format(
                  "Member terminated: [service] %s [cluster] %s [member] %s",
                  event.getServiceName(), event.getClusterId(), event.getMemberId()));
        }
      }

      notifyEventListeners(event);
      return true;

    } 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));
      }
    }
  }
コード例 #4
0
  private boolean doProcess(MemberMaintenanceModeEvent event, Topology topology) {

    String serviceName = event.getServiceName();
    String clusterId = event.getClusterId();

    // Apply service filter
    if (TopologyServiceFilter.apply(serviceName)) {
      return false;
    }

    // Apply cluster filter
    if (TopologyClusterFilter.apply(clusterId)) {
      return false;
    }

    // Validate event against the existing topology
    Service service = topology.getService(event.getServiceName());
    if (service == null) {
      if (log.isWarnEnabled()) {
        log.warn(String.format("Service does not exist: [service] %s", event.getServiceName()));
      }
      return false;
    }
    Cluster cluster = service.getCluster(event.getClusterId());
    if (cluster == null) {
      if (log.isWarnEnabled()) {
        log.warn(
            String.format(
                "Cluster does not exist: [service] %s [cluster] %s",
                event.getServiceName(), event.getClusterId()));
      }
      return false;
    }

    // Apply application filter
    if (TopologyApplicationFilter.apply(cluster.getAppId())) {
      return false;
    }

    Member member = cluster.getMember(event.getMemberId());
    if (member == null) {
      if (log.isWarnEnabled()) {
        log.warn(
            String.format(
                "Member does not exist: [service] %s [cluster] %s [member] %s",
                event.getServiceName(), event.getClusterId(), event.getMemberId()));
      }
      return false;
    }

    // Apply member filter
    if (TopologyMemberFilter.apply(member.getLbClusterId(), member.getNetworkPartitionId())) {
      return false;
    }

    if (member.getStatus() == MemberStatus.In_Maintenance) {
      if (log.isDebugEnabled()) {
        log.debug(
            String.format(
                "Member already updated as In_Maintenance: "
                    + "[service] %s [cluster] %s [member] %s",
                event.getServiceName(), event.getClusterId(), event.getMemberId()));
      }
    } else {

      // Apply changes to the topology
      if (!member.isStateTransitionValid(MemberStatus.In_Maintenance)) {
        log.error(
            "Invalid State Transition from "
                + member.getStatus()
                + " to "
                + MemberStatus.In_Maintenance);
      }
      member.setStatus(MemberStatus.In_Maintenance);

      if (log.isInfoEnabled()) {
        log.info(
            String.format(
                "Member updated as In_Maintenance: [service] %s [cluster] %s [member] %s",
                event.getServiceName(), event.getClusterId(), event.getMemberId()));
      }
    }

    // Notify event listeners
    notifyEventListeners(event);
    return true;
  }