ManagedLedgerImpl (Managed Ledger 2.10.0-rc-202112212205 API)

java.lang.Object
- org.apache.bookkeeper.mledger.impl.ManagedLedgerImpl

All Implemented Interfaces:

AsyncCallback.CreateCallback, ManagedLedger

Direct Known Subclasses:

ReadOnlyManagedLedgerImpl
```
public class ManagedLedgerImpl
extends Object
implements ManagedLedger, AsyncCallback.CreateCallback
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ManagedLedgerImpl.PositionBound

static class ManagedLedgerImpl.State

Nested Classes
Modifier and Type	Class and Description
`static class`	`ManagedLedgerImpl.PositionBound`
`static class`	`ManagedLedgerImpl.State`

Field Summary

Fields
Modifier and Type	Field and Description
`protected static AtomicLongFieldUpdater<ManagedLedgerImpl>`	`ADD_OP_COUNT_UPDATER`
`protected static int`	`AsyncOperationTimeoutSeconds`
`protected BookKeeper`	`bookKeeper`
`protected Clock`	`clock`
`protected ManagedLedgerConfig`	`config`
`protected static int`	`DEFAULT_LEDGER_DELETE_BACKOFF_TIME_SEC`
`protected static int`	`DEFAULT_LEDGER_DELETE_RETRIES`
`protected NavigableMap<Long,MLDataFormats.ManagedLedgerInfo.LedgerInfo>`	`ledgers`
`protected ManagedLedgerMBeanImpl`	`mbean`
`protected Supplier<Boolean>`	`mlOwnershipChecker`
`protected String`	`name`
`protected Map<String,String>`	`propertiesMap`
`protected ManagedLedgerImpl.State`	`state`
`protected MetaStore`	`store`

Constructor Summary

Constructors
Constructor and Description
`ManagedLedgerImpl(ManagedLedgerFactoryImpl factory, BookKeeper bookKeeper, MetaStore store, ManagedLedgerConfig config, org.apache.bookkeeper.common.util.OrderedScheduler scheduledExecutor, String name)`
`ManagedLedgerImpl(ManagedLedgerFactoryImpl factory, BookKeeper bookKeeper, MetaStore store, ManagedLedgerConfig config, org.apache.bookkeeper.common.util.OrderedScheduler scheduledExecutor, String name, Supplier<Boolean> mlOwnershipChecker)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`activateCursor(ManagedCursor cursor)`
`Position`	`addEntry(byte[] data)` Append a new entry to the end of a managed ledger.
`Position`	`addEntry(byte[] data, int numberOfMessages)` Append a new entry to the end of a managed ledger.
`Position`	`addEntry(byte[] data, int offset, int length)` Append a new entry to the end of a managed ledger.
`Position`	`addEntry(byte[] data, int numberOfMessages, int offset, int length)` Append a new entry to the end of a managed ledger.
`void`	`addWaitingEntryCallBack(WaitingEntryCallBack cb)`
`void`	`asyncAddEntry(byte[] data, AsyncCallbacks.AddEntryCallback callback, Object ctx)` Append a new entry asynchronously.
`void`	`asyncAddEntry(byte[] data, int offset, int length, AsyncCallbacks.AddEntryCallback callback, Object ctx)` Append a new entry asynchronously.
`void`	`asyncAddEntry(byte[] data, int numberOfMessages, int offset, int length, AsyncCallbacks.AddEntryCallback callback, Object ctx)` Append a new entry asynchronously.
`void`	`asyncAddEntry(io.netty.buffer.ByteBuf buffer, AsyncCallbacks.AddEntryCallback callback, Object ctx)` Append a new entry asynchronously.
`void`	`asyncAddEntry(io.netty.buffer.ByteBuf buffer, int numberOfMessages, AsyncCallbacks.AddEntryCallback callback, Object ctx)` Append a new entry asynchronously.
`void`	`asyncClose(AsyncCallbacks.CloseCallback callback, Object ctx)` Close the ManagedLedger asynchronously.
`protected void`	`asyncCreateLedger(BookKeeper bookKeeper, ManagedLedgerConfig config, BookKeeper.DigestType digestType, AsyncCallback.CreateCallback cb, Map<String,byte[]> metadata)` Create ledger async and schedule a timeout task to check ledger-creation is complete else it fails the callback with TimeoutException.
`void`	`asyncDelete(AsyncCallbacks.DeleteLedgerCallback callback, Object ctx)` Async delete a ledger.
`void`	`asyncDeleteCursor(String consumerName, AsyncCallbacks.DeleteCursorCallback callback, Object ctx)` Delete a ManagedCursor asynchronously.
`void`	`asyncDeleteProperty(String key, AsyncCallbacks.UpdatePropertiesCallback callback, Object ctx)` Async delete the property by key.
`CompletableFuture<Position>`	`asyncFindPosition(com.google.common.base.Predicate<Entry> predicate)` Find position by sequenceId.
`void`	`asyncOffloadPrefix(Position pos, AsyncCallbacks.OffloadCallback callback, Object ctx)` Offload as many entries before position as possible to longterm storage.
`void`	`asyncOpenCursor(String cursorName, AsyncCallbacks.OpenCursorCallback callback, Object ctx)` Open a ManagedCursor asynchronously.
`void`	`asyncOpenCursor(String cursorName, CommandSubscribe.InitialPosition initialPosition, AsyncCallbacks.OpenCursorCallback callback, Object ctx)` Open a ManagedCursor asynchronously.
`void`	`asyncOpenCursor(String cursorName, CommandSubscribe.InitialPosition initialPosition, Map<String,Long> properties, AsyncCallbacks.OpenCursorCallback callback, Object ctx)` Open a ManagedCursor asynchronously.
`void`	`asyncReadEntry(PositionImpl position, AsyncCallbacks.ReadEntryCallback callback, Object ctx)`
`protected void`	`asyncReadEntry(org.apache.bookkeeper.client.api.ReadHandle ledger, long firstEntry, long lastEntry, boolean isSlowestReader, org.apache.bookkeeper.mledger.impl.OpReadEntry opReadEntry, Object ctx)`
`protected void`	`asyncReadEntry(org.apache.bookkeeper.client.api.ReadHandle ledger, PositionImpl position, AsyncCallbacks.ReadEntryCallback callback, Object ctx)`
`void`	`asyncSetProperties(Map<String,String> properties, AsyncCallbacks.UpdatePropertiesCallback callback, Object ctx)` Async update managed-ledger's properties.
`void`	`asyncSetProperty(String key, String value, AsyncCallbacks.UpdatePropertiesCallback callback, Object ctx)` Async add key-value to propertiesMap.
`void`	`asyncTerminate(AsyncCallbacks.TerminateCallback callback, Object ctx)`
`CompletableFuture<Void>`	`asyncTruncate()` Truncate ledgers The truncate operation will move all cursors to the end of the topic and delete all inactive ledgers.
`protected boolean`	`checkAndCompleteLedgerOpTask(int rc, LedgerHandle lh, Object ctx)` check if ledger-op task is already completed by timeout-task.
`void`	`close()` Close the ManagedLedger.
`void`	`createComplete(int rc, LedgerHandle lh, Object ctx)`
`static ManagedLedgerException`	`createManagedLedgerException(int bkErrorCode)`
`static ManagedLedgerException`	`createManagedLedgerException(Throwable t)`
`void`	`deactivateCursor(ManagedCursor cursor)`
`void`	`delete()` Delete this ManagedLedger completely from the system.
`void`	`deleteCursor(String name)` Remove a ManagedCursor from this ManagedLedger.
`void`	`deleteProperty(String key)` Delete the property by key.
`ManagedCursorContainer`	`getActiveCursors()` Get a list of all the active cursors reading from this ManagedLedger.
`long`	`getCacheSize()`
`Clock`	`getClock()`
`ManagedLedgerConfig`	`getConfig()` Returns managed-ledger config.
`long`	`getCurrentLedgerEntries()`
`long`	`getCurrentLedgerSize()`
`ManagedCursorContainer`	`getCursors()` Get a list of all the cursors reading from this ManagedLedger
`CompletableFuture<Long>`	`getEarliestMessagePublishTimeInBacklog()` Get the publishing time of the oldest message in the backlog.
`CompletableFuture<Long>`	`getEarliestMessagePublishTimeOfPos(PositionImpl pos)`
`CompletableFuture<Set<org.apache.bookkeeper.net.BookieId>>`	`getEnsemblesAsync(long ledgerId)`
`long`	`getEntriesAddedCounter()`
`long`	`getEstimatedBacklogSize()` Get estimated total unconsumed or backlog size in bytes for the managed ledger, without accounting for replicas.
`long`	`getEstimatedBacklogSize(PositionImpl pos)` Get estimated backlog size from a specific position.
`PositionImpl`	`getFirstPosition()`
`Position`	`getLastConfirmedEntry()` Gets last confirmed entry of the managed ledger.
`long`	`getLastLedgerCreatedTimestamp()`
`long`	`getLastLedgerCreationFailureTimestamp()`
`long`	`getLastOffloadedFailureTimestamp()` Get last failed offloaded timestamp.
`long`	`getLastOffloadedLedgerId()` Get last offloaded ledgerId.
`long`	`getLastOffloadedSuccessTimestamp()` Get last suceessful offloaded timestamp.
`CompletableFuture<MLDataFormats.ManagedLedgerInfo.LedgerInfo>`	`getLedgerInfo(long ledgerId)` Get basic ledger summary.
`CompletableFuture<String>`	`getLedgerMetadata(long ledgerId)`
`NavigableMap<Long,MLDataFormats.ManagedLedgerInfo.LedgerInfo>`	`getLedgersInfo()`
`List<MLDataFormats.ManagedLedgerInfo.LedgerInfo>`	`getLedgersInfoAsList()`
`ManagedLedgerInterceptor`	`getManagedLedgerInterceptor()` Get the ManagedLedgerInterceptor for ManagedLedger.
`CompletableFuture<ManagedLedgerInternalStats>`	`getManagedLedgerInternalStats(boolean includeLedgerMetadata)` Get managed ledger internal stats
`ManagedLedgerMBeanImpl`	`getMBean()`
`String`	`getName()`
`Long`	`getNextValidLedger(long ledgerId)`
`PositionImpl`	`getNextValidPosition(PositionImpl position)`
`PositionImpl`	`getNextValidPositionInternal(PositionImpl position)`
`long`	`getNumberOfActiveEntries()` Get the total number of active entries for this managed ledger.
`long`	`getNumberOfEntries()` Get the total number of entries for this managed ledger.
`long`	`getOffloadedSize()` Return the size of all ledgers offloaded to 2nd tier storage
`int`	`getPendingAddEntriesCount()`
`PositionImpl`	`getPositionAfterN(PositionImpl startPosition, long n, ManagedLedgerImpl.PositionBound startRange)` Get the entry position at a given distance from a given position.
`PositionImpl`	`getPreviousPosition(PositionImpl position)` Get the entry position that come before the specified position in the message stream, using information from the ledger list and each ledger entries count.
`Map<String,String>`	`getProperties()` Returns managed-ledger's properties.
`ManagedCursor`	`getSlowestConsumer()` Get the slowest consumer.
`ManagedLedgerImpl.State`	`getState()`
`ManagedLedgerMXBean`	`getStats()`
`long`	`getTotalSize()` Get the total sizes in bytes of the managed ledger, without accounting for replicas.
`int`	`getWaitingCursorsCount()`
`boolean`	`hasActiveCursors()` Tells whether the managed ledger has any active-cursor registered.
`boolean`	`hasMoreEntries(PositionImpl position)`
`boolean`	`isCursorActive(ManagedCursor cursor)`
`protected boolean`	`isReadOnly()`
`boolean`	`isTerminated()` Returns whether the managed ledger was terminated.
`boolean`	`isValidPosition(PositionImpl position)` Validate whether a specified position is valid for the current managed ledger.
`boolean`	`ledgerExists(long ledgerId)`
`void`	`maybeUpdateCursorBeforeTrimmingConsumedLedger()`
`ManagedCursor`	`newNonDurableCursor(Position startCursorPosition)` Creates a new cursor whose metadata is not backed by durable storage.
`ManagedCursor`	`newNonDurableCursor(Position startPosition, String subscriptionName)`
`ManagedCursor`	`newNonDurableCursor(Position startCursorPosition, String cursorName, CommandSubscribe.InitialPosition initialPosition)`
`Position`	`offloadPrefix(Position pos)` Offload as many entries before position as possible to longterm storage.
`ManagedCursor`	`openCursor(String cursorName)` Open a ManagedCursor in this ManagedLedger.
`ManagedCursor`	`openCursor(String cursorName, CommandSubscribe.InitialPosition initialPosition)` Open a ManagedCursor in this ManagedLedger.
`ManagedCursor`	`openCursor(String cursorName, CommandSubscribe.InitialPosition initialPosition, Map<String,Long> properties)` Open a ManagedCursor in this ManagedLedger.
`void`	`readyToCreateNewLedger()` Signaling managed ledger that we can resume after BK write failure
`void`	`rollCurrentLedgerIfFull()` Roll current ledger if it is full
`void`	`setConfig(ManagedLedgerConfig config)` Updates managed-ledger config.
`void`	`setEntriesAddedCounter(long count)`
`void`	`setProperties(Map<String,String> properties)` Update managed-ledger's properties.
`void`	`setProperty(String key, String value)` Add key-value to propertiesMap.
`Position`	`terminate()` Terminate the managed ledger and return the last committed entry.
`void`	`trimConsumedLedgersInBackground(boolean isTruncate, CompletableFuture<?> promise)`
`void`	`trimConsumedLedgersInBackground(CompletableFuture<?> promise)` Trim consumed ledgers in background
`void`	`updateLedgersIdsComplete(Stat stat)`

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

