Java Replica.getName方法代码示例

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

import org.apache.solr.common.cloud.Replica; //导入方法依赖的package包/类
private String checkCollectionExpectations(String collectionName, List<Integer> numShardsNumReplicaList, List<String> nodesAllowedToRunShards) {
    ClusterState clusterState = getCommonCloudSolrServer().getZkStateReader().getClusterState();
    
    int expectedSlices = numShardsNumReplicaList.get(0);
    // The Math.min thing is here, because we expect replication-factor to be reduced to if there are not enough live nodes to spread all shards of a collection over different nodes
    int expectedShardsPerSlice = numShardsNumReplicaList.get(1);
    int expectedTotalShards = expectedSlices * expectedShardsPerSlice;
    
//      Map<String,DocCollection> collections = clusterState
//          .getCollectionStates();
      if (clusterState.hasCollection(collectionName)) {
        Map<String,Slice> slices = clusterState.getCollection(collectionName).getSlicesMap();
        // did we find expectedSlices slices/shards?
      if (slices.size() != expectedSlices) {
        return "Found new collection " + collectionName + ", but mismatch on number of slices. Expected: " + expectedSlices + ", actual: " + slices.size();
      }
      int totalShards = 0;
      for (String sliceName : slices.keySet()) {
        for (Replica replica : slices.get(sliceName).getReplicas()) {
          if (nodesAllowedToRunShards != null && !nodesAllowedToRunShards.contains(replica.getStr(ZkStateReader.NODE_NAME_PROP))) {
            return "Shard " + replica.getName() + " created on node " + replica.getNodeName() + " not allowed to run shards for the created collection " + collectionName;
          }
        }
        totalShards += slices.get(sliceName).getReplicas().size();
      }
      if (totalShards != expectedTotalShards) {
        return "Found new collection " + collectionName + " with correct number of slices, but mismatch on number of shards. Expected: " + expectedTotalShards + ", actual: " + totalShards; 
        }
      return null;
    } else {
      return "Could not find new collection " + collectionName;
    }
  }
 

import org.apache.solr.common.cloud.Replica; //导入方法依赖的package包/类
private String waitForCoreNodeName(String collectionName, String msgNodeName, String msgCore) {
  int retryCount = 320;
  while (retryCount-- > 0) {
    Map<String,Slice> slicesMap = zkStateReader.getClusterState()
        .getSlicesMap(collectionName);
    if (slicesMap != null) {
      
      for (Slice slice : slicesMap.values()) {
        for (Replica replica : slice.getReplicas()) {
          // TODO: for really large clusters, we could 'index' on this
          
          String nodeName = replica.getStr(ZkStateReader.NODE_NAME_PROP);
          String core = replica.getStr(ZkStateReader.CORE_NAME_PROP);
          
          if (nodeName.equals(msgNodeName) && core.equals(msgCore)) {
            return replica.getName();
          }
        }
      }
    }
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
  }
  throw new SolrException(ErrorCode.SERVER_ERROR, "Could not find coreNodeName");
}
 

import org.apache.solr.common.cloud.Replica; //导入方法依赖的package包/类
private String getShardId(String collection, String coreNodeName) {
  Map<String,Slice> slices = zkStateReader.getClusterState().getSlicesMap(collection);
  if (slices != null) {
    for (Slice slice : slices.values()) {
      for (Replica replica : slice.getReplicas()) {
        String cnn = replica.getName();
        if (coreNodeName.equals(cnn)) {
          return slice.getName();
        }
      }
    }
  }
  return null;
}
 

