ManagedLedgerConfig (Managed Ledger 2.10.0-rc-202201102205 API)

java.lang.Object
- org.apache.bookkeeper.mledger.ManagedLedgerConfig

@InterfaceAudience.LimitedPrivate
 @InterfaceStability.Stable
public class ManagedLedgerConfig
extends Object

Configuration class for a ManagedLedger.

Constructor Summary

Constructors
Constructor and Description

ManagedLedgerConfig()

Constructors
Constructor and Description
`ManagedLedgerConfig()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`getAckQuorumSize()`
`long`	`getAddEntryTimeoutSeconds()`
`Class<? extends EnsemblePlacementPolicy>`	`getBookKeeperEnsemblePlacementPolicyClassName()` Managed-ledger can setup different custom EnsemblePlacementPolicy (eg: affinity to write ledgers to only setup of group of bookies).
`Map<String,Object>`	`getBookKeeperEnsemblePlacementPolicyProperties()` Returns properties required by configured bookKeeperEnsemblePlacementPolicy.
`Clock`	`getClock()` Get clock to use to time operations
`org.apache.bookkeeper.client.api.DigestType`	`getDigestType()`
`int`	`getEnsembleSize()`
`LedgerOffloader`	`getLedgerOffloader()` Get ledger offloader which will be used to offload ledgers to longterm storage.
`int`	`getLedgerRolloverTimeout()`
`ManagedLedgerInterceptor`	`getManagedLedgerInterceptor()`
`int`	`getMaxBatchDeletedIndexToPersist()`
`int`	`getMaxEntriesPerLedger()`
`long`	`getMaximumRolloverTimeMs()`
`int`	`getMaxSizePerLedgerMb()`
`int`	`getMaxUnackedRangesToPersist()`
`int`	`getMaxUnackedRangesToPersistInZk()`
`int`	`getMetadataAckQuorumSize()`
`int`	`getMetadataEnsemblesize()`
`int`	`getMetadataMaxEntriesPerLedger()`
`long`	`getMetadataOperationsTimeoutSeconds()` Ledger-Op (Create/Delete) timeout
`int`	`getMetadataWriteQuorumSize()`
`int`	`getMinimumRolloverTimeMs()`
`int`	`getNewEntriesCheckDelayInMillis()`
`byte[]`	`getPassword()`
`long`	`getReadEntryTimeoutSeconds()` Ledger read-entry timeout
`long`	`getRetentionSizeInMB()`
`long`	`getRetentionTimeMillis()`
`double`	`getThrottleMarkDelete()`
`int`	`getWriteQuorumSize()`
`boolean`	`isAutoSkipNonRecoverableData()` Skip reading non-recoverable/unreadable data-ledger under managed-ledger's list.
`boolean`	`isCreateIfMissing()`
`boolean`	`isDeletionAtBatchIndexLevelEnabled()`
`boolean`	`isLazyCursorRecovery()`
`boolean`	`isUnackedRangesOpenCacheSetEnabled()` should use `ConcurrentOpenLongPairRangeSet` to store unacked ranges.
`ManagedLedgerConfig`	`setAckQuorumSize(int ackQuorumSize)`
`ManagedLedgerConfig`	`setAddEntryTimeoutSeconds(long addEntryTimeoutSeconds)` Add-entry timeout after which add-entry callback will be failed if add-entry is not succeeded.
`void`	`setAutoSkipNonRecoverableData(boolean skipNonRecoverableData)`
`void`	`setBookKeeperEnsemblePlacementPolicyClassName(Class<? extends EnsemblePlacementPolicy> bookKeeperEnsemblePlacementPolicyClassName)` Returns EnsemblePlacementPolicy configured for the Managed-ledger.
`void`	`setBookKeeperEnsemblePlacementPolicyProperties(Map<String,Object> bookKeeperEnsemblePlacementPolicyProperties)` Managed-ledger can setup different custom EnsemblePlacementPolicy which needs bookKeeperEnsemblePlacementPolicy-Properties.
`ManagedLedgerConfig`	`setClock(Clock clock)` Set clock to use for time operations
`ManagedLedgerConfig`	`setCreateIfMissing(boolean createIfMissing)`
`void`	`setDeletionAtBatchIndexLevelEnabled(boolean deletionAtBatchIndexLevelEnabled)`
`ManagedLedgerConfig`	`setDigestType(org.apache.bookkeeper.client.api.DigestType digestType)`
`ManagedLedgerConfig`	`setEnsembleSize(int ensembleSize)`
`ManagedLedgerConfig`	`setLazyCursorRecovery(boolean lazyCursorRecovery)` Whether to recover cursors lazily when trying to recover a managed ledger backing a persistent topic.
`ManagedLedgerConfig`	`setLedgerOffloader(LedgerOffloader offloader)` Set ledger offloader to use for offloading ledgers to longterm storage.
`ManagedLedgerConfig`	`setLedgerRolloverTimeout(int ledgerRolloverTimeout)`
`void`	`setManagedLedgerInterceptor(ManagedLedgerInterceptor managedLedgerInterceptor)`
`ManagedLedgerConfig`	`setMaxEntriesPerLedger(int maxEntriesPerLedger)`
`void`	`setMaximumRolloverTime(int maximumRolloverTime, TimeUnit unit)` Set the maximum rollover time for ledgers in this managed ledger.
`ManagedLedgerConfig`	`setMaxSizePerLedgerMb(int maxSizePerLedgerMb)`
`ManagedLedgerConfig`	`setMaxUnackedRangesToPersist(int maxUnackedRangesToPersist)`
`void`	`setMaxUnackedRangesToPersistInZk(int maxUnackedRangesToPersistInZk)`
`ManagedLedgerConfig`	`setMetadataAckQuorumSize(int metadataAckQuorumSize)`
`ManagedLedgerConfig`	`setMetadataEnsembleSize(int metadataEnsembleSize)`
`ManagedLedgerConfig`	`setMetadataMaxEntriesPerLedger(int metadataMaxEntriesPerLedger)`
`ManagedLedgerConfig`	`setMetadataOperationsTimeoutSeconds(long metadataOperationsTimeoutSeconds)` Ledger-Op (Create/Delete) timeout after which callback will be completed with failure
`ManagedLedgerConfig`	`setMetadataWriteQuorumSize(int metadataWriteQuorumSize)`
`void`	`setMinimumRolloverTime(int minimumRolloverTime, TimeUnit unit)` Set the minimum rollover time for ledgers in this managed ledger.
`void`	`setNewEntriesCheckDelayInMillis(int newEntriesCheckDelayInMillis)`
`ManagedLedgerConfig`	`setPassword(String password)`
`ManagedLedgerConfig`	`setReadEntryTimeoutSeconds(long readEntryTimeoutSeconds)` Ledger read entry timeout after which callback will be completed with failure.
`ManagedLedgerConfig`	`setRetentionSizeInMB(long retentionSizeInMB)` The retention size is used to set a maximum retention size quota on the ManagedLedger.
`ManagedLedgerConfig`	`setRetentionTime(int retentionTime, TimeUnit unit)` Set the retention time for the ManagedLedger.
`ManagedLedgerConfig`	`setThrottleMarkDelete(double throttleMarkDelete)` Set the rate limiter on how many mark-delete calls per second are allowed.
`ManagedLedgerConfig`	`setUnackedRangesOpenCacheSetEnabled(boolean unackedRangesOpenCacheSetEnabled)`
`ManagedLedgerConfig`	`setWriteQuorumSize(int writeQuorumSize)`

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

- Constructor Detail
  - ManagedLedgerConfig
```
public ManagedLedgerConfig()
```
- Method Detail
  - isCreateIfMissing
```
public boolean isCreateIfMissing()
```
  - setCreateIfMissing
```
public ManagedLedgerConfig setCreateIfMissing(boolean createIfMissing)
```
  - isLazyCursorRecovery
```
public boolean isLazyCursorRecovery()
```
    Returns:
    
    the lazyCursorRecovery
  - setLazyCursorRecovery
```
public ManagedLedgerConfig setLazyCursorRecovery(boolean lazyCursorRecovery)
```
    Whether to recover cursors lazily when trying to recover a managed ledger backing a persistent topic. It can improve write availability of topics. The caveat is now when recovered ledger is ready to write we're not sure if all old consumers last mark delete position can be recovered or not.
    
    Parameters:
    
    lazyCursorRecovery - if enable lazy cursor recovery.
  - getMaxEntriesPerLedger
```
public int getMaxEntriesPerLedger()
```
    Returns:
    
    the maxEntriesPerLedger
  - setMaxEntriesPerLedger
```
public ManagedLedgerConfig setMaxEntriesPerLedger(int maxEntriesPerLedger)
```
    Parameters:
    
    maxEntriesPerLedger - the maxEntriesPerLedger to set
  - getMaxSizePerLedgerMb
```
public int getMaxSizePerLedgerMb()
```
    Returns:
    
    the maxSizePerLedgerMb
  - setMaxSizePerLedgerMb
```
public ManagedLedgerConfig setMaxSizePerLedgerMb(int maxSizePerLedgerMb)
```
    Parameters:
    
    maxSizePerLedgerMb - the maxSizePerLedgerMb to set
  - getMinimumRolloverTimeMs
```
public int getMinimumRolloverTimeMs()
```
    Returns:
    
    the minimum rollover time
  - setMinimumRolloverTime
```
public void setMinimumRolloverTime(int minimumRolloverTime,
                                   TimeUnit unit)
