Java ZkCoreNodeProps类代码示例

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的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.ZkCoreNodeProps; //导入依赖的package包/类
public List<List<String>> extractShardUrls(String zkHost, String collection) {

    DocCollection docCollection = extractDocCollection(zkHost, collection);
    List<Slice> slices = getSortedSlices(docCollection.getSlices());
    List<List<String>> solrUrls = new ArrayList<>(slices.size());
    for (Slice slice : slices) {
      if (slice.getLeader() == null) {
        throw new IllegalArgumentException("Cannot find SolrCloud slice leader. " +
            "It looks like not all of your shards are registered in ZooKeeper yet");
      }
      Collection<Replica> replicas = slice.getReplicas();
      List<String> urls = new ArrayList<>(replicas.size());
      for (Replica replica : replicas) {
        ZkCoreNodeProps props = new ZkCoreNodeProps(replica);
        urls.add(props.getCoreUrl());
      }
      solrUrls.add(urls);
    }
    return solrUrls;
  }
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
private void checkConsistency(String replicatedCollection)
    throws SolrServerException {
  Collection<Slice> slices = cloudClient.getZkStateReader().getClusterState()
      .getSlices(replicatedCollection);
  for (Slice slice : slices) {
    Collection<Replica> replicas = slice.getReplicas();
    long found = -1;
    for (Replica replica : replicas) {
      HttpSolrServer client = new HttpSolrServer(
          new ZkCoreNodeProps(replica).getCoreUrl());
      SolrQuery query = new SolrQuery("*:*");
      query.set("distrib", false);
      QueryResponse replicaResults = client.query(query);
      long count = replicaResults.getResults().getNumFound();
      if (found != -1) {
        assertEquals(slice.getName() + " is inconsistent "
            + new ZkCoreNodeProps(replica).getCoreUrl(), found, count);
      }
      found = count;
      client.shutdown();
    }
  }
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
private List<Node> getSubShardLeaders(DocCollection coll, String shardId, String docId, SolrInputDocument doc) {
  Collection<Slice> allSlices = coll.getSlices();
  List<Node> nodes = null;
  for (Slice aslice : allSlices) {
    if (Slice.CONSTRUCTION.equals(aslice.getState()) || Slice.RECOVERY.equals(aslice.getState()))  {
      DocRouter.Range myRange = coll.getSlice(shardId).getRange();
      if (myRange == null) myRange = new DocRouter.Range(Integer.MIN_VALUE, Integer.MAX_VALUE);
      boolean isSubset = aslice.getRange() != null && aslice.getRange().isSubsetOf(myRange);
      if (isSubset &&
          (docId == null // in case of deletes
          || (docId != null && coll.getRouter().isTargetSlice(docId, doc, req.getParams(), aslice.getName(), coll)))) {
        Replica sliceLeader = aslice.getLeader();
        // slice leader can be null because node/shard is created zk before leader election
        if (sliceLeader != null && zkController.getClusterState().liveNodesContain(sliceLeader.getNodeName()))  {
          if (nodes == null) nodes = new ArrayList<>();
          ZkCoreNodeProps nodeProps = new ZkCoreNodeProps(sliceLeader);
          nodes.add(new StdNode(nodeProps, coll.getName(), shardId));
        }
      }
    }
  }
  return nodes;
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的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.ZkCoreNodeProps; //导入依赖的package包/类
public boolean sync(ZkController zkController, SolrCore core, ZkNodeProps leaderProps, boolean peerSyncOnlyWithActive) {
  if (SKIP_AUTO_RECOVERY) {
    return true;
  }
  boolean success;
  SolrQueryRequest req = new LocalSolrQueryRequest(core, new ModifiableSolrParams());
  SolrQueryResponse rsp = new SolrQueryResponse();
  SolrRequestInfo.setRequestInfo(new SolrRequestInfo(req, rsp));
  try {
    if (isClosed) {
      log.warn("Closed, skipping sync up.");
      return false;
    }
    log.info("Sync replicas to " + ZkCoreNodeProps.getCoreUrl(leaderProps));
    
    if (core.getUpdateHandler().getUpdateLog() == null) {
      log.error("No UpdateLog found - cannot sync");
      return false;
    }

    success = syncReplicas(zkController, core, leaderProps, peerSyncOnlyWithActive);
  } finally {
    SolrRequestInfo.clearRequestInfo();
  }
  return success;
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
private boolean syncWithReplicas(ZkController zkController, SolrCore core,
    ZkNodeProps props, String collection, String shardId, boolean peerSyncOnlyWithActive) {
  List<ZkCoreNodeProps> nodes = zkController.getZkStateReader()
      .getReplicaProps(collection, shardId,core.getCoreDescriptor().getCloudDescriptor().getCoreNodeName());
  
  if (nodes == null) {
    // I have no replicas
    return true;
  }
  
  List<String> syncWith = new ArrayList<>();
  for (ZkCoreNodeProps node : nodes) {
    syncWith.add(node.getCoreUrl());
  }
  
  // if we can't reach a replica for sync, we still consider the overall sync a success
  // TODO: as an assurance, we should still try and tell the sync nodes that we couldn't reach
  // to recover once more?
  PeerSync peerSync = new PeerSync(core, syncWith, core.getUpdateHandler().getUpdateLog().numRecordsToKeep, true, true, peerSyncOnlyWithActive);
  return peerSync.sync();
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
public LeaderInitiatedRecoveryThread(ZkController zkController, 
                                     CoreContainer cc, 
                                     String collection, 
                                     String shardId, 
                                     ZkCoreNodeProps nodeProps,
                                     int maxTries,
                                     String leaderCoreNodeName)
{
  super("LeaderInitiatedRecoveryThread-"+nodeProps.getCoreName());
  this.zkController = zkController;
  this.coreContainer = cc;
  this.collection = collection;
  this.shardId = shardId;    
  this.nodeProps = nodeProps;
  this.maxTries = maxTries;
  this.leaderCoreNodeName = leaderCoreNodeName;
  
  setDaemon(true);
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
private String getLeaderUrl(final String collection, final String slice)
    throws KeeperException, InterruptedException {
  int iterCount = 60;
  while (iterCount-- > 0) {
    try {
      byte[] data = zkClient.getData(
          ZkStateReader.getShardLeadersPath(collection, slice), null, null,
          true);
      ZkCoreNodeProps leaderProps = new ZkCoreNodeProps(
          ZkNodeProps.load(data));
      return leaderProps.getCoreUrl();
    } catch (NoNodeException e) {
      Thread.sleep(500);
    }
  }
  zkClient.printLayoutToStdOut();
  throw new RuntimeException("Could not get leader props");
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的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);
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
protected void checkSubShardConsistency(String shard) throws SolrServerException {
  SolrQuery query = new SolrQuery("*:*").setRows(1000).setFields("id", "_version_");
  query.set("distrib", false);

  ClusterState clusterState = cloudClient.getZkStateReader().getClusterState();
  Slice slice = clusterState.getSlice(AbstractDistribZkTestBase.DEFAULT_COLLECTION, shard);
  long[] numFound = new long[slice.getReplicasMap().size()];
  int c = 0;
  for (Replica replica : slice.getReplicas()) {
    String coreUrl = new ZkCoreNodeProps(replica).getCoreUrl();
    HttpSolrServer server = new HttpSolrServer(coreUrl);
    QueryResponse response;
    try {
      response = server.query(query);
    } finally {
      server.shutdown();
    }
    numFound[c++] = response.getResults().getNumFound();
    log.info("Shard: " + shard + " Replica: {} has {} docs", coreUrl, String.valueOf(response.getResults().getNumFound()));
    assertTrue("Shard: " + shard + " Replica: " + coreUrl + " has 0 docs", response.getResults().getNumFound() > 0);
  }
  for (int i = 0; i < slice.getReplicasMap().size(); i++) {
    assertEquals(shard + " is not consistent", numFound[0], numFound[i]);
  }
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
private List<Node> getCollectionUrls(SolrQueryRequest req, String collection, String coreNodeName) {
  ClusterState clusterState = req.getCore().getCoreDescriptor()
      .getCoreContainer().getZkController().getClusterState();
  List<Node> urls = new ArrayList<Node>();
  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()) && !entry.getKey().equals(coreNodeName)) {
        urls.add(new StdNode(nodeProps));
      }
    }
  }
  if (urls.size() == 0) {
    return null;
  }
  return urls;
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
private void handleSyncShardAction(SolrQueryRequest req, SolrQueryResponse rsp) throws KeeperException, InterruptedException, SolrServerException, IOException {
  log.info("Syncing shard : " + req.getParamString());
  String collection = req.getParams().required().get("collection");
  String shard = req.getParams().required().get("shard");
  
  ClusterState clusterState = coreContainer.getZkController().getClusterState();
  
  ZkNodeProps leaderProps = clusterState.getLeader(collection, shard);
  ZkCoreNodeProps nodeProps = new ZkCoreNodeProps(leaderProps);
  
  HttpSolrServer server = new HttpSolrServer(nodeProps.getBaseUrl());
  server.setConnectionTimeout(15000);
  server.setSoTimeout(30000);
  RequestSyncShard reqSyncShard = new CoreAdminRequest.RequestSyncShard();
  reqSyncShard.setCollection(collection);
  reqSyncShard.setShard(shard);
  reqSyncShard.setCoreName(nodeProps.getCoreName());
  server.request(reqSyncShard);
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
public boolean sync(ZkController zkController, SolrCore core,
    ZkNodeProps leaderProps) {
  if (SKIP_AUTO_RECOVERY) {
    return true;
  }
  log.info("Sync replicas to " + ZkCoreNodeProps.getCoreUrl(leaderProps));
  // TODO: look at our state usage of sync
  // zkController.publish(core, ZkStateReader.SYNC);
  
  // solrcloud_debug
  // System.out.println("SYNC UP");
  if (core.getUpdateHandler().getUpdateLog() == null) {
    log.error("No UpdateLog found - cannot sync");
    return false;
  }
  boolean success = syncReplicas(zkController, core, leaderProps);
  return success;
}
 

import org.apache.solr.common.cloud.ZkCoreNodeProps; //导入依赖的package包/类
private boolean syncWithReplicas(ZkController zkController, SolrCore core,
    ZkNodeProps props, String collection, String shardId) {
  List<ZkCoreNodeProps> nodes = zkController.getZkStateReader()
      .getReplicaProps(collection, shardId,
          zkController.getCoreNodeName(core.getCoreDescriptor()),
          props.getStr(ZkStateReader.CORE_NAME_PROP));
  
  if (nodes == null) {
    // I have no replicas
    return true;
  }
  
  List<String> syncWith = new ArrayList<String>();
  for (ZkCoreNodeProps node : nodes) {
    syncWith.add(node.getCoreUrl());
  }
  
  // if we can't reach a replica for sync, we still consider the overall sync a success
  // TODO: as an assurance, we should still try and tell the sync nodes that we couldn't reach
  // to recover once more?
  PeerSync peerSync = new PeerSync(core, syncWith, core.getUpdateHandler().getUpdateLog().numRecordsToKeep, true, true);
  return peerSync.sync();
}