Java RoutingAllocation.routingNodes方法代码示例

import org.elasticsearch.cluster.routing.allocation.RoutingAllocation; //导入方法依赖的package包/类
/**
 * Allocate unassigned shards to nodes (if any) where valid copies of the shard already exist.
 * It is up to the individual implementations of {@link #makeAllocationDecision(ShardRouting, RoutingAllocation, Logger)}
 * to make decisions on assigning shards to nodes.
 *
 * @param allocation the allocation state container object
 */
public void allocateUnassigned(RoutingAllocation allocation) {
    final RoutingNodes routingNodes = allocation.routingNodes();
    final RoutingNodes.UnassignedShards.UnassignedIterator unassignedIterator = routingNodes.unassigned().iterator();
    while (unassignedIterator.hasNext()) {
        final ShardRouting shard = unassignedIterator.next();
        final AllocateUnassignedDecision allocateUnassignedDecision = makeAllocationDecision(shard, allocation, logger);

        if (allocateUnassignedDecision.isDecisionTaken() == false) {
            // no decision was taken by this allocator
            continue;
        }

        if (allocateUnassignedDecision.getAllocationDecision() == AllocationDecision.YES) {
            unassignedIterator.initialize(allocateUnassignedDecision.getTargetNode().getId(),
                allocateUnassignedDecision.getAllocationId(),
                shard.primary() ? ShardRouting.UNAVAILABLE_EXPECTED_SHARD_SIZE :
                                  allocation.clusterInfo().getShardSize(shard, ShardRouting.UNAVAILABLE_EXPECTED_SHARD_SIZE),
                allocation.changes());
        } else {
            unassignedIterator.removeAndIgnore(allocateUnassignedDecision.getAllocationStatus(), allocation.changes());
        }
    }
}
 

import org.elasticsearch.cluster.routing.allocation.RoutingAllocation; //导入方法依赖的package包/类
/**
 * Builds decisions for all nodes in the cluster, so that the explain API can provide information on
 * allocation decisions for each node, while still waiting to allocate the shard (e.g. due to fetching shard data).
 */
protected List<NodeAllocationResult> buildDecisionsForAllNodes(ShardRouting shard, RoutingAllocation allocation) {
    List<NodeAllocationResult> results = new ArrayList<>();
    for (RoutingNode node : allocation.routingNodes()) {
        Decision decision = allocation.deciders().canAllocate(shard, node, allocation);
        results.add(new NodeAllocationResult(node.node(), null, decision));
    }
    return results;
}
 

import org.elasticsearch.cluster.routing.allocation.RoutingAllocation; //导入方法依赖的package包/类
public Balancer(Logger logger, RoutingAllocation allocation, WeightFunction weight, float threshold) {
    this.logger = logger;
    this.allocation = allocation;
    this.weight = weight;
    this.threshold = threshold;
    this.routingNodes = allocation.routingNodes();
    this.metaData = allocation.metaData();
    avgShardsPerNode = ((float) metaData.getTotalNumberOfShards()) / routingNodes.size();
    nodes = Collections.unmodifiableMap(buildModelFromAssigned());
    sorter = newNodeSorter();
}
 

import org.elasticsearch.cluster.routing.allocation.RoutingAllocation; //导入方法依赖的package包/类
@Override
public RerouteExplanation execute(RoutingAllocation allocation, boolean explain) {
    DiscoveryNode discoNode = allocation.nodes().resolveNode(node);
    ShardRouting shardRouting = null;
    RoutingNodes routingNodes = allocation.routingNodes();
    RoutingNode routingNode = routingNodes.node(discoNode.getId());
    IndexMetaData indexMetaData = null;
    if (routingNode != null) {
        indexMetaData = allocation.metaData().index(index());
        if (indexMetaData == null) {
            throw new IndexNotFoundException(index());
        }
        ShardId shardId = new ShardId(indexMetaData.getIndex(), shardId());
        shardRouting = routingNode.getByShardId(shardId);
    }
    if (shardRouting == null) {
        if (explain) {
            return new RerouteExplanation(this, allocation.decision(Decision.NO, "cancel_allocation_command",
                "can't cancel " + shardId + ", failed to find it on node " + discoNode));
        }
        throw new IllegalArgumentException("[cancel_allocation] can't cancel " + shardId + ", failed to find it on node " + discoNode);
    }
    if (shardRouting.primary() && allowPrimary == false) {
        if ((shardRouting.initializing() && shardRouting.relocatingNodeId() != null) == false) {
            // only allow cancelling initializing shard of primary relocation without allowPrimary flag
            if (explain) {
                return new RerouteExplanation(this, allocation.decision(Decision.NO, "cancel_allocation_command",
                    "can't cancel " + shardId + " on node " + discoNode + ", shard is primary and " +
                        shardRouting.state().name().toLowerCase(Locale.ROOT)));
            }
            throw new IllegalArgumentException("[cancel_allocation] can't cancel " + shardId + " on node " +
                discoNode + ", shard is primary and " + shardRouting.state().name().toLowerCase(Locale.ROOT));
        }
    }
    routingNodes.failShard(Loggers.getLogger(CancelAllocationCommand.class), shardRouting,
        new UnassignedInfo(UnassignedInfo.Reason.REROUTE_CANCELLED, null), indexMetaData, allocation.changes());
    return new RerouteExplanation(this, allocation.decision(Decision.YES, "cancel_allocation_command",
            "shard " + shardId + " on node " + discoNode + " can be cancelled"));
}
 

