org.elasticsearch.index.shard

Class IndexShard

java.lang.Object

org.elasticsearch.index.shard.AbstractIndexShardComponent

org.elasticsearch.index.shard.IndexShard

All Implemented Interfaces:

IndexShardComponent, IndicesClusterStateService.Shard

Direct Known Subclasses:

ShadowIndexShard

public class IndexShard
extends AbstractIndexShardComponent
implements IndicesClusterStateService.Shard

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	IndexShard.ShardFailure Simple struct encapsulating a shard failure

Field Summary

Fields

Modifier and Type	Field and Description
protected java.util.concurrent.atomic.AtomicReference<Engine>	currentEngineReference
protected EngineFactory	engineFactory
protected long	primaryTerm
protected ShardRouting	shardRouting
protected IndexShardState	state
static java.util.EnumSet<IndexShardState>	writeAllowedStatesForPrimary

Fields inherited from class org.elasticsearch.index.shard.AbstractIndexShardComponent

deprecationLogger, indexSettings, logger, shardId

Constructor Summary

Constructors

Constructor and Description

IndexShard(ShardRouting shardRouting, IndexSettings indexSettings, ShardPath path, Store store, IndexCache indexCache, MapperService mapperService, SimilarityService similarityService, IndexFieldDataService indexFieldDataService, EngineFactory engineFactory, IndexEventListener indexEventListener, IndexSearcherWrapper indexSearcherWrapper, ThreadPool threadPool, BigArrays bigArrays, Engine.Warmer warmer, java.util.List<SearchOperationListener> searchOperationListener, java.util.List<IndexingOperationListener> listeners)

Method Summary

