com.sleepycat.je.rep.txn

Class ReplayTxn

java.lang.Object

com.sleepycat.je.txn.Locker

com.sleepycat.je.txn.Txn

com.sleepycat.je.rep.txn.ReplayTxn

All Implemented Interfaces:

Loggable, VersionedWriteLoggable

public class ReplayTxn
extends Txn

Used for replaying replicated operations at replica nodes.

Field Summary

Fields inherited from class com.sleepycat.je.txn.Txn

ACCUMULATED_LIMIT, commitLsn, dbCleanupSet, firstLoggedLsn, lastLoggedLsn, openedDatabaseHandles, repContext, undoDatabases

Fields inherited from class com.sleepycat.je.txn.Locker

afterWaiterHook, envImpl, id, lockManager, thread

Constructor Summary

Constructors

Constructor and Description
ReplayTxn(EnvironmentImpl envImpl, TransactionConfig config, long txnId, Logger logger) Used when creating ReplayTxns at recovery.
ReplayTxn(EnvironmentImpl envImpl, TransactionConfig config, long txnId, SimpleTxnMap<ReplayTxn> activeTxns, Logger logger) Used when creating ReplayTxns for Replay.

Method Summary

Modifier and Type	Method and Description
void	abort() Abort this transaction.
long	abort(boolean forceFlush) Abort this transaction.
long	abort(ReplicationContext clientRepContext, int abortMasterNodeId, long abortDTVLSN)
void	cleanup() Invoked when a ReplayTxn is being abandoned on shutdown.
void	close(boolean isCommit) Close and unregister this txn.
long	commit() Call commit() with the default sync configuration property.
long	commit(Durability.SyncPolicy syncPolicy, ReplicationContext clientRepContext, int commitMasterNodeId, long commitDTVLSN) Commits the txn being replayed.
long	commit(Durability durability) Commit this transaction; it involves the following logical steps: 1.
void	copyDatabasesForConversion(Txn masterTxn)
long	elapsedTime() Returns the elapsed time associated with this transaction.
protected long	generateId(TxnManager txnManager, long mandatedId) Replay transactions always use the txn id that is included in its replicated operation.
protected long	getDTVLSN() This method is overridden by replication txn subclasses and returns the DTVLSN associated with the Txn.
long	getEndTime() Returns the time when this transaction was committed or aborted.
protected long	getInitialLockTimeout() Don't let the ReplayTxn have a timeout of 0.
boolean	getRepGroupDbChange()
protected int	getReplicatorNodeId() This method is overridden by HA txn subclasses and returns the node id of the master node that committed or aborted the txn.
boolean	isLocalWrite() Returns true if writes may only be to non-replicated DBs using this locker, or false if writes may only be to replicated DBs.
void	noteRepGroupDbChange()
void	registerWithActiveTxns(SimpleTxnMap<ReplayTxn> newActiveTxns)
Collection<Long>	rollback(long matchpointLsn) Rollback all write operations that are logged with an LSN > the matchpointLsn parameter.
void	setLastAppliedVLSN(VLSN justApplied)
void	setRepContext(ReplicationContext repContext) ReplicatedTxns set it when the txn commit or abort arrives.
void	stealLockFromMasterTxn(Long lsn) Transfer a lock from another transaction to this one.
String	toString() This method is safe to call without synchronizing and this fact is relied on by LockManager when creating exception messages.
protected boolean	updateLoggedForTxn() Always return true in order to ensure that the VLSN is logged.

Methods inherited from class com.sleepycat.je.txn.Txn

