TransactionManager

java.lang.Object
- fabric.worker.transaction.TransactionManager

```
public final class TransactionManager
extends java.lang.Object
```
Holds transaction management information for a single thread. Each thread has its own TransactionManager.
We say that a transaction has acquired a write lock on an object if any entry in the object's $history list has $writeLockHolder set to that transaction. @see fabric.lang.Object._Impl

We say that a transaction has acquired a read lock if it is in the "read list" for that object. @see fabric.lang.Object._Impl.$readMapEntry

When a transaction acquires a read lock, we ensure that the read condition holds: that the holder of the write lock is an ancestor of that transaction. Before reading an object, we ensure that the transaction holds a read lock and that the read condition still holds.

When a transaction acquires a write lock, we ensure that the write condition holds: the holders of the read and write locks are all ancestors of that transaction. Before writing an object, we ensure that the transaction holds a write lock and that the write condition still holds.

Assumptions:
- Once the top-level transaction within a thread aborts or commits, that thread will terminate without performing further operations on the transaction manager.
- The fetch operation will not be invoked concurrently on the same object.
The following objects are used as condition variables:
- Log.children - for signalling that all sub-transactions of a given transaction have finished.
- Impl objects - for signalling to readers and writers that a read or write lock on that object has been released.

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.ThreadLocal<java.lang.Long>`	`COMMIT_TIME` XXX Really gross HACK to make actual transaction commit times visible to the application.
`static java.lang.ThreadLocal<java.lang.String[]>`	`CONTACTED_NODES` XXX Similarly gross HACK for making the nodes contacted by this client during commit visible to the application.
`static java.lang.ThreadLocal<java.lang.Integer>`	`ROUND_TRIPS` XXX Similarly gross HACK for making transaction commit round trips visible to the application.
`static boolean`	`TRACE_WRITE_LOCKS` A debugging switch for storing a stack trace each time a write lock is obtained.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`abortReaders(Store store, long onum)`
`void`	`abortTransaction()` Aborts the transaction, recursing to any workers that were called, and any stores that were contacted.
`void`	`associateAndSyncLog(Log log, TransactionID tid)` Associates the given log with this worker's transaction manager and synchronizes the log with the given tid.
`void`	`associateLog(Log log)` Associates the given transaction log with this transaction manager.
`boolean`	`checkForStaleObjects()` Checks whether any of the objects used by a transaction are stale.
`void`	`commitTransaction()` Commits the transaction if possible; otherwise, aborts the transaction.
`void`	`commitTransaction(boolean ignoreRetrySignal)`
`void`	`deregisterThread(java.lang.Thread thread)` Registers that the given thread has finished.
`Log`	`getCurrentLog()`
`TransactionID`	`getCurrentTid()`
`RemoteWorker`	`getFetchWorker(Object._Proxy proxy)`
`static TransactionManager`	`getInstance()`
`static ReadMap.Entry`	`getReadMapEntry(Object._Impl impl, long expiry)`
`SecurityCache`	`getSecurityCache()`
`WriterMap`	`getWriterMap()`
`static boolean`	`haveReaders(Store store, long onum)`
`void`	`registerCreate(Object._Impl obj)`
`void`	`registerLabelsInitialized(Object._Impl obj)`
`void`	`registerRead(Object._Impl obj)`
`void`	`registerRemoteCall(RemoteWorker worker)` Registers a remote call to the given worker.
`void`	`registerThread(java.lang.Thread thread)` Registers the given thread with the current transaction.
`boolean`	`registerWrite(Object._Impl obj)` This should be called before the object is modified.
`void`	`sendCommitMessagesAndCleanUp()` Sends commit messages to the cohorts in a distributed transaction.
`void`	`sendPrepareMessages()` Sends prepare messages to the cohorts in a distributed transaction.
`static void`	`startThread(java.lang.Thread thread)` Starts the given thread, registering it as necessary.
`void`	`startTransaction()` Starts a new transaction.
`void`	`startTransaction(TransactionID tid)` Starts a new transaction with the given tid.

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

- Field Detail
  - TRACE_WRITE_LOCKS
```
public static boolean TRACE_WRITE_LOCKS
```
    A debugging switch for storing a stack trace each time a write lock is obtained. Enable this by passing "--trace-locks" as a command-line argument to the node.
  - COMMIT_TIME
```
public static final java.lang.ThreadLocal<java.lang.Long> COMMIT_TIME
```
    XXX Really gross HACK to make actual transaction commit times visible to the application. This allows us to measure end-to-end application-level transaction latency.
  - ROUND_TRIPS
```
public static final java.lang.ThreadLocal<java.lang.Integer> ROUND_TRIPS
```
    XXX Similarly gross HACK for making transaction commit round trips visible to the application.
  - CONTACTED_NODES
```
public static final java.lang.ThreadLocal<java.lang.String[]> CONTACTED_NODES
```
    XXX Similarly gross HACK for making the nodes contacted by this client during commit visible to the application.
- Method Detail
  - haveReaders
```
public static boolean haveReaders(Store store,
                                  long onum)