import org.elasticsearch.cluster.routing.allocation.RoutingAllocation; //导入方法依赖的package包/类
private void assertClusterHealthStatus(RoutingAllocation allocation, ClusterHealthStatus expectedStatus) {
    RoutingTable oldRoutingTable = allocation.routingTable();
    RoutingNodes newRoutingNodes = allocation.routingNodes();
    final RoutingTable newRoutingTable = new RoutingTable.Builder()
                                                         .updateNodes(oldRoutingTable.version(), newRoutingNodes)
                                                         .build();
    ClusterState clusterState = ClusterState.builder(new ClusterName("test-cluster"))
                                            .routingTable(newRoutingTable)
                                            .build();
    ClusterStateHealth clusterStateHealth = new ClusterStateHealth(clusterState);
    assertThat(clusterStateHealth.getStatus().ordinal(), lessThanOrEqualTo(expectedStatus.ordinal()));
}
 

import org.elasticsearch.cluster.routing.allocation.RoutingAllocation; //导入方法依赖的package包/类
public Balancer(ESLogger logger, RoutingAllocation allocation, WeightFunction weight, float threshold) {
    this.logger = logger;
    this.allocation = allocation;
    this.weight = weight;
    this.threshold = threshold;
    this.routingNodes = allocation.routingNodes();
    for (RoutingNode node : routingNodes) {
        nodes.put(node.nodeId(), new ModelNode(node.nodeId()));
    }
    metaData = routingNodes.metaData();
    avgShardsPerNode = ((float) metaData.totalNumberOfShards()) / nodes.size();
}
 

import org.elasticsearch.cluster.routing.allocation.RoutingAllocation; //导入方法依赖的package包/类
@Override
public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
    Iterable<ShardRouting> assignedShards = allocation.routingNodes().assignedShards(shardRouting.shardId());
    Decision decision = decideSameNode(shardRouting, node, allocation, assignedShards);
    if (decision.type() == Decision.Type.NO || sameHost == false) {
        // if its already a NO decision looking at the node, or we aren't configured to look at the host, return the decision
        return decision;
    }
    if (node.node() != null) {
        for (RoutingNode checkNode : allocation.routingNodes()) {
            if (checkNode.node() == null) {
                continue;
            }
            // check if its on the same host as the one we want to allocate to
            boolean checkNodeOnSameHostName = false;
            boolean checkNodeOnSameHostAddress = false;
            if (Strings.hasLength(checkNode.node().getHostAddress()) && Strings.hasLength(node.node().getHostAddress())) {
                if (checkNode.node().getHostAddress().equals(node.node().getHostAddress())) {
                    checkNodeOnSameHostAddress = true;
                }
            } else if (Strings.hasLength(checkNode.node().getHostName()) && Strings.hasLength(node.node().getHostName())) {
                if (checkNode.node().getHostName().equals(node.node().getHostName())) {
                    checkNodeOnSameHostName = true;
                }
            }
            if (checkNodeOnSameHostAddress || checkNodeOnSameHostName) {
                for (ShardRouting assignedShard : assignedShards) {
                    if (checkNode.nodeId().equals(assignedShard.currentNodeId())) {
                        String hostType = checkNodeOnSameHostAddress ? "address" : "name";
                        String host = checkNodeOnSameHostAddress ? node.node().getHostAddress() : node.node().getHostName();
                        return allocation.decision(Decision.NO, NAME,
                            "the shard cannot be allocated on host %s [%s], where it already exists on node [%s]; " +
                                "set cluster setting [%s] to false to allow multiple nodes on the same host to hold the same " +
                                "shard copies",
                            hostType, host, node.nodeId(), CLUSTER_ROUTING_ALLOCATION_SAME_HOST_SETTING.getKey());
                    }
                }
            }
        }
    }
    return allocation.decision(Decision.YES, NAME, "the shard does not exist on the same host");
}