abort, addDbCleanup, addLock, addLogInfo, addOpenedDatabase, checkIfFrozen, checkPreempted, checkState, cleanupDatabaseImpls, clearReadLocks, clearWriteLocks, collectStats, commit, createAutoTxn, createLocalAutoTxn, createLocalTxn, dumpLog, getCommitDurability, getCommitToken, getDbCleanupSet, getDefaultDurability, getEmbeddedLoggables, getEnvironmentImpl, getExplicitDurabilityConfigured, getExplicitSyncConfigured, getFirstActiveLsn, getImportunate, getLastFormatChange, getLastLsn, getLogSize, getLogSize, getPrepared, getReadLockIds, getState, getTransaction, getTransactionId, getTriggerDbs, getTxnLocker, getUndoDatabases, getWriteLockIds, getWriteLockInfo, hasReplicationFormat, isAutoTxn, isClosed, isMasterTxn, isOnlyAbortable, isReadCommittedIsolation, isReadOnly, isReplicationFormatWorthwhile, isRolledBack, isSerializableIsolation, isSuspended, isTransactional, isValid, lockingRequired, lockInternal, logicalEquals, newNonTxnLocker, nonTxnOperationEnd, noteTriggerDb, operationEnd, postLogAbortHook, postLogCommitAbortHook, postLogCommitHook, preLogAbortHook, preLogCommitHook, preLogWithoutLock, prepare, propagatePostCommitException, readFromLog, registerCursor, registerImmediately, releaseNonTxnLocks, releaseWriteLocks, removeLock, setDbCleanupState, setImportunate, setOnlyAbortable, setPrepared, setRollback, setSuspended, setTransaction, txnBeginHook, undo, unRegisterCursor, writeToLog, writeToLog

Methods inherited from class com.sleepycat.je.txn.Locker

addDeleteInfo, allowReleaseLockAfterLsnChange, demoteLock, disallowReplicaWrite, dumpLockTable, getDefaultNoWait, getEnvironment, getId, getLockTimeout, getPreemptable, getTxnTimeout, isReadUncommittedDefault, isReplicated, isTimedOut, lock, lockAfterLsnChange, nonBlockingLock, openCursorHook, operationEnd, operationEnd, releaseLock, setClosingLocker, setDefaultNoWait, setLockTimeout, setPreemptable, setPreempted, setTxnTimeout, sharesLocksWith

Methods inherited from class java.lang.Object

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

Constructor Detail

ReplayTxn

public ReplayTxn(EnvironmentImpl envImpl,
                 TransactionConfig config,
                 long txnId,
                 SimpleTxnMap<ReplayTxn> activeTxns,
                 Logger logger)
          throws DatabaseException

Used when creating ReplayTxns for Replay. The ReplayTxn adds itself to the activeTxns map.

Throws:

DatabaseException

ReplayTxn

public ReplayTxn(EnvironmentImpl envImpl,
                 TransactionConfig config,
                 long txnId,
                 Logger logger)
          throws DatabaseException

Used when creating ReplayTxns at recovery. No ActiveTxns map is available.

Throws:

DatabaseException

Method Detail

getInitialLockTimeout

protected long getInitialLockTimeout()

Don't let the ReplayTxn have a timeout of 0. If it did, it could be deadlocked against a reader txn. As long as there is a non zero timeout, any conflicts will be adjugated by the LockManager in its favor.

Overrides:

getInitialLockTimeout in class Locker

isLocalWrite

public boolean isLocalWrite()

Description copied from class: Locker

Returns true if writes may only be to non-replicated DBs using this locker, or false if writes may only be to replicated DBs. By default (this implementation) local-write is true, since it is allowed for all non-txnal lockers and for all lockers in a standalone environment. This method is overridden and returns false for for user transactions in a replicated environment that are not explicitly configured for local-write. This method is used to describe a locker's configured usage for checking the validity of an API write operation. This is checked by Cursor methods at the beginning of each write operation.

Overrides:

isLocalWrite in class Locker

getRepGroupDbChange

public boolean getRepGroupDbChange()

noteRepGroupDbChange

public void noteRepGroupDbChange()

registerWithActiveTxns

public void registerWithActiveTxns(SimpleTxnMap<ReplayTxn> newActiveTxns)

generateId

protected long generateId(TxnManager txnManager,
                          long mandatedId)

Replay transactions always use the txn id that is included in its replicated operation.

Overrides:

generateId in class Txn

getReplicatorNodeId

protected int getReplicatorNodeId()

Description copied from class: Txn

This method is overridden by HA txn subclasses and returns the node id of the master node that committed or aborted the txn.

Overrides:

getReplicatorNodeId in class Txn