```
  - abortReaders
```
public static void abortReaders(Store store,
                                long onum)
```
  - getReadMapEntry
```
public static ReadMap.Entry getReadMapEntry(Object._Impl impl,
                                            long expiry)
```
  - getInstance
```
public static TransactionManager getInstance()
```
  - abortTransaction
```
public void abortTransaction()
```
    Aborts the transaction, recursing to any workers that were called, and any stores that were contacted.
  - commitTransaction
```
public void commitTransaction()
                       throws AbortException,
                              TransactionRestartingException,
                              TransactionAtomicityViolationException
```
    Commits the transaction if possible; otherwise, aborts the transaction.
    
    Throws:
    
    AbortException - if the transaction was aborted.
    
    TransactionRestartingException - if the transaction was aborted and needs to be retried.
    
    TransactionAtomicityViolationException
  - commitTransaction
```
public void commitTransaction(boolean ignoreRetrySignal)
```
    Throws:
    
    TransactionRestartingException - if the prepare fails.
  - sendPrepareMessages
```
public void sendPrepareMessages()
```
    Sends prepare messages to the cohorts in a distributed transaction. Also sends abort messages if any cohort fails to prepare.
    
    Throws:
    
    TransactionRestartingException - if the prepare fails.
  - sendCommitMessagesAndCleanUp
```
public void sendCommitMessagesAndCleanUp()
                                  throws TransactionAtomicityViolationException
```
    Sends commit messages to the cohorts in a distributed transaction.
    
    Throws:
    
    TransactionAtomicityViolationException
  - registerCreate
```
public void registerCreate(Object._Impl obj)
```
  - registerLabelsInitialized
```
public void registerLabelsInitialized(Object._Impl obj)
```
  - registerRead
```
public void registerRead(Object._Impl obj)
```
  - registerWrite
```
public boolean registerWrite(Object._Impl obj)
```
    This should be called before the object is modified.
    
    Returns:
    
    whether a new (top-level) transaction was created.
  - checkForStaleObjects
```
public boolean checkForStaleObjects()
```
    Checks whether any of the objects used by a transaction are stale.
    
    Returns:
    
    true iff stale objects were found
  - startTransaction
```
public void startTransaction()
```
    Starts a new transaction. The sub-transaction runs in the same thread as the caller.
  - startTransaction
```
public void startTransaction(TransactionID tid)
```
    Starts a new transaction with the given tid. The given tid is assumed to be a valid descendant of the current tid. If the given tid is null, a random tid is generated for the sub-transaction.
  - startThread
```
public static void startThread(java.lang.Thread thread)
```
    Starts the given thread, registering it as necessary.
  - registerThread
```
public void registerThread(java.lang.Thread thread)
```
    Registers the given thread with the current transaction. This should be called before the thread is started.
  - deregisterThread
```
public void deregisterThread(java.lang.Thread thread)
```
    Registers that the given thread has finished.
  - registerRemoteCall
```
public void registerRemoteCall(RemoteWorker worker)
```
    Registers a remote call to the given worker.
  - associateLog
```
public void associateLog(Log log)
```
    Associates the given transaction log with this transaction manager.
  - getCurrentLog
```
public Log getCurrentLog()
```
  - getCurrentTid
```
public TransactionID getCurrentTid()
```
  - getWriterMap
```
public WriterMap getWriterMap()
```
  - getFetchWorker
```
public RemoteWorker getFetchWorker(Object._Proxy proxy)
```
    Returns:
    
    the worker on which the object resides. An object resides on a worker if it is either on that worker's local store, or if it was created by the current transaction and is owned by that worker.
  - getSecurityCache
```
public SecurityCache getSecurityCache()
```
  - associateAndSyncLog
```
public void associateAndSyncLog(Log log,
                                TransactionID tid)
```
    Associates the given log with this worker's transaction manager and synchronizes the log with the given tid.

Class TransactionManager

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TRACE_WRITE_LOCKS

COMMIT_TIME

ROUND_TRIPS

CONTACTED_NODES

Method Detail

haveReaders

abortReaders

getReadMapEntry

getInstance

abortTransaction

commitTransaction

commitTransaction

sendPrepareMessages

sendCommitMessagesAndCleanUp

registerCreate

registerLabelsInitialized

registerRead

registerWrite

checkForStaleObjects

startTransaction

startTransaction

startThread

registerThread

deregisterThread

registerRemoteCall

associateLog

getCurrentLog

getCurrentTid

getWriterMap

getFetchWorker

getSecurityCache

associateAndSyncLog