- Field Detail
  - AsyncOperationTimeoutSeconds
```
protected static final int AsyncOperationTimeoutSeconds
```
    See Also:
    
    Constant Field Values
  - bookKeeper
```
protected final BookKeeper bookKeeper
```
  - name
```
protected final String name
```
  - config
```
protected ManagedLedgerConfig config
```
  - propertiesMap
```
protected Map<String,String> propertiesMap
```
  - store
```
protected final MetaStore store
```
  - ledgers
```
protected final NavigableMap<Long,MLDataFormats.ManagedLedgerInfo.LedgerInfo> ledgers
```
  - mlOwnershipChecker
```
protected final Supplier<Boolean> mlOwnershipChecker
```
  - DEFAULT_LEDGER_DELETE_RETRIES
```
protected static final int DEFAULT_LEDGER_DELETE_RETRIES
```
    See Also:
    
    Constant Field Values
  - DEFAULT_LEDGER_DELETE_BACKOFF_TIME_SEC
```
protected static final int DEFAULT_LEDGER_DELETE_BACKOFF_TIME_SEC
```
    See Also:
    
    Constant Field Values
  - state
```
protected volatile ManagedLedgerImpl.State state
```
  - mbean
```
protected final ManagedLedgerMBeanImpl mbean
```
  - clock
