Java ClusterChangedEvent.state方法代码示例

import org.elasticsearch.cluster.ClusterChangedEvent; //导入方法依赖的package包/类
@Override
public synchronized void applyClusterState(final ClusterChangedEvent event) {
    if (!lifecycle.started()) {
        return;
    }

    final ClusterState state = event.state();

    // we need to clean the shards and indices we have on this node, since we
    // are going to recover them again once state persistence is disabled (no master / not recovered)
    // TODO: feels hacky, a block disables state persistence, and then we clean the allocated shards, maybe another flag in blocks?
    if (state.blocks().disableStatePersistence()) {
        for (AllocatedIndex<? extends Shard> indexService : indicesService) {
            indicesService.removeIndex(indexService.index(), NO_LONGER_ASSIGNED,
                "cleaning index (disabled block persistence)"); // also cleans shards
        }
        return;
    }

    updateFailedShardsCache(state);

    deleteIndices(event); // also deletes shards of deleted indices

    removeUnallocatedIndices(event); // also removes shards of removed indices

    failMissingShards(state);

    removeShards(state);   // removes any local shards that doesn't match what the master expects

    updateIndices(event); // can also fail shards, but these are then guaranteed to be in failedShardsCache

    createIndices(state);

    createOrUpdateShards(state);
}
 

import org.elasticsearch.cluster.ClusterChangedEvent; //导入方法依赖的package包/类
private void innerPublish(final ClusterChangedEvent clusterChangedEvent, final Set<DiscoveryNode> nodesToPublishTo,
                          final SendingController sendingController, final boolean sendFullVersion,
                          final Map<Version, BytesReference> serializedStates, final Map<Version, BytesReference> serializedDiffs) {

    final ClusterState clusterState = clusterChangedEvent.state();
    final ClusterState previousState = clusterChangedEvent.previousState();
    final TimeValue publishTimeout = discoverySettings.getPublishTimeout();

    final long publishingStartInNanos = System.nanoTime();

    for (final DiscoveryNode node : nodesToPublishTo) {
        // try and serialize the cluster state once (or per version), so we don't serialize it
        // per node when we send it over the wire, compress it while we are at it...
        // we don't send full version if node didn't exist in the previous version of cluster state
        if (sendFullVersion || !previousState.nodes().nodeExists(node)) {
            sendFullClusterState(clusterState, serializedStates, node, publishTimeout, sendingController);
        } else {
            sendClusterStateDiff(clusterState, serializedDiffs, serializedStates, node, publishTimeout, sendingController);
        }
    }

    sendingController.waitForCommit(discoverySettings.getCommitTimeout());

    try {
        long timeLeftInNanos = Math.max(0, publishTimeout.nanos() - (System.nanoTime() - publishingStartInNanos));
        final BlockingClusterStatePublishResponseHandler publishResponseHandler = sendingController.getPublishResponseHandler();
        sendingController.setPublishingTimedOut(!publishResponseHandler.awaitAllNodes(TimeValue.timeValueNanos(timeLeftInNanos)));
        if (sendingController.getPublishingTimedOut()) {
            DiscoveryNode[] pendingNodes = publishResponseHandler.pendingNodes();
            // everyone may have just responded
            if (pendingNodes.length > 0) {
                logger.warn("timed out waiting for all nodes to process published state [{}] (timeout [{}], pending nodes: {})",
                    clusterState.version(), publishTimeout, pendingNodes);
            }
        }
    } catch (InterruptedException e) {
        // ignore & restore interrupt
        Thread.currentThread().interrupt();
    }
}
 

import org.elasticsearch.cluster.ClusterChangedEvent; //导入方法依赖的package包/类
public void testNoWriteIfNothingChanged() throws Exception {
    boolean initializing = false;
    boolean versionChanged = false;
    boolean stateInMemory = true;
    boolean masterEligible = randomBoolean();
    boolean expectMetaData = false;
    ClusterChangedEvent event = generateEvent(initializing, versionChanged, masterEligible);
    ClusterChangedEvent newEventWithNothingChanged = new ClusterChangedEvent("test cluster state", event.state(), event.state());
    assertState(newEventWithNothingChanged, stateInMemory, expectMetaData);
}
 

import org.elasticsearch.cluster.ClusterChangedEvent; //导入方法依赖的package包/类
@Override
public void clusterChanged(ClusterChangedEvent event) {
    clusterState = event.state();
}
 

import org.elasticsearch.cluster.ClusterChangedEvent; //导入方法依赖的package包/类
private void publish(final ClusterChangedEvent clusterChangedEvent, final Set<DiscoveryNode> nodesToPublishTo,
                     final BlockingClusterStatePublishResponseHandler publishResponseHandler) {

    Map<Version, BytesReference> serializedStates = Maps.newHashMap();
    Map<Version, BytesReference> serializedDiffs = Maps.newHashMap();

    final ClusterState clusterState = clusterChangedEvent.state();
    final ClusterState previousState = clusterChangedEvent.previousState();
    final AtomicBoolean timedOutWaitingForNodes = new AtomicBoolean(false);
    final TimeValue publishTimeout = discoverySettings.getPublishTimeout();
    final boolean sendFullVersion = !discoverySettings.getPublishDiff() || previousState == null;
    Diff<ClusterState> diff = null;

    for (final DiscoveryNode node : nodesToPublishTo) {

        // try and serialize the cluster state once (or per version), so we don't serialize it
        // per node when we send it over the wire, compress it while we are at it...
        // we don't send full version if node didn't exist in the previous version of cluster state
        if (sendFullVersion || !previousState.nodes().nodeExists(node.id())) {
            sendFullClusterState(clusterState, serializedStates, node, timedOutWaitingForNodes, publishTimeout, publishResponseHandler);
        } else {
            if (diff == null) {
                diff = clusterState.diff(previousState);
            }
            sendClusterStateDiff(clusterState, diff, serializedDiffs, node, timedOutWaitingForNodes, publishTimeout, publishResponseHandler);
        }
    }

    if (publishTimeout.millis() > 0) {
        // only wait if the publish timeout is configured...
        try {
            timedOutWaitingForNodes.set(!publishResponseHandler.awaitAllNodes(publishTimeout));
            if (timedOutWaitingForNodes.get()) {
                DiscoveryNode[] pendingNodes = publishResponseHandler.pendingNodes();
                // everyone may have just responded
                if (pendingNodes.length > 0) {
                    logger.warn("timed out waiting for all nodes to process published state [{}] (timeout [{}], pending nodes: {})", clusterState.version(), publishTimeout, pendingNodes);
                }
            }
        } catch (InterruptedException e) {
            // ignore & restore interrupt
            Thread.currentThread().interrupt();
        }
    }
}