Java ExternalView.getStateMap方法代码示例

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private ViewInfo createViewInfo(Map<String, List<String>> partitionHostMap) {
  ExternalView externalView = new ExternalView(RESOURCE);
  for (Map.Entry<String, List<String>> entry : partitionHostMap.entrySet()) {
    String host = entry.getKey();
    for (String partition : entry.getValue()) {
      String partitionInHelix = RESOURCE + "$" + partition;
      Map<String, String> stateMap = externalView.getStateMap(partitionInHelix);
      if (stateMap == null) {
        stateMap = Maps.newHashMap();
        stateMap.put(host, "ONLINE");
        externalView.setStateMap(partitionInHelix, stateMap);
      } else {
        stateMap.put(host, "ONLINE");
      }
    }
  }
  return new ViewInfo(externalView);
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private Set<String> getServingDataResource(List<ExternalView> externalViewList) {
  Set<String> servingDataResourceSet = new HashSet<String>();
  for (ExternalView externalView : externalViewList) {
    if (externalView.getResourceName().equals(CommonConstants.Helix.BROKER_RESOURCE_INSTANCE)) {
      Set<String> dataResources = externalView.getPartitionSet();
      for (String dataResource : dataResources) {
        Map<String, String> dataResourceToServingBrokerMap = externalView.getStateMap(dataResource);
        if (dataResourceToServingBrokerMap.containsKey(_instanceId)
            && "ONLINE".equals(dataResourceToServingBrokerMap.get(_instanceId))) {
          servingDataResourceSet.add(dataResource);
        }
      }
    }
  }
  LOGGER.info("Current serving data resource : " + Arrays.toString(servingDataResourceSet.toArray(new String[0])));
  return servingDataResourceSet;
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private Map<String, Integer> getStateCountMap(ExternalView externalView) {
  Map<String, Integer> stateCountMap = new HashMap<String, Integer>();
  if (externalView == null) {
    return stateCountMap;
  }
  for (String slice : externalView.getPartitionSet()) {
    Map<String, String> stateMap = externalView.getStateMap(slice);
    for (String instance : stateMap.keySet()) {
      String state = stateMap.get(instance);
      if (!stateCountMap.containsKey(state)) {
        stateCountMap.put(state, 0);
      }
      stateCountMap.put(state, stateCountMap.get(state) + 1);
    }
  }
  return stateCountMap;
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private static void printState(String msg) {
  System.out.println("CLUSTER STATE: " + msg);
  ExternalView resourceExternalView = admin.getResourceExternalView(CLUSTER_NAME, RESOURCE_NAME);
  TreeSet<String> sortedSet = new TreeSet<String>(resourceExternalView.getPartitionSet());
  StringBuilder sb = new StringBuilder("\t\t");
  for (int i = 0; i < NUM_NODES; i++) {
    sb.append(INSTANCE_CONFIG_LIST.get(i).getInstanceName()).append("\t");
  }
  System.out.println(sb);
  for (String partitionName : sortedSet) {
    sb.delete(0, sb.length() - 1);
    sb.append(partitionName).append("\t");
    for (int i = 0; i < NUM_NODES; i++) {
      Map<String, String> stateMap = resourceExternalView.getStateMap(partitionName);
      if (stateMap != null && stateMap.containsKey(INSTANCE_CONFIG_LIST.get(i).getInstanceName())) {
        sb.append(stateMap.get(INSTANCE_CONFIG_LIST.get(i).getInstanceName()).charAt(0)).append(
            "\t\t");
      } else {
        sb.append("-").append("\t\t");
      }
    }
    System.out.println(sb);
  }
  System.out.println("###################################################################");
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
@Test(dependsOnMethods = "testAddParticipant")
public void testStopAndReStartParticipant()
    throws InterruptedException {
  MockParticipantManager participant = _participants.get(0);
  String instance = participant.getInstanceName();

  Map<String, MasterSlaveSMD.States> affectedPartitions =
      new HashMap<String, MasterSlaveSMD.States>();

  ExternalView externalView = _accessor.getProperty(_keyBuilder.externalView(DB_NAME));

  for (String partition : externalView.getPartitionSet()) {
    Map<String, String> stateMap = externalView.getStateMap(partition);
    if (stateMap.containsKey(instance)) {
      affectedPartitions.put(partition, MasterSlaveSMD.States.valueOf(stateMap.get(instance)));
    }
  }

  stopParticipant(participant, affectedPartitions);

  // create a new participant
  participant = new MockParticipantManager(ZK_ADDR, CLUSTER_NAME, instance);
  _participants.set(0, participant);
  startParticipant(participant, affectedPartitions);
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private void startParticipant(
    MockParticipantManager participant, Map<String, MasterSlaveSMD.States> affectedPartitions)
    throws InterruptedException {
  String instance = participant.getInstanceName();
  participant.syncStart();

  Thread.sleep(2000);

  ExternalView externalView = _accessor.getProperty(_keyBuilder.externalView(DB_NAME));
  // Everything back to the initial state
  for (Map.Entry<String, MasterSlaveSMD.States> entry : affectedPartitions.entrySet()) {
    Map<String, String> stateMap = externalView.getStateMap(entry.getKey());
    Assert.assertEquals(stateMap.size(), REPLICA_NUMBER);

    Assert.assertTrue(stateMap.containsKey(instance));
    Assert.assertEquals(stateMap.get(instance), entry.getValue().toString());
  }
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private boolean isParentTaskDone(ExternalView ev) {
  Set<String> partitionSet = ev.getPartitionSet();
  if (partitionSet.isEmpty()) {
    return false;
  }

  for (String partition : partitionSet) {
    Map<String, String> stateMap = ev.getStateMap(partition);
    for (String instance : stateMap.keySet()) {
      if (!stateMap.get(instance).equalsIgnoreCase("Online")) {
        return false;
      }
    }
  }
  return true;
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private static void printStatus(HelixAdmin admin, String cluster, String resource) {
  ExternalView externalView = admin.getResourceExternalView(cluster, resource);
  // System.out.println(externalView);
  TreeSet<String> treeSet = new TreeSet<String>(externalView.getPartitionSet());
  System.out.println("lockName" + "\t" + "acquired By");
  System.out.println("======================================");
  for (String lockName : treeSet) {
    Map<String, String> stateMap = externalView.getStateMap(lockName);
    String acquiredBy = null;
    if (stateMap != null) {
      for (String instanceName : stateMap.keySet()) {
        if ("ONLINE".equals(stateMap.get(instanceName))) {
          acquiredBy = instanceName;
          break;
        }
      }
    }
    System.out.println(lockName + "\t" + ((acquiredBy != null) ? acquiredBy : "NONE"));
  }
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
public ViewInfo(ExternalView externalView) {
  this.resource = externalView.getResourceName();
  Set<String> partitionSet = externalView.getPartitionSet();
  this.partitionMap = Maps.newTreeMap();
  for (String partition : partitionSet) {
    Map<String, String> stateMap = externalView.getStateMap(partition);
    Pair<String, Integer> resourceAndPartitionNum =
        TerrapinUtil.getResourceAndPartitionNum(partition);
    if (resourceAndPartitionNum == null) {
      LOG.warn("Invalid helix partition for " + resource + " : " + partition);
      continue;
    }
    if (stateMap == null) {
      continue;
    }
    List<String> instanceList = Lists.newArrayListWithCapacity(5);
    for (Map.Entry<String, String> entry : stateMap.entrySet()) {
      if (entry.getValue().equals("ONLINE")) {
        instanceList.add(entry.getKey());
      }
    }
    // Keep the list in alphabetical order.
    if (!instanceList.isEmpty()) {
      Collections.sort(instanceList);
      this.partitionMap.put(TerrapinUtil.getViewPartitionName(resource,
              resourceAndPartitionNum.getRight()), instanceList);
    }
  }
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private boolean ifExternalViewChangeReflectedForState(String tableName, String segmentName, String targetState,
    long timeoutMillis, boolean considerErrorStateAsDifferentFromTarget) {
  long externalViewChangeCompletedDeadline = System.currentTimeMillis() + timeoutMillis;

  deadlineLoop:
  while (System.currentTimeMillis() < externalViewChangeCompletedDeadline) {
    ExternalView externalView = _helixAdmin.getResourceExternalView(_helixClusterName, tableName);
    Map<String, String> segmentStatsMap = externalView.getStateMap(segmentName);
    if (segmentStatsMap != null) {
      for (String instance : segmentStatsMap.keySet()) {
        final String segmentState = segmentStatsMap.get(instance);

        // jfim: Ignore segments in error state as part of checking if the external view change is reflected
        if (!segmentState.equalsIgnoreCase(targetState)) {
          if ("ERROR".equalsIgnoreCase(segmentState) && !considerErrorStateAsDifferentFromTarget) {
            // Segment is in error and we don't consider error state as different from target, therefore continue
          } else {
            // Will try to read data every 500 ms, only if external view not updated.
            Uninterruptibles.sleepUninterruptibly(_externalViewUpdateRetryInterval, TimeUnit.MILLISECONDS);
            continue deadlineLoop;
          }
        }
      }

      // All segments match with the expected external view state
      return true;
    }
  }

  // Timed out
  return false;
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
@Override
public List<ServerToSegmentSetMap> computeRoutingTableFromExternalView(String tableName, ExternalView externalView,
    List<InstanceConfig> instanceConfigList) {

  RoutingTableInstancePruner pruner = new RoutingTableInstancePruner(instanceConfigList);

  Set<String> segments = externalView.getPartitionSet();
  List<ServerToSegmentSetMap> routingTable = new ArrayList<ServerToSegmentSetMap>();
  Map<String, Map<String, Set<String>>> groupIdToRouting = new HashMap<String, Map<String, Set<String>>>();
  for (String segment : segments) {
    Map<String, String> instanceMap = externalView.getStateMap(segment);
    for (String instance : instanceMap.keySet()) {
      if (instanceMap.get(instance).equals(CommonConstants.Helix.StateModel.SegmentOnlineOfflineStateModel.OFFLINE)
          || pruner.isShuttingDown(instance)) {
        continue;
      }

      String groupId = SegmentNameBuilder.Realtime.extractGroupIdName(segment);
      if (!groupIdToRouting.containsKey(groupId)) {
        groupIdToRouting.put(groupId, new HashMap<String, Set<String>>());
      }
      if (!groupIdToRouting.get(groupId).containsKey(instance)) {
        groupIdToRouting.get(groupId).put(instance, new HashSet<String>());
      }
      groupIdToRouting.get(groupId).get(instance).add(segment);
    }
  }
  for (Map<String, Set<String>> replicaRouting : groupIdToRouting.values()) {
    routingTable.add(new ServerToSegmentSetMap(replicaRouting));
  }
  return routingTable;
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
/**
 * Returns the set of online instances from external view.
 *
 * @param resourceExternalView External view for the resource.
 * @return Set<String> of online instances in the external view for the resource.
 */
public static Set<String> getOnlineInstanceFromExternalView(ExternalView resourceExternalView) {
  Set<String> instanceSet = new HashSet<String>();
  if (resourceExternalView != null) {
    for (String partition : resourceExternalView.getPartitionSet()) {
      Map<String, String> stateMap = resourceExternalView.getStateMap(partition);
      for (String instance : stateMap.keySet()) {
        if (stateMap.get(instance).equalsIgnoreCase(ONLINE)) {
          instanceSet.add(instance);
        }
      }
    }
  }
  return instanceSet;
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
/**
 * Get a set of offline instance from the external view of the resource.
 *
 * @param resourceExternalView External view of the resource
 * @return Set of string instance names of the offline instances in the external view.
 */
public static Set<String> getOfflineInstanceFromExternalView(ExternalView resourceExternalView) {
  Set<String> instanceSet = new HashSet<String>();
  for (String partition : resourceExternalView.getPartitionSet()) {
    Map<String, String> stateMap = resourceExternalView.getStateMap(partition);
    for (String instance : stateMap.keySet()) {
      if (stateMap.get(instance).equalsIgnoreCase(OFFLINE)) {
        instanceSet.add(instance);
      }
    }
  }
  return instanceSet;
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private String getCurrentMaster(int randomSlice) {
  String resourceName = MySQLConstants.MASTER_SLAVE_RESOURCE_NAME;
  ExternalView resourceExternalView = _admin.getResourceExternalView(_clusterName, resourceName);
  Map<String, String> instanceStateMap =
      resourceExternalView.getStateMap(resourceName + "_" + randomSlice);
  String currentMaster = null;
  for (String instance : instanceStateMap.keySet()) {
    if (instanceStateMap.get(instance).equalsIgnoreCase("MASTER")) {
      currentMaster = instance;
      break;
    }
  }
  return currentMaster;
}
 

import org.apache.helix.model.ExternalView; //导入方法依赖的package包/类
private void refresh(Collection<ExternalView> externalViewList,
    Collection<InstanceConfig> instanceConfigList) {
  Map<String, InstanceConfig> instanceConfigMap = new HashMap<>();
  for (InstanceConfig config : instanceConfigList) {
    instanceConfigMap.put(config.getId(), config);
  }
  if (externalViewList != null) {
    for (ExternalView extView : externalViewList) {
      String resourceName = extView.getId();
      for (String partitionName : extView.getPartitionSet()) {
        Map<String, String> stateMap = extView.getStateMap(partitionName);
        for (String instanceName : stateMap.keySet()) {
          String currentState = stateMap.get(instanceName);
          if (instanceConfigMap.containsKey(instanceName)) {
            InstanceConfig instanceConfig = instanceConfigMap.get(instanceName);
            if (extView.isGroupRoutingEnabled()) {
              addEntry(resourceName, extView.getResourceGroupName(),
                  extView.getInstanceGroupTag(), partitionName, currentState, instanceConfig);
            } else {
              addEntry(resourceName, partitionName, currentState, instanceConfig);
            }
          } else {
            logger.error("Invalid instance name. " + instanceName
                + " .Not found in /cluster/configs/. instanceName: ");
          }
        }
      }
    }
  }
}