public long getVersion() { return version(); }
private PingRequest newPingRequest() { return new PingRequest(node, clusterName, localNode, clusterStateSupplier.get().version()); }
/** * tries and commit the current state, if a decision wasn't made yet * * @return true if successful */ private synchronized boolean markAsCommitted() { if (committedOrFailed()) { return committed; } logger.trace("committing version [{}]", clusterState.version()); committed = true; committedOrFailedLatch.countDown(); return true; }
/** * tries marking the publishing as failed, if a decision wasn't made yet * * @return true if the publishing was failed and the cluster state is *not* committed **/ private synchronized boolean markAsFailed(String reason) { if (committedOrFailed()) { return committed == false; } logger.trace("failed to commit version [{}]. {}", clusterState.version(), reason); committed = false; committedOrFailedLatch.countDown(); return true; }
private void callClusterStateListeners(ClusterChangedEvent clusterChangedEvent) { Stream.concat(clusterStateListeners.stream(), timeoutClusterStateListeners.stream()).forEach(listener -> { try { logger.trace("calling [{}] with change to version [{}]", listener, clusterChangedEvent.state().version()); listener.clusterChanged(clusterChangedEvent); } catch (Exception ex) { logger.warn("failed to notify ClusterStateListener", ex); } }); }
private void callClusterStateAppliers(ClusterChangedEvent clusterChangedEvent) { clusterStateAppliers.forEach(applier -> { try { logger.trace("calling [{}] with change to version [{}]", applier, clusterChangedEvent.state().version()); applier.applyClusterState(clusterChangedEvent); } catch (Exception ex) { logger.warn("failed to notify ClusterStateApplier", ex); } }); }
/** * returns true if stored state is older then given state or they are from a different master, meaning they can't be compared * */ public boolean isOlderOrDifferentMaster(ClusterState clusterState) { return version < clusterState.version() || Objects.equals(masterNodeId, clusterState.nodes().getMasterNodeId()) == false; } }
@Override public void handleResponse(TransportResponse.Empty response) { if (sendingController.getPublishingTimedOut()) { logger.debug("node {} responded for cluster state [{}] (took longer than [{}])", node, clusterState.version(), publishTimeout); } sendingController.onNodeSendAck(node); }
public Discovery.AckListener createAckListener(ThreadPool threadPool, ClusterState newClusterState) { return new DelegatingAckListener(nonFailedTasks.stream() .filter(task -> task.listener instanceof AckedClusterStateTaskListener) .map(task -> new AckCountDownListener((AckedClusterStateTaskListener) task.listener, newClusterState.version(), newClusterState.nodes(), threadPool)) .collect(Collectors.toList())); }
public synchronized void onNodeSendAck(DiscoveryNode node) { if (committed) { assert sendAckedBeforeCommit.isEmpty(); sendCommitToNode(node, clusterState, this); } else if (committedOrFailed()) { logger.trace("ignoring ack from [{}] for cluster state version [{}]. already failed", node, clusterState.version()); } else { // we're still waiting sendAckedBeforeCommit.add(node); if (node.isMasterNode()) { checkForCommitOrFailIfNoPending(node); } } }
StoredState(ClusterState clusterState) { this.masterNodeId = clusterState.nodes().getMasterNodeId(); this.version = clusterState.version(); }
@Override public void handleResponse(TransportResponse.Empty response) { if (sendingController.getPublishingTimedOut()) { logger.debug("node {} responded to cluster state commit [{}]", node, clusterState.version()); } sendingController.getPublishResponseHandler().onResponse(node); }
public synchronized void onNodeSendFailed(DiscoveryNode node, Exception e) { if (node.isMasterNode()) { logger.trace("master node {} failed to ack cluster state version [{}]. " + "processing ... (current pending [{}], needed [{}])", node, clusterState.version(), pendingMasterNodes, neededMastersToCommit); decrementPendingMasterAcksAndChangeForFailure(); } publishResponseHandler.onFailure(node, e); }
@Override public void onFailure(String source, Exception e) { rerouting.set(false); ClusterState state = clusterService.state(); if (logger.isTraceEnabled()) { logger.error(() -> new ParameterizedMessage("unexpected failure during [{}], current state:\n{}", source, state), e); } else { logger.error(() -> new ParameterizedMessage("unexpected failure during [{}], current state version [{}]", source, state.version()), e); } } });
@Override public String toString() { return String.format( Locale.ROOT, "[uuid[%s], v[%d], m[%s]]", stateUUID(), state.version(), state.nodes().getMasterNodeId() ); } }
/** * a cluster state supersedes another state if they are from the same master and the version of this state is higher than that of the * other state. * <p> * In essence that means that all the changes from the other cluster state are also reflected by the current one */ public boolean supersedes(ClusterState other) { return this.nodes().getMasterNodeId() != null && this.nodes().getMasterNodeId().equals(other.nodes().getMasterNodeId()) && this.version() > other.version(); }
public PingResponse(DiscoveryNode node, DiscoveryNode master, ClusterState state) { this(node, master, state.getClusterName(), state.blocks().hasGlobalBlock(STATE_NOT_RECOVERED_BLOCK) ? ElectMasterService.MasterCandidate.UNRECOVERED_CLUSTER_VERSION : state.version()); }
@Override public void handleException(TransportException exp) { logger.debug(() -> new ParameterizedMessage("failed to commit cluster state (uuid [{}], version [{}]) to {}", clusterState.stateUUID(), clusterState.version(), node), exp); sendingController.getPublishResponseHandler().onFailure(node, exp); } });
@Override protected void doMasterOperation(final GetMappingsRequest request, String[] concreteIndices, final ClusterState state, final ActionListener<GetMappingsResponse> listener) { logger.trace("serving getMapping request based on version {}", state.version()); try { ImmutableOpenMap<String, ImmutableOpenMap<String, MappingMetaData>> result = state.metaData().findMappings(concreteIndices, request.types(), indicesService.getFieldFilter()); listener.onResponse(new GetMappingsResponse(result)); } catch (IOException e) { listener.onFailure(e); } } }
public Builder(ClusterState state) { this.clusterName = state.clusterName; this.version = state.version(); this.uuid = state.stateUUID(); this.nodes = state.nodes(); this.routingTable = state.routingTable(); this.metaData = state.metaData(); this.blocks = state.blocks(); this.customs = ImmutableOpenMap.builder(state.customs()); this.fromDiff = false; }