LifecycleTransaction (apache-cassandra API)

java.lang.Object
- org.apache.cassandra.utils.concurrent.Transactional.AbstractTransactional
- - org.apache.cassandra.db.lifecycle.LifecycleTransaction

All Implemented Interfaces:

java.lang.AutoCloseable, Transactional
```
public class LifecycleTransaction
extends Transactional.AbstractTransactional
```
IMPORTANT: When this object is involved in a transactional graph, for correct behaviour its commit MUST occur before any others, since it may legitimately fail. This is consistent with the Transactional API, which permits one failing action to occur at the beginning of the commit phase, but also *requires* that the prepareToCommit() phase only take actions that can be rolled back.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class LifecycleTransaction.ReaderState
- Nested classes/interfaces inherited from interface org.apache.cassandra.utils.concurrent.Transactional
  Transactional.AbstractTransactional

Nested Classes
Modifier and Type	Class and Description
`static class`	`LifecycleTransaction.ReaderState`

Field Summary

Fields
Modifier and Type Field and Description

Tracker tracker

Fields
Modifier and Type	Field and Description
`Tracker`	`tracker`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`cancel(java.lang.Iterable<SSTableReader> cancels)` remove the readers from the set we're modifying
`void`	`cancel(SSTableReader cancel)` remove the reader from the set we're modifying
`void`	`checkpoint()` call when a consistent batch of changes is ready to be made atomically visible these will be exposed in the Tracker atomically, or an exception will be thrown; in this case the transaction should be rolled back
`java.lang.Iterable<SSTableReader>`	`current()` returns the currently visible readers managed by this transaction
`SSTableReader`	`current(SSTableReader reader)` return the current version of the provided reader, whether or not it is visible or staged; i.e.
`java.lang.Throwable`	`doAbort(java.lang.Throwable accumulate)` undo all of the changes made by this transaction, resetting the state to its original form
`java.lang.Throwable`	`doCommit(java.lang.Throwable accumulate)` point of no return: commit all changes, but leave all readers marked as compacting
`protected java.lang.Throwable`	`doPostCleanup(java.lang.Throwable accumulate)` perform an exception-safe post-abort cleanup
`void`	`doPrepare()` Do any preparatory work prior to commit.
`static java.util.List<java.io.File>`	`getFiles(java.nio.file.Path folder, java.util.function.BiFunction<java.io.File,Directories.FileType,java.lang.Boolean> filter, Directories.OnTxnErr onTxnErr)` Get the files in the folder specified, provided that the filter returns true.
`boolean`	`isObsolete(SSTableReader reader)` indicates if the reader has been marked for obsoletion
`boolean`	`isOffline()`
`org.apache.cassandra.db.lifecycle.LogTransaction`	`log()`
`void`	`obsolete(SSTableReader reader)` mark this reader as for obsoletion : on checkpoint() the reader will be removed from the live set
`void`	`obsoleteOriginals()` obsolete every file in the original transaction
`static LifecycleTransaction`	`offline(OperationType operationType)` construct an empty Transaction with no existing readers
`static LifecycleTransaction`	`offline(OperationType operationType, java.lang.Iterable<SSTableReader> readers)` construct a Transaction for use in an offline operation
`static LifecycleTransaction`	`offline(OperationType operationType, SSTableReader reader)` construct a Transaction for use in an offline operation
`SSTableReader`	`onlyOne()`
`java.util.UUID`	`opId()`
`OperationType`	`opType()`
`java.util.Set<SSTableReader>`	`originals()` the set of readers guarded by this transaction _in their original instance/state_ call current(SSTableReader) on any reader in this set to get the latest instance
`void`	`permitRedundantTransitions()`
`static void`	`removeUnfinishedLeftovers(CFMetaData metadata)`
`static void`	`rescheduleFailedDeletions()` Retry all deletions that failed the first time around (presumably b/c the sstable was still mmap'd.) Useful because there are times when we know GC has been invoked; also exposed as an mbean.
`LifecycleTransaction`	`split(java.util.Collection<SSTableReader> readers)` remove the provided readers from this Transaction, and return a new Transaction to manage them only permitted to be called if the current Transaction has never been used
`LifecycleTransaction.ReaderState`	`state(SSTableReader reader)`
`java.lang.String`	`toString()`
`void`	`trackNew(SSTable table)`
`void`	`untrackNew(SSTable table)`
`void`	`update(java.util.Collection<SSTableReader> readers, boolean original)`
`void`	`update(SSTableReader reader, boolean original)` update a reader: if !original, this is a reader that is being introduced by this transaction; otherwise it must be in the originals() set, i.e.
`static void`	`waitForDeletions()` Deletions run on the nonPeriodicTasks executor, (both failedDeletions or global tidiers in SSTableReader) so by scheduling a new empty task and waiting for it we ensure any prior deletion has completed.

Methods inherited from class org.apache.cassandra.utils.concurrent.Transactional.AbstractTransactional
abort, abort, close, commit, commit, doPreCleanup, finish, prepareToCommit, state

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

- Field Detail
  - tracker
```
public final Tracker tracker
```
- Method Detail
  - offline
```
public static LifecycleTransaction offline(OperationType operationType,
                                           SSTableReader reader)
```
    construct a Transaction for use in an offline operation
  - offline
```
public static LifecycleTransaction offline(OperationType operationType,
                                           java.lang.Iterable<SSTableReader> readers)
```
    construct a Transaction for use in an offline operation
  - offline
```
public static LifecycleTransaction offline(OperationType operationType)
```
    construct an empty Transaction with no existing readers
  - log
```
public org.apache.cassandra.db.lifecycle.LogTransaction log()
```
  - opType
```
public OperationType opType()
```
  - opId
```
public java.util.UUID opId()
```
  - doPrepare
```
public void doPrepare()
```
    Description copied from class: Transactional.AbstractTransactional
    
    Do any preparatory work prior to commit. This method should throw any exceptions that can be encountered during the finalization of the behaviour.
    
    Specified by:
    
    doPrepare in class Transactional.AbstractTransactional
  - doCommit
```
public java.lang.Throwable doCommit(java.lang.Throwable accumulate)
```
    point of no return: commit all changes, but leave all readers marked as compacting
    
    Specified by:
    
    doCommit in class Transactional.AbstractTransactional
  - doAbort
```
public java.lang.Throwable doAbort(java.lang.Throwable accumulate)
```
    undo all of the changes made by this transaction, resetting the state to its original form
    
    Specified by:
    
    doAbort in class Transactional.AbstractTransactional
  - doPostCleanup
```
protected java.lang.Throwable doPostCleanup(java.lang.Throwable accumulate)
```
    Description copied from class: Transactional.AbstractTransactional
    
    perform an exception-safe post-abort cleanup
    
    Overrides:
    
    doPostCleanup in class Transactional.AbstractTransactional
  - isOffline
```
public boolean isOffline()
```
  - permitRedundantTransitions
```
public void permitRedundantTransitions()
```
    Overrides:
    
    permitRedundantTransitions in class Transactional.AbstractTransactional
  - checkpoint
```
public void checkpoint()
```
    call when a consistent batch of changes is ready to be made atomically visible these will be exposed in the Tracker atomically, or an exception will be thrown; in this case the transaction should be rolled back
  - update
```
public void update(SSTableReader reader,
                   boolean original)
```
    update a reader: if !original, this is a reader that is being introduced by this transaction; otherwise it must be in the originals() set, i.e. a reader guarded by this transaction
  - update
```
public void update(java.util.Collection<SSTableReader> readers,
                   boolean original)
```
  - obsolete
```
public void obsolete(SSTableReader reader)
```
    mark this reader as for obsoletion : on checkpoint() the reader will be removed from the live set
  - obsoleteOriginals
```
public void obsoleteOriginals()
```
    obsolete every file in the original transaction
  - current
```
public java.lang.Iterable<SSTableReader> current()
```
    returns the currently visible readers managed by this transaction
  - originals
```
public java.util.Set<SSTableReader> originals()
```
    the set of readers guarded by this transaction _in their original instance/state_ call current(SSTableReader) on any reader in this set to get the latest instance
  - isObsolete
```
public boolean isObsolete(SSTableReader reader)
```
    indicates if the reader has been marked for obsoletion
  - current
```
public SSTableReader current(SSTableReader reader)
```
    return the current version of the provided reader, whether or not it is visible or staged; i.e. returns the first version present by testing staged, logged and originals in order.
  - cancel
```
public void cancel(SSTableReader cancel)
```
    remove the reader from the set we're modifying
  - cancel
```
public void cancel(java.lang.Iterable<SSTableReader> cancels)
```
    remove the readers from the set we're modifying
  - split
```
public LifecycleTransaction split(java.util.Collection<SSTableReader> readers)
```
    remove the provided readers from this Transaction, and return a new Transaction to manage them only permitted to be called if the current Transaction has never been used
  - onlyOne
```
public SSTableReader onlyOne()
```
  - trackNew
```
public void trackNew(SSTable table)
```
  - untrackNew
```
public void untrackNew(SSTable table)
```
  - removeUnfinishedLeftovers
```
public static void removeUnfinishedLeftovers(CFMetaData metadata)
```
  - getFiles
```
public static java.util.List<java.io.File> getFiles(java.nio.file.Path folder,
                                                    java.util.function.BiFunction<java.io.File,Directories.FileType,java.lang.Boolean> filter,
                                                    Directories.OnTxnErr onTxnErr)
```
    Get the files in the folder specified, provided that the filter returns true. A filter is given each file and its type, and decides which files should be returned and which should be discarded. To classify files into their type, we read transaction log files. Should we fail to read these log files after a few times, we look at onTxnErr to determine what to do.
    
    Parameters:
    
    folder - - the folder to scan
    
    onTxnErr - - how to handle a failure to read a txn log file
    
    filter - - A function that receives each file and its type, it should return true to have the file returned
    
    Returns:
    
    - the list of files that were scanned and for which the filter returned true
  - rescheduleFailedDeletions
```
public static void rescheduleFailedDeletions()
```
    Retry all deletions that failed the first time around (presumably b/c the sstable was still mmap'd.) Useful because there are times when we know GC has been invoked; also exposed as an mbean.
  - waitForDeletions
```
public static void waitForDeletions()
```
    Deletions run on the nonPeriodicTasks executor, (both failedDeletions or global tidiers in SSTableReader) so by scheduling a new empty task and waiting for it we ensure any prior deletion has completed.
  - state
```
public LifecycleTransaction.ReaderState state(SSTableReader reader)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class LifecycleTransaction

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.cassandra.utils.concurrent.Transactional

Field Summary

Method Summary

Methods inherited from class org.apache.cassandra.utils.concurrent.Transactional.AbstractTransactional

Methods inherited from class java.lang.Object

Field Detail

tracker

Method Detail

offline

offline

offline

log

opType

opId

doPrepare

doCommit

doAbort

doPostCleanup

isOffline

permitRedundantTransitions

checkpoint

update

update

obsolete

obsoleteOriginals

current

originals

isObsolete

current

cancel

cancel

split

onlyOne

trackNew

untrackNew

removeUnfinishedLeftovers

getFiles

rescheduleFailedDeletions

waitForDeletions

state

toString