org.apache.tinkerpop.gremlin.structure.util

Class AbstractTransaction

java.lang.Object

org.apache.tinkerpop.gremlin.structure.util.AbstractTransaction

All Implemented Interfaces:

Closeable, AutoCloseable, Transaction

public abstract class AbstractTransaction
extends Object
implements Transaction

A simple base class for Transaction that provides some common functionality and default behavior. Vendors can use this class as a starting point for their own implementations. Implementers should note that this class assumes that threaded transactions are not enabled. Vendors should explicitly override createThreadedTx() to implement that functionality if required.

Note that transaction listeners are registered in a ThreadLocal fashion which matches the pattern expected of vendor implementations of a Transaction.

Author:

Stephen Mallette (http://stephen.genoprime.com)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AbstractTransaction.TransactionException An "internal" exception thrown by vendors when calls to doCommit() or doRollback() fail.

Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction

Transaction.CLOSE_BEHAVIOR, Transaction.Exceptions, Transaction.READ_WRITE_BEHAVIOR, Transaction.Status, Transaction.Workload<R>

Field Summary

Fields

Modifier and Type	Field and Description
protected Consumer<Transaction>	closeConsumer
protected Consumer<Transaction>	readWriteConsumer

Constructor Summary

Constructors

Constructor and Description
AbstractTransaction(Graph g)

Method Summary

Modifier and Type	Method and Description
void	addTransactionListener(Consumer<Transaction.Status> listener) Adds a listener that is called back with a status when a commit or rollback is successful.
void	clearTransactionListeners() Removes all transaction listeners.
void	close() Closes the transaction where the default close behavior will be executed.
void	commit() Commits a transaction.
<G extends Graph> G	createThreadedTx() Creates a transaction that can be executed across multiple threads.
protected abstract void	doCommit() Called with commit() after the readWriteConsumer has been notified.
protected abstract void	doOpen() Called within open() if it is determined that the transaction is not yet open given Transaction.isOpen().
protected abstract void	doRollback() Called with rollback() after the readWriteConsumer has been notified.
Transaction	onClose(Consumer<Transaction> consumer) Describes what happens to a transaction on a call to AutoCloseable.close().
Transaction	onReadWrite(Consumer<Transaction> consumer) Describes how a transaction is started when a read or a write occurs.
void	open() Opens a transaction.
void	readWrite() An internal function that signals a read or a write has occurred - not meant to be called directly by end users.
void	removeTransactionListener(Consumer<Transaction.Status> listener) Removes a transaction listener.
void	rollback() Rolls back a transaction.
<R> Transaction.Workload<R>	submit(Function<Graph,R> work) Submit a unit of work that represents a transaction returning a Transaction.Workload that can be automatically retried in the event of failure.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction

isOpen

Field Detail

readWriteConsumer

protected Consumer<Transaction> readWriteConsumer

closeConsumer

protected Consumer<Transaction> closeConsumer

Constructor Detail

AbstractTransaction

public AbstractTransaction(Graph g)

Method Detail

doOpen

protected abstract void doOpen()

Called within open() if it is determined that the transaction is not yet open given Transaction.isOpen(). Implementers should assume the transaction is not yet started and should thus open one.

doCommit

protected abstract void doCommit()
                          throws AbstractTransaction.TransactionException

Called with commit() after the readWriteConsumer has been notified. Implementers should include their commit logic here.

Throws:

AbstractTransaction.TransactionException

doRollback

protected abstract void doRollback()
                            throws AbstractTransaction.TransactionException

Called with rollback() after the readWriteConsumer has been notified. Implementers should include their rollback logic here.

Throws:

AbstractTransaction.TransactionException

open

public void open()

Description copied from interface: Transaction

Opens a transaction.

Specified by:

open in interface Transaction

commit

public void commit()

Description copied from interface: Transaction

Commits a transaction.

Specified by:

commit in interface Transaction

rollback

public void rollback()

Description copied from interface: Transaction

Rolls back a transaction.

Specified by:

rollback in interface Transaction

submit

public <R> Transaction.Workload<R> submit(Function<Graph,R> work)

Description copied from interface: Transaction

Submit a unit of work that represents a transaction returning a Transaction.Workload that can be automatically retried in the event of failure.

Specified by:

submit in interface Transaction

createThreadedTx

public <G extends Graph> G createThreadedTx()

Description copied from interface: Transaction

Creates a transaction that can be executed across multiple threads. The Graph returned from this method is not meant to represent some form of child transaction that can be committed from this object. A threaded transaction is a Graph instance that has a transaction context that enables multiple threads to collaborate on the same transaction. A standard transactional context tied to a Graph that supports transactions will typically bind a transaction to a single thread via ThreadLocal.

Specified by:

createThreadedTx in interface Transaction

readWrite

public void readWrite()

Description copied from interface: Transaction

An internal function that signals a read or a write has occurred - not meant to be called directly by end users.

Specified by:

readWrite in interface Transaction

close

public void close()

Description copied from interface: Transaction

Closes the transaction where the default close behavior will be executed.

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Specified by:

close in interface Transaction

onReadWrite

public Transaction onReadWrite(Consumer<Transaction> consumer)

Description copied from interface: Transaction

Describes how a transaction is started when a read or a write occurs. This value can be set using standard behaviors defined in Transaction.READ_WRITE_BEHAVIOR or a mapper Consumer function.

Specified by:

onReadWrite in interface Transaction

onClose

public Transaction onClose(Consumer<Transaction> consumer)

Description copied from interface: Transaction

Describes what happens to a transaction on a call to AutoCloseable.close(). This value can be set using standard behavior defined in Transaction.CLOSE_BEHAVIOR or a mapper Consumer function.

Specified by:

onClose in interface Transaction

addTransactionListener

public void addTransactionListener(Consumer<Transaction.Status> listener)

Description copied from interface: Transaction

Adds a listener that is called back with a status when a commit or rollback is successful. It is expected that listeners be bound to the current thread as is standard for transactions. Therefore a listener registered in the current thread will not get callback events from a commit or rollback call in a different thread.

Specified by:

addTransactionListener in interface Transaction

removeTransactionListener

public void removeTransactionListener(Consumer<Transaction.Status> listener)

Description copied from interface: Transaction

Removes a transaction listener.

Specified by:

removeTransactionListener in interface Transaction

clearTransactionListeners

public void clearTransactionListeners()

Description copied from interface: Transaction

Removes all transaction listeners.

Specified by:

clearTransactionListeners in interface Transaction