```
    Set the minimum rollover time for ledgers in this managed ledger.
    If this time is > 0, a ledger will not be rolled over more frequently than the specified time, even if it has reached the maximum number of entries or maximum size. This parameter can be used to reduce the amount of rollovers on managed ledger with high write throughput.
    
    Parameters:
    
    minimumRolloverTime - the minimum rollover time
    
    unit - the time unit
  - getMaximumRolloverTimeMs
```
public long getMaximumRolloverTimeMs()
```
    Returns:
    
    the maximum rollover time.
  - setMaximumRolloverTime
```
public void setMaximumRolloverTime(int maximumRolloverTime,
                                   TimeUnit unit)
```
    Set the maximum rollover time for ledgers in this managed ledger.
    If the ledger is not rolled over until this time, even if it has not reached the number of entry or size limit, this setting will trigger rollover. This parameter can be used for topics with low request rate to force rollover, so recovery failure does not have to go far back.
    
    Parameters:
    
    maximumRolloverTime - the maximum rollover time
    
    unit - the time unit
  - getEnsembleSize
```
public int getEnsembleSize()
```
    Returns:
    
    the ensembleSize
  - setEnsembleSize
```
public ManagedLedgerConfig setEnsembleSize(int ensembleSize)
```
    Parameters:
    
    ensembleSize - the ensembleSize to set
  - getAckQuorumSize
```
public int getAckQuorumSize()
```
    Returns:
    
    the ackQuorumSize
  - getWriteQuorumSize
```
public int getWriteQuorumSize()
```
    Returns:
    
    the writeQuorumSize
  - setWriteQuorumSize
```
public ManagedLedgerConfig setWriteQuorumSize(int writeQuorumSize)
```
    Parameters:
    
    writeQuorumSize - the writeQuorumSize to set
  - setAckQuorumSize
```
public ManagedLedgerConfig setAckQuorumSize(int ackQuorumSize)
```
    Parameters:
    
    ackQuorumSize - the ackQuorumSize to set
  - getDigestType
```
public org.apache.bookkeeper.client.api.DigestType getDigestType()
```
    Returns:
    
    the digestType
  - setDigestType
```
public ManagedLedgerConfig setDigestType(org.apache.bookkeeper.client.api.DigestType digestType)
```
    Parameters:
    
    digestType - the digestType to set
  - getPassword
```
public byte[] getPassword()
```
    Returns:
    
    the password
  - setPassword
```
public ManagedLedgerConfig setPassword(String password)
```
    Parameters:
    
    password - the password to set
  - isUnackedRangesOpenCacheSetEnabled
```
public boolean isUnackedRangesOpenCacheSetEnabled()
```
    should use ConcurrentOpenLongPairRangeSet to store unacked ranges.
    
    Returns:
  - setUnackedRangesOpenCacheSetEnabled
```
public ManagedLedgerConfig setUnackedRangesOpenCacheSetEnabled(boolean unackedRangesOpenCacheSetEnabled)
```
  - getMetadataEnsemblesize
```
public int getMetadataEnsemblesize()
```
    Returns:
    
    the metadataEnsemblesize
  - setMetadataEnsembleSize
```
public ManagedLedgerConfig setMetadataEnsembleSize(int metadataEnsembleSize)
```
    Parameters:
    
    metadataEnsembleSize - the metadataEnsembleSize to set
  - getMetadataAckQuorumSize
```
public int getMetadataAckQuorumSize()
```
    Returns:
    
    the metadataAckQuorumSize
  - getMetadataWriteQuorumSize
```
public int getMetadataWriteQuorumSize()
```
    Returns:
    
    the metadataWriteQuorumSize
  - setMetadataAckQuorumSize
```
public ManagedLedgerConfig setMetadataAckQuorumSize(int metadataAckQuorumSize)
```
    Parameters:
    
    metadataAckQuorumSize - the metadataAckQuorumSize to set
  - setMetadataWriteQuorumSize
```
public ManagedLedgerConfig setMetadataWriteQuorumSize(int metadataWriteQuorumSize)
```
    Parameters:
    
    metadataWriteQuorumSize - the metadataWriteQuorumSize to set
  - getMetadataMaxEntriesPerLedger
```
public int getMetadataMaxEntriesPerLedger()
```
    Returns:
    
    the metadataMaxEntriesPerLedger
  - setMetadataMaxEntriesPerLedger
```
public ManagedLedgerConfig setMetadataMaxEntriesPerLedger(int metadataMaxEntriesPerLedger)
```
    Parameters:
    
    metadataMaxEntriesPerLedger - the metadataMaxEntriesPerLedger to set
  - getLedgerRolloverTimeout
```
public int getLedgerRolloverTimeout()
```
    Returns:
    
    the ledgerRolloverTimeout
  - setLedgerRolloverTimeout
```
public ManagedLedgerConfig setLedgerRolloverTimeout(int ledgerRolloverTimeout)
```
    Parameters:
    
    ledgerRolloverTimeout - the ledgerRolloverTimeout to set
  - getThrottleMarkDelete
```
public double getThrottleMarkDelete()
```
    Returns:
    
    the throttling rate limit for mark-delete calls
  - setThrottleMarkDelete
```
public ManagedLedgerConfig setThrottleMarkDelete(double throttleMarkDelete)
```
    Set the rate limiter on how many mark-delete calls per second are allowed. If the value is set to 0, the rate limiter is disabled. Default is 0.
    
    Parameters:
    
    throttleMarkDelete - the max number of mark-delete calls allowed per second
  - setRetentionTime
```
public ManagedLedgerConfig setRetentionTime(int retentionTime,
                                            TimeUnit unit)
