org.apache.omid.transaction

Class AbstractTransactionManager

java.lang.Object

org.apache.omid.transaction.AbstractTransactionManager

All Implemented Interfaces:

Closeable, AutoCloseable, TransactionManager

public abstract class AbstractTransactionManager
extends Object
implements TransactionManager

Omid's base abstract implementation of the TransactionManager interface. Provides extra methods to allow transaction manager developers to perform different actions before/after the methods exposed by the TransactionManager interface. So, this abstract class must be extended by particular implementations of transaction managers related to different storage systems (HBase...)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	AbstractTransactionManager.TransactionFactory<T extends CellId>

Field Summary

Fields

Modifier and Type	Field and Description
protected CommitTable.Client	commitTableClient
protected TSOProtocol	tsoClient

Constructor Summary

Constructors

Constructor and Description
AbstractTransactionManager(MetricsRegistry metrics, PostCommitActions postCommitter, TSOProtocol tsoClient, CommitTable.Client commitTableClient, CommitTable.Writer commitTableWriter, AbstractTransactionManager.TransactionFactory<? extends CellId> transactionFactory) Base constructor

Method Summary

Modifier and Type	Method and Description
Transaction	begin() Starts a new transaction.
void	close()
protected abstract void	closeResources()
void	commit(Transaction transaction) Commits a transaction.
Transaction	fence(byte[] tableName) Creates a fence Creates a fence and returns a Transaction interface implementation that contains the fence information.
CommitTable.Client	getCommitTableClient() Return the commit table client
abstract long	getHashForTable(byte[] tableName) Generates hash ID for table name, this hash is later-on sent to the TSO and used for fencing
boolean	isLowLatency()
void	postBegin(AbstractTransaction<? extends CellId> transaction) Allows transaction manager developers to perform actions after having started a transaction.
void	postCommit(AbstractTransaction<? extends CellId> transaction) Allows transaction manager developers to perform actions after committing a transaction.
void	postRollback(AbstractTransaction<? extends CellId> transaction) Allows transaction manager developers to perform actions after rolling-back a transaction.
void	preBegin() Allows transaction manager developers to perform actions before creating a transaction.
void	preCommit(AbstractTransaction<? extends CellId> transaction) Allows transaction manager developers to perform actions before committing a transaction.
void	preRollback(AbstractTransaction<? extends CellId> transaction) Allows transaction manager developers to perform actions before rolling-back a transaction.
void	rollback(Transaction transaction) Aborts a transaction.

Methods inherited from class java.lang.Object

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

Field Detail

tsoClient

protected final TSOProtocol tsoClient

commitTableClient

protected final CommitTable.Client commitTableClient

Constructor Detail

AbstractTransactionManager

public AbstractTransactionManager(MetricsRegistry metrics,
                                  PostCommitActions postCommitter,
                                  TSOProtocol tsoClient,
                                  CommitTable.Client commitTableClient,
                                  CommitTable.Writer commitTableWriter,
                                  AbstractTransactionManager.TransactionFactory<? extends CellId> transactionFactory)

Base constructor

Parameters:

metrics - instrumentation metrics

postCommitter - post commit action executor

tsoClient - a client for accessing functionality of the status oracle

commitTableClient - a client for accessing functionality of the commit table

transactionFactory - a transaction factory to create the specific transaction objects required by the transaction manager being implemented.

Method Detail

preBegin

public void preBegin()
              throws TransactionManagerException

Allows transaction manager developers to perform actions before creating a transaction.

Throws:

TransactionManagerException - in case of any issues

begin

public final Transaction begin()
                        throws TransactionException

Description copied from interface: TransactionManager

Starts a new transaction. Creates and returns a Transaction interface implementation that will be used in TTable's methods for doing operations on the transactional context defined by the returned object.

Specified by:

begin in interface TransactionManager

Returns:

transaction representation of the created transaction

Throws:

TransactionException - in case of any issues

See Also:

TransactionManager.begin()

getHashForTable

public abstract long getHashForTable(byte[] tableName)

Generates hash ID for table name, this hash is later-on sent to the TSO and used for fencing

Parameters:

tableName - - the table name

Returns:

getCommitTableClient

public CommitTable.Client getCommitTableClient()

Return the commit table client

Returns:

commitTableClient

fence

public final Transaction fence(byte[] tableName)
                        throws TransactionException

Description copied from interface: TransactionManager

Creates a fence Creates a fence and returns a Transaction interface implementation that contains the fence information.

Specified by:

fence in interface TransactionManager

Parameters:

tableName - name of the table that requires a fence

Returns:

transaction representation contains the fence timestamp as the TransactionId.

Throws:

TransactionException - in case of any issues

See Also:

TransactionManager.fence(byte[])

postBegin

public void postBegin(AbstractTransaction<? extends CellId> transaction)
               throws TransactionManagerException

Allows transaction manager developers to perform actions after having started a transaction.

Parameters:

transaction - the transaction that was just created.

Throws:

TransactionManagerException - in case of any issues

preCommit

public void preCommit(AbstractTransaction<? extends CellId> transaction)
               throws TransactionManagerException

Allows transaction manager developers to perform actions before committing a transaction.

Parameters:

transaction - the transaction that is going to be committed.

Throws:

TransactionManagerException - in case of any issues

commit

public final void commit(Transaction transaction)
                  throws RollbackException,
                         TransactionException

Description copied from interface: TransactionManager

Commits a transaction. If the transaction was marked for rollback or has conflicts with another concurrent transaction it will be rolledback automatically and a RollbackException will be thrown.

Specified by:

commit in interface TransactionManager

Parameters:

transaction - transaction to be committed.

Throws:

RollbackException - thrown when transaction has conflicts with another transaction or when was marked for rollback.

TransactionException - in case of any issues

See Also:

TransactionManager.commit(Transaction)

postCommit

public void postCommit(AbstractTransaction<? extends CellId> transaction)
                throws TransactionManagerException

Allows transaction manager developers to perform actions after committing a transaction.

Parameters:

transaction - the transaction that was committed.

Throws:

TransactionManagerException - in case of any issues

preRollback

public void preRollback(AbstractTransaction<? extends CellId> transaction)
                 throws TransactionManagerException

Allows transaction manager developers to perform actions before rolling-back a transaction.

Parameters:

transaction - the transaction that is going to be rolled-back.

Throws:

TransactionManagerException - in case of any issues

rollback

public final void rollback(Transaction transaction)
                    throws TransactionException

Description copied from interface: TransactionManager

Aborts a transaction. Automatically rollbacks the changes performed by the transaction.

Specified by:

rollback in interface TransactionManager

Parameters:

transaction - transaction to be rolled-back

Throws:

TransactionException - in case of any issues

See Also:

TransactionManager.rollback(Transaction)

postRollback

public void postRollback(AbstractTransaction<? extends CellId> transaction)
                  throws TransactionManagerException

Allows transaction manager developers to perform actions after rolling-back a transaction.

Parameters:

transaction - the transaction that was rolled-back.

Throws:

TransactionManagerException - in case of any issues

closeResources

protected abstract void closeResources()
                                throws IOException

Throws:

IOException

close

public final void close()
                 throws IOException

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Throws:

IOException

See Also:

Closeable.close()

isLowLatency

public boolean isLowLatency()