How to use

disableStatePersistence

method

in

org.elasticsearch.cluster.block.ClusterBlocks

  @Override
  public void clusterChanged(ClusterChangedEvent event) {
    if (event.state().blocks().disableStatePersistence() == false) {
      processDanglingIndices(event.state().metaData());
    }
  }
}

private void applyChanges(UpdateTask task, ClusterState previousClusterState, ClusterState newClusterState) {
  ClusterChangedEvent clusterChangedEvent = new ClusterChangedEvent(task.source, newClusterState, previousClusterState);
  // new cluster state, notify all listeners
  final DiscoveryNodes.Delta nodesDelta = clusterChangedEvent.nodesDelta();
  if (nodesDelta.hasChanges() && logger.isInfoEnabled()) {
    String summary = nodesDelta.shortSummary();
    if (summary.length() > 0) {
      logger.info("{}, reason: {}", summary, task.source);
    }
  }
  nodeConnectionsService.connectToNodes(newClusterState.nodes());
  logger.debug("applying cluster state version {}", newClusterState.version());
  try {
    // nothing to do until we actually recover from the gateway or any other block indicates we need to disable persistency
    if (clusterChangedEvent.state().blocks().disableStatePersistence() == false && clusterChangedEvent.metaDataChanged()) {
      final Settings incomingSettings = clusterChangedEvent.state().metaData().settings();
      clusterSettings.applySettings(incomingSettings);
    }
  } catch (Exception ex) {
    logger.warn("failed to apply cluster settings", ex);
  }
  logger.debug("apply cluster state with version {}", newClusterState.version());
  callClusterStateAppliers(clusterChangedEvent);
  nodeConnectionsService.disconnectFromNodesExcept(newClusterState.nodes());
  logger.debug("set locally applied cluster state to version {}", newClusterState.version());
  state.set(newClusterState);
  callClusterStateListeners(clusterChangedEvent);
  task.listener.onSuccess(task.source);
}

if (state.blocks().disableStatePersistence()) {

@Override
public ClusterState execute(ClusterState currentState) {
  if (currentState.blocks().disableStatePersistence()) {
    return currentState;

if (event.state().blocks().disableStatePersistence()) {
  return;

@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);
}

  @Override
  public void clusterChanged(ClusterChangedEvent event) {
    if (event.state().blocks().disableStatePersistence() == false) {
      processDanglingIndices(event.state().metaData());
    }
  }
}

  @Override
  public void clusterChanged(ClusterChangedEvent event) {
    if (event.state().blocks().disableStatePersistence() == false) {
      processDanglingIndices(event.state().metaData());
    }
  }
}

  @Override
  public void clusterChanged(ClusterChangedEvent event) {
    if (event.state().blocks().disableStatePersistence() == false) {
      processDanglingIndices(event.state().metaData());
    }
  }
}

private void applyChanges(UpdateTask task, ClusterState previousClusterState, ClusterState newClusterState) {
  ClusterChangedEvent clusterChangedEvent = new ClusterChangedEvent(task.source, newClusterState, previousClusterState);
  // new cluster state, notify all listeners
  final DiscoveryNodes.Delta nodesDelta = clusterChangedEvent.nodesDelta();
  if (nodesDelta.hasChanges() && logger.isInfoEnabled()) {
    String summary = nodesDelta.shortSummary();
    if (summary.length() > 0) {
      logger.info("{}, reason: {}", summary, task.source);
    }
  }
  nodeConnectionsService.connectToNodes(newClusterState.nodes());
  logger.debug("applying cluster state version {}", newClusterState.version());
  try {
    // nothing to do until we actually recover from the gateway or any other block indicates we need to disable persistency
    if (clusterChangedEvent.state().blocks().disableStatePersistence() == false && clusterChangedEvent.metaDataChanged()) {
      final Settings incomingSettings = clusterChangedEvent.state().metaData().settings();
      clusterSettings.applySettings(incomingSettings);
    }
  } catch (Exception ex) {
    logger.warn("failed to apply cluster settings", ex);
  }
  logger.debug("apply cluster state with version {}", newClusterState.version());
  callClusterStateAppliers(clusterChangedEvent);
  nodeConnectionsService.disconnectFromNodesExcept(newClusterState.nodes());
  logger.debug("set locally applied cluster state to version {}", newClusterState.version());
  state.set(newClusterState);
  callClusterStateListeners(clusterChangedEvent);
  task.listener.onSuccess(task.source);
}

@Override
public void clusterChanged(ClusterChangedEvent event) {
  if (event.state().blocks().disableStatePersistence()) {
    return;

private void applyChanges(UpdateTask task, ClusterState previousClusterState, ClusterState newClusterState) {
  ClusterChangedEvent clusterChangedEvent = new ClusterChangedEvent(task.source, newClusterState, previousClusterState);
  // new cluster state, notify all listeners
  final DiscoveryNodes.Delta nodesDelta = clusterChangedEvent.nodesDelta();
  if (nodesDelta.hasChanges() && logger.isInfoEnabled()) {
    String summary = nodesDelta.shortSummary();
    if (summary.length() > 0) {
      logger.info("{}, reason: {}", summary, task.source);
    }
  }
  nodeConnectionsService.connectToNodes(newClusterState.nodes());
  logger.debug("applying cluster state version {}", newClusterState.version());
  try {
    // nothing to do until we actually recover from the gateway or any other block indicates we need to disable persistency
    if (clusterChangedEvent.state().blocks().disableStatePersistence() == false && clusterChangedEvent.metaDataChanged()) {
      final Settings incomingSettings = clusterChangedEvent.state().metaData().settings();
      clusterSettings.applySettings(incomingSettings);
    }
  } catch (Exception ex) {
    logger.warn("failed to apply cluster settings", ex);
  }
  logger.debug("apply cluster state with version {}", newClusterState.version());
  callClusterStateAppliers(clusterChangedEvent);
  nodeConnectionsService.disconnectFromNodesExcept(newClusterState.nodes());
  logger.debug("set locally applied cluster state to version {}", newClusterState.version());
  state.set(newClusterState);
  callClusterStateListeners(clusterChangedEvent);
  task.listener.onSuccess(task.source);
}

@Override
public ClusterState execute(ClusterState currentState) {
  if (currentState.blocks().disableStatePersistence()) {
    return currentState;

@Override
public ClusterState execute(ClusterState currentState) {
  if (currentState.blocks().disableStatePersistence()) {
    return currentState;

@Override
public ClusterState execute(ClusterState currentState) {
  if (currentState.blocks().disableStatePersistence()) {
    return currentState;

@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);
}

@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);
}

@Override
public ClusterState execute(ClusterState currentState) {
  if (currentState.blocks().disableStatePersistence()) {
    return currentState;

@Override
public void clusterChanged(ClusterChangedEvent event) {
  if (!event.routingTableChanged()) {
    return;
  }
  if (event.state().blocks().disableStatePersistence()) {
    return;
  }
  for (IndexRoutingTable indexRoutingTable : event.state().routingTable()) {
    // Note, closed indices will not have any routing information, so won't be deleted
    for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
      if (shardCanBeDeleted(event.state(), indexShardRoutingTable)) {
        ShardId shardId = indexShardRoutingTable.shardId();
        if (indicesService.canDeleteShardContent(shardId, event.state().getMetaData().index(shardId.getIndex()))) {
          deleteShardIfExistElseWhere(event.state(), indexShardRoutingTable);
        }
      }
    }
  }
}

if (event.state().blocks().disableStatePersistence()) {
  for (IndexService indexService : indicesService) {
    String index = indexService.index().getName();