```
protected final Clock clock
```
  - ADD_OP_COUNT_UPDATER
```
protected static final AtomicLongFieldUpdater<ManagedLedgerImpl> ADD_OP_COUNT_UPDATER
```
- Constructor Detail
  - ManagedLedgerImpl
```
public ManagedLedgerImpl(ManagedLedgerFactoryImpl factory,
                         BookKeeper bookKeeper,
                         MetaStore store,
                         ManagedLedgerConfig config,
                         org.apache.bookkeeper.common.util.OrderedScheduler scheduledExecutor,
                         String name)
```
  - ManagedLedgerImpl
```
public ManagedLedgerImpl(ManagedLedgerFactoryImpl factory,
                         BookKeeper bookKeeper,
                         MetaStore store,
                         ManagedLedgerConfig config,
                         org.apache.bookkeeper.common.util.OrderedScheduler scheduledExecutor,
                         String name,
                         Supplier<Boolean> mlOwnershipChecker)
```
- Method Detail
  - getName
```
public String getName()
```
    Specified by:
    
    getName in interface ManagedLedger
    
    Returns:
    
    the unique name of this ManagedLedger
  - addEntry
```
public Position addEntry(byte[] data)
                  throws InterruptedException,
                         ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Append a new entry to the end of a managed ledger.
    
    Specified by:
    
    addEntry in interface ManagedLedger
    
    Parameters:
    
    data - data entry to be persisted
    
    Returns:
    
    the Position at which the entry has been inserted
    
    Throws:
    
    ManagedLedgerException
    
    InterruptedException
  - addEntry
```
public Position addEntry(byte[] data,
                         int numberOfMessages)
                  throws InterruptedException,
                         ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Append a new entry to the end of a managed ledger.
    
    Specified by:
    
    addEntry in interface ManagedLedger
    
    Parameters:
    
    data - data entry to be persisted
    
    numberOfMessages - numberOfMessages of entry
    
    Returns:
    
    the Position at which the entry has been inserted
    
    Throws:
    
    ManagedLedgerException
    
    InterruptedException
  - addEntry
```
public Position addEntry(byte[] data,
                         int offset,
                         int length)
                  throws InterruptedException,
                         ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Append a new entry to the end of a managed ledger.
    
    Specified by:
    
    addEntry in interface ManagedLedger
    
    Parameters:
    
    data - data entry to be persisted
    
    offset - offset in the data array
    
    length - number of bytes
    
    Returns:
    
    the Position at which the entry has been inserted
    
    Throws:
    
    ManagedLedgerException
    
    InterruptedException
  - addEntry
```
public Position addEntry(byte[] data,
                         int numberOfMessages,
                         int offset,
                         int length)
                  throws InterruptedException,
                         ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Append a new entry to the end of a managed ledger.
    
    Specified by:
    
    addEntry in interface ManagedLedger
    
    Parameters:
    
    data - data entry to be persisted
    
    numberOfMessages - numberOfMessages of entry
    
    offset - offset in the data array
    
    length - number of bytes
    
    Returns:
    
    the Position at which the entry has been inserted
    
    Throws:
    
    ManagedLedgerException
    
    InterruptedException
  - asyncAddEntry
