co.cask.tephra

Interface TransactionExecutor

All Known Implementing Classes:

AbstractTransactionExecutor, DefaultTransactionExecutor

public interface TransactionExecutor

Utility that wraps the execution of a function into the context of a transaction.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	TransactionExecutor.Function<I,O> A function is a class with a single method that takes an argument and returns a result.
static interface	TransactionExecutor.Procedure<I> A procedure is a class with a single void method that takes an argument.
static interface	TransactionExecutor.Subroutine A subroutine is a class with a single void method without arguments.

Method Summary

Methods

Modifier and Type	Method and Description
<O> O	execute(Callable<O> callable) Like execute(Function, Object) but the callable has no argument.
<I,O> O	execute(TransactionExecutor.Function<I,O> function, I input) Execute a function under transactional semantics.
<I> void	execute(TransactionExecutor.Procedure<I> procedure, I input) Like execute(Function, Object) but without a return value.
void	execute(TransactionExecutor.Subroutine subroutine) Like execute(Function, Object) but without argument or return value.
<O> O	executeUnchecked(Callable<O> callable) Same as execute(Callable) but suppresses exception with Throwables.propagate(Throwable)
<I,O> O	executeUnchecked(TransactionExecutor.Function<I,O> function, I input) Same as execute(Function, Object) but suppresses exception with Throwables.propagate(Throwable)
<I> void	executeUnchecked(TransactionExecutor.Procedure<I> procedure, I input) Same as execute(Procedure, Object) but suppresses exception with Throwables.propagate(Throwable)
void	executeUnchecked(TransactionExecutor.Subroutine subroutine) Same as execute(Subroutine) but suppresses exception with Throwables.propagate(Throwable)
<O> com.google.common.util.concurrent.ListenableFuture<O>	submit(Callable<O> callable) Same as execute(Callable) but executes asynchronously
<I,O> com.google.common.util.concurrent.ListenableFuture<O>	submit(TransactionExecutor.Function<I,O> function, I input) Same as execute(Function, Object) but executes asynchronously
<I> com.google.common.util.concurrent.ListenableFuture<?>	submit(TransactionExecutor.Procedure<I> procedure, I input) Same as execute(Procedure, Object) but executes asynchronously
com.google.common.util.concurrent.ListenableFuture<?>	submit(TransactionExecutor.Subroutine subroutine) Same as execute(Subroutine) but executes asynchronously

Method Detail

execute

<I,O> O execute(TransactionExecutor.Function<I,O> function,
              I input)
          throws TransactionFailureException,
                 InterruptedException

Execute a function under transactional semantics. A transaction is started and all datasets are initialized with the transaction. Then the passed function is executed, the transaction is committed, and the function return value is returned as the return value of this method. If any exception is caught, the transaction is aborted and the original exception is rethrown, wrapped into a TransactionFailureException. If the transaction fails due to a write conflict, a TransactionConflictException is thrown.

Type Parameters:

I - the input type of the function

O - the result type of the function

Parameters:

function - the function to execute

input - the input parameter for the function

Returns:

the function's return value

Throws:

TransactionConflictException - if there is a write conflict with another transaction.

TransactionFailureException - if any exception is caught, be it from the function or from the datasets.

InterruptedException

execute

<I> void execute(TransactionExecutor.Procedure<I> procedure,
               I input)
             throws TransactionFailureException,
                    InterruptedException

Like execute(Function, Object) but without a return value.

Throws:

TransactionFailureException

InterruptedException

execute

<O> O execute(Callable<O> callable)
          throws TransactionFailureException,
                 InterruptedException

Like execute(Function, Object) but the callable has no argument.

Throws:

TransactionFailureException

InterruptedException

execute

void execute(TransactionExecutor.Subroutine subroutine)
             throws TransactionFailureException,
                    InterruptedException

Like execute(Function, Object) but without argument or return value.

Throws:

TransactionFailureException

InterruptedException

executeUnchecked

<I,O> O executeUnchecked(TransactionExecutor.Function<I,O> function,
                       I input)

Same as execute(Function, Object) but suppresses exception with Throwables.propagate(Throwable)

executeUnchecked

<I> void executeUnchecked(TransactionExecutor.Procedure<I> procedure,
                        I input)

Same as execute(Procedure, Object) but suppresses exception with Throwables.propagate(Throwable)

executeUnchecked

<O> O executeUnchecked(Callable<O> callable)

Same as execute(Callable) but suppresses exception with Throwables.propagate(Throwable)

executeUnchecked

void executeUnchecked(TransactionExecutor.Subroutine subroutine)

Same as execute(Subroutine) but suppresses exception with Throwables.propagate(Throwable)

submit

<I,O> com.google.common.util.concurrent.ListenableFuture<O> submit(TransactionExecutor.Function<I,O> function,
                                                                 I input)

Same as execute(Function, Object) but executes asynchronously

submit

<I> com.google.common.util.concurrent.ListenableFuture<?> submit(TransactionExecutor.Procedure<I> procedure,
                                                               I input)

Same as execute(Procedure, Object) but executes asynchronously

submit

<O> com.google.common.util.concurrent.ListenableFuture<O> submit(Callable<O> callable)

Same as execute(Callable) but executes asynchronously

submit

com.google.common.util.concurrent.ListenableFuture<?> submit(TransactionExecutor.Subroutine subroutine)

Same as execute(Subroutine) but executes asynchronously