import org.apache.solr.common.cloud.Replica; //导入方法依赖的package包/类
private String checkCollectionExpectations(String collectionName, List<Integer> numShardsNumReplicaList, List<String> nodesAllowedToRunShards) {
  ClusterState clusterState = getCommonCloudSolrServer().getZkStateReader().getClusterState();
  
  int expectedSlices = numShardsNumReplicaList.get(0);
  // The Math.min thing is here, because we expect replication-factor to be reduced to if there are not enough live nodes to spread all shards of a collection over different nodes
  int expectedShardsPerSlice = numShardsNumReplicaList.get(1);
  int expectedTotalShards = expectedSlices * expectedShardsPerSlice;
  
    Map<String,DocCollection> collections = clusterState
        .getCollectionStates();
    if (collections.containsKey(collectionName)) {
      Map<String,Slice> slices = collections.get(collectionName).getSlicesMap();
      // did we find expectedSlices slices/shards?
    if (slices.size() != expectedSlices) {
      return "Found new collection " + collectionName + ", but mismatch on number of slices. Expected: " + expectedSlices + ", actual: " + slices.size();
    }
    int totalShards = 0;
    for (String sliceName : slices.keySet()) {
      for (Replica replica : slices.get(sliceName).getReplicas()) {
        if (nodesAllowedToRunShards != null && !nodesAllowedToRunShards.contains(replica.getStr(ZkStateReader.NODE_NAME_PROP))) {
          return "Shard " + replica.getName() + " created on node " + replica.getStr(ZkStateReader.NODE_NAME_PROP) + " not allowed to run shards for the created collection " + collectionName;
        }
      }
      totalShards += slices.get(sliceName).getReplicas().size();
    }
    if (totalShards != expectedTotalShards) {
      return "Found new collection " + collectionName + " with correct number of slices, but mismatch on number of shards. Expected: " + expectedTotalShards + ", actual: " + totalShards; 
      }
    return null;
  } else {
    return "Could not find new collection " + collectionName;
  }
}
 

import org.apache.solr.common.cloud.Replica; //导入方法依赖的package包/类
private List<Node> setupRequest() {
  List<Node> nodes = null;
  String shardId = cloudDesc.getShardId();

  try {
    Replica leaderReplica = zkController.getZkStateReader().getLeaderRetry(
        collection, shardId);
    String leaderCoreNodeName = leaderReplica.getName();

    String coreNodeName = zkController.getCoreNodeName(req.getCore().getCoreDescriptor());
    isLeader = coreNodeName.equals(leaderCoreNodeName);

    // TODO: what if we are no longer the leader?

    forwardToLeader = false;
    List<ZkCoreNodeProps> replicaProps = zkController.getZkStateReader()
        .getReplicaProps(collection, shardId, coreNodeName,
            req.getCore().getName());
    if (replicaProps != null) {
      nodes = new ArrayList<Node>(replicaProps.size());
      for (ZkCoreNodeProps props : replicaProps) {
        nodes.add(new StdNode(props));
      }
    }
  } catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    throw new ZooKeeperException(SolrException.ErrorCode.SERVER_ERROR, "",
        e);
  }

  return nodes;
}
 

import org.apache.solr.common.cloud.Replica; //导入方法依赖的package包/类
private String waitForCoreNodeName(DocCollection collection, String msgNodeName, String msgCore) {
  int retryCount = 320;
  while (retryCount-- > 0) {
    Map<String,Slice> slicesMap = zkStateReader.getClusterState()
        .getSlicesMap(collection.getName());
    if (slicesMap != null) {
      
      for (Slice slice : slicesMap.values()) {
        for (Replica replica : slice.getReplicas()) {
          // TODO: for really large clusters, we could 'index' on this
          
          String nodeName = replica.getStr(ZkStateReader.NODE_NAME_PROP);
          String core = replica.getStr(ZkStateReader.CORE_NAME_PROP);
          
          if (nodeName.equals(msgNodeName) && core.equals(msgCore)) {
            return replica.getName();
          }
        }
      }
    }
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
  }
  throw new SolrException(ErrorCode.SERVER_ERROR, "Could not find coreNodeName");
}
 

import org.apache.solr.common.cloud.Replica; //导入方法依赖的package包/类
/**
 * <p>
 * Helper method that returns true if the Runnable managed by this factory 
 * should be responseible of doing periodica deletes.
 * </p>
 * <p>
 * In simple standalone instalations this method always returns true, 
 * but in cloud mode it will be true if and only if we are currently the leader 
 * of the (active) slice with the first name (lexigraphically).
 * </p>
 * <p>
 * If this method returns false, it may have also logged a message letting the user 
 * know why we aren't attempting period deletion (but it will attempt to not log 
 * this excessively)
 * </p>
 */
