Java ClusterState类代码示例

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
protected static String printClusterStateInfo(String collection) throws Exception {
  cloudSolrClient.getZkStateReader().updateClusterState();
  String cs = null;
  ClusterState clusterState = cloudSolrClient.getZkStateReader().getClusterState();
  if (collection != null) {
    cs = clusterState.getCollection(collection).toString();
  } else {
    Map<String, DocCollection> map = new HashMap<String, DocCollection>();
    for (String coll : clusterState.getCollections())
      map.put(coll, clusterState.getCollection(coll));
    CharArr out = new CharArr();
    new JSONWriter(out, 2).write(map);
    cs = out.toString();
  }
  return cs;
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
private Set<String> getCollectionList(ClusterState clusterState,
    String collection) {
  // Extract each comma separated collection name and store in a List.
  List<String> rawCollectionsList = StrUtils.splitSmart(collection, ",", true);
  Set<String> collectionsList = new HashSet<>();
  // validate collections
  for (String collectionName : rawCollectionsList) {
    if (!clusterState.getCollections().contains(collectionName)) {
      Aliases aliases = zkStateReader.getAliases();
      String alias = aliases.getCollectionAlias(collectionName);
      if (alias != null) {
        List<String> aliasList = StrUtils.splitSmart(alias, ",", true); 
        collectionsList.addAll(aliasList);
        continue;
      }
      
      throw new SolrException(ErrorCode.BAD_REQUEST, "Collection not found: " + collectionName);
    }
    
    collectionsList.add(collectionName);
  }
  return collectionsList;
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
public static String getUrlFromZk(ClusterState clusterState, String collection) {
  Map<String,Slice> slices = clusterState.getCollection(collection).getSlicesMap();

  if (slices == null) {
    throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "Could not find collection:" + collection);
  }

  for (Map.Entry<String,Slice> entry : slices.entrySet()) {
    Slice slice = entry.getValue();
    Map<String,Replica> shards = slice.getReplicasMap();
    Set<Map.Entry<String,Replica>> shardEntries = shards.entrySet();
    for (Map.Entry<String,Replica> shardEntry : shardEntries) {
      final ZkNodeProps node = shardEntry.getValue();
      if (clusterState.liveNodesContain(node.getStr(ZkStateReader.NODE_NAME_PROP))) {
        return ZkCoreNodeProps.getCoreUrl(node.getStr(ZkStateReader.BASE_URL_PROP), collection); //new ZkCoreNodeProps(node).getCoreUrl();
      }
    }
  }

  throw new RuntimeException("Could not find a live node for collection:" + collection);
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
protected void checkForMissingCollection(String collectionName)
    throws Exception {
  // check for a  collection - we poll the state
  long timeoutAt = System.currentTimeMillis() + 45000;
  boolean found = true;
  while (System.currentTimeMillis() < timeoutAt) {
    getCommonCloudSolrServer().getZkStateReader().updateClusterState(true);
    ClusterState clusterState = getCommonCloudSolrServer().getZkStateReader().getClusterState();
    if (!clusterState.hasCollection(collectionName)) {
      found = false;
      break;
    }
    Thread.sleep(100);
  }
  if (found) {
    fail("Found collection that should be gone " + collectionName);
  }
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
protected String printClusterStateInfo(String collection) throws Exception {
  cloudClient.getZkStateReader().updateClusterState(true);
  String cs = null;
  ClusterState clusterState = cloudClient.getZkStateReader().getClusterState();
  if (collection != null) {
    cs = clusterState.getCollection(collection).toString();
  } else {
    Map<String,DocCollection> map = new HashMap<String,DocCollection>();
    for (String coll : clusterState.getCollections())
      map.put(coll, clusterState.getCollection(coll));
    CharArr out = new CharArr();
    new JSONWriter(out, 2).write(map);
    cs = out.toString();
  }
  return cs;
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
protected void assertAllActive(String collection,ZkStateReader zkStateReader)
    throws KeeperException, InterruptedException {

    zkStateReader.updateClusterState(true);
    ClusterState clusterState = zkStateReader.getClusterState();
    Map<String,Slice> slices = clusterState.getSlicesMap(collection);
    if (slices == null) {
      throw new IllegalArgumentException("Cannot find collection:" + collection);
    }
    for (Map.Entry<String,Slice> entry : slices.entrySet()) {
      Map<String,Replica> shards = entry.getValue().getReplicasMap();
      for (Map.Entry<String,Replica> shard : shards.entrySet()) {

        String state = shard.getValue().getStr(ZkStateReader.STATE_PROP);
        if (!state.equals(ZkStateReader.ACTIVE)) {
          fail("Not all shards are ACTIVE - found a shard that is: " + state);
        }
      }
    }
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
private List<Node> getCollectionUrls(SolrQueryRequest req, String collection) {
  ClusterState clusterState = req.getCore().getCoreDescriptor()
      .getCoreContainer().getZkController().getClusterState();
  List<Node> urls = new ArrayList<>();
  Map<String,Slice> slices = clusterState.getSlicesMap(collection);
  if (slices == null) {
    throw new ZooKeeperException(ErrorCode.BAD_REQUEST,
        "Could not find collection in zk: " + clusterState);
  }
  for (Map.Entry<String,Slice> sliceEntry : slices.entrySet()) {
    Slice replicas = slices.get(sliceEntry.getKey());

    Map<String,Replica> shardMap = replicas.getReplicasMap();
    
    for (Entry<String,Replica> entry : shardMap.entrySet()) {
      ZkCoreNodeProps nodeProps = new ZkCoreNodeProps(entry.getValue());
      if (clusterState.liveNodesContain(nodeProps.getNodeName())) {
        urls.add(new StdNode(nodeProps, collection, replicas.getName()));
      }
    }
  }
  if (urls.size() == 0) {
    return null;
  }
  return urls;
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
public static String assignNode(String collection, ClusterState state) {
  Map<String, Slice> sliceMap = state.getSlicesMap(collection);
  if (sliceMap == null) {
    return "core_node1";
  }

  int max = 0;
  for (Slice slice : sliceMap.values()) {
    for (Replica replica : slice.getReplicas()) {
      Matcher m = COUNT.matcher(replica.getName());
      if (m.matches()) {
        max = Math.max(max, Integer.parseInt(m.group(1)));
      }
    }
  }

  return "core_node" + (max + 1);
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
private void updateZkStates(ClusterState clusterState) throws KeeperException, InterruptedException {
  TimerContext timerContext = stats.time("update_state");
  boolean success = false;
  try {
    zkClient.setData(ZkStateReader.CLUSTER_STATE, ZkStateReader.toJSON(clusterState), true);
    lastUpdatedTime = System.nanoTime();
    success = true;
  } finally {
    timerContext.stop();
    if (success)  {
      stats.success("update_state");
    } else  {
      stats.error("update_state");
    }
  }
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
private ClusterState createReplica(ClusterState clusterState, ZkNodeProps message) {
  log.info("createReplica() {} ", message);
  String coll = message.getStr(ZkStateReader.COLLECTION_PROP);
  if (!checkCollectionKeyExistence(message)) return clusterState;
  String slice = message.getStr(ZkStateReader.SHARD_ID_PROP);
  Slice sl = clusterState.getSlice(coll, slice);
  if(sl == null){
    log.error("Invalid Collection/Slice {}/{} ",coll,slice);
    return clusterState;
  }

  String coreNodeName = Assign.assignNode(coll, clusterState);
  Replica replica = new Replica(coreNodeName,
      makeMap(
      ZkStateReader.CORE_NAME_PROP, message.getStr(ZkStateReader.CORE_NAME_PROP),
      ZkStateReader.BASE_URL_PROP,message.getStr(ZkStateReader.BASE_URL_PROP),
      ZkStateReader.STATE_PROP,message.getStr(ZkStateReader.STATE_PROP)));
  sl.getReplicasMap().put(coreNodeName, replica);
  return clusterState;
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
private ClusterState buildCollection(ClusterState clusterState, ZkNodeProps message) {
  String collection = message.getStr("name");
  log.info("building a new collection: " + collection);
  if(clusterState.hasCollection(collection) ){
    log.warn("Collection {} already exists. exit" ,collection);
    return clusterState;
  }

  ArrayList<String> shardNames = new ArrayList<>();

  if(ImplicitDocRouter.NAME.equals( message.getStr("router.name",DocRouter.DEFAULT_NAME))){
    getShardNames(shardNames,message.getStr("shards",DocRouter.DEFAULT_NAME));
  } else {
    int numShards = message.getInt(ZkStateReader.NUM_SHARDS_PROP, -1);
    if(numShards<1) throw new SolrException(SolrException.ErrorCode.SERVER_ERROR,"numShards is a required parameter for 'compositeId' router");
    getShardNames(numShards, shardNames);
  }

  return createCollection(clusterState,collection,shardNames,message);
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
private ClusterState updateShardState(ClusterState clusterState, ZkNodeProps message) {
  String collection = message.getStr(ZkStateReader.COLLECTION_PROP);
  if (!checkCollectionKeyExistence(message)) return clusterState;
  log.info("Update shard state invoked for collection: " + collection + " with message: " + message);
  for (String key : message.keySet()) {
    if (ZkStateReader.COLLECTION_PROP.equals(key)) continue;
    if (QUEUE_OPERATION.equals(key)) continue;

    Slice slice = clusterState.getSlice(collection, key);
    if (slice == null)  {
      throw new RuntimeException("Overseer.updateShardState unknown collection: " + collection + " slice: " + key);
    }
    log.info("Update shard state " + key + " to " + message.getStr(key));
    Map<String, Object> props = slice.shallowCopy();
    if (Slice.RECOVERY.equals(props.get(Slice.STATE)) && Slice.ACTIVE.equals(message.getStr(key))) {
      props.remove(Slice.PARENT);
    }
    props.put(Slice.STATE, message.getStr(key));
    Slice newSlice = new Slice(slice.getName(), slice.getReplicasCopy(), props);
    clusterState = updateSlice(clusterState, collection, newSlice);
  }

  return clusterState;
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
private ClusterState removeRoutingRule(ClusterState clusterState, ZkNodeProps message) {
  String collection = message.getStr(ZkStateReader.COLLECTION_PROP);
  if (!checkCollectionKeyExistence(message)) return clusterState;
  String shard = message.getStr(ZkStateReader.SHARD_ID_PROP);
  String routeKeyStr = message.getStr("routeKey");

  log.info("Overseer.removeRoutingRule invoked for collection: " + collection
      + " shard: " + shard + " routeKey: " + routeKeyStr);

  Slice slice = clusterState.getSlice(collection, shard);
  if (slice == null)  {
    log.warn("Unknown collection: " + collection + " shard: " + shard);
    return clusterState;
  }
  Map<String, RoutingRule> routingRules = slice.getRoutingRules();
  if (routingRules != null) {
    routingRules.remove(routeKeyStr); // no rules left
    Map<String, Object> props = slice.shallowCopy();
    props.put("routingRules", routingRules);
    Slice newSlice = new Slice(slice.getName(), slice.getReplicasCopy(), props);
    clusterState = updateSlice(clusterState, collection, newSlice);
  }

  return clusterState;
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
private ClusterState updateStateNew(ClusterState clusterState, ZkNodeProps message) {
  String collection = message.getStr(ZkStateReader.COLLECTION_PROP);
  if (!checkCollectionKeyExistence(message)) return clusterState;
  String sliceName = message.getStr(ZkStateReader.SHARD_ID_PROP);

  if(collection==null || sliceName == null){
    log.error("Invalid collection and slice {}", message);
    return clusterState;
  }
  Slice slice = clusterState.getSlice(collection, sliceName);
  if(slice == null){
    log.error("No such slice exists {}", message);
    return clusterState;
  }

  return updateState(clusterState, message);
}
 

import org.apache.solr.common.cloud.ClusterState; //导入依赖的package包/类
private String getAssignedCoreNodeName(ClusterState state, ZkNodeProps message) {
  Collection<Slice> slices = state.getSlices(message.getStr(ZkStateReader.COLLECTION_PROP));
  if (slices != null) {
    for (Slice slice : slices) {
      for (Replica replica : slice.getReplicas()) {
        String nodeName = replica.getStr(ZkStateReader.NODE_NAME_PROP);
        String core = replica.getStr(ZkStateReader.CORE_NAME_PROP);
        
        String msgNodeName = message.getStr(ZkStateReader.NODE_NAME_PROP);
        String msgCore = message.getStr(ZkStateReader.CORE_NAME_PROP);
        
        if (nodeName.equals(msgNodeName) && core.equals(msgCore)) {
          return replica.getName();
        }
      }
    }
  }
  return null;
}