Java ZkNodeProps.containsKey方法代码示例

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private boolean checkExclusivity(ZkNodeProps message, String id) throws KeeperException, InterruptedException {
  String collectionName = message.containsKey(COLLECTION_PROP) ?
      message.getStr(COLLECTION_PROP) : message.getStr("name");

  if(collectionName == null)
    return true;

  // CLUSTERSTATUS is always mutually exclusive
  if(CLUSTERSTATUS.isEqual(message.getStr(Overseer.QUEUE_OPERATION)))
    return true;

  if(collectionWip.contains(collectionName))
    return false;

  if(runningZKTasks.contains(id))
    return false;

  return true;
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
/**
 * Returns true if the queue contains a task with the specified async id.
 */
public boolean containsTaskWithRequestId(String requestId)
    throws KeeperException, InterruptedException {

  List<String> childNames = zookeeper.getChildren(dir, null, true);
  for (String childName : childNames) {
    if (childName != null) {
      try {
        byte[] data = zookeeper.getData(dir + "/" + childName, null, null, true);
        if (data != null) {
          ZkNodeProps message = ZkNodeProps.load(data);
          if (message.containsKey(OverseerCollectionProcessor.ASYNC)) {
            LOG.debug(">>>> {}", message.get(OverseerCollectionProcessor.ASYNC));
            if(message.get(OverseerCollectionProcessor.ASYNC).equals(requestId)) return true;
          }
        }
      } catch (KeeperException.NoNodeException e) {
        // Another client removed the node first, try next
      }
    }
  }

  return false;
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void getConfName(String collection, String collectionPath,
    Map<String,Object> collectionProps) throws KeeperException,
    InterruptedException {
  // check for configName
  log.info("Looking for collection configName");
  List<String> configNames = null;
  int retry = 1;
  int retryLimt = 6;
  for (; retry < retryLimt; retry++) {
    if (zkClient.exists(collectionPath, true)) {
      ZkNodeProps cProps = ZkNodeProps.load(zkClient.getData(collectionPath, null, null, true));
      if (cProps.containsKey(CONFIGNAME_PROP)) {
        break;
      }
    }
   
    // if there is only one conf, use that
    try {
      configNames = zkClient.getChildren(CONFIGS_ZKNODE, null,
          true);
    } catch (NoNodeException e) {
      // just keep trying
    }
    if (configNames != null && configNames.size() == 1) {
      // no config set named, but there is only 1 - use it
      log.info("Only one config set found in zk - using it:" + configNames.get(0));
      collectionProps.put(CONFIGNAME_PROP,  configNames.get(0));
      break;
    }
    
    if (configNames != null && configNames.contains(collection)) {
      log.info("Could not find explicit collection configName, but found config name matching collection name - using that set.");
      collectionProps.put(CONFIGNAME_PROP,  collection);
      break;
    }
    
    log.info("Could not find collection configName - pausing for 3 seconds and trying again - try: " + retry);
    Thread.sleep(3000);
  }
  if (retry == retryLimt) {
    log.error("Could not find configName for collection " + collection);
    throw new ZooKeeperException(
        SolrException.ErrorCode.SERVER_ERROR,
        "Could not find configName for collection " + collection + " found:" + configNames);
  }
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void migrate(ClusterState clusterState, ZkNodeProps message, NamedList results) throws KeeperException, InterruptedException {
  String sourceCollectionName = message.getStr("collection");
  String splitKey = message.getStr("split.key");
  String targetCollectionName = message.getStr("target.collection");
  int timeout = message.getInt("forward.timeout", 10 * 60) * 1000;

  DocCollection sourceCollection = clusterState.getCollection(sourceCollectionName);
  if (sourceCollection == null) {
    throw new SolrException(ErrorCode.BAD_REQUEST, "Unknown source collection: " + sourceCollectionName);
  }
  DocCollection targetCollection = clusterState.getCollection(targetCollectionName);
  if (targetCollection == null) {
    throw new SolrException(ErrorCode.BAD_REQUEST, "Unknown target collection: " + sourceCollectionName);
  }
  if (!(sourceCollection.getRouter() instanceof CompositeIdRouter))  {
    throw new SolrException(ErrorCode.BAD_REQUEST, "Source collection must use a compositeId router");
  }
  if (!(targetCollection.getRouter() instanceof CompositeIdRouter))  {
    throw new SolrException(ErrorCode.BAD_REQUEST, "Target collection must use a compositeId router");
  }
  CompositeIdRouter sourceRouter = (CompositeIdRouter) sourceCollection.getRouter();
  CompositeIdRouter targetRouter = (CompositeIdRouter) targetCollection.getRouter();
  Collection<Slice> sourceSlices = sourceRouter.getSearchSlicesSingle(splitKey, null, sourceCollection);
  if (sourceSlices.isEmpty()) {
    throw new SolrException(ErrorCode.BAD_REQUEST,
        "No active slices available in source collection: " + sourceCollection + "for given split.key: " + splitKey);
  }
  Collection<Slice> targetSlices = targetRouter.getSearchSlicesSingle(splitKey, null, targetCollection);
  if (targetSlices.isEmpty()) {
    throw new SolrException(ErrorCode.BAD_REQUEST,
        "No active slices available in target collection: " + targetCollection + "for given split.key: " + splitKey);
  }

  String asyncId = null;
  if(message.containsKey(ASYNC) && message.get(ASYNC) != null)
    asyncId = message.getStr(ASYNC);

  for (Slice sourceSlice : sourceSlices) {
    for (Slice targetSlice : targetSlices) {
      log.info("Migrating source shard: {} to target shard: {} for split.key = " + splitKey, sourceSlice, targetSlice);
      migrateKey(clusterState, sourceCollection, sourceSlice, targetCollection, targetSlice, splitKey,
          timeout, results, asyncId, message);
    }
  }
}