RepImpl (starrocks-bdb-je 18.3.17 API)

java.lang.Object
- com.sleepycat.je.dbi.EnvironmentImpl
- - com.sleepycat.je.rep.impl.RepImpl

All Implemented Interfaces:: EnvConfigObserver, RepEnvConfigObserver

public class RepImpl
extends EnvironmentImpl
implements RepEnvConfigObserver

Nested Class Summary
- Nested classes/interfaces inherited from class com.sleepycat.je.dbi.EnvironmentImpl
  EnvironmentImpl.MBeanRegistrar

Field Summary
- Fields inherited from class com.sleepycat.je.dbi.EnvironmentImpl
  configManager, dbMapTree, envInternal, envLogger, formatter, needRepConvert, startupTracker, statKey, statManager, USE_JAVA5_ADLER32

Constructor Summary

Constructors
Constructor and Description

RepImpl(File envHome, EnvironmentConfig envConfig, EnvironmentImpl sharedCacheEnv, RepConfigProxy repConfigProxy)

Constructors
Constructor and Description
`RepImpl(File envHome, EnvironmentConfig envConfig, EnvironmentImpl sharedCacheEnv, RepConfigProxy repConfigProxy)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abnormalClose()` Used by error handling to forcibly close an environment, and by tests to close an environment to simulate a crash.
`boolean`	`addDbBackup(DbBackup backup)` For replicated environments only; just return true for a standalone environment.
`void`	`addRepConfigObserver(RepEnvConfigObserver o)`
`VLSN`	`assignVLSNs(LogEntry entry)` {@literal Generate the next VLSN and update the DTVLSN value in the item.
`void`	`awaitVLSNConsistency()` Ensure that the in-memory vlsn index encompasses all logged entries before it is flushed to disk.
`void`	`blockTxnCompletion(CountDownLatch blocker)` Installs the commit-blocking latch that is used to halt the commit/abort of transactions, in the final phase of a master transfer.
`void`	`checkIfMaster(Locker locker)` Ensures that the environment is currently a Master before proceeding with an operation that requires it to be the master.
`void`	`checkRecordExtinctionAvailable()` Checks that using the record extinction feature.
`void`	`checkRulesForExistingEnv(boolean dbTreeReplicatedBit, boolean dbTreePreserveVLSN)` Check whether this environment can be opened on an existing environment directory.
`void`	`checkTTLAvailable()` Checks that writing records with a TTL is allowed.
`void`	`clearedCachedFileChecksum(String fileName)` Clears the cached checksum for a file when it may be overwritten (e.g., entries may be erased).
`ReplicationConfig`	`cloneRepConfig()`
`ReplicationMutableConfig`	`cloneRepMutableConfig()`
`DatabasePreemptedException`	`createDatabasePreemptedException(String msg, String dbName, Database db)` For replicated environments only; only the overridden method should ever be called.
`DatabaseImpl`	`createGroupDb()` Called when a node has identified itself as the master, which is when the RepNode.selfElect is called.
`protected Environment`	`createInternalEnvironment()` Is overridden in RepImpl to create a ReplicatedEnvironment.
`LockPreemptedException`	`createLockPreemptedException(Locker locker, Throwable cause)` For replicated environments only; only the overridden method should ever be called.
`LogOverwriteException`	`createLogOverwriteException(String msg)` For replicated environments only; only the overridden method should ever be called.
`Txn`	`createReplayTxn(long txnId)` Create a ReplayTxn for recovery processing.
`ThreadLocker`	`createRepThreadLocker()` Create an appropriate type of ThreadLocker.
`Txn`	`createRepUserTxn(TransactionConfig config)` Create an appropriate type of Replicated transaction.
`StatManager`	`createStatManager()`
`void`	`doCloseAfterInvalid()` This method must be called while synchronized on DbEnvPool.
`String`	`dumpAckFeederState()` Dumps the state associated with all active Feeders that supply acknowledgments, along with identifying information about the node and its current HA state.
`String`	`dumpState()` Dump interesting aspects of the node's state.
`boolean`	`getAllowRepConvert()` True if ReplicationConfig set allowConvert as true.
`StreamAuthenticator`	`getAuthenticator()`
`boolean`	`getCacheVLSN()` Returns true if the VLSN is both preserved and cached.
`StateChangeListener`	`getChangeListener()`
`DataChannelFactory`	`getChannelFactory()`
`static int`	`getClockSkewMs()`
`ReplicaConsistencyPolicy`	`getConsistencyPolicy(String propValue)` Allows standalone JE code to construct a consistency policy using the CONSISTENCY_POLICY property value format.
`JEVersion`	`getCurrentJEVersion()` Returns the JE version that is currently running on this node, consulting the TEST_JE_VERSION configuration parameter for a test override.
`ReplicaConsistencyPolicy`	`getDefaultConsistencyPolicy()` Returns the default consistency policy for this EnvironmentImpl.
`String`	`getDiagnosticsClassName()`
`long`	`getEndOfLog()` Returns the end of the log.
`Set<MasterTxn>`	`getExistingMasterTxns()` Peruse the environment wide transaction table, and return a set of all existing MasterTxns.
`DataChannelFactory.ConnectOptions`	`getFeederConnectOptions()` Returns the options used to configure the feeder channel connection.
`FeederFilter`	`getFeederFilter()`
`FeederTxns`	`getFeederTxns()`
`DatabaseImpl`	`getGroupDb()` Open the group db, which should exist already, using NO_CONSISTENCY.
`Set<InetSocketAddress>`	`getHelperSockets()` Returns the set of sockets associated with helper nodes.
`InetSocketAddress`	`getHostAddress()` Returns the socket address associated with this node, with a port of zero suitable for binding locally to any free port associated with the address.
`String`	`getHostName()` Returns the hostname associated with this node.
`boolean`	`getIsMaster()` Returns whether this is a replicated environment that is the master, else false.
`VLSN`	`getLastTxnEnd()`
`long`	`getLoggedDTVLSN()` Returns the logged durable txn VLSN.
`LogFileRewriteListener`	`getLogRewriteListener()`
`String`	`getMonitorClassName()`
`String`	`getName()` Get an environment name, for tagging onto logging and debug message.
`NameIdPair`	`getNameIdPair()`
`int`	`getNodeId()`
`String`	`getNodeName()` Get the node name if this is a replicated environment or else return null.
`NodeState`	`getNodeState()`
`StatGroup`	`getNodeStats()`
`int`	`getPort()` Returns the port used by the replication node.
`boolean`	`getPreserveVLSN()` Returns true if the VLSN is preserved as the record version.
`Replay`	`getReplay()`
`int`	`getReplayFreeDiskPercent()` Returns the deprecated HA REPLAY_FREE_DISK_PERCENT parameter, or zero if this is not an HA env.
`long`	`getReplayTxnTimeout()`
`ReplicationNetworkConfig`	`getRepNetConfig()`
`RepNode`	`getRepNode()`
`Collection<StatGroup>`	`getRepStatGroups(StatsConfig config, Integer statKey1)`
`InetSocketAddress`	`getSocket()`
`SortedSet<String>`	`getStatCaptureProjections()`
`ReplicatedEnvironment.State`	`getState()` Returns the current state associated with this ReplicatedEnvironment
`StateChangeEvent`	`getStateChangeEvent()` Returns the state change event that transitioned the ReplicatedEnviroment to its current state.
`ReplicatedEnvironmentStats`	`getStats(StatsConfig config)`
`ReplicatedEnvironmentStats`	`getStats(StatsConfig config, Integer contextKey)`
`ReplicatedEnvironmentStats`	`getStatsInternal(StatsConfig config)`
`UUID`	`getUUID()`
`VLSNIndex`	`getVLSNIndex()`
`VLSNRecoveryProxy`	`getVLSNProxy()` Used by environment recovery to get a tracker to collect VLSN-LSN mappings that are within the recovery part of the log.
`void`	`handleRestoreRequired(RestoreRequired restoreRequired)` Recovery encountered a RestoreRequired marker.
`protected DbConfigManager`	`initConfigManager(EnvironmentConfig envConfig, RepConfigProxy repConfigProxy)` Create a config manager that holds the configuration properties that have been passed in.
`protected void`	`initConfigParams(EnvironmentConfig envConfig, RepConfigProxy repConfigProxy)` Called by the EnvironmentImpl constructor.
`protected Formatter`	`initFormatter()`
`void`	`initializeChannelFactory()` Initialize the DataChannelFactory in our configuration for use.
`void`	`invalidate(EnvironmentFailureException e)` Invalidate the environment.
`void`	`invalidateBackups(long fileNumber)`
`boolean`	`isArbiter()` Return true if this environment is used as an Arbiter.
`boolean`	`isDesignatedPrimary()` Return true if the node has been configured as a Designated Primary.
`boolean`	`isMaster()`
`boolean`	`isReplicated()` Return true if this environment is part of a replication group.
`static boolean`	`isSimulatePreDTVLSNMaster()`
`ReplicatedEnvironment.State`	`joinGroup(ReplicaConsistencyPolicy consistency, QuorumPolicy initialElectionPolicy)` Wait for this node to join a replication group and return whether it is a MASTER or REPLICA.
`ReplicatedEnvironment`	`makeEnvironment()`
`protected void`	`postCheckpointClose(boolean checkpointed)` Close any resources that need to be closed after the closing checkpoint.
`void`	`postLogAbortHook(MasterTxn txn)` Releases the block latch lock, if held.
`void`	`postLogCommitAbortHook(MasterTxn txn)` Removes any pending acknowledgments that were registered by the preLogCommitHook.
`void`	`postLogCommitHook(MasterTxn txn, LogItem commitItem)` It ensures that the feeder obtains the requisite number of acknowledgments required for a successful commit.
`protected void`	`postRecoveryConversion()` Called after recovery but before any other initialization.
`void`	`preCheckpointEndFlush()` Flush any information that needs to go out at checkpoint.
`void`	`preLogAbortHook(MasterTxn txn)` Invoked before aborting a MasterTxn, this happens when the master is going to be a replica because of mastership transfer.
`void`	`preLogCommitHook(MasterTxn txn)` This hook is used primarily to perform the final checks before allowing the commit operation to proceed.
`void`	`preRecoveryCheckpointInit(RecoveryInfo recoveryInfo)` The VLSNIndex must be created, merged and flushed before the recovery checkpoint.
`DatabaseImpl`	`probeGroupDb()` Open the group db, which should exist already, using NO_CONSISTENCY.
`void`	`registerVLSN(LogItem logItem)` A replicated log entry has been written on this node.
`void`	`removeDbBackup(DbBackup backup)` For replicated environments only; do nothing for a standalone environment.
`void`	`repEnvConfigUpdate(RepConfigManager configMgr, ReplicationMutableConfig newConfig)` Notifies the observer that one or more mutable rep properties have been changed.
`protected DbConfigManager`	`resetConfigManager(EnvironmentConfig newConfig)` Make a new config manager that has all the properties needed.
`void`	`setAuthenticator(StreamAuthenticator authenticator)`
`void`	`setBackupProhibited(boolean backupProhibited)`
`void`	`setChangeListener(StateChangeListener listener)`
`void`	`setDefaultConsistencyPolicy(ReplicaConsistencyPolicy policy)` The default consistency is not currently mutable in the API, but can be set for testing purposes.
`void`	`setHardRecoveryInfo(RollbackException e)` If this node was started with a hard recovery, preserve that information.
`void`	`setReplicaLatestVLSNSeq(long seq)`
`void`	`setRepMutableConfig(ReplicationMutableConfig config)`
`static void`	`setSimulatePreDTVLSNMaster(boolean simulatePreDTVLSNMaster)` Test method to create pre-DTVLSN logs.
`static void`	`setSkewMs(int skewMs)` Used during testing to introduce artificial clock skews.
`void`	`setSyncupProgress(SyncupProgress progress)`
`void`	`setSyncupProgress(SyncupProgress progress, long n, long total)`
`protected void`	`setupClose(PrintWriter errors)` Release any resources from a subclass that need to be released before close is called on regular environment components.
`void`	`shutdownGroupSetup(long timeoutMs)` Sets up the environment for group shutdown when the environment is closed.
`String`	`transferMaster(Set<String> replicas, long timeout, boolean force)`
`boolean`	`tryTruncateVlsnHead(VLSN deleteEnd, long deleteFileNum)` Truncate the head of the VLSNIndex to unprotect the given file, if possible.
`boolean`	`tryVlsnHeadTruncate(long bytesNeeded)` Truncate the head of the VLSNIndex to allow file deletion, if possible.
`void`	`txnBeginHook(MasterTxn txn)` Ensure that a sufficient number of feeders are available before proceeding with a master transaction begin.
`void`	`unblockTxnCompletion()` Releases the transaction block latch.
`void`	`updateCBVLSN(LocalCBVLSNUpdater updater)` If the GlobalCBVLSN is not defunct, updates the CBVLSN on behalf of a Feeder input thread (or FeederManager running in the RepNode thread).

Methods inherited from class com.sleepycat.je.dbi.EnvironmentImpl
addConfigObserver, addToCompressorQueue, addToCompressorQueue, allowBlindOps, allowBlindPuts, appendException, checkDiskLimitViolation, checkIfInvalid, checkImmutablePropsForEquality, checkOpen, cloneConfig, cloneMutableConfig, close, close, closeAfterInvalid, closeHandlers, coordinateWithCheckpoint, createRepTxn, criticalEviction, daemonEviction, decThreadLocalReferenceCount, envConfigUpdate, expiresWithin, expiresWithin, finishInit, flushLog, forceLogFileFlip, fullyInitialized, getAdler32ChunkSize, getAppOpenCount, getBackupCount, getBackupManager, getCheckpointer, getClassLoader, getCleaner, getCompactMaxKeyLength, getConfigManager, getConfiguredHandler, getConsoleHandler, getDataEraser, getDataVerifier, getDbEviction, getDbTree, getDeadlockDetection, getDeadlockDetectionDelay, getDidFullThreadDump, getDiskLimitViolation, getDupConvertPreloadConfig, getEnvironmentHome, getEvictor, getExceptionListener, getExpirationProfile, getExposeUserData, getExtinctionScanner, getExtinctionState, getExtinctionState, getExtinctionStatus, getFileHandler, getFileManager, getFileProtector, getINCompressor, getINCompressorQueueSize, getInMemoryINs, getInternalEnvHandle, getInvalidatingException, getInvalidatingExceptionReference, getLatchTimeoutMs, getLockTimeout, getLogFlusher, getLogger, getLogManager, getMaxEmbeddedLN, getMemoryBudget, getMetadataStore, getNoComparators, getNodeSequence, getOffHeapCache, getOptionalNodeName, getRecoveryProgressListener, getReservedFilesAutoRepair, getRootLsn, getSecondaryAssociationLock, getSharedCache, getStartupTracker, getThreadLocalReferenceCount, getThroughputStat, getTtlClockTolerance, getTtlLnPurgeDelay, getTtlMaxTxnTime, getTxnManager, getTxnTimeout, getUtilizationProfile, getUtilizationTracker, hasExtinctionFilter, incBinDeltaDeletes, incBinDeltaGets, incBinDeltaInserts, incBinDeltaUpdates, incDeleteFailOps, incDeleteOps, incInsertFailOps, incInsertOps, incPositionOps, incRelatchesRequired, incRootSplits, incSearchFailOps, incSearchOps, incThreadLocalReferenceCount, incUpdateOps, invalidate, invokeCheckpoint, invokeCleaner, invokeCompressor, invokeEvictor, isClosed, isClosing, isDbLoggingDisabled, isExpirationEnabled, isExpired, isExpired, isInInit, isMemOnly, isNoLocking, isReadOnly, isRepConverted, isTransactional, isValid, lazyCompress, lazyCompress, loadStats, loadStatsInternal, lockStat, logMapTreeRoot, logMapTreeRoot, makeDaemonThreadName, maybeForceYield, mayNotWrite, needRepConvert, noteBackupCopyFilesCount, noteBackupCopyFilesMs, open, preload, readMapTreeFromLog, registerMBean, removeConfigObserver, requestShutdownDaemons, resetLoggingLevel, rewriteMapTreeRoot, setBackgroundSleepHook, setDidFullThreadDump, setLockTimeout, setMutableConfig, shutdownDaemons, sleepAfterBackgroundIO, specialEviction, txnBegin, txnStat, updateBackgroundReads, updateBackgroundWrites, useOffHeapChecksums, verify, verifyCursors, wasInvalidated

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

- Constructor Detail
  - RepImpl
```
public RepImpl(File envHome,
               EnvironmentConfig envConfig,
               EnvironmentImpl sharedCacheEnv,
               RepConfigProxy repConfigProxy)
        throws EnvironmentNotFoundException,
               EnvironmentLockedException
```
    Throws:
    
    EnvironmentNotFoundException
    
    EnvironmentLockedException
- Method Detail
  - initConfigParams
```
protected void initConfigParams(EnvironmentConfig envConfig,
                                RepConfigProxy repConfigProxy)
```
    Called by the EnvironmentImpl constructor. Some rep params, preserveVLSN for example, are accessed by the EnvironmentImpl via methods (getPreserveVLSN for example), so they need to be initialized early.
    
    Overrides:
    
    initConfigParams in class EnvironmentImpl
    
    repConfigProxy - unused
  - initFormatter
```
protected Formatter initFormatter()
```
    Overrides:
    
    initFormatter in class EnvironmentImpl
  - getMonitorClassName
```
public String getMonitorClassName()
```
    Overrides:
    
    getMonitorClassName in class EnvironmentImpl
  - getDiagnosticsClassName
```
public String getDiagnosticsClassName()
```
    Overrides:
    
    getDiagnosticsClassName in class EnvironmentImpl
  - initConfigManager
```
protected DbConfigManager initConfigManager(EnvironmentConfig envConfig,
                                            RepConfigProxy repConfigProxy)
```
    Description copied from class: EnvironmentImpl
    
    Create a config manager that holds the configuration properties that have been passed in. These properties are already validated, and have had the proper order of precedence applied; that is, the je.properties file has been applied. The configuration properties need to be available before the rest of environment creation proceeds. This method is overridden by replication environments.
    
    Overrides:
    
    initConfigManager in class EnvironmentImpl
    
    Parameters:
    
    envConfig - is the environment configuration to use
    
    repConfigProxy - are the replication configurations to use. In this case, the Properties bag has been extracted from the configuration instance, to avoid crossing the compilation firewall.
  - getAllowRepConvert
```
public boolean getAllowRepConvert()
```
    Description copied from class: EnvironmentImpl
    
    True if ReplicationConfig set allowConvert as true. Standalone environment is prohibited from doing a conversion, return false.
    
    Overrides:
    
    getAllowRepConvert in class EnvironmentImpl
  - resetConfigManager
```
protected DbConfigManager resetConfigManager(EnvironmentConfig newConfig)
```
    Description copied from class: EnvironmentImpl
    
    Make a new config manager that has all the properties needed. More complicated for subclasses.
    
    Overrides:
    
    resetConfigManager in class EnvironmentImpl
  - cloneRepConfig
```
public ReplicationConfig cloneRepConfig()
```
  - makeEnvironment
```
public ReplicatedEnvironment makeEnvironment()
```
  - cloneRepMutableConfig
```
public ReplicationMutableConfig cloneRepMutableConfig()
```
  - setRepMutableConfig
```
public void setRepMutableConfig(ReplicationMutableConfig config)
                         throws DatabaseException
```
    Throws:
    
    DatabaseException
  - repEnvConfigUpdate
```
public void repEnvConfigUpdate(RepConfigManager configMgr,
                               ReplicationMutableConfig newConfig)
                        throws DatabaseException
```
    Description copied from interface: RepEnvConfigObserver
    
    Notifies the observer that one or more mutable rep properties have been changed.
    
    Specified by:
    
    repEnvConfigUpdate in interface RepEnvConfigObserver
    
    Throws:
    
    DatabaseException
  - addRepConfigObserver
```
public void addRepConfigObserver(RepEnvConfigObserver o)
```
  - preRecoveryCheckpointInit
```
public void preRecoveryCheckpointInit(RecoveryInfo recoveryInfo)
```
    The VLSNIndex must be created, merged and flushed before the recovery checkpoint. This method should be called even if there is no recovery checkpoint, because it sets up needed data structures. On the face of it, it seems that one could flush the VLSNIndex cache after the recovery checkpoint, before the Replicator constructor returns and before any user level HA operations can start. That's not sufficient because the recovery checkpoint is shortening the recovery interval for future recoveries, and any information that has been garnered must be persisted. Here's an example of what might happen after a series of recoveries if we fail to flush VLSNIndex as part of the recovery checkpoint: Environment recovers for first time, brand new environment recovery did not find any VLSNs in log, because log is brand new recovery logs ckpt 1start recovery logs ckpt 1 end VLSN 1 logged VLSN 2 logged VLSN 3 logged crash .... Environment recovers recovery crawls log from ckpt 1 start onward, finds VLSNs 1-3 recovery logs ckpt 2 start recovery logs ckpt 2 end VLSN index instantiated, VLSNs 1-3 added in but not written too disk crash ... Environment recovers recovery crawls log from ckpt start 2 start onward, finds no VLSNs. Instead, the flushed VLSN has to be logged before the checkpoint end record that is used for the next recovery.
    
    Overrides:
    
    preRecoveryCheckpointInit in class EnvironmentImpl
  - getState
```
public ReplicatedEnvironment.State getState()
```
    Returns the current state associated with this ReplicatedEnvironment
    
    Returns:
    
    the externally visible ReplicatedEnvironment state
  - getStateChangeEvent
```
public StateChangeEvent getStateChangeEvent()
```
    Returns the state change event that transitioned the ReplicatedEnviroment to its current state.
  - getNodeState
```
public NodeState getNodeState()
```
  - joinGroup
```
public ReplicatedEnvironment.State joinGroup(ReplicaConsistencyPolicy consistency,
                                             QuorumPolicy initialElectionPolicy)
                                      throws ReplicaConsistencyException,
                                             DatabaseException
```
    Wait for this node to join a replication group and return whether it is a MASTER or REPLICA. Note that any method that creates or clears the repNode field must be synchronized.
    
    Throws:
    
    ReplicaConsistencyException
    
    DatabaseException
  - initializeChannelFactory
```
public void initializeChannelFactory()
```
    Initialize the DataChannelFactory in our configuration for use. This is public to allow access by the ReplicatedEnvironment constructor.
    
    Throws:
    
    IllegalArgumentException - if the ReplicationNetworkConfig is invalid.
  - createInternalEnvironment
```
protected Environment createInternalEnvironment()
```
    Description copied from class: EnvironmentImpl
    
    Is overridden in RepImpl to create a ReplicatedEnvironment.
    
    Overrides:
    
    createInternalEnvironment in class EnvironmentImpl
  - setupClose
```
protected void setupClose(PrintWriter errors)
                   throws DatabaseException
```
    Description copied from class: EnvironmentImpl
    
    Release any resources from a subclass that need to be released before close is called on regular environment components.
    
    Overrides:
    
    setupClose in class EnvironmentImpl
    
    Throws:
    
    DatabaseException
    
    See Also:
    
    Release all replication resources that can be released before the checkpoint. Note that any method that creates or clears the repNode field must be called from a synchronized caller. Note that the vlsnIndex is closed as a callback, from postCheckpointPreEnvClose()
  - postCheckpointClose
```
protected void postCheckpointClose(boolean checkpointed)
                            throws DatabaseException
```
    Close any resources that need to be closed after the closing checkpoint. Note that since Replay.close closes open transactions, it must be invoked after the checkpoint has been completed, so that the checkpoint operation can correctly account for the open transactions.
    
    Overrides:
    
    postCheckpointClose in class EnvironmentImpl
    
    Parameters:
    
    checkpointed - if true, a checkpoint as issued before the close
    
    Throws:
    
    DatabaseException
  - postRecoveryConversion
```
protected void postRecoveryConversion()
```
    Description copied from class: EnvironmentImpl
    
    Called after recovery but before any other initialization. Is overridden by ReplImpl to convert user defined databases to replicated after doing recovery.
    
    Overrides:
    
    postRecoveryConversion in class EnvironmentImpl
    
    See Also:
    
    Note: this conversion process will iterate over all user created databases in the environment, which could be potentially be a costly affair. However, let's opt for simplicity and defer any optimizations until we see whether this is an important use case.
  - doCloseAfterInvalid
```
public void doCloseAfterInvalid()
```
    Description copied from class: EnvironmentImpl
    
    This method must be called while synchronized on DbEnvPool.
    
    Overrides:
    
    doCloseAfterInvalid in class EnvironmentImpl
  - abnormalClose
```
public void abnormalClose()
                   throws DatabaseException
```
    Used by error handling to forcibly close an environment, and by tests to close an environment to simulate a crash. Database handles do not have to be closed before calling this method. A checkpoint is not performed. The various thread pools will be shutdown abruptly.
    
    Overrides:
    
    abnormalClose in class EnvironmentImpl
    
    Throws:
    
    DatabaseException
  - registerVLSN
```
public void registerVLSN(LogItem logItem)
```
    A replicated log entry has been written on this node. Update the VLSN->LSN mapping. Called outside the log write latch.
    
    Overrides:
    
    registerVLSN in class EnvironmentImpl
    
    Throws:
    
    DatabaseException
  - assignVLSNs
```
public VLSN assignVLSNs(LogEntry entry)
```
    Generate the next VLSN and update the DTVLSN value in the item. Note that this method is only invoked when the node is in the Master state, since the master assigns new VLSNs and DTVLSNs, and the replicas simply preserve them. The DTVLSN value must be calculated under the same latch as the updating of the VLSN to ensure that the following invariants are maintained: lsn1 > lsn2 ==> VLSN(lsn1) > VLSN(lsn2) vlsn2 > vlsn1 ==> DTVLSN(vlsn2) >= DTVLSN(vlsn1) where vlsn2 and vlsn1 are transaction commit or abort records. Replicas, when replaying their stream, verify that this invariant is maintained. Commit/Abort records for Replication groups that have a single electable and durable node have their dtvlsn written as the associated VLSN, that is, DTVLSN(vlsn) == vlsn. For all other RG configurations, DTVLSN(vlsn) < vlsn. Commit/Abort Log records that are created by replaying an HA stream from a pre DTVLSN feeder, will have their dtvlsns set to VLSN.UNINITIALIZED_VLSN_SEQUENCE during replica replay. They do not follow this code path.
    
    Overrides:
    
    assignVLSNs in class EnvironmentImpl
    
    Parameters:
    
    entry - the log entry with which the VLSN will be associated. If the log entry represents a commit or abort entry, its DTVLSN is modified so that it's correct when it's serialized out.
    
    Returns:
    
    a non-null VLSN for all replicated log items
  - preCheckpointEndFlush
```
public void preCheckpointEndFlush()
                           throws DatabaseException
```
    Flush any information that needs to go out at checkpoint. Specifically, write any in-memory VLSN->LSN mappings to the VLSNIndex database so we are guaranteed that the VLSNIndex database will recover properly. This must be committed with noSync because - the ensuing checkpoint end record will be logged with an fsync and will effectively force this out - it's important to minmize lock contention on the vlsn index and any fsync done during a checkpoint will be expensive, as there may be quite a lot to push to disk. We don't want to incur that cost while holding locks on the vlsn index. [#20702]
    
    Overrides:
    
    preCheckpointEndFlush in class EnvironmentImpl
    
    Throws:
    
    DatabaseException
  - isMaster
```
public boolean isMaster()
```
    Overrides:
    
    isMaster in class EnvironmentImpl
  - setChangeListener
```
public void setChangeListener(StateChangeListener listener)
```
  - getChangeListener
```
public StateChangeListener getChangeListener()
```
  - getVLSNIndex
```
public VLSNIndex getVLSNIndex()
```
  - getFeederTxns
```
public FeederTxns getFeederTxns()
```
  - getStats
```
public ReplicatedEnvironmentStats getStats(StatsConfig config)
```
  - getRepStatGroups
```
public Collection<StatGroup> getRepStatGroups(StatsConfig config,
                                              Integer statKey1)
```
    Overrides:
    
    getRepStatGroups in class EnvironmentImpl
  - getStatCaptureProjections
```
public SortedSet<String> getStatCaptureProjections()
```
    Overrides:
    
    getStatCaptureProjections in class EnvironmentImpl
  - createStatManager
```
public StatManager createStatManager()
```
    Overrides:
    
    createStatManager in class EnvironmentImpl
  - getFeederFilter
```
public FeederFilter getFeederFilter()
```
  - getStatsInternal
```
public ReplicatedEnvironmentStats getStatsInternal(StatsConfig config)
```
  - getStats
```
public ReplicatedEnvironmentStats getStats(StatsConfig config,
                                           Integer contextKey)
```
  - getReplay
```
public Replay getReplay()
```
  - checkIfMaster
```
public void checkIfMaster(Locker locker)
                   throws UnknownMasterException,
                          ReplicaWriteException
```
    Ensures that the environment is currently a Master before proceeding with an operation that requires it to be the master.
    
    Throws:
    
    UnknownMasterException - if the node is disconnected
    
    ReplicaWriteException - if the node is currently a replica
  - getRepNode
```
public RepNode getRepNode()
```
    Returns:
    
    the repNode. May return null.
  - createRepThreadLocker
```
public ThreadLocker createRepThreadLocker()
```
    Create an appropriate type of ThreadLocker. Specifically, it creates an MasterThreadLocker if the node is currently a Master, and a ReplicaThreadLocker otherwise, that is, if the node is a Replica, or it's currently in a DETACHED state.
    
    Overrides:
    
    createRepThreadLocker in class EnvironmentImpl
    
    Returns:
    
    an instance of MasterThreadLocker or ReplicaThreadLocker
  - createRepUserTxn
```
public Txn createRepUserTxn(TransactionConfig config)
                     throws DatabaseException
```
    Create an appropriate type of Replicated transaction. Specifically, it creates a MasterTxn, if the node is currently a Master, a ReadonlyTxn otherwise, that is, if the node is a Replica, or it's currently in a DETACHED state. Note that a ReplicaTxn, used for transaction replay on a Replica is not created on this path. It's created explicitly in the Replay loop by a Replica.
    
    Overrides:
    
    createRepUserTxn in class EnvironmentImpl
    
    Parameters:
    
    config - the transaction configuration
    
    Returns:
    
    an instance of MasterTxn or ReadonlyTxn
    
    Throws:
    
    DatabaseException
  - txnBeginHook
```
public void txnBeginHook(MasterTxn txn)
                  throws InterruptedException,
                         DatabaseException
```
    Ensure that a sufficient number of feeders are available before proceeding with a master transaction begin.
    
    Parameters:
    
    txn - the master transaction being initiated.
    
    Throws:
    
    InterruptedException
    
    DatabaseException - if there were insufficient Replicas after the timeout period.
  - blockTxnCompletion
```
public void blockTxnCompletion(CountDownLatch blocker)
                        throws InterruptedException
```
    Installs the commit-blocking latch that is used to halt the commit/abort of transactions, in the final phase of a master transfer.
    
    Throws:
    
    InterruptedException
    
    See Also:
    
    updateCBVLSN(LocalCBVLSNUpdater)
  - updateCBVLSN
```
public void updateCBVLSN(LocalCBVLSNUpdater updater)
```
    If the GlobalCBVLSN is not defunct, updates the CBVLSN on behalf of a Feeder input thread (or FeederManager running in the RepNode thread). If the GlobalCBVLSN is defunct, does nothing.
    Does the update while avoiding the possibility that any resulting GroupDB update may get blocked behind the final phase of a master transfer.
    We skip the update if we're at the point of blocking new transactions for a master transfer. And we use a read/write lock in order to be able to examine that state safely.
  - unblockTxnCompletion
```
public void unblockTxnCompletion()
```
    Releases the transaction block latch.
  - preLogCommitHook
```
public void preLogCommitHook(MasterTxn txn)
                      throws InsufficientReplicasException,
                             RestartRequiredException,
                             UnknownMasterException,
                             ReplicaWriteException,
                             EnvironmentFailureException
```
    This hook is used primarily to perform the final checks before allowing the commit operation to proceed. The following checks are performed here: 1) Check for master 2) Check for sufficient Feeder connections to ensure that the commit policy could be implemented. There is no guarantee that they will all ack the commit request. The method also associates a latch with the transaction. The latch is used to delay the commit operation until a sufficient number of commits have been received. In addition, when mastership transfers are done, and this node is the original master, commits and aborts are blocked so as to avoid hard recovery after electing a new master, see [#18081].
    
    Parameters:
    
    txn - the master transaction being committed
    
    Throws:
    
    InsufficientReplicasException - if the feeder is not in contact with enough replicas.
    
    RestartRequiredException - if the environment is invalid.
    
    UnknownMasterException - if the current master is unknown.
    
    ReplicaWriteException - if the node transitioned to a Replica after the transaction was initiated.
    
    EnvironmentFailureException
  - postLogCommitHook
```
public void postLogCommitHook(MasterTxn txn,
                              LogItem commitItem)
                       throws InsufficientAcksException,
                              InterruptedException,
                              EnvironmentFailureException
```
    It ensures that the feeder obtains the requisite number of acknowledgments required for a successful commit.
    
    Parameters:
    
    txn - The MasterTxn that was committed locally.
    
    Throws:
    
    InterruptedException - if the thread was interrupted while waiting for acknowledgments.
    
    InsufficientAcksException - if the master received an insufficient number of commit acknowledgments within the replica commit timeout period.
    
    EnvironmentFailureException
  - preLogAbortHook
```
public void preLogAbortHook(MasterTxn txn)
                     throws EnvironmentFailureException,
                            ReplicaWriteException,
                            UnknownMasterException
```
    Invoked before aborting a MasterTxn, this happens when the master is going to be a replica because of mastership transfer. We do this to make sure that the replica going to be the master has the most recent log and no hard recovery would happen after its election, see SR [#18081].
    
    Parameters:
    
    txn - The MasterTxn that was aborted locally.
    
    Throws:
    
    ReplicaWriteException - if the node transitioned to a Replica after the transaction was initiated.
    
    UnknownMasterException - if the current master is unknown.
    
    EnvironmentFailureException
  - postLogAbortHook
```
public void postLogAbortHook(MasterTxn txn)
```
    Releases the block latch lock, if held. This hook is called in the normal course of Txn.abort(), once the abort log record has been written and the associated VLSN stored.
  - postLogCommitAbortHook
```
public void postLogCommitAbortHook(MasterTxn txn)
```
    Removes any pending acknowledgments that were registered by the preLogCommitHook. This hook is called only when a commit() fails and therefore must be aborted.
  - createReplayTxn
```
public Txn createReplayTxn(long txnId)
                    throws DatabaseException
```
    Create a ReplayTxn for recovery processing.
    
    Overrides:
    
    createReplayTxn in class EnvironmentImpl
    
    Throws:
    
    DatabaseException
  - getVLSNProxy
```
public VLSNRecoveryProxy getVLSNProxy()
```
    Used by environment recovery to get a tracker to collect VLSN-LSN mappings that are within the recovery part of the log. These might not be reflected in the persistent mapping db.
    
    Overrides:
    
    getVLSNProxy in class EnvironmentImpl
  - getUUID
```
public UUID getUUID()
```
  - setSkewMs
```
public static void setSkewMs(int skewMs)
```
    Used during testing to introduce artificial clock skews.
  - getClockSkewMs
```
public static int getClockSkewMs()
```
  - tryVlsnHeadTruncate
```
public boolean tryVlsnHeadTruncate(long bytesNeeded)
```
    Truncate the head of the VLSNIndex to allow file deletion, if possible.
    
    Overrides:
    
    tryVlsnHeadTruncate in class EnvironmentImpl
  - tryTruncateVlsnHead
```
public boolean tryTruncateVlsnHead(VLSN deleteEnd,
                                   long deleteFileNum)
```
    Truncate the head of the VLSNIndex to unprotect the given file, if possible.
    
    Overrides:
    
    tryTruncateVlsnHead in class EnvironmentImpl
  - clearedCachedFileChecksum
```
public void clearedCachedFileChecksum(String fileName)
```
    Clears the cached checksum for a file when it may be overwritten (e.g., entries may be erased).
    
    Overrides:
    
    clearedCachedFileChecksum in class EnvironmentImpl
  - getNodeId
```
public int getNodeId()
```
  - getNameIdPair
```
public NameIdPair getNameIdPair()
```
  - getReplayTxnTimeout
```
public long getReplayTxnTimeout()
```
    Overrides:
    
    getReplayTxnTimeout in class EnvironmentImpl
  - getDefaultConsistencyPolicy
```
public ReplicaConsistencyPolicy getDefaultConsistencyPolicy()
```
    Description copied from class: EnvironmentImpl
    
    Returns the default consistency policy for this EnvironmentImpl. When a Txn is created directly for internal use, the default consistency is needed. For example, SyncDB uses this method. This method returns null for a standalone Environment, and returns the default consistency policy for a ReplicatedEnvironment.
    
    Overrides:
    
    getDefaultConsistencyPolicy in class EnvironmentImpl
  - getConsistencyPolicy
```
public ReplicaConsistencyPolicy getConsistencyPolicy(String propValue)
```
    Description copied from class: EnvironmentImpl
    
    Allows standalone JE code to construct a consistency policy using the CONSISTENCY_POLICY property value format. This method returns null for a standalone Environment, and returns the given consistency policy for a ReplicatedEnvironment.
    
    Overrides:
    
    getConsistencyPolicy in class EnvironmentImpl
  - setDefaultConsistencyPolicy
```
public void setDefaultConsistencyPolicy(ReplicaConsistencyPolicy policy)
```
    The default consistency is not currently mutable in the API, but can be set for testing purposes. TODO: Make it mutable in the API, since Durability is mutable.
  - getLoggedDTVLSN
```
public long getLoggedDTVLSN()
                     throws FileNotFoundException
```
    Returns the logged durable txn VLSN. The logged DTVLSN is part of the last txn commit or abort entry.
    
    Returns:
    
    the persistent DTVLSN. The value may be VLSN.UNINITIALIZED_VLSN_SEQUENCE if the environment was newly created, that is, it has no transactions in it as yet, or if the last entry was created by a pre-DTVLSN master.
    
    Throws:
    
    FileNotFoundException - if the file containing the last txn commit or abort entry does not exist
  - getEndOfLog
```
public long getEndOfLog()
```
    Description copied from class: EnvironmentImpl
    
    Returns the end of the log. Returned value is a Lsn if it's a standalone Environment, otherwise it's a VLSN.
    
    Overrides:
    
    getEndOfLog in class EnvironmentImpl
  - getPreserveVLSN
```
public boolean getPreserveVLSN()
```
    Returns true if the VLSN is preserved as the record version.
    
    Overrides:
    
    getPreserveVLSN in class EnvironmentImpl
  - getCacheVLSN
```
public boolean getCacheVLSN()
```
    Returns true if the VLSN is both preserved and cached.
    
    Overrides:
    
    getCacheVLSN in class EnvironmentImpl
  - getName
```
public String getName()
```
    Description copied from class: EnvironmentImpl
    
    Get an environment name, for tagging onto logging and debug message. Useful for multiple environments in a JVM, or for HA.
    
    Overrides:
    
    getName in class EnvironmentImpl
    
    See Also:
    
    EnvironmentImpl.getName()
  - getNodeName
```
public String getNodeName()
```
    Description copied from class: EnvironmentImpl
    
    Get the node name if this is a replicated environment or else return null.
    
    Overrides:
    
    getNodeName in class EnvironmentImpl
  - getIsMaster
```
public boolean getIsMaster()
```
    Description copied from class: EnvironmentImpl
    
    Returns whether this is a replicated environment that is the master, else false.
    
    Overrides:
    
    getIsMaster in class EnvironmentImpl
  - isReplicated
```
public boolean isReplicated()
```
    Return true if this environment is part of a replication group.
    
    Overrides:
    
    isReplicated in class EnvironmentImpl
  - isArbiter
```
public boolean isArbiter()
```
    Return true if this environment is used as an Arbiter.
    
    Overrides:
    
    isArbiter in class EnvironmentImpl
  - checkRulesForExistingEnv
```
public void checkRulesForExistingEnv(boolean dbTreeReplicatedBit,
                                     boolean dbTreePreserveVLSN)
                              throws UnsupportedOperationException
```
    Check whether this environment can be opened on an existing environment directory.
    
    Overrides:
    
    checkRulesForExistingEnv in class EnvironmentImpl
    
    Throws:
    
    UnsupportedOperationException - via Environment ctor.
  - getHostName
```
public String getHostName()
```
    Returns the hostname associated with this node.
    
    Returns:
    
    the hostname
  - getHostAddress
```
public InetSocketAddress getHostAddress()
```
    Returns the socket address associated with this node, with a port of zero suitable for binding locally to any free port associated with the address.
  - getFeederConnectOptions
```
public DataChannelFactory.ConnectOptions getFeederConnectOptions()
```
    Returns the options used to configure the feeder channel connection. Note that soTimeout is not set since it's a blocking channel and setSoTimeout has no effect on a blocking nio channel. Push responses out rapidly, they are small (heart beat or commit response) and need timely delivery to the master. (tcpNoDelay = true)
  - getPort
```
public int getPort()
```
    Returns the port used by the replication node.
    
    Returns:
    
    the port number
  - getSocket
```
public InetSocketAddress getSocket()
```
  - getCurrentJEVersion
```
public JEVersion getCurrentJEVersion()
```
    Returns the JE version that is currently running on this node, consulting the TEST_JE_VERSION configuration parameter for a test override.
  - getHelperSockets
```
public Set<InetSocketAddress> getHelperSockets()
```
    Returns the set of sockets associated with helper nodes.
    
    Returns:
    
    the set of helper sockets, returns an empty set if there are no helpers.
  - createGroupDb
```
public DatabaseImpl createGroupDb()
                           throws DatabaseException
```
    Called when a node has identified itself as the master, which is when the RepNode.selfElect is called. The database should not exist at this point. Lock hierarchy: GroupDbLock -> sync on EnvironmentImpl
    
    Throws:
    
    DatabaseException
  - getGroupDb
```
public DatabaseImpl getGroupDb()
                        throws DatabaseNotFoundException,
                               DatabaseException
```
    Open the group db, which should exist already, using NO_CONSISTENCY.
    
    Throws:
    
    DatabaseNotFoundException
    
    DatabaseException
  - probeGroupDb
```
public DatabaseImpl probeGroupDb()
                          throws DatabaseException
```
    Open the group db, which should exist already, using NO_CONSISTENCY. Do not wait on the group db lock, return null if the databaseImpl hasn't been created and we can't obtain it. Lock hierarchy: GroupDbLock -> sync on EnvironmentImpl
    
    Throws:
    
    DatabaseException
  - isDesignatedPrimary
```
public boolean isDesignatedPrimary()
```
    Return true if the node has been configured as a Designated Primary. This does not necessarily mean that the node is actively operating in designated primary mode. See Arbiter.isActive()
  - addDbBackup
```
public boolean addDbBackup(DbBackup backup)
```
    Description copied from class: EnvironmentImpl
    
    For replicated environments only; just return true for a standalone environment.
    
    Overrides:
    
    addDbBackup in class EnvironmentImpl
  - removeDbBackup
```
public void removeDbBackup(DbBackup backup)
```
    Description copied from class: EnvironmentImpl
    
    For replicated environments only; do nothing for a standalone environment.
    
    Overrides:
    
    removeDbBackup in class EnvironmentImpl
  - invalidateBackups
```
public void invalidateBackups(long fileNumber)
```
  - setBackupProhibited
```
public void setBackupProhibited(boolean backupProhibited)
```
  - createLockPreemptedException
```
public LockPreemptedException createLockPreemptedException(Locker locker,
                                                           Throwable cause)
```
    Description copied from class: EnvironmentImpl
    
    For replicated environments only; only the overridden method should ever be called.
    
    Overrides:
    
    createLockPreemptedException in class EnvironmentImpl
  - createDatabasePreemptedException
```
public DatabasePreemptedException createDatabasePreemptedException(String msg,
                                                                   String dbName,
                                                                   Database db)
```
    Description copied from class: EnvironmentImpl
    
    For replicated environments only; only the overridden method should ever be called.
    
    Overrides:
    
    createDatabasePreemptedException in class EnvironmentImpl
  - createLogOverwriteException
```
public LogOverwriteException createLogOverwriteException(String msg)
```
    Description copied from class: EnvironmentImpl
    
    For replicated environments only; only the overridden method should ever be called.
    
    Overrides:
    
    createLogOverwriteException in class EnvironmentImpl
  - getReplayFreeDiskPercent
```
public int getReplayFreeDiskPercent()
```
    Description copied from class: EnvironmentImpl
    
    Returns the deprecated HA REPLAY_FREE_DISK_PERCENT parameter, or zero if this is not an HA env.
    
    Overrides:
    
    getReplayFreeDiskPercent in class EnvironmentImpl
  - shutdownGroupSetup
```
public void shutdownGroupSetup(long timeoutMs)
```
    Sets up the environment for group shutdown when the environment is closed.
    
    See Also:
    
    ReplicatedEnvironment.shutdownGroup(long, TimeUnit)
  - transferMaster
```
public String transferMaster(Set<String> replicas,
                             long timeout,
                             boolean force)
```
  - dumpState
```
public String dumpState()
```
    Dump interesting aspects of the node's state. Currently for debugging use, possibly useful for field support.
  - dumpAckFeederState
```
public String dumpAckFeederState()
```
    Dumps the state associated with all active Feeders that supply acknowledgments, along with identifying information about the node and its current HA state.
  - setHardRecoveryInfo
```
public void setHardRecoveryInfo(RollbackException e)
```
    If this node was started with a hard recovery, preserve that information.
  - getNodeStats
```
public StatGroup getNodeStats()
```
  - awaitVLSNConsistency
```
public void awaitVLSNConsistency()
```
    Ensure that the in-memory vlsn index encompasses all logged entries before it is flushed to disk. A No-Op for non-replicated systems. [#19754]
    
    Overrides:
    
    awaitVLSNConsistency in class EnvironmentImpl
  - setSyncupProgress
```
public void setSyncupProgress(SyncupProgress progress)
```
  - setSyncupProgress
```
public void setSyncupProgress(SyncupProgress progress,
                              long n,
                              long total)
```
  - setSimulatePreDTVLSNMaster
```
public static void setSimulatePreDTVLSNMaster(boolean simulatePreDTVLSNMaster)
```
    Test method to create pre-DTVLSN logs. When this is turned on in a test environment the dtvlsn value in the log is written as a UNINITIALIZED_VLSN_SEQUENCE (zero), which is the value that deserialization would assign to it if a new replica came across an older version commit or abort record.
  - isSimulatePreDTVLSNMaster
```
public static boolean isSimulatePreDTVLSNMaster()
```
  - getLogRewriteListener
```
public LogFileRewriteListener getLogRewriteListener()
```
  - getRepNetConfig
```
public ReplicationNetworkConfig getRepNetConfig()
```
  - getChannelFactory
```
public DataChannelFactory getChannelFactory()
```
  - invalidate
```
public void invalidate(EnvironmentFailureException e)
```
    Description copied from class: EnvironmentImpl
    
    Invalidate the environment. Done when a fatal exception (EnvironmentFailureException) is thrown.
    
    Overrides:
    
    invalidate in class EnvironmentImpl
  - getLastTxnEnd
```
public VLSN getLastTxnEnd()
```
  - getExistingMasterTxns
```
public Set<MasterTxn> getExistingMasterTxns()
```
    Peruse the environment wide transaction table, and return a set of all existing MasterTxns.
  - checkTTLAvailable
```
public void checkTTLAvailable()
```
    Checks that writing records with a TTL is allowed.
    
    Overrides:
    
    checkTTLAvailable in class EnvironmentImpl
    
    Throws:
    
    IllegalStateException - if any node in the group is less than JE_TTL_VERSION.
  - checkRecordExtinctionAvailable
```
public void checkRecordExtinctionAvailable()
```
    Description copied from class: EnvironmentImpl
    
    Checks that using the record extinction feature.
    
    Overrides:
    
    checkRecordExtinctionAvailable in class EnvironmentImpl
  - handleRestoreRequired
```
public void handleRestoreRequired(RestoreRequired restoreRequired)
```
    Recovery encountered a RestoreRequired marker.
    
    Overrides:
    
    handleRestoreRequired in class EnvironmentImpl
    
    Parameters:
    
    restoreRequired - getFailureType() is used to indicate the how the environment can be healed.
  - setAuthenticator
```
public void setAuthenticator(StreamAuthenticator authenticator)
```
  - getAuthenticator
```
public StreamAuthenticator getAuthenticator()
```
  - setReplicaLatestVLSNSeq
```
public void setReplicaLatestVLSNSeq(long seq)
```
    Overrides:
    
    setReplicaLatestVLSNSeq in class EnvironmentImpl

Class RepImpl

Nested Class Summary

Nested classes/interfaces inherited from class com.sleepycat.je.dbi.EnvironmentImpl

Field Summary

Fields inherited from class com.sleepycat.je.dbi.EnvironmentImpl

Constructor Summary

Method Summary

Methods inherited from class com.sleepycat.je.dbi.EnvironmentImpl

Methods inherited from class java.lang.Object

Constructor Detail

RepImpl

Method Detail

initConfigParams

initFormatter

getMonitorClassName

getDiagnosticsClassName

initConfigManager

getAllowRepConvert

resetConfigManager

cloneRepConfig

makeEnvironment

cloneRepMutableConfig

setRepMutableConfig

repEnvConfigUpdate

addRepConfigObserver

preRecoveryCheckpointInit

getState

getStateChangeEvent

getNodeState

joinGroup

initializeChannelFactory

createInternalEnvironment

setupClose

postCheckpointClose

postRecoveryConversion

doCloseAfterInvalid

abnormalClose

registerVLSN

assignVLSNs

preCheckpointEndFlush

isMaster

setChangeListener

getChangeListener

getVLSNIndex

getFeederTxns

getStats

getRepStatGroups

getStatCaptureProjections

createStatManager

getFeederFilter

getStatsInternal

getStats

getReplay

checkIfMaster

getRepNode

createRepThreadLocker

createRepUserTxn

txnBeginHook

blockTxnCompletion

updateCBVLSN

unblockTxnCompletion

preLogCommitHook

postLogCommitHook

preLogAbortHook

postLogAbortHook

postLogCommitAbortHook

createReplayTxn

getVLSNProxy

getUUID

setSkewMs

getClockSkewMs

tryVlsnHeadTruncate

tryTruncateVlsnHead

clearedCachedFileChecksum

getNodeId

getNameIdPair

getReplayTxnTimeout

getDefaultConsistencyPolicy

getConsistencyPolicy

setDefaultConsistencyPolicy