Engine (server 6.3.2 API)

java.lang.Object
- org.elasticsearch.index.engine.Engine

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable

Direct Known Subclasses:

InternalEngine
```
public abstract class Engine
extends java.lang.Object
implements java.io.Closeable
```

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`Engine.CommitId`
`static class`	`Engine.Delete`
`static class`	`Engine.DeleteResult`
`static interface`	`Engine.EventListener`
`static class`	`Engine.Get`
`static class`	`Engine.GetResult`
`static class`	`Engine.Index`
`static class`	`Engine.IndexCommitRef`
`static class`	`Engine.IndexResult`
`protected static class`	`Engine.IndexThrottle`	A throttling class that can be activated, causing the `acquireThrottle` method to block on a lock when throttling is enabled
`static class`	`Engine.NoOp`
`protected static class`	`Engine.NoOpLock`	A Lock implementation that always allows the lock to be acquired
`static class`	`Engine.NoOpResult`
`static class`	`Engine.Operation`
`static class`	`Engine.Result`	Base class for index and delete operation results Holds result meta data (e.g.
`static class`	`Engine.Searcher`
`static class`	`Engine.SearcherScope`
`static class`	`Engine.SyncedFlushResult`
`static interface`	`Engine.Warmer`	Called for each new opened engine searcher to warm new segments

Field Summary

Fields
Modifier and Type	Field	Description
`protected java.lang.String`	`allocationId`
`protected EngineConfig`	`engineConfig`
`protected Engine.EventListener`	`eventListener`
`protected org.apache.lucene.util.SetOnce<java.lang.Exception>`	`failedEngine`
`protected java.util.concurrent.locks.ReentrantLock`	`failEngineLock`
`static java.lang.String`	`HISTORY_UUID_KEY`
`protected java.util.concurrent.atomic.AtomicBoolean`	`isClosed`
`protected long`	`lastWriteNanos`
`protected org.apache.logging.log4j.Logger`	`logger`
`protected ReleasableLock`	`readLock`
`protected java.util.concurrent.locks.ReentrantReadWriteLock`	`rwl`
`protected ShardId`	`shardId`
`protected Store`	`store`
`static java.lang.String`	`SYNC_COMMIT_ID`
`protected ReleasableLock`	`writeLock`

Constructor Summary

Constructors
Modifier Constructor Description

protected Engine(EngineConfig engineConfig)

Constructors
Modifier	Constructor	Description
`protected`	`Engine(EngineConfig engineConfig)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`abstract Engine.IndexCommitRef`	`acquireLastIndexCommit(boolean flushFirst)`	Snapshots the most recent index and returns a handle to it.
`abstract Engine.IndexCommitRef`	`acquireSafeIndexCommit()`	Snapshots the most recent safe index commit from the engine.
`Engine.Searcher`	`acquireSearcher(java.lang.String source)`	Returns a new searcher instance.
`abstract Engine.Searcher`	`acquireSearcher(java.lang.String source, Engine.SearcherScope scope)`	Returns a new searcher instance.
`java.io.Closeable`	`acquireTranslogRetentionLock()`
`abstract void`	`activateThrottling()`	Request that this engine throttle incoming indexing requests to one thread.
`void`	`close()`
`protected abstract void`	`closeNoLock(java.lang.String reason, java.util.concurrent.CountDownLatch closedLatch)`	Method to close the engine while the write lock is held.
`CommitStats`	`commitStats()`	get commits stats for the last commit
`EngineConfig`	`config()`
`abstract void`	`deactivateThrottling()`	Reverses a previous `activateThrottling()` call.
`abstract Engine.DeleteResult`	`delete(Engine.Delete delete)`	Perform document delete operation on the engine
`protected void`	`ensureOpen()`
`protected void`	`ensureOpen(java.lang.Exception suppressed)`
`abstract boolean`	`ensureTranslogSynced(java.util.stream.Stream<Translog.Location> locations)`	Ensures that all locations in the given stream have been written to the underlying storage.
`int`	`estimateTranslogOperationsFromMinSeq(long minSeqNo)`	Returns the estimated number of translog operations in this engine whose seq# at least the provided seq#.
`void`	`failEngine(java.lang.String reason, java.lang.Exception failure)`	fail engine due to some error.
`abstract int`	`fillSeqNoGaps(long primaryTerm)`	Fills up the local checkpoints history with no-ops until the local checkpoint and the max seen sequence ID are identical.
`abstract Engine.CommitId`	`flush()`	Flushes the state of the engine including the transaction log, clearing memory and persisting documents in the lucene index to disk including a potentially heavy and durable fsync operation.
`abstract Engine.CommitId`	`flush(boolean force, boolean waitIfOngoing)`	Flushes the state of the engine including the transaction log, clearing memory.
`void`	`flushAndClose()`	Flush the engine (committing segments to disk and truncating the translog) and close it.
`void`	`forceMerge(boolean flush)`	Force merges to 1 segment
`abstract void`	`forceMerge(boolean flush, int maxNumSegments, boolean onlyExpungeDeletes, boolean upgrade, boolean upgradeOnlyAncientSegments)`	Triggers a forced merge on this engine
`abstract Engine.GetResult`	`get(Engine.Get get, java.util.function.BiFunction<java.lang.String,Engine.SearcherScope,Engine.Searcher> searcherFactory)`
`protected Engine.GetResult`	`getFromSearcher(Engine.Get get, java.util.function.BiFunction<java.lang.String,Engine.SearcherScope,Engine.Searcher> searcherFactory, Engine.SearcherScope scope)`
`abstract java.lang.String`	`getHistoryUUID()`	returns the history uuid for the engine
`abstract long`	`getIndexBufferRAMBytesUsed()`	How much heap is used that would be freed by a refresh.
`abstract long`	`getIndexThrottleTimeInMillis()`	Returns the number of milliseconds this engine was under index throttling.
`protected abstract org.apache.lucene.index.SegmentInfos`	`getLastCommittedSegmentInfos()`
`long`	`getLastSyncedGlobalCheckpoint()`	Returns the latest global checkpoint value that has been persisted in the underlying storage (i.e.
`long`	`getLastWriteNanos()`	Returns the timestamp of the last write in nanoseconds.
`abstract LocalCheckpointTracker`	`getLocalCheckpointTracker()`	The sequence number service for this engine.
`MergeStats`	`getMergeStats()`
`protected Segment[]`	`getSegmentInfo(org.apache.lucene.index.SegmentInfos lastCommittedSegmentInfos, boolean verbose)`
`Translog.Location`	`getTranslogLastWriteLocation()`	Returns the last location that the translog of this engine has written into.
`TranslogStats`	`getTranslogStats()`
`abstract long`	`getWritingBytes()`	Returns how many bytes we are currently moving from heap to disk
`protected static long`	`guardedRamBytesUsed(org.apache.lucene.util.Accountable a)`	Returns 0 in the case where accountable is null, otherwise returns `ramBytesUsed()`
`abstract Engine.IndexResult`	`index(Engine.Index index)`	Perform document index operation on the engine
`protected static boolean`	`isMergedSegment(org.apache.lucene.index.LeafReader reader)`	Returns whether a leaf reader comes from a merge (versus flush or addIndexes).
`boolean`	`isRecovering()`	Returns `true` iff this engine is currently recovering from translog.
`abstract boolean`	`isThrottled()`	Returns the `true` iff this engine is currently under index throttling.
`boolean`	`isTranslogSyncNeeded()`	Checks if the underlying storage sync is required.
`protected boolean`	`maybeFailEngine(java.lang.String source, java.lang.Exception e)`	Check whether the engine should be failed
`abstract void`	`maybePruneDeletes()`	Tries to prune buffered deletes from the version map.
`Translog.Snapshot`	`newTranslogSnapshotFromMinSeqNo(long minSeqNo)`	Creates a new translog snapshot from this engine for reading translog operations whose seq# at least the provided seq#.
`abstract Engine.NoOpResult`	`noOp(Engine.NoOp noOp)`
`void`	`onSettingsChanged()`
`abstract Engine`	`recoverFromTranslog()`	Performs recovery from the transaction log.
`abstract void`	`refresh(java.lang.String source)`	Synchronously refreshes the engine for new search operations to reflect the latest changes.
`boolean`	`refreshNeeded()`
`abstract void`	`restoreLocalCheckpointFromTranslog()`	Marks operations in the translog as completed.
`abstract void`	`rollTranslogGeneration()`	Rolls the translog generation and cleans unneeded.
`abstract java.util.List<Segment>`	`segments(boolean verbose)`	The list of segments in the engine.
`SegmentsStats`	`segmentsStats(boolean includeSegmentFileSizes)`	Global stats on segments.
`abstract boolean`	`shouldPeriodicallyFlush()`	Checks if this engine should be flushed periodically.
`boolean`	`shouldRollTranslogGeneration()`	Tests whether or not the translog generation should be rolled to a new generation.
`abstract void`	`skipTranslogRecovery()`	Do not replay translog operations, but make the engine be ready.
`abstract Engine.SyncedFlushResult`	`syncFlush(java.lang.String syncId, Engine.CommitId expectedCommitId)`	Attempts to do a special commit where the given syncID is put into the commit data.
`abstract void`	`syncTranslog()`
`abstract void`	`trimTranslog()`	checks and removes translog files that no longer need to be retained.
`abstract void`	`writeIndexingBuffer()`	Called when our engine is using too much heap and should move buffered indexed/deleted documents to disk.
`protected void`	`writerSegmentStats(SegmentsStats stats)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - SYNC_COMMIT_ID
```
public static final java.lang.String SYNC_COMMIT_ID
```
    See Also:
    
    Constant Field Values
  - HISTORY_UUID_KEY
```
public static final java.lang.String HISTORY_UUID_KEY
```
    See Also:
    
    Constant Field Values
  - shardId
```
protected final ShardId shardId
```
  - allocationId
```
protected final java.lang.String allocationId
```
  - logger
```
protected final org.apache.logging.log4j.Logger logger
```
  - engineConfig
```
protected final EngineConfig engineConfig
```
  - store
```
protected final Store store
```
  - isClosed
```
protected final java.util.concurrent.atomic.AtomicBoolean isClosed
```
  - eventListener
```
protected final Engine.EventListener eventListener
```
  - failEngineLock
```
protected final java.util.concurrent.locks.ReentrantLock failEngineLock
```
  - rwl
```
protected final java.util.concurrent.locks.ReentrantReadWriteLock rwl
```
  - readLock
```
protected final ReleasableLock readLock
```
  - writeLock
```
protected final ReleasableLock writeLock
```
  - failedEngine
```
protected final org.apache.lucene.util.SetOnce<java.lang.Exception> failedEngine
```
  - lastWriteNanos
```
protected volatile long lastWriteNanos
```
- Constructor Detail
  - Engine
```
protected Engine(EngineConfig engineConfig)
```
- Method Detail
  - guardedRamBytesUsed
```
protected static long guardedRamBytesUsed(org.apache.lucene.util.Accountable a)
```
    Returns 0 in the case where accountable is null, otherwise returns ramBytesUsed()
  - isMergedSegment
```
protected static boolean isMergedSegment(org.apache.lucene.index.LeafReader reader)
```
    Returns whether a leaf reader comes from a merge (versus flush or addIndexes).
  - config
```
public final EngineConfig config()
```
  - getLastCommittedSegmentInfos
```
protected abstract org.apache.lucene.index.SegmentInfos getLastCommittedSegmentInfos()
```
  - getMergeStats
```
public MergeStats getMergeStats()
```
  - getHistoryUUID
```
public abstract java.lang.String getHistoryUUID()
```
    returns the history uuid for the engine
  - getWritingBytes
```
public abstract long getWritingBytes()
```
    Returns how many bytes we are currently moving from heap to disk
  - getIndexThrottleTimeInMillis
```
public abstract long getIndexThrottleTimeInMillis()
```
    Returns the number of milliseconds this engine was under index throttling.
  - isThrottled
```
public abstract boolean isThrottled()
```
    Returns the true iff this engine is currently under index throttling.
    
    See Also:
    
    getIndexThrottleTimeInMillis()
  - index
```
public abstract Engine.IndexResult index(Engine.Index index)
                                  throws java.io.IOException
```
    Perform document index operation on the engine
    
    Parameters:
    
    index - operation to perform
    
    Returns:
    
    Engine.IndexResult containing updated translog location, version and document specific failures Note: engine level failures (i.e. persistent engine failures) are thrown
    
    Throws:
    
    java.io.IOException
  - delete
```
public abstract Engine.DeleteResult delete(Engine.Delete delete)
                                    throws java.io.IOException
```
    Perform document delete operation on the engine
    
    Parameters:
    
    delete - operation to perform
    
    Returns:
    
    Engine.DeleteResult containing updated translog location, version and document specific failures Note: engine level failures (i.e. persistent engine failures) are thrown
    
    Throws:
    
    java.io.IOException
  - noOp
```
public abstract Engine.NoOpResult noOp(Engine.NoOp noOp)
```
  - syncFlush
```
public abstract Engine.SyncedFlushResult syncFlush(java.lang.String syncId,
                                                   Engine.CommitId expectedCommitId)
                                            throws EngineException
```
    Attempts to do a special commit where the given syncID is put into the commit data. The attempt succeeds if there are not pending writes in lucene and the current point is equal to the expected one.
    
    Parameters:
    
    syncId - id of this sync
    
    expectedCommitId - the expected value of
    
    Returns:
    
    true if the sync commit was made, false o.w.
    
    Throws:
    
    EngineException
  - getFromSearcher
```
protected final Engine.GetResult getFromSearcher(Engine.Get get,
                                                 java.util.function.BiFunction<java.lang.String,Engine.SearcherScope,Engine.Searcher> searcherFactory,
                                                 Engine.SearcherScope scope)
                                          throws EngineException
```
    Throws:
    
    EngineException
  - get
```
public abstract Engine.GetResult get(Engine.Get get,
                                     java.util.function.BiFunction<java.lang.String,Engine.SearcherScope,Engine.Searcher> searcherFactory)
                              throws EngineException
```
    Throws:
    
    EngineException
  - acquireSearcher
```
public final Engine.Searcher acquireSearcher(java.lang.String source)
                                      throws EngineException
```
    Returns a new searcher instance. The consumer of this API is responsible for releasing the returned searcher in a safe manner, preferably in a try/finally block.
    
    Parameters:
    
    source - the source API or routing that triggers this searcher acquire
    
    Throws:
    
    EngineException
    
    See Also:
    
    Engine.Searcher.close()
  - acquireSearcher
```
public abstract Engine.Searcher acquireSearcher(java.lang.String source,
                                                Engine.SearcherScope scope)
                                         throws EngineException
```
    Returns a new searcher instance. The consumer of this API is responsible for releasing the returned searcher in a safe manner, preferably in a try/finally block.
    
    Parameters:
    
    source - the source API or routing that triggers this searcher acquire
    
    scope - the scope of this searcher ie. if the searcher will be used for get or search purposes
    
    Throws:
    
    EngineException
    
    See Also:
    
    Engine.Searcher.close()
  - isTranslogSyncNeeded
```
public boolean isTranslogSyncNeeded()
```
    Checks if the underlying storage sync is required.
  - ensureTranslogSynced
```
public abstract boolean ensureTranslogSynced(java.util.stream.Stream<Translog.Location> locations)
                                      throws java.io.IOException
```
    Ensures that all locations in the given stream have been written to the underlying storage.
    
    Throws:
    
    java.io.IOException
  - syncTranslog
```
public abstract void syncTranslog()
                           throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - acquireTranslogRetentionLock
```
public java.io.Closeable acquireTranslogRetentionLock()
```
  - newTranslogSnapshotFromMinSeqNo
```
public Translog.Snapshot newTranslogSnapshotFromMinSeqNo(long minSeqNo)
                                                  throws java.io.IOException
```
    Creates a new translog snapshot from this engine for reading translog operations whose seq# at least the provided seq#. The caller has to close the returned snapshot after finishing the reading.
    
    Throws:
    
    java.io.IOException
  - estimateTranslogOperationsFromMinSeq
```
public int estimateTranslogOperationsFromMinSeq(long minSeqNo)
```
    Returns the estimated number of translog operations in this engine whose seq# at least the provided seq#.
  - getTranslogStats
```
public TranslogStats getTranslogStats()
```
  - getTranslogLastWriteLocation
```
public Translog.Location getTranslogLastWriteLocation()
```
    Returns the last location that the translog of this engine has written into.
  - ensureOpen
```
protected final void ensureOpen(java.lang.Exception suppressed)
```
  - ensureOpen
```
protected final void ensureOpen()
```
  - commitStats
```
public CommitStats commitStats()
```
    get commits stats for the last commit
  - getLocalCheckpointTracker
```
public abstract LocalCheckpointTracker getLocalCheckpointTracker()
```
    The sequence number service for this engine.
    
    Returns:
    
    the sequence number service
  - getLastSyncedGlobalCheckpoint
```
public long getLastSyncedGlobalCheckpoint()
```
    Returns the latest global checkpoint value that has been persisted in the underlying storage (i.e. translog's checkpoint)
  - segmentsStats
```
public final SegmentsStats segmentsStats(boolean includeSegmentFileSizes)
```
    Global stats on segments.
  - writerSegmentStats
```
protected void writerSegmentStats(SegmentsStats stats)
```
  - getIndexBufferRAMBytesUsed
```
public abstract long getIndexBufferRAMBytesUsed()
```
    How much heap is used that would be freed by a refresh. Note that this may throw AlreadyClosedException.
  - getSegmentInfo
```
protected Segment[] getSegmentInfo(org.apache.lucene.index.SegmentInfos lastCommittedSegmentInfos,
                                   boolean verbose)
```
  - segments
```
public abstract java.util.List<Segment> segments(boolean verbose)
```
    The list of segments in the engine.
  - refreshNeeded
```
public final boolean refreshNeeded()
```
  - refresh
```
@Nullable
public abstract void refresh(java.lang.String source)
                      throws EngineException
```
    Synchronously refreshes the engine for new search operations to reflect the latest changes.
    
    Throws:
    
    EngineException
  - writeIndexingBuffer
```
public abstract void writeIndexingBuffer()
                                  throws EngineException
```
    Called when our engine is using too much heap and should move buffered indexed/deleted documents to disk.
    
    Throws:
    
    EngineException
  - shouldPeriodicallyFlush
```
public abstract boolean shouldPeriodicallyFlush()
```
    Checks if this engine should be flushed periodically. This check is mainly based on the uncommitted translog size and the translog flush threshold setting.
  - flush
```
public abstract Engine.CommitId flush(boolean force,
                                      boolean waitIfOngoing)
                               throws EngineException
```
    Flushes the state of the engine including the transaction log, clearing memory.
    
    Parameters:
    
    force - if true a lucene commit is executed even if no changes need to be committed.
    
    waitIfOngoing - if true this call will block until all currently running flushes have finished. Otherwise this call will return without blocking.
    
    Returns:
    
    the commit Id for the resulting commit
    
    Throws:
    
    EngineException
  - flush
```
public abstract Engine.CommitId flush()
                               throws EngineException
```
    Flushes the state of the engine including the transaction log, clearing memory and persisting documents in the lucene index to disk including a potentially heavy and durable fsync operation. This operation is not going to block if another flush operation is currently running and won't write a lucene commit if nothing needs to be committed.
    
    Returns:
    
    the commit Id for the resulting commit
    
    Throws:
    
    EngineException
  - trimTranslog
```
public abstract void trimTranslog()
                           throws EngineException
```
    checks and removes translog files that no longer need to be retained. See TranslogDeletionPolicy for details
    
    Throws:
    
    EngineException
  - shouldRollTranslogGeneration
```
public boolean shouldRollTranslogGeneration()
```
    Tests whether or not the translog generation should be rolled to a new generation. This test is based on the size of the current generation compared to the configured generation threshold size.
    
    Returns:
    
    true if the current generation should be rolled to a new generation
  - rollTranslogGeneration
```
public abstract void rollTranslogGeneration()
                                     throws EngineException
```
    Rolls the translog generation and cleans unneeded.
    
    Throws:
    
    EngineException
  - forceMerge
```
public void forceMerge(boolean flush)
                throws java.io.IOException
```
    Force merges to 1 segment
    
    Throws:
    
    java.io.IOException
  - forceMerge
```
public abstract void forceMerge(boolean flush,
                                int maxNumSegments,
                                boolean onlyExpungeDeletes,
                                boolean upgrade,
                                boolean upgradeOnlyAncientSegments)
                         throws EngineException,
                                java.io.IOException
```
    Triggers a forced merge on this engine
    
    Throws:
    
    EngineException
    
    java.io.IOException
  - acquireLastIndexCommit
```
public abstract Engine.IndexCommitRef acquireLastIndexCommit(boolean flushFirst)
                                                      throws EngineException
```
    Snapshots the most recent index and returns a handle to it. If needed will try and "commit" the lucene index to make sure we have a "fresh" copy of the files to snapshot.
    
    Parameters:
    
    flushFirst - indicates whether the engine should flush before returning the snapshot
    
    Throws:
    
    EngineException
  - acquireSafeIndexCommit
```
public abstract Engine.IndexCommitRef acquireSafeIndexCommit()
                                                      throws EngineException
```
    Snapshots the most recent safe index commit from the engine.
    
    Throws:
    
    EngineException
  - failEngine
```
public void failEngine(java.lang.String reason,
                       @Nullable
                       java.lang.Exception failure)
```
    fail engine due to some error. the engine will also be closed. The underlying store is marked corrupted iff failure is caused by index corruption
  - maybeFailEngine
```
protected boolean maybeFailEngine(java.lang.String source,
                                  java.lang.Exception e)
```
    Check whether the engine should be failed
  - closeNoLock
```
protected abstract void closeNoLock(java.lang.String reason,
                                    java.util.concurrent.CountDownLatch closedLatch)
```
    Method to close the engine while the write lock is held. Must decrement the supplied when closing work is done and resources are freed.
  - flushAndClose
```
public void flushAndClose()
                   throws java.io.IOException
```
    Flush the engine (committing segments to disk and truncating the translog) and close it.
    
    Throws:
    
    java.io.IOException
  - close
```
public void close()
           throws java.io.IOException
```
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    Specified by:
    
    close in interface java.io.Closeable
    
    Throws:
    
    java.io.IOException
  - onSettingsChanged
```
public void onSettingsChanged()
```
  - getLastWriteNanos
```
public long getLastWriteNanos()
```
    Returns the timestamp of the last write in nanoseconds. Note: this time might not be absolutely accurate since the Engine.Operation.startTime() is used which might be slightly inaccurate.
    
    See Also:
    
    System.nanoTime(), Engine.Operation.startTime()
  - activateThrottling
```
public abstract void activateThrottling()
```
    Request that this engine throttle incoming indexing requests to one thread. Must be matched by a later call to deactivateThrottling().
  - deactivateThrottling
```
public abstract void deactivateThrottling()
```
    Reverses a previous activateThrottling() call.
  - restoreLocalCheckpointFromTranslog
```
public abstract void restoreLocalCheckpointFromTranslog()
                                                 throws java.io.IOException
```
    Marks operations in the translog as completed. This is used to restore the state of the local checkpoint tracker on primary promotion.
    
    Throws:
    
    java.io.IOException - if an I/O exception occurred reading the translog
  - fillSeqNoGaps
```
public abstract int fillSeqNoGaps(long primaryTerm)
                           throws java.io.IOException
```
    Fills up the local checkpoints history with no-ops until the local checkpoint and the max seen sequence ID are identical.
    
    Parameters:
    
    primaryTerm - the shards primary term this engine was created for
    
    Returns:
    
    the number of no-ops added
    
    Throws:
    
    java.io.IOException
  - recoverFromTranslog
```
public abstract Engine recoverFromTranslog()
                                    throws java.io.IOException
```
    Performs recovery from the transaction log. This operation will close the engine if the recovery fails.
    
    Throws:
    
    java.io.IOException
  - skipTranslogRecovery
```
public abstract void skipTranslogRecovery()
```
    Do not replay translog operations, but make the engine be ready.
  - isRecovering
```
public boolean isRecovering()
```
    Returns true iff this engine is currently recovering from translog.
  - maybePruneDeletes
```
public abstract void maybePruneDeletes()
```
    Tries to prune buffered deletes from the version map.

Class Engine

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SYNC_COMMIT_ID

HISTORY_UUID_KEY

shardId

allocationId

logger

engineConfig

store

isClosed

eventListener

failEngineLock

rwl

readLock

writeLock

failedEngine

lastWriteNanos

Constructor Detail

Engine

Method Detail

guardedRamBytesUsed

isMergedSegment

config

getLastCommittedSegmentInfos

getMergeStats

getHistoryUUID

getWritingBytes

getIndexThrottleTimeInMillis

isThrottled

index

delete

noOp

syncFlush

getFromSearcher

get

acquireSearcher

acquireSearcher

isTranslogSyncNeeded

ensureTranslogSynced

syncTranslog

acquireTranslogRetentionLock

newTranslogSnapshotFromMinSeqNo

estimateTranslogOperationsFromMinSeq

getTranslogStats

getTranslogLastWriteLocation

ensureOpen

ensureOpen

commitStats

getLocalCheckpointTracker

getLastSyncedGlobalCheckpoint

segmentsStats

writerSegmentStats

getIndexBufferRAMBytesUsed

getSegmentInfo

segments

refreshNeeded

refresh

writeIndexingBuffer

shouldPeriodicallyFlush

flush

flush

trimTranslog

shouldRollTranslogGeneration

rollTranslogGeneration

forceMerge

forceMerge

acquireLastIndexCommit

acquireSafeIndexCommit

failEngine

maybeFailEngine

closeNoLock

flushAndClose

close

onSettingsChanged

getLastWriteNanos