commit

public long commit(Durability.SyncPolicy syncPolicy,
                   ReplicationContext clientRepContext,
                   int commitMasterNodeId,
                   long commitDTVLSN)
            throws DatabaseException

Commits the txn being replayed.

Parameters:

syncPolicy - to be used for the commit.

clientRepContext - the replication context it encapsulates the VLSN associated with the txn.

commitDTVLSN - the dtvlsn

Returns:

the commit LSN

Throws:

DatabaseException

commit

public long commit()

Description copied from class: Txn

Call commit() with the default sync configuration property.

Overrides:

commit in class Txn

commit

public long commit(Durability durability)

Description copied from class: Txn

Commit this transaction; it involves the following logical steps: 1. Run pre-commit hook. 2. Release read locks. 3. Log a txn commit record and flush the log as indicated by the durability policy. 4. Run the post-commit hook. 5. Add deleted LN info to IN compressor queue. 6. Release all write locks If this transaction has not made any changes to the database, that is, it is a read-only transaction, no entry is made to the log. Otherwise, a concerted effort is made to log a commit entry, or an abort entry, but NOT both. If exceptions are encountered and neither entry can be logged, a EnvironmentFailureException is thrown. Error conditions (in contrast to Exceptions) always result in the environment being invalidated and the Error being propagated back to the application. In addition, if the environment is made invalid in another thread, or the transaction is closed by another thread, then we propagate the exception and we do not attempt to abort. This special handling is prior to the pre-commit stage. From an exception handling viewpoint the commit goes through two stages: a pre-commit stage spanning steps 1-3, and a post-commit stage spanning steps 4-5. The post-commit stage is entered only after a commit entry has been successfully logged. Any exceptions detected during the pre-commit stage results in an attempt to log an abort entry. A NULL commitLsn (and abortLsn) indicates that we are in the pre-commit stage. Note in particular, that if the log of the commit entry (step 3) fails due to an IOException, then the lower levels are responsible for wrapping it in a EnvironmentFailureException which is propagated directly to the application. Exceptions thrown in the post-commit stage are examined to see if they are expected and must be propagated back to the caller after completing any pending cleanup; some replication exceptions fall into this category. If the exception was unexpected, the environment is invalidated and a EnvironmentFailureException is thrown instead. The current implementation only allows propagation of exceptions from the post-commit hook, since we do not expect exceptions from any of the other post-commit operations. When there are multiple failures in commit(), we want the caller to receive the first exception, to make the problem manifest. So an effort is made to preserve that primary exception and propagate it instead of any following, secondary exceptions. The secondary exception is always logged in such a circumstance.

Overrides:

commit in class Txn

abort

public void abort()

Description copied from class: Txn

Abort this transaction. This flavor does not return an LSN, nor does it require the logging of a durable abort record.

Overrides:

abort in class Txn

abort

public long abort(boolean forceFlush)

Description copied from class: Txn

Abort this transaction. Steps are: 1. Release LN read locks. 2. Write a txn abort entry to the log. This is used for log file cleaning optimization and replication, and there's no need to guarantee a flush to disk. 3. Find the last LN log entry written for this txn, and use that to traverse the log looking for nodes to undo. For each node, use the same undo logic as recovery to undo the transaction. Note that we walk the log in order to undo in reverse order of the actual operations. For example, suppose the txn did this: delete K1/D1 (in LN 10) create K1/D1 (in LN 20) If we process LN10 before LN 20, we'd inadvertently create a duplicate tree of "K1", which would be fatal for the mapping tree. 4. Release the write lock for this LN. An abort differs from a rollback in that the former always undoes every operation, and returns it to the pre-txn state. A rollback may return the txn to an intermediate state, or to the pre-txn state.

Overrides:

abort in class Txn

getDTVLSN

protected long getDTVLSN()

Description copied from class: Txn

This method is overridden by replication txn subclasses and returns the DTVLSN associated with the Txn.

Overrides:

getDTVLSN in class Txn

abort

public long abort(ReplicationContext clientRepContext,
                  int abortMasterNodeId,
                  long abortDTVLSN)
           throws DatabaseException

