Java ZkStateReader类代码示例

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
protected List<Replica> getActiveOrRecoveringReplicas(String testCollectionName, String shardId) throws Exception {    
  Map<String,Replica> activeReplicas = new HashMap<String,Replica>();    
  ZkStateReader zkr = cloudClient.getZkStateReader();
  ClusterState cs = zkr.getClusterState();
  assertNotNull(cs);
  for (Slice shard : cs.getActiveSlices(testCollectionName)) {
    if (shard.getName().equals(shardId)) {
      for (Replica replica : shard.getReplicas()) {
        String replicaState = replica.getStr(ZkStateReader.STATE_PROP);
        if (ZkStateReader.ACTIVE.equals(replicaState) || ZkStateReader.RECOVERING.equals(replicaState)) {
          activeReplicas.put(replica.getName(), replica);
        }
      }
    }
  }        
  List<Replica> replicas = new ArrayList<Replica>();
  replicas.addAll(activeReplicas.values());
  return replicas;
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
/**
 * Retrieve all requests recorded by this queue which were sent to given collection and shard
 *
 * @param zkStateReader  the {@link org.apache.solr.common.cloud.ZkStateReader} from which cluster state is read
 * @param collectionName the given collection name for which requests have to be extracted
 * @param shardId        the given shard name for which requests have to be extracted
 * @return a list of {@link org.apache.solr.handler.component.TrackingShardHandlerFactory.ShardRequestAndParams}
 * or empty list if none are found
 */
public List<ShardRequestAndParams> getShardRequests(ZkStateReader zkStateReader, String collectionName, String shardId) {
  DocCollection collection = zkStateReader.getClusterState().getCollection(collectionName);
  assert collection != null;
  Slice slice = collection.getSlice(shardId);
  assert slice != null;

  for (Map.Entry<String, List<ShardRequestAndParams>> entry : requests.entrySet()) {
    // multiple shard addresses may be present separated by '|'
    List<String> list = StrUtils.splitSmart(entry.getKey(), '|');
    for (Map.Entry<String, Replica> replica : slice.getReplicasMap().entrySet()) {
      String coreUrl = new ZkCoreNodeProps(replica.getValue()).getCoreUrl();
      if (list.contains(coreUrl)) {
        return new ArrayList<>(entry.getValue());
      }
    }
  }
  return Collections.emptyList();
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
protected void initCloud() throws Exception {
  assert(cloudInit == false);
  cloudInit = true;
  try {
    cloudClient = createCloudClient(DEFAULT_COLLECTION);
    
    cloudClient.connect();
  } catch (MalformedURLException e) {
    throw new RuntimeException(e);
  }
  
  ZkStateReader zkStateReader = cloudClient.getZkStateReader();
  
  chaosMonkey = new ChaosMonkey(zkServer, zkStateReader, DEFAULT_COLLECTION,
      shardToJetty, shardToLeaderJetty);
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
protected void waitForCollection(ZkStateReader reader, String collection, int slices) throws Exception {
  // wait until shards have started registering...
  int cnt = 30;
  while (!reader.getClusterState().getCollections().contains(collection)) {
    if (cnt == 0) {
      throw new RuntimeException("timeout waiting for collection in cluster state: collection=" + collection);
    }
    cnt--;
    Thread.sleep(500);
  }
  cnt = 30;
  while (reader.getClusterState().getSlices(collection).size() < slices) {
    if (cnt == 0) {
      throw new RuntimeException("timeout waiting for collection shards to come up: collection="+collection
          + ", slices.expected="+slices+ " slices.actual= " + reader.getClusterState().getSlices(collection).size()
          + " slices : "+ reader.getClusterState().getSlices(collection) );
    }
    cnt--;
    Thread.sleep(500);
  }
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
/**
 * Executes a query against each live and active replica of the specified shard 
 * and aserts that the results are identical.
 *
 * @see #queryAndCompare
 */
public QueryResponse queryAndCompareReplicas(SolrParams params, String shard) 
  throws Exception {

  ArrayList<SolrServer> shardClients = new ArrayList<>(7);

  updateMappingsFromZk(jettys, clients);
  ZkStateReader zkStateReader = cloudClient.getZkStateReader();
  List<CloudJettyRunner> solrJetties = shardToJetty.get(shard);
  assertNotNull("no jetties found for shard: " + shard, solrJetties);


  for (CloudJettyRunner cjetty : solrJetties) {
    ZkNodeProps props = cjetty.info;
    String nodeName = props.getStr(ZkStateReader.NODE_NAME_PROP);
    boolean active = props.getStr(ZkStateReader.STATE_PROP).equals(ZkStateReader.ACTIVE);
    boolean live = zkStateReader.getClusterState().liveNodesContain(nodeName);
    if (active && live) {
      shardClients.add(cjetty.client.solrClient);
    }
  }
  return queryAndCompare(params, shardClients);
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的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.ZkStateReader; //导入依赖的package包/类
private SolrZkClient electNewOverseer(String address)
    throws InterruptedException, TimeoutException, IOException,
    KeeperException, ParserConfigurationException, SAXException {
  SolrZkClient zkClient = new SolrZkClient(address, TIMEOUT);
  ZkStateReader reader = new ZkStateReader(zkClient);
  readers.add(reader);
  LeaderElector overseerElector = new LeaderElector(zkClient);
  if (overseers.size() > 0) {
    overseers.get(overseers.size() -1).close();
    overseers.get(overseers.size() -1).getZkStateReader().getZkClient().close();
  }
  UpdateShardHandler updateShardHandler = new UpdateShardHandler(null);
  Overseer overseer = new Overseer(
      new HttpShardHandlerFactory().getShardHandler(), updateShardHandler, "/admin/cores", reader, null, new MockConfigSolr());
  overseers.add(overseer);
  ElectionContext ec = new OverseerElectionContext(zkClient, overseer,
      address.replaceAll("/", "_"));
  overseerElector.setup(ec);
  overseerElector.joinElection(ec, false);
  return zkClient;
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
private boolean checkIfCoreNodeNameAlreadyExists(CoreDescriptor dcore) {
  ZkStateReader zkStateReader = coreContainer.getZkController()
      .getZkStateReader();
  DocCollection collection = zkStateReader.getClusterState().getCollectionOrNull(dcore.getCollectionName());
  if (collection != null) {
    Collection<Slice> slices = collection.getSlices();
    
    for (Slice slice : slices) {
      Collection<Replica> replicas = slice.getReplicas();
      for (Replica replica : replicas) {
        if (replica.getName().equals(
            dcore.getCloudDescriptor().getCoreNodeName())) {
          return true;
        }
      }
    }
  }
  return false;
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
public void processSync(ResponseBuilder rb, int nVersions, String sync) {
  
  boolean onlyIfActive = rb.req.getParams().getBool("onlyIfActive", false);
  
  if (onlyIfActive) {
    if (!rb.req.getCore().getCoreDescriptor().getCloudDescriptor().getLastPublished().equals(ZkStateReader.ACTIVE)) {
      log.info("Last published state was not ACTIVE, cannot sync.");
      rb.rsp.add("sync", "false");
      return;
    }
  }
  
  List<String> replicas = StrUtils.splitSmart(sync, ",", true);
  
  boolean cantReachIsSuccess = rb.req.getParams().getBool("cantReachIsSuccess", false);
  
  PeerSync peerSync = new PeerSync(rb.req.getCore(), replicas, nVersions, cantReachIsSuccess, true);
  boolean success = peerSync.sync();
  
  // TODO: more complex response?
  rb.rsp.add("sync", success);
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
public void checkOverseerDesignate() {
  try {
    byte[] data = zkClient.getData(ZkStateReader.ROLES, null, new Stat(), true);
    if(data ==null) return;
    Map roles = (Map) ZkStateReader.fromJSON(data);
    if(roles ==null) return;
    List nodeList= (List) roles.get("overseer");
    if(nodeList == null) return;
    if(nodeList.contains(getNodeName())){
      ZkNodeProps props = new ZkNodeProps(Overseer.QUEUE_OPERATION, CollectionParams.CollectionAction.ADDROLE.toString().toLowerCase(Locale.ROOT),
          "node", getNodeName(),
          "role", "overseer");
      log.info("Going to add role {} ",props);
      getOverseerCollectionQueue().offer(ZkStateReader.toJSON(props));
    }
  } catch (NoNodeException nne){
    return;
  } catch (Exception e) {
    log.warn("could not readd the overseer designate ",e);
  }
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
public ClientThread(ElectorSetup es, String shard, int nodeNumber, long runLeaderDelay) throws Exception {
  super("Thread-" + shard + nodeNumber);
  this.shard = shard;
  this.nodeName = shard + nodeNumber;
  this.runLeaderDelay = runLeaderDelay;

  props = new ZkNodeProps(ZkStateReader.BASE_URL_PROP, Integer.toString(nodeNumber), ZkStateReader.CORE_NAME_PROP, "");

  this.es = es;
  if (this.es == null) {
    this.es = new ElectorSetup(new OnReconnect() {
      @Override
      public void command() {
        try {
          setupOnConnect();
        } catch (Throwable t) {
        }
      }
    });
  }
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的package包/类
private void handleProp(ZkNodeProps message)  {
  String name = message.getStr("name");
  String val = message.getStr("val");
  Map m =  reader.getClusterProps();
  if(val ==null) m.remove(name);
  else m.put(name,val);

  try {
    if(reader.getZkClient().exists(ZkStateReader.CLUSTER_PROPS,true))
      reader.getZkClient().setData(ZkStateReader.CLUSTER_PROPS,ZkStateReader.toJSON(m),true);
    else
      reader.getZkClient().create(ZkStateReader.CLUSTER_PROPS, ZkStateReader.toJSON(m),CreateMode.PERSISTENT, true);
    clusterProps = reader.getClusterProps();
  } catch (Exception e) {
    log.error("Unable to set cluster property", e);

  }
}
 

import org.apache.solr.common.cloud.ZkStateReader; //导入依赖的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.ZkStateReader; //导入依赖的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.ZkStateReader; //导入依赖的package包/类
private String getUrlFromZk(String collection) {
  ClusterState clusterState = getCommonCloudSolrServer().getZkStateReader().getClusterState();
  Map<String,Slice> slices = clusterState.getSlicesMap(collection);
  
  if (slices == null) {
    throw new 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);
}