Java ShardRouting.id方法代码示例

import org.elasticsearch.cluster.routing.ShardRouting; //导入方法依赖的package包/类
private void processShardRouting(Map<String, Map<String, List<Integer>>> routing, ShardRouting shardRouting, ShardId shardId) {
    String node;
    int id;
    String index = shardId.getIndex();

    if (shardRouting == null) {
        node = service.localNode().id();
        id = UnassignedShard.markUnassigned(shardId.id());
    } else {
        node = shardRouting.currentNodeId();
        id = shardRouting.id();
    }
    Map<String, List<Integer>> nodeMap = routing.get(node);
    if (nodeMap == null) {
        nodeMap = new TreeMap<>();
        routing.put(node, nodeMap);
    }

    List<Integer> shards = nodeMap.get(index);
    if (shards == null) {
        shards = new ArrayList<>();
        nodeMap.put(index, shards);
    }
    shards.add(id);
}
 

import org.elasticsearch.cluster.routing.ShardRouting; //导入方法依赖的package包/类
public int numReplicas() {
    int count = 0;
    for (ShardRouting msr : routing) {
        if (msr.primary() == false && msr.id()==0) {
            count++;
        }
    }
    return count;
}
 

import org.elasticsearch.cluster.routing.ShardRouting; //导入方法依赖的package包/类
private MoveAllocationCommand getAllocationCommand() {
    String fromNodeId = null;
    String toNodeId = null;
    ShardRouting shardToBeMoved = null;
    ClusterStateResponse clusterStateResponse = client().admin().cluster().prepareState().get();
    for (RoutingNode routingNode : clusterStateResponse.getState().getRoutingNodes()) {
        if (routingNode.node().isDataNode()) {
            if (fromNodeId == null && routingNode.numberOfOwningShards() > 0) {
                fromNodeId = routingNode.nodeId();
                shardToBeMoved = routingNode.copyShards().get(randomInt(routingNode.size() - 1));
            } else {
                toNodeId = routingNode.nodeId();
            }

            if (toNodeId != null && fromNodeId != null) {
                break;
            }
        }
    }

    assertNotNull(fromNodeId);
    assertNotNull(toNodeId);
    assertNotNull(shardToBeMoved);

    logger.info("==> going to move shard [{}] from [{}] to [{}]", shardToBeMoved, fromNodeId, toNodeId);
    return new MoveAllocationCommand(shardToBeMoved.getIndexName(), shardToBeMoved.id(), fromNodeId, toNodeId);
}
 

import org.elasticsearch.cluster.routing.ShardRouting; //导入方法依赖的package包/类
/**
 * Tries to find a relocation from the max node to the minimal node for an arbitrary shard of the given index on the
 * balance model. Iff this method returns a <code>true</code> the relocation has already been executed on the
 * simulation model as well as on the cluster.
 */
private boolean tryRelocateShard(ModelNode minNode, ModelNode maxNode, String idx, float minCost) {
    final ModelIndex index = maxNode.getIndex(idx);
    Decision decision = null;
    if (index != null) {
        if (logger.isTraceEnabled()) {
            logger.trace("Try relocating shard for index index [{}] from node [{}] to node [{}]", idx, maxNode.getNodeId(),
                    minNode.getNodeId());
        }
        ShardRouting candidate = null;
        final AllocationDeciders deciders = allocation.deciders();
        for (ShardRouting shard : index.getAllShards()) {
            if (shard.started()) {
                // skip initializing, unassigned and relocating shards we can't relocate them anyway
                Decision allocationDecision = deciders.canAllocate(shard, minNode.getRoutingNode(routingNodes), allocation);
                Decision rebalanceDecision = deciders.canRebalance(shard, allocation);
                if (((allocationDecision.type() == Type.YES) || (allocationDecision.type() == Type.THROTTLE))
                        && ((rebalanceDecision.type() == Type.YES) || (rebalanceDecision.type() == Type.THROTTLE))) {
                    if (maxNode.containsShard(shard)) {
                        // simulate moving shard from maxNode to minNode
                        final float delta = weight.weightShardAdded(this, minNode, idx) - weight.weightShardRemoved(this, maxNode, idx);
                        if (delta < minCost ||
                                (candidate != null && delta == minCost && candidate.id() > shard.id())) {
                            /* this last line is a tie-breaker to make the shard allocation alg deterministic
                             * otherwise we rely on the iteration order of the index.getAllShards() which is a set.*/
                            minCost = delta;
                            candidate = shard;
                            decision = new Decision.Multi().add(allocationDecision).add(rebalanceDecision);
                        }
                    }
                }
            }
        }

        if (candidate != null) {

            /* allocate on the model even if not throttled */
            maxNode.removeShard(candidate);
            minNode.addShard(candidate, decision);
            if (decision.type() == Type.YES) { /* only allocate on the cluster if we are not throttled */
                if (logger.isTraceEnabled()) {
                    logger.trace("Relocate shard [{}] from node [{}] to node [{}]", candidate, maxNode.getNodeId(),
                            minNode.getNodeId());
                }
                /* now allocate on the cluster - if we are started we need to relocate the shard */
                if (candidate.started()) {
                    routingNodes.relocate(candidate, minNode.getNodeId(), allocation.clusterInfo().getShardSize(candidate, ShardRouting.UNAVAILABLE_EXPECTED_SHARD_SIZE));

                } else {
                    routingNodes.initialize(candidate, minNode.getNodeId(), allocation.clusterInfo().getShardSize(candidate, ShardRouting.UNAVAILABLE_EXPECTED_SHARD_SIZE));
                }
                return true;

            }
        }
    }
    if (logger.isTraceEnabled()) {
        logger.trace("Couldn't find shard to relocate from node [{}] to node [{}] allocation decision [{}]", maxNode.getNodeId(),
                minNode.getNodeId(), decision == null ? "NO" : decision.type().name());
    }
    return false;
}