Java ClusterState.nodes方法代码示例

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
/**
 * make sure that nodes in clusterState are pinged. Any pinging to nodes which are not
 * part of the cluster will be stopped
 */
public void updateNodesAndPing(ClusterState clusterState) {
    // remove any nodes we don't need, this will cause their FD to stop
    for (DiscoveryNode monitoredNode : nodesFD.keySet()) {
        if (!clusterState.nodes().nodeExists(monitoredNode)) {
            nodesFD.remove(monitoredNode);
        }
    }
    // add any missing nodes

    for (DiscoveryNode node : clusterState.nodes()) {
        if (node.equals(localNode)) {
            // no need to monitor the local node
            continue;
        }
        if (!nodesFD.containsKey(node)) {
            NodeFD fd = new NodeFD(node);
            // it's OK to overwrite an existing nodeFD - it will just stop and the new one will pick things up.
            nodesFD.put(node, fd);
            // we use schedule with a 0 time value to run the pinger on the pool as it will run on later
            threadPool.schedule(TimeValue.timeValueMillis(0), ThreadPool.Names.SAME, fd);
        }
    }
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
private Async(ClearScrollRequest request, ActionListener<ClearScrollResponse> listener, ClusterState clusterState) {
    int expectedOps = 0;
    this.nodes = clusterState.nodes();
    if (request.getScrollIds().size() == 1 && "_all".equals(request.getScrollIds().get(0))) {
        expectedOps = nodes.getSize();
    } else {
        for (String parsedScrollId : request.getScrollIds()) {
            ScrollIdForNode[] context = parseScrollId(parsedScrollId).getContext();
            expectedOps += context.length;
            this.contexts.add(context);
        }
    }
    this.listener = listener;
    this.expHolder = new AtomicReference<>();
    this.expectedOps = new CountDown(expectedOps);
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
/**
 * make sure that nodes in clusterState are pinged. Any pinging to nodes which are not
 * part of the cluster will be stopped
 */
public void updateNodesAndPing(ClusterState clusterState) {
    // remove any nodes we don't need, this will cause their FD to stop
    for (DiscoveryNode monitoredNode : nodesFD.keySet()) {
        if (!clusterState.nodes().nodeExists(monitoredNode.id())) {
            nodesFD.remove(monitoredNode);
        }
    }
    // add any missing nodes

    for (DiscoveryNode node : clusterState.nodes()) {
        if (node.equals(localNode)) {
            // no need to monitor the local node
            continue;
        }
        if (!nodesFD.containsKey(node)) {
            NodeFD fd = new NodeFD(node);
            // it's OK to overwrite an existing nodeFD - it will just stop and the new one will pick things up.
            nodesFD.put(node, fd);
            // we use schedule with a 0 time value to run the pinger on the pool as it will run on later
            threadPool.schedule(TimeValue.timeValueMillis(0), ThreadPool.Names.SAME, fd);
        }
    }
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
public RoutingAllocation.Result reroute(ClusterState clusterState, AllocationCommands commands, boolean explain) {
    RoutingNodes routingNodes = getMutableRoutingNodes(clusterState);
    // we don't shuffle the unassigned shards here, to try and get as close as possible to
    // a consistent result of the effect the commands have on the routing
    // this allows systems to dry run the commands, see the resulting cluster state, and act on it
    RoutingAllocation allocation = new RoutingAllocation(allocationDeciders, routingNodes, clusterState.nodes(), clusterInfoService.getClusterInfo(), currentNanoTime());
    // don't short circuit deciders, we want a full explanation
    allocation.debugDecision(true);
    // we ignore disable allocation, because commands are explicit
    allocation.ignoreDisable(true);
    RoutingExplanations explanations = commands.execute(allocation, explain);
    // we revert the ignore disable flag, since when rerouting, we want the original setting to take place
    allocation.ignoreDisable(false);
    // the assumption is that commands will move / act on shards (or fail through exceptions)
    // so, there will always be shard "movements", so no need to check on reroute
    reroute(allocation);
    RoutingTable routingTable = new RoutingTable.Builder().updateNodes(routingNodes).build().validateRaiseException(clusterState.metaData());
    RoutingAllocation.Result result = new RoutingAllocation.Result(true, routingTable, explanations);
    logClusterHealthStateChange(
            new ClusterStateHealth(clusterState),
            new ClusterStateHealth(clusterState.getMetaData(), routingTable),
            "reroute commands"
    );
    return result;
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
public void nodeIndexDeleted(final ClusterState clusterState, final String index, final Settings indexSettings, final String nodeId) {
    final DiscoveryNodes nodes = clusterState.nodes();
    transportService.sendRequest(clusterState.nodes().masterNode(),
            INDEX_DELETED_ACTION_NAME, new NodeIndexDeletedMessage(index, nodeId), EmptyTransportResponseHandler.INSTANCE_SAME);
    if (nodes.localNode().isDataNode() == false) {
        logger.trace("[{}] not acking store deletion (not a data node)", index);
        return;
    }
    threadPool.generic().execute(new AbstractRunnable() {
        @Override
        public void onFailure(Throwable t) {
            logger.warn("[{}] failed to ack index store deleted for index", t, index);
        }

        @Override
        protected void doRun() throws Exception {
            lockIndexAndAck(index, nodes, nodeId, clusterState, indexSettings);
        }
    });
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
private Async(ClearScrollRequest request, ActionListener<ClearScrollResponse> listener, ClusterState clusterState) {
    int expectedOps = 0;
    this.nodes = clusterState.nodes();
    if (request.getScrollIds().size() == 1 && "_all".equals(request.getScrollIds().get(0))) {
        expectedOps = nodes.size();
    } else {
        for (String parsedScrollId : request.getScrollIds()) {
            ScrollIdForNode[] context = parseScrollId(parsedScrollId).getContext();
            expectedOps += context.length;
            this.contexts.add(context);
        }
    }

    this.request = request;
    this.listener = listener;
    this.expHolder = new AtomicReference<>();
    this.expectedOps = new CountDown(expectedOps);
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
/**
 * Creates a new {@link RoutingAllocation}
 *  @param deciders {@link AllocationDeciders} to used to make decisions for routing allocations
 * @param routingNodes Routing nodes in the current cluster
 * @param clusterState cluster state before rerouting
 * @param currentNanoTime the nano time to use for all delay allocation calculation (typically {@link System#nanoTime()})
 */
public RoutingAllocation(AllocationDeciders deciders, RoutingNodes routingNodes, ClusterState clusterState, ClusterInfo clusterInfo,
                         long currentNanoTime, boolean retryFailed) {
    this.deciders = deciders;
    this.routingNodes = routingNodes;
    this.metaData = clusterState.metaData();
    this.routingTable = clusterState.routingTable();
    this.nodes = clusterState.nodes();
    this.customs = clusterState.customs();
    this.clusterInfo = clusterInfo;
    this.currentNanoTime = currentNanoTime;
    this.retryFailed = retryFailed;
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
private AsyncSingleAction(Request request, ActionListener<Response> listener) {
    this.listener = listener;

    ClusterState clusterState = clusterService.state();
    if (logger.isTraceEnabled()) {
        logger.trace("executing [{}] based on cluster state version [{}]", request, clusterState.version());
    }
    nodes = clusterState.nodes();
    ClusterBlockException blockException = checkGlobalBlock(clusterState);
    if (blockException != null) {
        throw blockException;
    }

    String concreteSingleIndex;
    if (resolveIndex(request)) {
        concreteSingleIndex = indexNameExpressionResolver.concreteSingleIndex(clusterState, request).getName();
    } else {
        concreteSingleIndex = request.index();
    }
    this.internalRequest = new InternalRequest(request, concreteSingleIndex);
    resolveRequest(clusterState, internalRequest);

    blockException = checkRequestBlock(clusterState, internalRequest);
    if (blockException != null) {
        throw blockException;
    }

    this.shardIt = shards(clusterState, internalRequest);
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
protected void assertNodesInCurrentState(List<DiscoveryNode> expectedNodes) {
    final ClusterState state = clusterService.state();
    logger.info("assert for [{}] in:\n{}", expectedNodes, state);
    DiscoveryNodes discoveryNodes = state.nodes();
    for (DiscoveryNode node : expectedNodes) {
        assertThat("missing " + node + "\n" + discoveryNodes, discoveryNodes.get(node.getId()), equalTo(node));
    }
    assertThat(discoveryNodes.getSize(), equalTo(expectedNodes.size()));
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
TimedClusterService createTimedClusterService(boolean makeMaster) throws InterruptedException {
    TimedClusterService timedClusterService = new TimedClusterService(Settings.builder().put("cluster.name",
        "ClusterServiceTests").build(), new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
        threadPool, () -> new DiscoveryNode("node1", buildNewFakeTransportAddress(), emptyMap(),
        emptySet(), Version.CURRENT));
    timedClusterService.setNodeConnectionsService(new NodeConnectionsService(Settings.EMPTY, null, null) {
        @Override
        public void connectToNodes(DiscoveryNodes discoveryNodes) {
            // skip
        }

        @Override
        public void disconnectFromNodesExcept(DiscoveryNodes nodesToKeep) {
            // skip
        }
    });
    timedClusterService.setClusterStatePublisher((event, ackListener) -> {
    });
    timedClusterService.setDiscoverySettings(new DiscoverySettings(Settings.EMPTY,
        new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)));
    timedClusterService.start();
    ClusterState state = timedClusterService.state();
    final DiscoveryNodes nodes = state.nodes();
    final DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder(nodes)
        .masterNodeId(makeMaster ? nodes.getLocalNodeId() : null);
    state = ClusterState.builder(state).blocks(ClusterBlocks.EMPTY_CLUSTER_BLOCK)
        .nodes(nodesBuilder).build();
    setState(timedClusterService, state);
    return timedClusterService;
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
public void nodeMappingRefresh(final ClusterState state, final NodeMappingRefreshRequest request) {
    final DiscoveryNodes nodes = state.nodes();
    if (nodes.masterNode() == null) {
        logger.warn("can't send mapping refresh for [{}][{}], no master known.", request.index(), Strings.arrayToCommaDelimitedString(request.types()));
        return;
    }
    transportService.sendRequest(nodes.masterNode(), ACTION_NAME, request, EmptyTransportResponseHandler.INSTANCE_SAME);
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
private AsyncSingleAction(Request request, ActionListener<Response> listener) {
    this.listener = listener;

    ClusterState clusterState = clusterService.state();
    if (logger.isTraceEnabled()) {
        logger.trace("executing [{}] based on cluster state version [{}]", request, clusterState.version());
    }
    nodes = clusterState.nodes();
    ClusterBlockException blockException = checkGlobalBlock(clusterState);
    if (blockException != null) {
        throw blockException;
    }

    String concreteSingleIndex;
    if (resolveIndex(request)) {
        concreteSingleIndex = indexNameExpressionResolver.concreteSingleIndex(clusterState, request);
    } else {
        concreteSingleIndex = request.index();
    }
    this.internalRequest = new InternalRequest(request, concreteSingleIndex);
    resolveRequest(clusterState, internalRequest);

    blockException = checkRequestBlock(clusterState, internalRequest);
    if (blockException != null) {
        throw blockException;
    }

    this.shardIt = shards(clusterState, internalRequest);
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
protected void doStart(ClusterState clusterState) {
    final Predicate<ClusterState> masterChangePredicate = MasterNodeChangePredicate.build(clusterState);
    final DiscoveryNodes nodes = clusterState.nodes();
    if (nodes.isLocalNodeElectedMaster() || localExecute(request)) {
        // check for block, if blocked, retry, else, execute locally
        final ClusterBlockException blockException = checkBlock(request, clusterState);
        if (blockException != null) {
            if (!blockException.retryable()) {
                listener.onFailure(blockException);
            } else {
                logger.trace("can't execute due to a cluster block, retrying", blockException);
                retry(blockException, newState -> {
                    ClusterBlockException newException = checkBlock(request, newState);
                    return (newException == null || !newException.retryable());
                });
            }
        } else {
            ActionListener<Response> delegate = new ActionListener<Response>() {
                @Override
                public void onResponse(Response response) {
                    listener.onResponse(response);
                }

                @Override
                public void onFailure(Exception t) {
                    if (t instanceof Discovery.FailedToCommitClusterStateException
                            || (t instanceof NotMasterException)) {
                        logger.debug((org.apache.logging.log4j.util.Supplier<?>) () -> new ParameterizedMessage("master could not publish cluster state or stepped down before publishing action [{}], scheduling a retry", actionName), t);
                        retry(t, masterChangePredicate);
                    } else {
                        listener.onFailure(t);
                    }
                }
            };
            threadPool.executor(executor).execute(new ActionRunnable(delegate) {
                @Override
                protected void doRun() throws Exception {
                    masterOperation(task, request, clusterState, delegate);
                }
            });
        }
    } else {
        if (nodes.getMasterNode() == null) {
            logger.debug("no known master node, scheduling a retry");
            retry(null, masterChangePredicate);
        } else {
            transportService.sendRequest(nodes.getMasterNode(), actionName, request, new ActionListenerResponseHandler<Response>(listener, TransportMasterNodeAction.this::newResponse) {
                @Override
                public void handleException(final TransportException exp) {
                    Throwable cause = exp.unwrapCause();
                    if (cause instanceof ConnectTransportException) {
                        // we want to retry here a bit to see if a new master is elected
                        logger.debug("connection exception while trying to forward request with action name [{}] to master node [{}], scheduling a retry. Error: [{}]",
                                actionName, nodes.getMasterNode(), exp.getDetailedMessage());
                        retry(cause, masterChangePredicate);
                    } else {
                        listener.onFailure(exp);
                    }
                }
            });
        }
    }
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
public void testLocalNodeMasterListenerCallbacks() throws Exception {
    TimedClusterService timedClusterService = createTimedClusterService(false);

    AtomicBoolean isMaster = new AtomicBoolean();
    timedClusterService.addLocalNodeMasterListener(new LocalNodeMasterListener() {
        @Override
        public void onMaster() {
            isMaster.set(true);
        }

        @Override
        public void offMaster() {
            isMaster.set(false);
        }

        @Override
        public String executorName() {
            return ThreadPool.Names.SAME;
        }
    });

    ClusterState state = timedClusterService.state();
    DiscoveryNodes nodes = state.nodes();
    DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder(nodes).masterNodeId(nodes.getLocalNodeId());
    state = ClusterState.builder(state).blocks(ClusterBlocks.EMPTY_CLUSTER_BLOCK).nodes(nodesBuilder).build();
    setState(timedClusterService, state);
    assertThat(isMaster.get(), is(true));

    nodes = state.nodes();
    nodesBuilder = DiscoveryNodes.builder(nodes).masterNodeId(null);
    state = ClusterState.builder(state).blocks(ClusterBlocks.builder().addGlobalBlock(DiscoverySettings.NO_MASTER_BLOCK_WRITES))
        .nodes(nodesBuilder).build();
    setState(timedClusterService, state);
    assertThat(isMaster.get(), is(false));
    nodesBuilder = DiscoveryNodes.builder(nodes).masterNodeId(nodes.getLocalNodeId());
    state = ClusterState.builder(state).blocks(ClusterBlocks.EMPTY_CLUSTER_BLOCK).nodes(nodesBuilder).build();
    setState(timedClusterService, state);
    assertThat(isMaster.get(), is(true));

    timedClusterService.close();
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
protected void doStart() {
    final ClusterState clusterState = observer.observedState();
    final DiscoveryNodes nodes = clusterState.nodes();
    if (nodes.localNodeMaster() || localExecute(request)) {
        // check for block, if blocked, retry, else, execute locally
        final ClusterBlockException blockException = checkBlock(request, clusterState);
        if (blockException != null) {
            if (!blockException.retryable()) {
                listener.onFailure(blockException);
            } else {
                logger.trace("can't execute due to a cluster block, retrying", blockException);
                retry(blockException, retryableOrNoBlockPredicate);
            }
        } else {
            final ActionListener<Response> delegate = new ActionListener<Response>() {
                @Override
                public void onResponse(Response response) {
                    listener.onResponse(response);
                }

                @Override
                public void onFailure(Throwable t) {
                    if (t instanceof NotMasterException) {
                        logger.debug("master could not publish cluster state or stepped down before publishing action [{}], scheduling a retry", t, actionName);
                        retry(t, masterNodeChangedPredicate);
                    } else {
                        listener.onFailure(t);
                    }
                }
            };
            taskManager.registerChildTask(task, nodes.getLocalNodeId());
            threadPool.executor(executor).execute(new ActionRunnable(delegate) {
                @Override
                protected void doRun() throws Exception {
                    masterOperation(task, request, clusterService.state(), delegate);
                }
            });
        }
    } else {
        if (nodes.masterNode() == null) {
            logger.debug("no known master node, scheduling a retry");
            retry(null, masterNodeChangedPredicate);
        } else {
            taskManager.registerChildTask(task, nodes.masterNode().getId());
            transportService.sendRequest(nodes.masterNode(), actionName, request, new ActionListenerResponseHandler<Response>(listener) {
                @Override
                public Response newInstance() {
                    return newResponse();
                }

                @Override
                public void handleException(final TransportException exp) {
                    Throwable cause = exp.unwrapCause();
                    if (cause instanceof ConnectTransportException) {
                        // we want to retry here a bit to see if a new master is elected
                        logger.debug("connection exception while trying to forward request with action name [{}] to master node [{}], scheduling a retry. Error: [{}]",
                                actionName, nodes.masterNode(), exp.getDetailedMessage());
                        retry(cause, masterNodeChangedPredicate);
                    } else {
                        listener.onFailure(exp);
                    }
                }
            });
        }
    }
}