Modifier and Type	Method and Description
org.apache.lucene.index.IndexCommit	acquireIndexCommit(boolean flushFirst) Creates a new IndexCommit snapshot form the currently running engine.
void	acquirePrimaryOperationLock(ActionListener<Releasable> onLockAcquired, java.lang.String executorOnDelay) Acquire a primary operation lock whenever the shard is ready for indexing.
void	acquireReplicaOperationLock(long opPrimaryTerm, ActionListener<Releasable> onLockAcquired, java.lang.String executorOnDelay) Acquire a replica operation lock whenever the shard is ready for indexing (see acquirePrimaryOperationLock).
Engine.Searcher	acquireSearcher(java.lang.String source)
Translog.View	acquireTranslogView()
void	activateThrottling()
void	addRefreshListener(Translog.Location location, java.util.function.Consumer<java.lang.Boolean> listener) Add a listener for refreshes.
void	addShardFailureCallback(java.util.function.Consumer<IndexShard.ShardFailure> onShardFailure)
protected RefreshListeners	buildRefreshListeners() Build RefreshListeners for this shard.
boolean	canIndex() returns true if this shard supports indexing (i.e., write) operations.
void	checkIdle(long inactiveTimeNS) Called by IndexingMemoryController to check whether more than inactiveTimeNS has passed since the last indexing operation, and notify listeners that we are now inactive so e.g.
void	close(java.lang.String reason, boolean flushEngine)
CommitStats	commitStats()
CompletionStats	completionStats(java.lang.String... fields)
void	deactivateThrottling()
Engine.DeleteResult	delete(Engine.Delete delete)
DocsStats	docStats()
void	failShard(java.lang.String reason, java.lang.Exception e) Fails the shard and marks the shard store as corrupted if e is caused by index corruption
ShardFieldData	fieldData()
FieldDataStats	fieldDataStats(java.lang.String... fields)
void	finalizeRecovery() perform the last stages of recovery once all translog operations are done.
Engine.CommitId	flush(FlushRequest request)
void	flushAndCloseEngine()
FlushStats	flushStats()
void	forceMerge(ForceMergeRequest forceMerge)
Engine.GetResult	get(Engine.Get get)
int	getActiveOperationsCount()
protected Engine	getEngineOrNull() NOTE: returns null if engine is not yet started (e.g.
long	getIndexBufferRAMBytesUsed() Returns number of heap bytes used by the indexing buffer for this shard, or 0 if the shard is closed
IndexEventListener	getIndexEventListener()
long	getPrimaryTerm() Returns the primary term the index shard is on.
org.apache.lucene.search.QueryCachingPolicy	getQueryCachingPolicy()
SearchOperationListener	getSearchOperationListener()
ShardGetService	getService()
GetStats	getStats()
Translog	getTranslog()
Translog.Durability	getTranslogDurability() Returns the current translog durability mode
long	getWritingBytes() Returns how many bytes we are currently moving from heap to disk
boolean	ignoreRecoveryAttempt() Returns true if this shard can ignore a recovery attempt made to it (since the already doing/done it)
Engine.IndexResult	index(Engine.Index index)
IndexFieldDataService	indexFieldDataService()
IndexingStats	indexingStats(java.lang.String... types)
boolean	isActive()
boolean	isRefreshNeeded() Returns true iff one or more changes to the engine are not visible to via the current searcher *or* there are pending refresh listeners.
MapperService	mapperService()
IndexShardState	markAsRecovering(java.lang.String reason, RecoveryState recoveryState) Marks the shard as recovering based on a recovery state, fails with exception is recovering is not allowed to be set.
boolean	maybeFlush() Schedules a flush if needed but won't schedule more than one flush concurrently.
MergeStats	mergeStats()
org.apache.lucene.util.Version	minimumCompatibleVersion()
protected Engine	newEngine(EngineConfig config)
void	noopUpdate(java.lang.String type) Should be called for each no-op update operation to increment relevant statistics.
protected void	onNewEngine(Engine newEngine)
void	onSettingsChanged()
int	performBatchRecovery(java.lang.Iterable<Translog.Operation> operations) Applies all operations in the iterable to the current engine and returns the number of operations applied.
void	performRecoveryRestart() called if recovery has to be restarted after network error / delay **
void	performTranslogRecovery(boolean indexExists) After the store has been recovered, we need to start the engine in order to apply operations
IndexShard	postRecovery(java.lang.String reason)
Engine.Delete	prepareDeleteOnPrimary(java.lang.String type, java.lang.String id, long version, VersionType versionType)
Engine.Delete	prepareDeleteOnReplica(java.lang.String type, java.lang.String id, long version, VersionType versionType)
void	prepareForIndexRecovery() called before starting to copy index files over
Engine.Index	prepareIndexOnPrimary(SourceToParse source, long version, VersionType versionType, long autoGeneratedIdTimestamp, boolean isRetry)
Engine.Index	prepareIndexOnReplica(SourceToParse source, long version, VersionType versionType, long autoGeneratedIdTimestamp, boolean isRetry)
void	readAllowed()
boolean	recoverFromLocalShards(java.util.function.BiConsumer<java.lang.String,MappingMetaData> mappingUpdateConsumer, java.util.List<IndexShard> localShards)
boolean	recoverFromStore()
RecoveryState	recoveryState() Returns the current RecoveryState if this shard is recovering or has been recovering.
RecoveryStats	recoveryStats() returns stats about ongoing recoveries, both source and target
void	refresh(java.lang.String source) Writes all indexing changes to disk and opens a new searcher reflecting all changes.
RefreshStats	refreshStats()
void	releaseIndexCommit(org.apache.lucene.index.IndexCommit snapshot) Releases a snapshot taken from acquireIndexCommit(boolean) this must be called to release the resources referenced by the given snapshot IndexCommit.
void	relocated(java.lang.String reason)
ShardRequestCache	requestCache()
boolean	restoreFromRepository(Repository repository)
ShardRouting	routingEntry() Returns the latest cluster routing entry received with this shard.
SearchStats	searchStats(java.lang.String... groups)
java.util.List<Segment>	segments(boolean verbose)
SegmentsStats	segmentStats(boolean includeSegmentFileSizes)
ShardBitsetFilterCache	shardBitsetFilterCache()
ShardPath	shardPath()
void	skipTranslogRecovery(long maxUnsafeAutoIdTimestamp) After the store has been recovered, we need to start the engine.
Store.MetadataSnapshot	snapshotStoreMetadata() gets a Store.MetadataSnapshot for the current directory.
void	startRecovery(RecoveryState recoveryState, PeerRecoveryTargetService recoveryTargetService, PeerRecoveryTargetService.RecoveryListener recoveryListener, RepositoriesService repositoriesService, java.util.function.BiConsumer<java.lang.String,MappingMetaData> mappingUpdateConsumer, IndicesService indicesService)
IndexShardState	state() Returns the latest internal shard state.
Store	store()
StoreStats	storeStats()
void	sync(Translog.Location location, java.util.function.Consumer<java.lang.Exception> syncListener) Syncs the given location with the underlying storage unless already synced.
Engine.SyncedFlushResult	syncFlush(java.lang.String syncId, Engine.CommitId expectedCommitId)
TranslogStats	translogStats()
void	updatePrimaryTerm(long newTerm) notifies the shard of an increase in the primary term
void	updateRoutingEntry(ShardRouting newRouting) Updates the shards routing entry.
org.apache.lucene.util.Version	upgrade(UpgradeRequest upgrade) Upgrades the shard to the current version of Lucene and returns the minimum segment version
protected void	verifyActive()
ShardIndexWarmerService	warmerService()
WarmerStats	warmerStats()
void	writeIndexingBuffer() Called when our shard is using too much heap and should move buffered indexed/deleted documents to disk.

Methods inherited from class org.elasticsearch.index.shard.AbstractIndexShardComponent

indexSettings, nodeName, shardId

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.elasticsearch.indices.cluster.IndicesClusterStateService.Shard

shardId

Field Detail

shardRouting

protected volatile ShardRouting shardRouting

state

protected volatile IndexShardState state

primaryTerm

protected volatile long primaryTerm

currentEngineReference

protected final java.util.concurrent.atomic.AtomicReference<Engine> currentEngineReference

engineFactory

protected final EngineFactory engineFactory

writeAllowedStatesForPrimary

public static final java.util.EnumSet<IndexShardState> writeAllowedStatesForPrimary

Constructor Detail

IndexShard

public IndexShard(ShardRouting shardRouting,
                  IndexSettings indexSettings,
                  ShardPath path,
                  Store store,
                  IndexCache indexCache,
                  MapperService mapperService,
                  SimilarityService similarityService,
                  IndexFieldDataService indexFieldDataService,
                  @Nullable
                  EngineFactory engineFactory,
                  IndexEventListener indexEventListener,
                  IndexSearcherWrapper indexSearcherWrapper,
                  ThreadPool threadPool,
                  BigArrays bigArrays,
                  Engine.Warmer warmer,
                  java.util.List<SearchOperationListener> searchOperationListener,
                  java.util.List<IndexingOperationListener> listeners)
           throws java.io.IOException

Throws:

java.io.IOException

Method Detail

store

public Store store()

canIndex

public boolean canIndex()

returns true if this shard supports indexing (i.e., write) operations.

getService

public ShardGetService getService()

shardBitsetFilterCache

public ShardBitsetFilterCache shardBitsetFilterCache()

indexFieldDataService

public IndexFieldDataService indexFieldDataService()

mapperService

public MapperService mapperService()

getSearchOperationListener

public SearchOperationListener getSearchOperationListener()

warmerService

public ShardIndexWarmerService warmerService()

requestCache

public ShardRequestCache requestCache()

fieldData

public ShardFieldData fieldData()

getPrimaryTerm

public long getPrimaryTerm()

Returns the primary term the index shard is on. See IndexMetaData.primaryTerm(int)

updatePrimaryTerm

public void updatePrimaryTerm(long newTerm)

notifies the shard of an increase in the primary term

routingEntry

public ShardRouting routingEntry()

Returns the latest cluster routing entry received with this shard.

Specified by:

routingEntry in interface IndicesClusterStateService.Shard

getQueryCachingPolicy

public org.apache.lucene.search.QueryCachingPolicy getQueryCachingPolicy()

updateRoutingEntry

public void updateRoutingEntry(ShardRouting newRouting)
                        throws java.io.IOException

Updates the shards routing entry. This mutate the shards internal state depending on the changes that get introduced by the new routing value. This method will persist shard level metadata.

Specified by:

updateRoutingEntry in interface IndicesClusterStateService.Shard

Throws:

IndexShardRelocatedException - if shard is marked as relocated and relocation aborted

java.io.IOException - if shard state could not be persisted

markAsRecovering

public IndexShardState markAsRecovering(java.lang.String reason,
                                        RecoveryState recoveryState)
                                 throws IndexShardStartedException,
                                        IndexShardRelocatedException,
                                        IndexShardRecoveringException,
                                        IndexShardClosedException

Marks the shard as recovering based on a recovery state, fails with exception is recovering is not allowed to be set.

Throws:

IndexShardStartedException

IndexShardRelocatedException

IndexShardRecoveringException

IndexShardClosedException

relocated

public void relocated(java.lang.String reason)
               throws IllegalIndexShardStateException,
                      java.lang.InterruptedException

Throws:

IllegalIndexShardStateException

java.lang.InterruptedException

state

public IndexShardState state()

Description copied from interface: IndicesClusterStateService.Shard

Returns the latest internal shard state.

Specified by:

state in interface IndicesClusterStateService.Shard

prepareIndexOnPrimary

public Engine.Index prepareIndexOnPrimary(SourceToParse source,
                                          long version,
                                          VersionType versionType,
                                          long autoGeneratedIdTimestamp,
                                          boolean isRetry)

prepareIndexOnReplica

public Engine.Index prepareIndexOnReplica(SourceToParse source,
                                          long version,
                                          VersionType versionType,
                                          long autoGeneratedIdTimestamp,
                                          boolean isRetry)

index

public Engine.IndexResult index(Engine.Index index)
                         throws java.io.IOException

Throws:

java.io.IOException

prepareDeleteOnPrimary

public Engine.Delete prepareDeleteOnPrimary(java.lang.String type,
                                            java.lang.String id,
                                            long version,
                                            VersionType versionType)

prepareDeleteOnReplica

public Engine.Delete prepareDeleteOnReplica(java.lang.String type,
                                            java.lang.String id,
                                            long version,
                                            VersionType versionType)

delete

public Engine.DeleteResult delete(Engine.Delete delete)
                           throws java.io.IOException

Throws:

java.io.IOException

get

public Engine.GetResult get(Engine.Get get)

refresh

public void refresh(java.lang.String source)

Writes all indexing changes to disk and opens a new searcher reflecting all changes. This can throw AlreadyClosedException.

getWritingBytes

public long getWritingBytes()

Returns how many bytes we are currently moving from heap to disk

refreshStats

public RefreshStats refreshStats()

flushStats

public FlushStats flushStats()

docStats

public DocsStats docStats()

commitStats

@Nullable
public CommitStats commitStats()

Returns:

CommitStats if engine is open, otherwise null

indexingStats

public IndexingStats indexingStats(java.lang.String... types)

searchStats

public SearchStats searchStats(java.lang.String... groups)

getStats

public GetStats getStats()

storeStats

public StoreStats storeStats()

mergeStats

public MergeStats mergeStats()

segmentStats

public SegmentsStats segmentStats(boolean includeSegmentFileSizes)

warmerStats

public WarmerStats warmerStats()

fieldDataStats

public FieldDataStats fieldDataStats(java.lang.String... fields)

translogStats

public TranslogStats translogStats()

completionStats

public CompletionStats completionStats(java.lang.String... fields)

syncFlush

public Engine.SyncedFlushResult syncFlush(java.lang.String syncId,
                                          Engine.CommitId expectedCommitId)

flush

public Engine.CommitId flush(FlushRequest request)
                      throws ElasticsearchException

Throws:

ElasticsearchException

forceMerge

public void forceMerge(ForceMergeRequest forceMerge)
                throws java.io.IOException

Throws:

java.io.IOException

upgrade

public org.apache.lucene.util.Version upgrade(UpgradeRequest upgrade)
                                       throws java.io.IOException

Upgrades the shard to the current version of Lucene and returns the minimum segment version

Throws:

java.io.IOException

minimumCompatibleVersion

public org.apache.lucene.util.Version minimumCompatibleVersion()

acquireIndexCommit

public org.apache.lucene.index.IndexCommit acquireIndexCommit(boolean flushFirst)
                                                       throws EngineException

Creates a new IndexCommit snapshot form the currently running engine. All resources referenced by this commit won't be freed until the commit / snapshot is released via releaseIndexCommit(IndexCommit).

Parameters:

flushFirst - true if the index should first be flushed to disk / a low level lucene commit should be executed

Throws:

EngineException

releaseIndexCommit

public void releaseIndexCommit(org.apache.lucene.index.IndexCommit snapshot)
                        throws java.io.IOException

Releases a snapshot taken from acquireIndexCommit(boolean) this must be called to release the resources referenced by the given snapshot IndexCommit.

Throws:

java.io.IOException

snapshotStoreMetadata

public Store.MetadataSnapshot snapshotStoreMetadata()
                                             throws java.io.IOException

gets a Store.MetadataSnapshot for the current directory. This method is safe to call in all lifecycle of the index shard, without having to worry about the current state of the engine and concurrent flushes.

Throws:

org.apache.lucene.index.IndexNotFoundException - if no index is found in the current directory

org.apache.lucene.index.CorruptIndexException - if the lucene index is corrupted. This can be caused by a checksum mismatch or an unexpected exception when opening the index reading the segments file.

org.apache.lucene.index.IndexFormatTooOldException - if the lucene index is too old to be opened.

org.apache.lucene.index.IndexFormatTooNewException - if the lucene index is too new to be opened.

java.io.FileNotFoundException - if one or more files referenced by a commit are not present.

java.nio.file.NoSuchFileException - if one or more files referenced by a commit are not present.

java.io.IOException

failShard

public void failShard(java.lang.String reason,
                      @Nullable
                      java.lang.Exception e)

Fails the shard and marks the shard store as corrupted if e is caused by index corruption

acquireSearcher

public Engine.Searcher acquireSearcher(java.lang.String source)

close

public void close(java.lang.String reason,
                  boolean flushEngine)
           throws java.io.IOException

Throws:

java.io.IOException

postRecovery

public IndexShard postRecovery(java.lang.String reason)
                        throws IndexShardStartedException,
                               IndexShardRelocatedException,
                               IndexShardClosedException

Throws:

IndexShardStartedException

IndexShardRelocatedException

IndexShardClosedException

prepareForIndexRecovery

public void prepareForIndexRecovery()

called before starting to copy index files over

performBatchRecovery

public int performBatchRecovery(java.lang.Iterable<Translog.Operation> operations)

Applies all operations in the iterable to the current engine and returns the number of operations applied. This operation will stop applying operations once an operation failed to apply. Note: This method is typically used in peer recovery to replay remote transaction log entries.

performTranslogRecovery

public void performTranslogRecovery(boolean indexExists)
                             throws java.io.IOException

After the store has been recovered, we need to start the engine in order to apply operations

Throws:

java.io.IOException

onNewEngine

protected void onNewEngine(Engine newEngine)

skipTranslogRecovery

public void skipTranslogRecovery(long maxUnsafeAutoIdTimestamp)
                          throws java.io.IOException

After the store has been recovered, we need to start the engine. This method starts a new engine but skips the replay of the transaction log which is required in cases where we restore a previous index or recover from a remote peer.

Throws:

java.io.IOException

performRecoveryRestart

public void performRecoveryRestart()
                            throws java.io.IOException

called if recovery has to be restarted after network error / delay **

Throws:

java.io.IOException

recoveryStats

public RecoveryStats recoveryStats()

returns stats about ongoing recoveries, both source and target

recoveryState

public RecoveryState recoveryState()

Returns the current RecoveryState if this shard is recovering or has been recovering. Returns null if the recovery has not yet started or shard was not recovered (created via an API).

Specified by:

recoveryState in interface IndicesClusterStateService.Shard

finalizeRecovery

public void finalizeRecovery()

perform the last stages of recovery once all translog operations are done. note that you should still call postRecovery(String).

ignoreRecoveryAttempt

public boolean ignoreRecoveryAttempt()

Returns true if this shard can ignore a recovery attempt made to it (since the already doing/done it)

readAllowed

public void readAllowed()
                 throws IllegalIndexShardStateException

Throws:

IllegalIndexShardStateException

verifyActive

protected final void verifyActive()
                           throws IllegalIndexShardStateException

Throws:

IllegalIndexShardStateException

getIndexBufferRAMBytesUsed

public long getIndexBufferRAMBytesUsed()

Returns number of heap bytes used by the indexing buffer for this shard, or 0 if the shard is closed

addShardFailureCallback

public void addShardFailureCallback(java.util.function.Consumer<IndexShard.ShardFailure> onShardFailure)

checkIdle

public void checkIdle(long inactiveTimeNS)

Called by IndexingMemoryController to check whether more than inactiveTimeNS has passed since the last indexing operation, and notify listeners that we are now inactive so e.g. sync'd flush can happen.

isActive

public boolean isActive()

shardPath

public ShardPath shardPath()

recoverFromLocalShards

public boolean recoverFromLocalShards(java.util.function.BiConsumer<java.lang.String,MappingMetaData> mappingUpdateConsumer,
                                      java.util.List<IndexShard> localShards)
                               throws java.io.IOException

Throws:

java.io.IOException

recoverFromStore

public boolean recoverFromStore()

restoreFromRepository

public boolean restoreFromRepository(Repository repository)

onSettingsChanged

public void onSettingsChanged()

acquireTranslogView

public Translog.View acquireTranslogView()

segments

public java.util.List<Segment> segments(boolean verbose)

flushAndCloseEngine

public void flushAndCloseEngine()
                         throws java.io.IOException

Throws:

java.io.IOException

getTranslog

public Translog getTranslog()

getIndexEventListener

public IndexEventListener getIndexEventListener()

activateThrottling

public void activateThrottling()

deactivateThrottling

public void deactivateThrottling()

writeIndexingBuffer

public void writeIndexingBuffer()

Called when our shard is using too much heap and should move buffered indexed/deleted documents to disk.

noopUpdate

public void noopUpdate(java.lang.String type)

Should be called for each no-op update operation to increment relevant statistics.

Parameters:

type - the doc type of the update

getEngineOrNull

protected Engine getEngineOrNull()

NOTE: returns null if engine is not yet started (e.g. recovery phase 1, copying over index files, is still running), or if engine is closed.

startRecovery

public void startRecovery(RecoveryState recoveryState,
                          PeerRecoveryTargetService recoveryTargetService,
                          PeerRecoveryTargetService.RecoveryListener recoveryListener,
                          RepositoriesService repositoriesService,
                          java.util.function.BiConsumer<java.lang.String,MappingMetaData> mappingUpdateConsumer,
                          IndicesService indicesService)

newEngine

protected Engine newEngine(EngineConfig config)

acquirePrimaryOperationLock

public void acquirePrimaryOperationLock(ActionListener<Releasable> onLockAcquired,
                                        java.lang.String executorOnDelay)

Acquire a primary operation lock whenever the shard is ready for indexing. If the lock is directly available, the provided ActionListener will be called on the calling thread. During relocation hand-off, lock acquisition can be delayed. The provided ActionListener will then be called using the provided executor.

acquireReplicaOperationLock

public void acquireReplicaOperationLock(long opPrimaryTerm,
                                        ActionListener<Releasable> onLockAcquired,
                                        java.lang.String executorOnDelay)

Acquire a replica operation lock whenever the shard is ready for indexing (see acquirePrimaryOperationLock). If the given primary term is lower then the one in shardRouting an IllegalArgumentException is thrown.

getActiveOperationsCount

public int getActiveOperationsCount()

sync

public final void sync(Translog.Location location,
                       java.util.function.Consumer<java.lang.Exception> syncListener)

Syncs the given location with the underlying storage unless already synced. This method might return immediately without actually fsyncing the location until the sync listener is called. Yet, unless there is already another thread fsyncing the transaction log the caller thread will be hijacked to run the fsync for all pending fsync operations. This method allows indexing threads to continue indexing without blocking on fsync calls. We ensure that there is only one thread blocking on the sync an all others can continue indexing. NOTE: if the syncListener throws an exception when it's processed the exception will only be logged. Users should make sure that the listener handles all exception cases internally.

getTranslogDurability

public Translog.Durability getTranslogDurability()

Returns the current translog durability mode

maybeFlush

public boolean maybeFlush()

Schedules a flush if needed but won't schedule more than one flush concurrently. The flush will be executed on the Flush thread-pool asynchronously.

Returns:

true if a new flush is scheduled otherwise false.

buildRefreshListeners

protected RefreshListeners buildRefreshListeners()

Build RefreshListeners for this shard. Protected so ShadowIndexShard can override it to return null.

isRefreshNeeded

public boolean isRefreshNeeded()

Returns true iff one or more changes to the engine are not visible to via the current searcher *or* there are pending refresh listeners. Otherwise false.

Throws:

org.apache.lucene.store.AlreadyClosedException - if the engine or internal indexwriter in the engine is already closed

addRefreshListener

public void addRefreshListener(Translog.Location location,
                               java.util.function.Consumer<java.lang.Boolean> listener)

Add a listener for refreshes.

Parameters:

location - the location to listen for

listener - for the refresh. Called with true if registering the listener ran it out of slots and forced a refresh. Called with false otherwise.