```
    Set the retention time for the ManagedLedger.
    Retention time and retention size (setRetentionSizeInMB(long)) are together used to retain the ledger data when when there are no cursors or when all the cursors have marked the data for deletion. Data will be deleted in this case when both retention time and retention size settings don't prevent deleting the data marked for deletion.
    A retention time of 0 (default) will make data to be deleted immediately.
    A retention time of -1 , means to have an unlimited retention time.
    
    Parameters:
    
    retentionTime - duration for which messages should be retained
    
    unit - time unit for retention time
  - getRetentionTimeMillis
```
public long getRetentionTimeMillis()
```
    Returns:
    
    duration for which messages are retained
  - setRetentionSizeInMB
```
public ManagedLedgerConfig setRetentionSizeInMB(long retentionSizeInMB)
```
    The retention size is used to set a maximum retention size quota on the ManagedLedger.
    Retention size and retention time (setRetentionTime(int, TimeUnit)) are together used to retain the ledger data when when there are no cursors or when all the cursors have marked the data for deletion. Data will be deleted in this case when both retention time and retention size settings don't prevent deleting the data marked for deletion.
    A retention size of 0 (default) will make data to be deleted immediately.
    A retention size of -1 , means to have an unlimited retention size.
    
    Parameters:
    
    retentionSizeInMB - quota for message retention
  - getRetentionSizeInMB
```
public long getRetentionSizeInMB()
```
    Returns:
    
    quota for message retention
  - isAutoSkipNonRecoverableData
```
public boolean isAutoSkipNonRecoverableData()
```
    Skip reading non-recoverable/unreadable data-ledger under managed-ledger's list. It helps when data-ledgers gets corrupted at bookkeeper and managed-cursor is stuck at that ledger.
  - setAutoSkipNonRecoverableData
```
public void setAutoSkipNonRecoverableData(boolean skipNonRecoverableData)
```
  - getMaxUnackedRangesToPersist
```
public int getMaxUnackedRangesToPersist()
```
    Returns:
    
    max unacked message ranges that will be persisted and recovered.
  - getMaxBatchDeletedIndexToPersist
```
public int getMaxBatchDeletedIndexToPersist()
```
    Returns:
    
    max batch deleted index that will be persisted and recoverd.
  - setMaxUnackedRangesToPersist
```
public ManagedLedgerConfig setMaxUnackedRangesToPersist(int maxUnackedRangesToPersist)
```
    Parameters:
    
    maxUnackedRangesToPersist - max unacked message ranges that will be persisted and receverd.
  - getMaxUnackedRangesToPersistInZk
```
public int getMaxUnackedRangesToPersistInZk()
```
    Returns:
    
    max unacked message ranges up to which it can store in Zookeeper
  - setMaxUnackedRangesToPersistInZk
```
public void setMaxUnackedRangesToPersistInZk(int maxUnackedRangesToPersistInZk)
```
  - getLedgerOffloader
```
public LedgerOffloader getLedgerOffloader()
```
    Get ledger offloader which will be used to offload ledgers to longterm storage. The default offloader throws an exception on any attempt to offload.
    
    Returns:
    
    a ledger offloader
  - setLedgerOffloader
```
public ManagedLedgerConfig setLedgerOffloader(LedgerOffloader offloader)
```
    Set ledger offloader to use for offloading ledgers to longterm storage.
    
    Parameters:
    
    offloader - the ledger offloader to use
  - getClock
```
public Clock getClock()
```
    Get clock to use to time operations
    
    Returns:
    
    a clock
  - setClock
```
public ManagedLedgerConfig setClock(Clock clock)
```
    Set clock to use for time operations
    
    Parameters:
    
    clock - the clock to use
  - getMetadataOperationsTimeoutSeconds
```
public long getMetadataOperationsTimeoutSeconds()
```
    Ledger-Op (Create/Delete) timeout
    
    Returns:
  - setMetadataOperationsTimeoutSeconds
```
public ManagedLedgerConfig setMetadataOperationsTimeoutSeconds(long metadataOperationsTimeoutSeconds)
```
    Ledger-Op (Create/Delete) timeout after which callback will be completed with failure
    
    Parameters:
    
    metadataOperationsTimeoutSeconds -
  - getReadEntryTimeoutSeconds
```
public long getReadEntryTimeoutSeconds()
```
    Ledger read-entry timeout
    
    Returns:
  - setReadEntryTimeoutSeconds
```
public ManagedLedgerConfig setReadEntryTimeoutSeconds(long readEntryTimeoutSeconds)
```
    Ledger read entry timeout after which callback will be completed with failure. (disable timeout by setting readTimeoutSeconds <= 0)
    
    Parameters:
    
    readEntryTimeoutSeconds -
    
    Returns:
  - getAddEntryTimeoutSeconds
```
public long getAddEntryTimeoutSeconds()
```
  - setAddEntryTimeoutSeconds
```
public ManagedLedgerConfig setAddEntryTimeoutSeconds(long addEntryTimeoutSeconds)
```
    Add-entry timeout after which add-entry callback will be failed if add-entry is not succeeded.
    
    Parameters:
    
    addEntryTimeoutSeconds -
  - getBookKeeperEnsemblePlacementPolicyClassName
```
public Class<? extends EnsemblePlacementPolicy> getBookKeeperEnsemblePlacementPolicyClassName()
```
    Managed-ledger can setup different custom EnsemblePlacementPolicy (eg: affinity to write ledgers to only setup of group of bookies).
    
    Returns:
  - setBookKeeperEnsemblePlacementPolicyClassName
```
public void setBookKeeperEnsemblePlacementPolicyClassName(Class<? extends EnsemblePlacementPolicy> bookKeeperEnsemblePlacementPolicyClassName)
```
    Returns EnsemblePlacementPolicy configured for the Managed-ledger.
    
    Parameters:
    
    bookKeeperEnsemblePlacementPolicyClassName -
  - getBookKeeperEnsemblePlacementPolicyProperties
```
public Map<String,Object> getBookKeeperEnsemblePlacementPolicyProperties()
```
    Returns properties required by configured bookKeeperEnsemblePlacementPolicy.
    
    Returns:
  - setBookKeeperEnsemblePlacementPolicyProperties
```
public void setBookKeeperEnsemblePlacementPolicyProperties(Map<String,Object> bookKeeperEnsemblePlacementPolicyProperties)
```
    Managed-ledger can setup different custom EnsemblePlacementPolicy which needs bookKeeperEnsemblePlacementPolicy-Properties.
    
    Parameters:
    
    bookKeeperEnsemblePlacementPolicyProperties -
  - isDeletionAtBatchIndexLevelEnabled
```
public boolean isDeletionAtBatchIndexLevelEnabled()
```
  - setDeletionAtBatchIndexLevelEnabled
```
public void setDeletionAtBatchIndexLevelEnabled(boolean deletionAtBatchIndexLevelEnabled)
```
  - getNewEntriesCheckDelayInMillis
```
public int getNewEntriesCheckDelayInMillis()
```
  - setNewEntriesCheckDelayInMillis
```
public void setNewEntriesCheckDelayInMillis(int newEntriesCheckDelayInMillis)
```
  - getManagedLedgerInterceptor
```
public ManagedLedgerInterceptor getManagedLedgerInterceptor()
```
  - setManagedLedgerInterceptor
```
public void setManagedLedgerInterceptor(ManagedLedgerInterceptor managedLedgerInterceptor)
```

Class ManagedLedgerConfig

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ManagedLedgerConfig

Method Detail

isCreateIfMissing

setCreateIfMissing

isLazyCursorRecovery

setLazyCursorRecovery

getMaxEntriesPerLedger

setMaxEntriesPerLedger

getMaxSizePerLedgerMb

setMaxSizePerLedgerMb

getMinimumRolloverTimeMs

setMinimumRolloverTime

getMaximumRolloverTimeMs

setMaximumRolloverTime

getEnsembleSize

setEnsembleSize

getAckQuorumSize

getWriteQuorumSize

setWriteQuorumSize

setAckQuorumSize

getDigestType

setDigestType

getPassword

setPassword

isUnackedRangesOpenCacheSetEnabled

setUnackedRangesOpenCacheSetEnabled

getMetadataEnsemblesize

setMetadataEnsembleSize

getMetadataAckQuorumSize

getMetadataWriteQuorumSize

setMetadataAckQuorumSize

setMetadataWriteQuorumSize

getMetadataMaxEntriesPerLedger

setMetadataMaxEntriesPerLedger

getLedgerRolloverTimeout

setLedgerRolloverTimeout

getThrottleMarkDelete

setThrottleMarkDelete

setRetentionTime

getRetentionTimeMillis

setRetentionSizeInMB

getRetentionSizeInMB

isAutoSkipNonRecoverableData

setAutoSkipNonRecoverableData

getMaxUnackedRangesToPersist

getMaxBatchDeletedIndexToPersist

setMaxUnackedRangesToPersist

getMaxUnackedRangesToPersistInZk

setMaxUnackedRangesToPersistInZk

getLedgerOffloader

setLedgerOffloader

getClock

setClock

getMetadataOperationsTimeoutSeconds

setMetadataOperationsTimeoutSeconds

getReadEntryTimeoutSeconds

setReadEntryTimeoutSeconds

getAddEntryTimeoutSeconds

setAddEntryTimeoutSeconds

getBookKeeperEnsemblePlacementPolicyClassName

setBookKeeperEnsemblePlacementPolicyClassName

getBookKeeperEnsemblePlacementPolicyProperties

setBookKeeperEnsemblePlacementPolicyProperties

isDeletionAtBatchIndexLevelEnabled

setDeletionAtBatchIndexLevelEnabled

getNewEntriesCheckDelayInMillis

setNewEntriesCheckDelayInMillis

getManagedLedgerInterceptor

setManagedLedgerInterceptor