```
public void asyncAddEntry(byte[] data,
                          AsyncCallbacks.AddEntryCallback callback,
                          Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Append a new entry asynchronously.
    
    Specified by:
    
    asyncAddEntry in interface ManagedLedger
    
    Parameters:
    
    data - data entry to be persisted
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.addEntry(byte[])
  - asyncAddEntry
```
public void asyncAddEntry(byte[] data,
                          int offset,
                          int length,
                          AsyncCallbacks.AddEntryCallback callback,
                          Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Append a new entry asynchronously.
    
    Specified by:
    
    asyncAddEntry in interface ManagedLedger
    
    Parameters:
    
    data - data entry to be persisted
    
    offset - offset in the data array
    
    length - number of bytes
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.addEntry(byte[])
  - asyncAddEntry
```
public void asyncAddEntry(byte[] data,
                          int numberOfMessages,
                          int offset,
                          int length,
                          AsyncCallbacks.AddEntryCallback callback,
                          Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Append a new entry asynchronously.
    
    Specified by:
    
    asyncAddEntry in interface ManagedLedger
    
    Parameters:
    
    data - data entry to be persisted
    
    numberOfMessages - numberOfMessages of entry
    
    offset - offset in the data array
    
    length - number of bytes
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.addEntry(byte[])
  - asyncAddEntry
```
public void asyncAddEntry(io.netty.buffer.ByteBuf buffer,
                          AsyncCallbacks.AddEntryCallback callback,
                          Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Append a new entry asynchronously.
    
    Specified by:
    
    asyncAddEntry in interface ManagedLedger
    
    Parameters:
    
    buffer - buffer with the data entry
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.addEntry(byte[])
  - asyncAddEntry
```
public void asyncAddEntry(io.netty.buffer.ByteBuf buffer,
                          int numberOfMessages,
                          AsyncCallbacks.AddEntryCallback callback,
                          Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Append a new entry asynchronously.
    
    Specified by:
    
    asyncAddEntry in interface ManagedLedger
    
    Parameters:
    
    buffer - buffer with the data entry
    
    numberOfMessages - numberOfMessages for data entry
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.addEntry(byte[])
  - readyToCreateNewLedger
```
public void readyToCreateNewLedger()
```
    Description copied from interface: ManagedLedger
    
    Signaling managed ledger that we can resume after BK write failure
    
    Specified by:
    
    readyToCreateNewLedger in interface ManagedLedger
  - openCursor
```
public ManagedCursor openCursor(String cursorName)
                         throws InterruptedException,
                                ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Open a ManagedCursor in this ManagedLedger.
    If the cursors doesn't exist, a new one will be created and its position will be at the end of the ManagedLedger.
    
    Specified by:
    
    openCursor in interface ManagedLedger
    
    Parameters:
    
    cursorName - the name associated with the ManagedCursor
    
    Returns:
    
    the ManagedCursor
    
    Throws:
    
    ManagedLedgerException
    
    InterruptedException
  - openCursor
```
public ManagedCursor openCursor(String cursorName,
                                CommandSubscribe.InitialPosition initialPosition)
                         throws InterruptedException,
                                ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Open a ManagedCursor in this ManagedLedger.
    If the cursors doesn't exist, a new one will be created and its position will be at the end of the ManagedLedger.
    
    Specified by:
    
    openCursor in interface ManagedLedger
    
    Parameters:
    
    cursorName - the name associated with the ManagedCursor
    
    initialPosition - the cursor will be set at latest position or not when first created default is true
    
    Returns:
    
    the ManagedCursor
    
    Throws:
    
    ManagedLedgerException
    
    InterruptedException
  - openCursor
```
public ManagedCursor openCursor(String cursorName,
                                CommandSubscribe.InitialPosition initialPosition,
                                Map<String,Long> properties)
                         throws InterruptedException,
                                ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Open a ManagedCursor in this ManagedLedger.
    If the cursors doesn't exist, a new one will be created and its position will be at the end of the ManagedLedger.
    
    Specified by:
    
    openCursor in interface ManagedLedger
    
    Parameters:
    
    cursorName - the name associated with the ManagedCursor
    
    initialPosition - the cursor will be set at latest position or not when first created default is true
    
    properties - user defined properties that will be attached to the first position of the cursor, if the open operation will trigger the creation of the cursor.
    
    Returns:
    
    the ManagedCursor
    
    Throws:
    
    ManagedLedgerException
    
    InterruptedException
  - asyncOpenCursor
```
public void asyncOpenCursor(String cursorName,
                            AsyncCallbacks.OpenCursorCallback callback,
                            Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Open a ManagedCursor asynchronously.
    
    Specified by:
    
    asyncOpenCursor in interface ManagedLedger
    
    Parameters:
    
    cursorName - the name associated with the ManagedCursor
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.openCursor(String)
  - asyncOpenCursor
```
public void asyncOpenCursor(String cursorName,
                            CommandSubscribe.InitialPosition initialPosition,
                            AsyncCallbacks.OpenCursorCallback callback,
                            Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Open a ManagedCursor asynchronously.
    
    Specified by:
    
    asyncOpenCursor in interface ManagedLedger
    
    Parameters:
    
    cursorName - the name associated with the ManagedCursor
    
    initialPosition - the cursor will be set at lastest position or not when first created default is true
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.openCursor(String)
  - asyncOpenCursor
```
public void asyncOpenCursor(String cursorName,
                            CommandSubscribe.InitialPosition initialPosition,
                            Map<String,Long> properties,
                            AsyncCallbacks.OpenCursorCallback callback,
                            Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Open a ManagedCursor asynchronously.
    
    Specified by:
    
    asyncOpenCursor in interface ManagedLedger
    
    Parameters:
    
    cursorName - the name associated with the ManagedCursor
    
    initialPosition - the cursor will be set at lastest position or not when first created default is true
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.openCursor(String)
  - asyncDeleteCursor
```
public void asyncDeleteCursor(String consumerName,
                              AsyncCallbacks.DeleteCursorCallback callback,
                              Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Delete a ManagedCursor asynchronously.
    
    Specified by:
    
    asyncDeleteCursor in interface ManagedLedger
    
    Parameters:
    
    consumerName - the name associated with the ManagedCursor
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.deleteCursor(String)
  - deleteCursor
```
public void deleteCursor(String name)
                  throws InterruptedException,
                         ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Remove a ManagedCursor from this ManagedLedger.
    If the cursor doesn't exist, the operation will still succeed.
    
    Specified by:
    
    deleteCursor in interface ManagedLedger
    
    Parameters:
    
    name - the name associated with the ManagedCursor
    
    Throws:
    
    InterruptedException
    
    ManagedLedgerException
  - newNonDurableCursor
```
public ManagedCursor newNonDurableCursor(Position startCursorPosition)
                                  throws ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Creates a new cursor whose metadata is not backed by durable storage. A caller can treat the non-durable cursor exactly like a normal cursor, with the only difference in that after restart it will not remember which entries were deleted. Also it does not prevent data from being deleted.
    The cursor is anonymous and can be positioned on an arbitrary position.
    This method is not-blocking.
    
    Specified by:
    
    newNonDurableCursor in interface ManagedLedger
    
    Parameters:
    
    startCursorPosition - the position where the cursor should be initialized, or null to start from the current latest entry. When starting on a particular cursor position, the first entry to be returned will be the entry next to the specified position
    
    Returns:
    
    the new NonDurableCursor
    
    Throws:
    
    ManagedLedgerException
  - newNonDurableCursor
```
public ManagedCursor newNonDurableCursor(Position startPosition,
                                         String subscriptionName)
                                  throws ManagedLedgerException
```
    Specified by:
    
    newNonDurableCursor in interface ManagedLedger
    
    Throws:
    
    ManagedLedgerException
  - newNonDurableCursor
```
public ManagedCursor newNonDurableCursor(Position startCursorPosition,
                                         String cursorName,
                                         CommandSubscribe.InitialPosition initialPosition)
                                  throws ManagedLedgerException
```
    Specified by:
    
    newNonDurableCursor in interface ManagedLedger
    
    Throws:
    
    ManagedLedgerException
  - getCursors
```
public ManagedCursorContainer getCursors()
```
    Description copied from interface: ManagedLedger
    
    Get a list of all the cursors reading from this ManagedLedger
    
    Specified by:
    
    getCursors in interface ManagedLedger
    
    Returns:
    
    a list of cursors
  - getActiveCursors
```
public ManagedCursorContainer getActiveCursors()
```
    Description copied from interface: ManagedLedger
    
    Get a list of all the active cursors reading from this ManagedLedger.
    
    Specified by:
    
    getActiveCursors in interface ManagedLedger
    
    Returns:
    
    a list of cursors
  - hasActiveCursors
```
public boolean hasActiveCursors()
```
    Tells whether the managed ledger has any active-cursor registered.
    
    Returns:
    
    true if at least a cursor exists
  - getNumberOfEntries
```
public long getNumberOfEntries()
```
    Description copied from interface: ManagedLedger
    
    Get the total number of entries for this managed ledger.
    This is defined by the number of entries in all the BookKeeper ledgers that are being maintained by this ManagedLedger.
    This method is non-blocking.
    
    Specified by:
    
    getNumberOfEntries in interface ManagedLedger
    
    Returns:
    
    the number of entries
  - getNumberOfActiveEntries
```
public long getNumberOfActiveEntries()
```
    Description copied from interface: ManagedLedger
    
    Get the total number of active entries for this managed ledger.
    This is defined by the number of non consumed entries in all the BookKeeper ledgers that are being maintained by this ManagedLedger.
    This method is non-blocking.
    
    Specified by:
    
    getNumberOfActiveEntries in interface ManagedLedger
    
    Returns:
    
    the number of entries
  - getTotalSize
```
public long getTotalSize()
```
    Description copied from interface: ManagedLedger
    
    Get the total sizes in bytes of the managed ledger, without accounting for replicas.
    This is defined by the sizes of all the BookKeeper ledgers that are being maintained by this ManagedLedger.
    This method is non-blocking.
    
    Specified by:
    
    getTotalSize in interface ManagedLedger
    
    Returns:
    
    total size in bytes
  - getEstimatedBacklogSize
```
public long getEstimatedBacklogSize()
```
    Description copied from interface: ManagedLedger
    
    Get estimated total unconsumed or backlog size in bytes for the managed ledger, without accounting for replicas.
    
    Specified by:
    
    getEstimatedBacklogSize in interface ManagedLedger
    
    Returns:
    
    estimated total backlog size
  - getEarliestMessagePublishTimeInBacklog
```
public CompletableFuture<Long> getEarliestMessagePublishTimeInBacklog()
```
    Description copied from interface: ManagedLedger
    
    Get the publishing time of the oldest message in the backlog.
    
    Specified by:
    
    getEarliestMessagePublishTimeInBacklog in interface ManagedLedger
    
    Returns:
    
    the publishing time of the oldest message
  - getEarliestMessagePublishTimeOfPos
```
public CompletableFuture<Long> getEarliestMessagePublishTimeOfPos(PositionImpl pos)
```
  - getEstimatedBacklogSize
```
public long getEstimatedBacklogSize(PositionImpl pos)
```
    Get estimated backlog size from a specific position.
  - asyncTerminate
```
public void asyncTerminate(AsyncCallbacks.TerminateCallback callback,
                           Object ctx)
```
    Specified by:
    
    asyncTerminate in interface ManagedLedger
  - terminate
```
public Position terminate()
                   throws InterruptedException,
                          ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Terminate the managed ledger and return the last committed entry.
    Once the managed ledger is terminated, it will not accept any more write
    
    Specified by:
    
    terminate in interface ManagedLedger
    
    Returns:
    
    Throws:
    
    InterruptedException
    
    ManagedLedgerException
  - isTerminated
```
public boolean isTerminated()
```
    Description copied from interface: ManagedLedger
    
    Returns whether the managed ledger was terminated.
    
    Specified by:
    
    isTerminated in interface ManagedLedger
  - close
```
public void close()
           throws InterruptedException,
                  ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Close the ManagedLedger.
    This will close all the underlying BookKeeper ledgers. All the ManagedCursors associated will be invalidated.
    
    Specified by:
    
    close in interface ManagedLedger
    
    Throws:
    
    ManagedLedgerException
    
    InterruptedException
  - asyncClose
```
public void asyncClose(AsyncCallbacks.CloseCallback callback,
                       Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Close the ManagedLedger asynchronously.
    
    Specified by:
    
    asyncClose in interface ManagedLedger
    
    Parameters:
    
    callback - callback object
    
    ctx - opaque context
    
    See Also:
    
    ManagedLedger.close()
  - createComplete
```
public void createComplete(int rc,
                           LedgerHandle lh,
                           Object ctx)
```
    Specified by:
    
    createComplete in interface AsyncCallback.CreateCallback
  - updateLedgersIdsComplete
```
public void updateLedgersIdsComplete(Stat stat)
```
  - rollCurrentLedgerIfFull
```
public void rollCurrentLedgerIfFull()
```
    Description copied from interface: ManagedLedger
    
    Roll current ledger if it is full
    
    Specified by:
    
    rollCurrentLedgerIfFull in interface ManagedLedger
  - asyncFindPosition
```
public CompletableFuture<Position> asyncFindPosition(com.google.common.base.Predicate<Entry> predicate)
```
    Description copied from interface: ManagedLedger
    
    Find position by sequenceId.
    
    Specified by:
    
    asyncFindPosition in interface ManagedLedger
  - getManagedLedgerInterceptor
```
public ManagedLedgerInterceptor getManagedLedgerInterceptor()
```
    Description copied from interface: ManagedLedger
    
    Get the ManagedLedgerInterceptor for ManagedLedger.
    
    Specified by:
    
    getManagedLedgerInterceptor in interface ManagedLedger
  - getLedgerMetadata
```
public CompletableFuture<String> getLedgerMetadata(long ledgerId)
```
  - getLedgerInfo
```
public CompletableFuture<MLDataFormats.ManagedLedgerInfo.LedgerInfo> getLedgerInfo(long ledgerId)
```
    Description copied from interface: ManagedLedger
    
    Get basic ledger summary. will got null if corresponding ledger not exists.
    
    Specified by:
    
    getLedgerInfo in interface ManagedLedger
  - asyncReadEntry
```
public void asyncReadEntry(PositionImpl position,
                           AsyncCallbacks.ReadEntryCallback callback,
                           Object ctx)
```
  - asyncReadEntry
```
protected void asyncReadEntry(org.apache.bookkeeper.client.api.ReadHandle ledger,
                              PositionImpl position,
                              AsyncCallbacks.ReadEntryCallback callback,
                              Object ctx)
```
  - asyncReadEntry
```
protected void asyncReadEntry(org.apache.bookkeeper.client.api.ReadHandle ledger,
                              long firstEntry,
                              long lastEntry,
                              boolean isSlowestReader,
                              org.apache.bookkeeper.mledger.impl.OpReadEntry opReadEntry,
                              Object ctx)
```
  - getStats
```
public ManagedLedgerMXBean getStats()
```
    Specified by:
    
    getStats in interface ManagedLedger
    
    Returns:
    
    the managed ledger stats MBean
  - hasMoreEntries
```
public boolean hasMoreEntries(PositionImpl position)
```
  - addWaitingEntryCallBack
```
public void addWaitingEntryCallBack(WaitingEntryCallBack cb)
```
  - maybeUpdateCursorBeforeTrimmingConsumedLedger
```
public void maybeUpdateCursorBeforeTrimmingConsumedLedger()
```
  - trimConsumedLedgersInBackground
```
public void trimConsumedLedgersInBackground(CompletableFuture<?> promise)
```
    Description copied from interface: ManagedLedger
    
    Trim consumed ledgers in background
    
    Specified by:
    
    trimConsumedLedgersInBackground in interface ManagedLedger
  - trimConsumedLedgersInBackground
```
public void trimConsumedLedgersInBackground(boolean isTruncate,
                                            CompletableFuture<?> promise)
```
  - delete
```
public void delete()
            throws InterruptedException,
                   ManagedLedgerException
```
    Delete this ManagedLedger completely from the system.
    
    Specified by:
    
    delete in interface ManagedLedger
    
    Throws:
    
    Exception
    
    InterruptedException
    
    ManagedLedgerException
  - asyncDelete
```
public void asyncDelete(AsyncCallbacks.DeleteLedgerCallback callback,
                        Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Async delete a ledger.
    
    Specified by:
    
    asyncDelete in interface ManagedLedger
  - offloadPrefix
```
public Position offloadPrefix(Position pos)
                       throws InterruptedException,
                              ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Offload as many entries before position as possible to longterm storage.
    
    Specified by:
    
    offloadPrefix in interface ManagedLedger
    
    Parameters:
    
    pos - the position before which entries will be offloaded
    
    Returns:
    
    the earliest position which was not offloaded
    
    Throws:
    
    InterruptedException
    
    ManagedLedgerException
    
    See Also:
    
    #asyncOffloadPrefix(Position,OffloadCallback,Object)
  - asyncOffloadPrefix
```
public void asyncOffloadPrefix(Position pos,
                               AsyncCallbacks.OffloadCallback callback,
                               Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Offload as many entries before position as possible to longterm storage. As internally, entries is stored in ledgers, and ledgers can only be operated on as a whole, it is likely not possible to offload every entry before the passed in position. Only complete ledgers will be offloaded. On completion a position will be passed to the callback. This position is the earliest entry which was not offloaded.
    
    Specified by:
    
    asyncOffloadPrefix in interface ManagedLedger
    
    Parameters:
    
    pos - the position before which entries will be offloaded
    
    callback - a callback which will be supplied with the earliest unoffloaded position on completion
    
    ctx - a context object which will be passed to the callback on completion
  - getPositionAfterN
```
public PositionImpl getPositionAfterN(PositionImpl startPosition,
                                      long n,
                                      ManagedLedgerImpl.PositionBound startRange)
```
    Get the entry position at a given distance from a given position.
    
    Parameters:
    
    startPosition - starting position
    
    n - number of entries to skip ahead
    
    startRange - specifies whether or not to include the start position in calculating the distance
    
    Returns:
    
    the new position that is n entries ahead
  - getPreviousPosition
```
public PositionImpl getPreviousPosition(PositionImpl position)
```
    Get the entry position that come before the specified position in the message stream, using information from the ledger list and each ledger entries count.
    
    Parameters:
    
    position - the current position
    
    Returns:
    
    the previous position
  - isValidPosition
```
public boolean isValidPosition(PositionImpl position)
```
    Validate whether a specified position is valid for the current managed ledger.
    
    Parameters:
    
    position - the position to validate
    
    Returns:
    
    true if the position is valid, false otherwise
  - ledgerExists
```
public boolean ledgerExists(long ledgerId)
```
  - getNextValidLedger
```
public Long getNextValidLedger(long ledgerId)
```
  - getNextValidPosition
```
public PositionImpl getNextValidPosition(PositionImpl position)
```
  - getNextValidPositionInternal
```
public PositionImpl getNextValidPositionInternal(PositionImpl position)
```
  - getFirstPosition
```
public PositionImpl getFirstPosition()
```
  - getSlowestConsumer
```
public ManagedCursor getSlowestConsumer()
```
    Description copied from interface: ManagedLedger
    
    Get the slowest consumer.
    
    Specified by:
    
    getSlowestConsumer in interface ManagedLedger
    
    Returns:
    
    the slowest consumer
  - activateCursor
```
public void activateCursor(ManagedCursor cursor)
```
  - deactivateCursor
```
public void deactivateCursor(ManagedCursor cursor)
```
  - isCursorActive
```
public boolean isCursorActive(ManagedCursor cursor)
```
  - getLedgersInfoAsList
```
public List<MLDataFormats.ManagedLedgerInfo.LedgerInfo> getLedgersInfoAsList()
```
  - getLedgersInfo
```
public NavigableMap<Long,MLDataFormats.ManagedLedgerInfo.LedgerInfo> getLedgersInfo()
```
  - getConfig
```
public ManagedLedgerConfig getConfig()
```
    Description copied from interface: ManagedLedger
    
    Returns managed-ledger config.
    
    Specified by:
    
    getConfig in interface ManagedLedger
  - setConfig
```
public void setConfig(ManagedLedgerConfig config)
```
    Description copied from interface: ManagedLedger
    
    Updates managed-ledger config.
    
    Specified by:
    
    setConfig in interface ManagedLedger
  - getEntriesAddedCounter
```
public long getEntriesAddedCounter()
```
  - getCurrentLedgerEntries
```
public long getCurrentLedgerEntries()
```
  - getCurrentLedgerSize
```
public long getCurrentLedgerSize()
```
  - getLastLedgerCreatedTimestamp
```
public long getLastLedgerCreatedTimestamp()
```
  - getLastLedgerCreationFailureTimestamp
```
public long getLastLedgerCreationFailureTimestamp()
```
  - getWaitingCursorsCount
```
public int getWaitingCursorsCount()
```
  - getPendingAddEntriesCount
```
public int getPendingAddEntriesCount()
```
  - getLastConfirmedEntry
```
public Position getLastConfirmedEntry()
```
    Description copied from interface: ManagedLedger
    
    Gets last confirmed entry of the managed ledger.
    
    Specified by:
    
    getLastConfirmedEntry in interface ManagedLedger
    
    Returns:
    
    the last confirmed entry id
  - getState
```
public ManagedLedgerImpl.State getState()
```
  - getMBean
```
public ManagedLedgerMBeanImpl getMBean()
```
  - getCacheSize
```
public long getCacheSize()
```
  - isReadOnly
```
protected boolean isReadOnly()
```
  - createManagedLedgerException
```
public static ManagedLedgerException createManagedLedgerException(int bkErrorCode)
```
  - createManagedLedgerException
```
public static ManagedLedgerException createManagedLedgerException(Throwable t)
```
  - asyncCreateLedger
```
protected void asyncCreateLedger(BookKeeper bookKeeper,
                                 ManagedLedgerConfig config,
                                 BookKeeper.DigestType digestType,
                                 AsyncCallback.CreateCallback cb,
                                 Map<String,byte[]> metadata)
```
    Create ledger async and schedule a timeout task to check ledger-creation is complete else it fails the callback with TimeoutException.
    
    Parameters:
    
    bookKeeper -
    
    config -
    
    digestType -
    
    cb -
    
    metadata -
  - getClock
```
public Clock getClock()
```
  - checkAndCompleteLedgerOpTask
```
protected boolean checkAndCompleteLedgerOpTask(int rc,
                                               LedgerHandle lh,
                                               Object ctx)
```
    check if ledger-op task is already completed by timeout-task. If completed then delete the created ledger
    
    Parameters:
    
    rc -
    
    lh -
    
    ctx -
    
    Returns:
  - getOffloadedSize
```
public long getOffloadedSize()
```
    Description copied from interface: ManagedLedger
    
    Return the size of all ledgers offloaded to 2nd tier storage
    
    Specified by:
    
    getOffloadedSize in interface ManagedLedger
  - getLastOffloadedLedgerId
```
public long getLastOffloadedLedgerId()
```
    Description copied from interface: ManagedLedger
    
    Get last offloaded ledgerId. If no offloaded yet, it returns 0.
    
    Specified by:
    
    getLastOffloadedLedgerId in interface ManagedLedger
    
    Returns:
    
    last offloaded ledgerId
  - getLastOffloadedSuccessTimestamp
```
public long getLastOffloadedSuccessTimestamp()
```
    Description copied from interface: ManagedLedger
    
    Get last suceessful offloaded timestamp. If no successful offload, it returns 0.
    
    Specified by:
    
    getLastOffloadedSuccessTimestamp in interface ManagedLedger
    
    Returns:
    
    last successful offloaded timestamp
  - getLastOffloadedFailureTimestamp
```
public long getLastOffloadedFailureTimestamp()
```
    Description copied from interface: ManagedLedger
    
    Get last failed offloaded timestamp. If no failed offload, it returns 0.
    
    Specified by:
    
    getLastOffloadedFailureTimestamp in interface ManagedLedger
    
    Returns:
    
    last failed offloaded timestamp
  - getProperties
```
public Map<String,String> getProperties()
```
    Description copied from interface: ManagedLedger
    
    Returns managed-ledger's properties.
    
    Specified by:
    
    getProperties in interface ManagedLedger
    
    Returns:
    
    key-values of properties
  - setProperty
```
public void setProperty(String key,
                        String value)
                 throws InterruptedException,
                        ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Add key-value to propertiesMap.
    
    Specified by:
    
    setProperty in interface ManagedLedger
    
    Parameters:
    
    key - key of property to add
    
    value - value of property to add
    
    Throws:
    
    InterruptedException
    
    ManagedLedgerException
  - asyncSetProperty
```
public void asyncSetProperty(String key,
                             String value,
                             AsyncCallbacks.UpdatePropertiesCallback callback,
                             Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Async add key-value to propertiesMap.
    
    Specified by:
    
    asyncSetProperty in interface ManagedLedger
    
    Parameters:
    
    key - key of property to add
    
    value - value of property to add
    
    callback - a callback which will be supplied with the newest properties in managedLedger.
    
    ctx - a context object which will be passed to the callback on completion.
  - deleteProperty
```
public void deleteProperty(String key)
                    throws InterruptedException,
                           ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Delete the property by key.
    
    Specified by:
    
    deleteProperty in interface ManagedLedger
    
    Parameters:
    
    key - key of property to delete
    
    Throws:
    
    InterruptedException
    
    ManagedLedgerException
  - asyncDeleteProperty
```
public void asyncDeleteProperty(String key,
                                AsyncCallbacks.UpdatePropertiesCallback callback,
                                Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Async delete the property by key.
    
    Specified by:
    
    asyncDeleteProperty in interface ManagedLedger
    
    Parameters:
    
    key - key of property to delete
    
    callback - a callback which will be supplied with the newest properties in managedLedger.
    
    ctx - a context object which will be passed to the callback on completion.
  - setProperties
```
public void setProperties(Map<String,String> properties)
                   throws InterruptedException,
                          ManagedLedgerException
```
    Description copied from interface: ManagedLedger
    
    Update managed-ledger's properties.
    
    Specified by:
    
    setProperties in interface ManagedLedger
    
    Parameters:
    
    properties - key-values of properties
    
    Throws:
    
    InterruptedException
    
    ManagedLedgerException
  - asyncSetProperties
```
public void asyncSetProperties(Map<String,String> properties,
                               AsyncCallbacks.UpdatePropertiesCallback callback,
                               Object ctx)
```
    Description copied from interface: ManagedLedger
    
    Async update managed-ledger's properties.
    
    Specified by:
    
    asyncSetProperties in interface ManagedLedger
    
    Parameters:
    
    properties - key-values of properties.
    
    callback - a callback which will be supplied with the newest properties in managedLedger.
    
    ctx - a context object which will be passed to the callback on completion.
  - setEntriesAddedCounter
```
public void setEntriesAddedCounter(long count)
```
  - asyncTruncate
```
public CompletableFuture<Void> asyncTruncate()
```
    Description copied from interface: ManagedLedger
    
    Truncate ledgers The truncate operation will move all cursors to the end of the topic and delete all inactive ledgers.
    
    Specified by:
    
    asyncTruncate in interface ManagedLedger
  - getManagedLedgerInternalStats
```
public CompletableFuture<ManagedLedgerInternalStats> getManagedLedgerInternalStats(boolean includeLedgerMetadata)
```
    Description copied from interface: ManagedLedger
    
    Get managed ledger internal stats
    
    Specified by:
    
    getManagedLedgerInternalStats in interface ManagedLedger
    
    Parameters:
    
    includeLedgerMetadata - the flag to control managed ledger internal stats include ledger metadata
    
    Returns:
    
    the future of managed ledger internal stats
  - getEnsemblesAsync
```
public CompletableFuture<Set<org.apache.bookkeeper.net.BookieId>> getEnsemblesAsync(long ledgerId)
```

Class ManagedLedgerImpl

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

AsyncOperationTimeoutSeconds

bookKeeper

name

config

propertiesMap

store

ledgers

mlOwnershipChecker

DEFAULT_LEDGER_DELETE_RETRIES

DEFAULT_LEDGER_DELETE_BACKOFF_TIME_SEC

state

mbean

clock

ADD_OP_COUNT_UPDATER

Constructor Detail

ManagedLedgerImpl

ManagedLedgerImpl

Method Detail

getName

addEntry

addEntry

addEntry

addEntry

asyncAddEntry

asyncAddEntry

asyncAddEntry

asyncAddEntry

asyncAddEntry

readyToCreateNewLedger

openCursor

openCursor

openCursor

asyncOpenCursor

asyncOpenCursor

asyncOpenCursor

asyncDeleteCursor

deleteCursor

newNonDurableCursor

newNonDurableCursor

newNonDurableCursor

getCursors

getActiveCursors

hasActiveCursors

getNumberOfEntries

getNumberOfActiveEntries

getTotalSize

getEstimatedBacklogSize

getEarliestMessagePublishTimeInBacklog

getEarliestMessagePublishTimeOfPos

getEstimatedBacklogSize

asyncTerminate

terminate

isTerminated

close

asyncClose

createComplete

updateLedgersIdsComplete

rollCurrentLedgerIfFull

asyncFindPosition

getManagedLedgerInterceptor

getLedgerMetadata

getLedgerInfo

asyncReadEntry

asyncReadEntry

asyncReadEntry

getStats

hasMoreEntries

addWaitingEntryCallBack

maybeUpdateCursorBeforeTrimmingConsumedLedger

trimConsumedLedgersInBackground

trimConsumedLedgersInBackground

delete

asyncDelete