Java ZkNodeProps.makeMap方法代码示例

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
@Override
public void doTest() throws Exception {
  int replicationFactor = 1;
  int maxShardsPerNode = 5;

  Map<String, Object> props = ZkNodeProps.makeMap(
      "router.name", ImplicitDocRouter.NAME,
      REPLICATION_FACTOR, replicationFactor,
      MAX_SHARDS_PER_NODE, maxShardsPerNode,
      NUM_SLICES, 1,
      SHARDS_PROP,"a,b");

  Map<String,List<Integer>> collectionInfos = new HashMap<>();

  String collectionName = "customcollreplicadeletion";

  createCollection(collectionInfos, collectionName, props, client);

  waitForRecoveriesToFinish(collectionName, false);

  DocCollection testcoll = getCommonCloudSolrServer().getZkStateReader()
      .getClusterState().getCollection(collectionName);
  Replica replica = testcoll.getSlice("a").getReplicas().iterator().next();

  removeAndWaitForLastReplicaGone(collectionName, replica, "a");
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void createCollection(String targetCollection) throws Exception {
  HashMap<String, List<Integer>> collectionInfos = new HashMap<>();
  CloudSolrServer client = null;
  try {
    client = createCloudClient(null);
    Map<String, Object> props = ZkNodeProps.makeMap(
        REPLICATION_FACTOR, 1,
        MAX_SHARDS_PER_NODE, 5,
        NUM_SLICES, 1);

    createCollection(collectionInfos, targetCollection, props, client);
  } finally {
    if (client != null) client.shutdown();
  }

  List<Integer> list = collectionInfos.get(targetCollection);
  checkForCollection(targetCollection, list, null);

  waitForRecoveriesToFinish(targetCollection, false);
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void handleProp(SolrQueryRequest req, SolrQueryResponse rsp) throws KeeperException, InterruptedException {
  req.getParams().required().check("name");
  String name = req.getParams().get("name");
  if(!OverseerCollectionProcessor.KNOWN_CLUSTER_PROPS.contains(name)){
    throw new SolrException(ErrorCode.BAD_REQUEST, "Not a known cluster property "+ name);
  }

  Map<String,Object> props = ZkNodeProps.makeMap(
      Overseer.QUEUE_OPERATION, CLUSTERPROP.toLower() );
  copyIfNotNull(req.getParams(),props,
      "name",
      "val");

  Overseer.getInQueue(coreContainer.getZkController().getZkClient()).offer(ZkStateReader.toJSON(props)) ;
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void handleRole(CollectionAction action, SolrQueryRequest req, SolrQueryResponse rsp) throws KeeperException, InterruptedException {
  req.getParams().required().check("role", "node");
  Map<String, Object> map = ZkNodeProps.makeMap(Overseer.QUEUE_OPERATION, action.toLower());
  copyIfNotNull(req.getParams(), map,"role", "node");
  ZkNodeProps m = new ZkNodeProps(map);
  if(!KNOWN_ROLES.contains(m.getStr("role"))) throw new SolrException(ErrorCode.BAD_REQUEST,"Unknown role. Supported roles are ,"+ KNOWN_ROLES);
  handleResponse(action.toString().toLowerCase(Locale.ROOT), m, rsp);
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void handleCreateAction(SolrQueryRequest req,
    SolrQueryResponse rsp) throws InterruptedException, KeeperException {
  log.info("Creating Collection : " + req.getParamString());
  String name = req.getParams().required().get("name");
  if (name == null) {
    log.error("Collection name is required to create a new collection");
    throw new SolrException(ErrorCode.BAD_REQUEST,
        "Collection name is required to create a new collection");
  }
  
  Map<String,Object> props = ZkNodeProps.makeMap(
      Overseer.QUEUE_OPERATION,
      OverseerCollectionProcessor.CREATECOLLECTION,
      "fromApi","true");
  copyIfNotNull(req.getParams(), props,
       "name",
       ZkStateReader.REPLICATION_FACTOR,
       COLL_CONF,
       NUM_SLICES,
       MAX_SHARDS_PER_NODE,
       CREATE_NODE_SET,
       SHARDS_PROP,
       ASYNC,
       AUTO_ADD_REPLICAS,
      "router.");

  copyPropertiesIfNotNull(req.getParams(), props);

  ZkNodeProps m = new ZkNodeProps(props);
  handleResponse(OverseerCollectionProcessor.CREATECOLLECTION, m, rsp);
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void handleProp(SolrQueryRequest req, SolrQueryResponse rsp) throws KeeperException, InterruptedException {
  req.getParams().required().check("name");
  String name = req.getParams().get("name");
  if(!OverseerCollectionProcessor.KNOWN_CLUSTER_PROPS.contains(name)){
    throw new SolrException(ErrorCode.BAD_REQUEST, "Not a known cluster property "+ name);
  }

  Map<String,Object> props = ZkNodeProps.makeMap(
      Overseer.QUEUE_OPERATION, CollectionAction.CLUSTERPROP.toString().toLowerCase(Locale.ROOT) );
  copyIfNotNull(req.getParams(),props,
      "name",
      "val");
  handleResponse(CollectionAction.CLUSTERPROP.toString().toLowerCase(Locale.ROOT),new ZkNodeProps(props),rsp);

}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void handleRole(CollectionAction action, SolrQueryRequest req, SolrQueryResponse rsp) throws KeeperException, InterruptedException {
  req.getParams().required().check("role", "node");
  Map<String, Object> map = ZkNodeProps.makeMap(Overseer.QUEUE_OPERATION, action.toString().toLowerCase(Locale.ROOT));
  copyIfNotNull(req.getParams(), map,"role", "node");
  ZkNodeProps m = new ZkNodeProps(map);
  if(!KNOWN_ROLES.contains(m.getStr("role"))) throw new SolrException(ErrorCode.BAD_REQUEST,"Unknown role. Supported roles are ,"+ KNOWN_ROLES);
  handleResponse(action.toString().toLowerCase(Locale.ROOT), m, rsp);
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void handleCreateAction(SolrQueryRequest req,
    SolrQueryResponse rsp) throws InterruptedException, KeeperException {
  log.info("Creating Collection : " + req.getParamString());
  String name = req.getParams().required().get("name");
  if (name == null) {
    log.error("Collection name is required to create a new collection");
    throw new SolrException(ErrorCode.BAD_REQUEST,
        "Collection name is required to create a new collection");
  }
  
  Map<String,Object> props = ZkNodeProps.makeMap(
      Overseer.QUEUE_OPERATION,
      OverseerCollectionProcessor.CREATECOLLECTION,
      "fromApi","true");
  copyIfNotNull(req.getParams(),props,
      "name",
      REPLICATION_FACTOR,
       COLL_CONF,
       NUM_SLICES,
       MAX_SHARDS_PER_NODE,
      CREATE_NODE_SET ,
      SHARDS_PROP,
      "router.");

  copyPropertiesIfNotNull(req.getParams(), props);

  ZkNodeProps m = new ZkNodeProps(props);
  handleResponse(OverseerCollectionProcessor.CREATECOLLECTION, m, rsp);
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void handleOverseerStatus(SolrQueryRequest req, SolrQueryResponse rsp) throws KeeperException, InterruptedException {
  Map<String, Object> props = ZkNodeProps.makeMap(
      Overseer.QUEUE_OPERATION, OVERSEERSTATUS.toLower());
  handleResponse(OVERSEERSTATUS.toLower(), new ZkNodeProps(props), rsp);
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
public Map<String,Object> getLeaderInitiatedRecoveryStateObject(String collection, String shardId, String coreNodeName) {

    if (collection == null || shardId == null || coreNodeName == null)
      return null; // if we don't have complete data about a core in cloud mode, return null
    
    String znodePath = getLeaderInitiatedRecoveryZnodePath(collection, shardId, coreNodeName);
    byte[] stateData = null;
    try {
      stateData = zkClient.getData(znodePath, null, new Stat(), false);
    } catch (NoNodeException ignoreMe) {
      // safe to ignore as this znode will only exist if the leader initiated recovery
    } catch (ConnectionLossException cle) {
      // sort of safe to ignore ??? Usually these are seen when the core is going down
      // or there are bigger issues to deal with than reading this znode
      log.warn("Unable to read "+znodePath+" due to: "+cle);
    } catch (SessionExpiredException see) {
      // sort of safe to ignore ??? Usually these are seen when the core is going down
      // or there are bigger issues to deal with than reading this znode
      log.warn("Unable to read "+znodePath+" due to: "+see);
    } catch (Exception exc) {
      log.error("Failed to read data from znode "+znodePath+" due to: "+exc);
      if (exc instanceof SolrException) {
        throw (SolrException)exc;
      } else {
        throw new SolrException(ErrorCode.SERVER_ERROR, 
            "Failed to read data from znodePath: "+znodePath, exc);
      }
    }

    Map<String,Object> stateObj = null;
    if (stateData != null && stateData.length > 0) {
      // TODO: Remove later ... this is for upgrading from 4.8.x to 4.10.3 (see: SOLR-6732)
      if (stateData[0] == (byte)'{') {
        Object parsedJson = ZkStateReader.fromJSON(stateData);
        if (parsedJson instanceof Map) {
          stateObj = (Map<String,Object>)parsedJson;
        } else {
          throw new SolrException(ErrorCode.SERVER_ERROR, "Leader-initiated recovery state data is invalid! "+parsedJson);
        }
      } else {
        // old format still in ZK
        stateObj = ZkNodeProps.makeMap("state", new String(stateData, StandardCharsets.UTF_8));
      }
    }

    return stateObj;
  }
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void deleteReplica(ClusterState clusterState, ZkNodeProps message, NamedList results) throws KeeperException, InterruptedException {
  checkRequired(message, COLLECTION_PROP, SHARD_ID_PROP,REPLICA_PROP);
  String collectionName = message.getStr(COLLECTION_PROP);
  String shard = message.getStr(SHARD_ID_PROP);
  String replicaName = message.getStr(REPLICA_PROP);
  DocCollection coll = clusterState.getCollection(collectionName);
  Slice slice = coll.getSlice(shard);
  ShardHandler shardHandler = shardHandlerFactory.getShardHandler();
  if(slice==null){
    throw new SolrException(ErrorCode.BAD_REQUEST, "Invalid shard name : "+shard+" in collection : "+ collectionName);
  }
  Replica replica = slice.getReplica(replicaName);
  if(replica == null){
    ArrayList<String> l = new ArrayList<>();
    for (Replica r : slice.getReplicas()) l.add(r.getName());
    throw new SolrException(ErrorCode.BAD_REQUEST, "Invalid replica : " + replicaName + " in shard/collection : "
        + shard + "/"+ collectionName + " available replicas are "+ StrUtils.join(l,','));
  }

  String baseUrl = replica.getStr(ZkStateReader.BASE_URL_PROP);
  String core = replica.getStr(ZkStateReader.CORE_NAME_PROP);
  
  // assume the core exists and try to unload it
  Map m = ZkNodeProps.makeMap("qt", adminPath, CoreAdminParams.ACTION,
      CoreAdminAction.UNLOAD.toString(), CoreAdminParams.CORE, core,
      CoreAdminParams.DELETE_INSTANCE_DIR, "true",
      CoreAdminParams.DELETE_DATA_DIR, "true");
  
  ShardRequest sreq = new ShardRequest();
  sreq.purpose = 1;
  sreq.shards = new String[] {baseUrl};
  sreq.actualShards = sreq.shards;
  sreq.params = new ModifiableSolrParams(new MapSolrParams(m));
  try {
    shardHandler.submit(sreq, baseUrl, sreq.params);
  } catch (Exception e) {
    log.warn("Exception trying to unload core " + sreq, e);
  }
  
  collectShardResponses(!Slice.ACTIVE.equals(replica.getStr(Slice.STATE)) ? new NamedList() : results,
      false, null, shardHandler);
  
  if (waitForCoreNodeGone(collectionName, shard, replicaName, 5000)) return;//check if the core unload removed the corenode zk enry
  deleteCoreNode(collectionName, replicaName, replica, core); // try and ensure core info is removed from clusterstate
  if(waitForCoreNodeGone(collectionName, shard, replicaName, 30000)) return;

  throw new SolrException(ErrorCode.SERVER_ERROR, "Could not  remove replica : " + collectionName + "/" + shard+"/" + replicaName);
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void testCreateShardRepFactor() throws Exception  {
  String collectionName = "testCreateShardRepFactor";
  HashMap<String, List<Integer>> collectionInfos = new HashMap<>();
  CloudSolrServer client = null;
  try {
    client = createCloudClient(null);
    Map<String, Object> props = ZkNodeProps.makeMap(
        REPLICATION_FACTOR, 1,
        MAX_SHARDS_PER_NODE, 5,
        NUM_SLICES, 2,
        "shards", "a,b",
        "router.name", "implicit");

    createCollection(collectionInfos, collectionName, props, client);
  } finally {
    if (client != null) client.shutdown();
  }
  ZkStateReader zkStateReader = getCommonCloudSolrServer().getZkStateReader();
  waitForRecoveriesToFinish(collectionName, zkStateReader, false);

  ModifiableSolrParams params = new ModifiableSolrParams();
  params.set("action", CollectionAction.CREATESHARD.toString());
  params.set("collection", collectionName);
  params.set("shard", "x");
  SolrRequest request = new QueryRequest(params);
  request.setPath("/admin/collections");
  createNewSolrServer("", getBaseUrl((HttpSolrServer) clients.get(0))).request(request);

  waitForRecoveriesToFinish(collectionName, zkStateReader, false);

  int replicaCount = 0;
  int attempts = 0;
  while (true) {
    if (attempts > 30) fail("Not enough active replicas in the shard 'x'");
    zkStateReader.updateClusterState(true);
    attempts++;
    replicaCount = zkStateReader.getClusterState().getSlice(collectionName, "x").getReplicas().size();
    if (replicaCount >= 1) break;
    Thread.sleep(500);
  }

  assertEquals("CREATESHARD API created more than replicationFactor number of replicas", 1, replicaCount);
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
public void splitByRouteFieldTest() throws Exception  {
  log.info("Starting testSplitWithRouteField");
  String collectionName = "routeFieldColl";
  int numShards = 4;
  int replicationFactor = 2;
  int maxShardsPerNode = (((numShards * replicationFactor) / getCommonCloudSolrServer()
      .getZkStateReader().getClusterState().getLiveNodes().size())) + 1;

  HashMap<String, List<Integer>> collectionInfos = new HashMap<>();
  CloudSolrServer client = null;
  String shard_fld = "shard_s";
  try {
    client = createCloudClient(null);
    Map<String, Object> props = ZkNodeProps.makeMap(
        REPLICATION_FACTOR, replicationFactor,
        MAX_SHARDS_PER_NODE, maxShardsPerNode,
        NUM_SLICES, numShards,
        "router.field", shard_fld);

    createCollection(collectionInfos, collectionName,props,client);
  } finally {
    if (client != null) client.shutdown();
  }

  List<Integer> list = collectionInfos.get(collectionName);
  checkForCollection(collectionName, list, null);

  waitForRecoveriesToFinish(false);

  String url = CustomCollectionTest.getUrlFromZk(getCommonCloudSolrServer().getZkStateReader().getClusterState(), collectionName);

  HttpSolrServer collectionClient = new HttpSolrServer(url);

  ClusterState clusterState = cloudClient.getZkStateReader().getClusterState();
  final DocRouter router = clusterState.getCollection(collectionName).getRouter();
  Slice shard1 = clusterState.getSlice(collectionName, SHARD1);
  DocRouter.Range shard1Range = shard1.getRange() != null ? shard1.getRange() : router.fullRange();
  final List<DocRouter.Range> ranges = router.partitionRange(2, shard1Range);
  final int[] docCounts = new int[ranges.size()];

  for (int i = 100; i <= 200; i++) {
    String shardKey = "" + (char)('a' + (i % 26)); // See comment in ShardRoutingTest for hash distribution

    collectionClient.add(getDoc(id, i, "n_ti", i, shard_fld, shardKey));
    int idx = getHashRangeIdx(router, ranges, shardKey);
    if (idx != -1)  {
      docCounts[idx]++;
    }
  }

  for (int i = 0; i < docCounts.length; i++) {
    int docCount = docCounts[i];
    log.info("Shard {} docCount = {}", "shard1_" + i, docCount);
  }

  collectionClient.commit();

  for (int i = 0; i < 3; i++) {
    try {
      splitShard(collectionName, SHARD1, null, null);
      break;
    } catch (HttpSolrServer.RemoteSolrException e) {
      if (e.code() != 500) {
        throw e;
      }
      log.error("SPLITSHARD failed. " + (i < 2 ? " Retring split" : ""), e);
      if (i == 2) {
        fail("SPLITSHARD was not successful even after three tries");
      }
    }
  }

  waitForRecoveriesToFinish(collectionName, false);

  assertEquals(docCounts[0], collectionClient.query(new SolrQuery("*:*").setParam("shards", "shard1_0")).getResults().getNumFound());
  assertEquals(docCounts[1], collectionClient.query(new SolrQuery("*:*").setParam("shards", "shard1_1")).getResults().getNumFound());
  collectionClient.shutdown();
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
private void deleteReplica(ClusterState clusterState, ZkNodeProps message, NamedList results) throws KeeperException, InterruptedException {
  checkRequired(message, COLLECTION_PROP, SHARD_ID_PROP,REPLICA_PROP);
  String collectionName = message.getStr(COLLECTION_PROP);
  String shard = message.getStr(SHARD_ID_PROP);
  String replicaName = message.getStr(REPLICA_PROP);
  DocCollection coll = clusterState.getCollection(collectionName);
  Slice slice = coll.getSlice(shard);
  if(slice==null){
    throw new SolrException(ErrorCode.BAD_REQUEST, "Invalid shard name : "+shard+" in collection : "+ collectionName);
  }
  Replica replica = slice.getReplica(replicaName);
  if(replica == null){
    ArrayList<String> l = new ArrayList<String>();
    for (Replica r : slice.getReplicas()) l.add(r.getName());
    throw new SolrException(ErrorCode.BAD_REQUEST, "Invalid replica : " + replicaName + " in shard/collection : "
        + shard + "/"+ collectionName + " available replicas are "+ StrUtils.join(l,','));
  }

  String baseUrl = replica.getStr(ZkStateReader.BASE_URL_PROP);
  String core = replica.getStr(ZkStateReader.CORE_NAME_PROP);
  
  // assume the core exists and try to unload it
  Map m = ZkNodeProps.makeMap("qt", adminPath, CoreAdminParams.ACTION,
      CoreAdminAction.UNLOAD.toString(), CoreAdminParams.CORE, core);
  
  ShardRequest sreq = new ShardRequest();
  sreq.purpose = 1;
  sreq.shards = new String[] {baseUrl};
  sreq.actualShards = sreq.shards;
  sreq.params = new ModifiableSolrParams(new MapSolrParams(m));
  try {
    shardHandler.submit(sreq, baseUrl, sreq.params);
  } catch (Exception e) {
    log.warn("Exception trying to unload core " + sreq, e);
  }
  
  collectShardResponses(!Slice.ACTIVE.equals(replica.getStr(Slice.STATE)) ? new NamedList() : results, false, null);
  
  if (waitForCoreNodeGone(collectionName, shard, replicaName, 5000)) return;//check if the core unload removed the corenode zk enry
  deleteCoreNode(collectionName, replicaName, replica, core); // try and ensure core info is removed from clusterstate
  if(waitForCoreNodeGone(collectionName, shard, replicaName, 30000)) return;

  throw new SolrException(ErrorCode.SERVER_ERROR, "Could not  remove replica : " + collectionName + "/" + shard+"/" + replicaName);
}
 

import org.apache.solr.common.cloud.ZkNodeProps; //导入方法依赖的package包/类
/**
 * Handled list collection request.
 * Do list collection request to zk host
 *
 * @param req solr request
 * @param rsp solr response
 * @throws KeeperException      zk connection failed
 * @throws InterruptedException connection interrupted
 */
private void handleListAction(SolrQueryRequest req, SolrQueryResponse rsp) throws KeeperException, InterruptedException {
  Map<String, Object> props = ZkNodeProps.makeMap(
      Overseer.QUEUE_OPERATION, CollectionAction.LIST.toString().toLowerCase(Locale.ROOT));
  handleResponse(CollectionAction.LIST.toString(), new ZkNodeProps(props), rsp);
}