private boolean iAmInChargeOfPeriodicDeletes() {
  ZkController zk = core.getCoreDescriptor().getCoreContainer().getZkController();

  if (null == zk) return true;
  
  // This is a lot simpler then doing our own "leader" election across all replicas 
  // of all shards since:
  //   a) we already have a per shard leader
  //   b) shard names must be unique
  //   c) ClusterState is already being "watched" by ZkController, no additional zk hits
  //   d) there might be multiple instances of this factory (in multiple chains) per 
  //      collection, so picking an ephemeral node name for our election would be tricky

  CloudDescriptor desc = core.getCoreDescriptor().getCloudDescriptor();
  String col = desc.getCollectionName();

  List<Slice> slices = new ArrayList<Slice>(zk.getClusterState().getActiveSlices(col));
  Collections.sort(slices, COMPARE_SLICES_BY_NAME);
  if (slices.isEmpty()) {
    log.error("Collection {} has no active Slices?", col);
    return false;
  }
  Replica firstSliceLeader = slices.get(0).getLeader();
  if (null == firstSliceLeader) {
    log.warn("Slice in charge of periodic deletes for {} does not currently have a leader",
             col);
    return false;
  }
  String leaderInCharge = firstSliceLeader.getName();
  String myCoreNodeName = desc.getCoreNodeName();
  
  boolean inChargeOfDeletesRightNow = leaderInCharge.equals(myCoreNodeName);

  if (previouslyInChargeOfDeletes && ! inChargeOfDeletesRightNow) {
    // don't spam the logs constantly, just log when we know that we're not the guy
    // (the first time -- or anytime we were, but no longer are)
    log.info("Not currently in charge of periodic deletes for this collection, " + 
             "will not trigger delete or log again until this changes");
  }

  previouslyInChargeOfDeletes = inChargeOfDeletesRightNow;
  return inChargeOfDeletesRightNow;
}
 

import org.apache.solr.common.cloud.Replica; //导入方法依赖的package包/类
/**
 * See if coreNodeName has been taken over by another baseUrl and unload core
 * + throw exception if it has been.
 */
public static void checkSharedFSFailoverReplaced(CoreContainer cc, CoreDescriptor desc) {
  
  ZkController zkController = cc.getZkController();
  String thisCnn = zkController.getCoreNodeName(desc);
  String thisBaseUrl = zkController.getBaseUrl();
  
  log.debug("checkSharedFSFailoverReplaced running for coreNodeName={} baseUrl={}", thisCnn, thisBaseUrl);

  // if we see our core node name on a different base url, unload
  Map<String,Slice> slicesMap = zkController.getClusterState().getSlicesMap(desc.getCloudDescriptor().getCollectionName());
  
  if (slicesMap != null) {
    for (Slice slice : slicesMap.values()) {
      for (Replica replica : slice.getReplicas()) {
        
        String cnn = replica.getName();
        String baseUrl = replica.getStr(ZkStateReader.BASE_URL_PROP);
        log.debug("compare against coreNodeName={} baseUrl={}", cnn, baseUrl);
        
        if (thisCnn != null && thisCnn.equals(cnn)
            && !thisBaseUrl.equals(baseUrl)) {
          if (cc.getCoreNames().contains(desc.getName())) {
            cc.unload(desc.getName());
          }
          
          File instanceDir = new File(desc.getInstanceDir());
          try {
            FileUtils.deleteDirectory(instanceDir);
          } catch (IOException e) {
            SolrException.log(log, "Failed to delete instance dir for core:"
                + desc.getName() + " dir:" + instanceDir.getAbsolutePath());
          }
          log.error("", new SolrException(ErrorCode.SERVER_ERROR,
              "Will not load SolrCore " + desc.getName()
                  + " because it has been replaced due to failover."));
          throw new SolrException(ErrorCode.SERVER_ERROR,
              "Will not load SolrCore " + desc.getName()
                  + " because it has been replaced due to failover.");
        }
      }
    }
  }
}