Throws:

DatabaseException

updateLoggedForTxn

protected boolean updateLoggedForTxn()

Always return true in order to ensure that the VLSN is logged. Normally this method returns false when no LN has been logged by the txn. But when replaying a Master txn, we need to guarantee that the VLSN is logged on the Replica. [#20543]

Overrides:

updateLoggedForTxn in class Txn

Returns:

true if this txn has logged any log entries.

close

public void close(boolean isCommit)
           throws DatabaseException

Description copied from class: Txn

Close and unregister this txn.

Overrides:

close in class Txn

Throws:

DatabaseException

cleanup

public void cleanup()
             throws DatabaseException

Invoked when a ReplayTxn is being abandoned on shutdown.

Throws:

DatabaseException

rollback

public Collection<Long> rollback(long matchpointLsn)
                          throws DatabaseException

Rollback all write operations that are logged with an LSN > the matchpointLsn parameter. This is logically a truncation of the log entries written by this transaction. Any log entries created by this transaction are marked obsolete. Note that this is by no means a complete implementation of what would be needed to support user visible savepoints. This method only rolls back write operations and doesn't handle other types of state, like read locks and open cursors. There are several key assumptions: - the transaction does not hold read locks. - the transaction will either be resumed, and any rolled back operations will be repeated, or the transaction will be aborted in its entirety. If all operations in the transaction are rolled back, this transaction is also unregistered and closed. Rolling back a log entry through rollback is akin to truncating the transactional log. The on-disk entries should not be referred to by anything in the in-memory tree or the transaction chain. JE's append only storage and the fact that the transactional log entries are intertwined through the physical log prohibits any log truncation. To mimic log truncation, any rolled back log entry is marked as obsolete. Since only the last version of any data record is alive, any future uses of this transaction must use the obsoleteDupsAllowed option (see Txn.countObsoleteExact) to prevent asserts about duplicate obsolete offsets. For example, suppose the transaction logs this: 100 LNa (version1) 200 LNa (version2) 300 LNa (version3) At this point in time, LSN 100 and 200 are obsolete. Now, suppose we roll back to LSN 100. LSNs 200 and 300 are marked obsolete by the rollback.(although LSN 200 was already obsolete). It is true that for an instance in time LSN 100 is incorrectly marked as obsolete, when it's really alive. But this transaction is going to either abort or resume exactly as it was before, so LSN 100 is going to be obsolete again. Suppose txn.abort() is called. The abort() logic will mark LSN 100 as obsolete, since it is the latest version of the record in the transaction. Using the obsoleteDupsAllowed option avoids an assertion on the double recording of LSN 100. Alternatively, suppose LNa (version2) is retransmitted and logged as LSN 400. Normal execution of LN.log() marks LSN 100 as obsolete, which would trigger the assertion were it not for obsoleteDupsAllowed.

Returns:

list of LSNs that were rolled back

Throws:

DatabaseException

elapsedTime

public long elapsedTime()

Returns the elapsed time associated with this transaction. If the transaction is in progress, it returns the running elapsed time.

Returns:

the elapsed time as above.

getEndTime

public long getEndTime()

Returns the time when this transaction was committed or aborted. Returns zero if the transaction is still in progress.

Returns:

the end time or zero

setLastAppliedVLSN

public void setLastAppliedVLSN(VLSN justApplied)

setRepContext

public void setRepContext(ReplicationContext repContext)

ReplicatedTxns set it when the txn commit or abort arrives.

toString

public String toString()

Description copied from class: Locker

This method is safe to call without synchronizing and this fact is relied on by LockManager when creating exception messages.

Overrides:

toString in class Locker

copyDatabasesForConversion

public void copyDatabasesForConversion(Txn masterTxn)

stealLockFromMasterTxn

public void stealLockFromMasterTxn(Long lsn)

Transfer a lock from another transaction to this one. Used for master-> replica transitions, when a node has to transform a MasterTxn into a ReplayTxn. Another approach would be to have this importunate ReplayTxn call lock() on the lsn, but that path is not available because we do not have a handle on a databaseImpl.