org.opendaylight.mdsal.binding.util

Interface ManagedTransactionFactory

All Known Subinterfaces:

ManagedNewTransactionRunner, ManagedTransactionChain

All Known Implementing Classes:

ManagedNewTransactionRunnerImpl, RetryingManagedNewTransactionRunner

@Beta
public interface ManagedTransactionFactory

Managed transaction factories provide managed transactions, i.e. transactions which are automatically submitted or cancelled (write) or closed (read).

This is a common interface for broker- and chain-based transaction managers, and should not be used directly.

Method Summary

Modifier and Type	Method and Description
<D extends Datastore,E extends Exception,R> R	applyInterruptiblyWithNewReadOnlyTransactionAndClose(Class<D> datastoreType, InterruptibleCheckedFunction<TypedReadTransaction<D>,R,E> txFunction) Invokes a function with a NEW TypedReadTransaction, and ensures that that transaction is closed.
<D extends Datastore,E extends Exception,R> R	applyWithNewReadOnlyTransactionAndClose(Class<D> datastoreType, CheckedFunction<TypedReadTransaction<D>,R,E> txFunction) Invokes a function with a NEW TypedReadTransaction, and ensures that that transaction is closed.
<D extends Datastore,E extends Exception,R> com.google.common.util.concurrent.FluentFuture<R>	applyWithNewReadWriteTransactionAndSubmit(Class<D> datastoreType, InterruptibleCheckedFunction<TypedReadWriteTransaction<D>,R,E> txFunction) Invokes a function with a NEW ReadWriteTransaction, and then submits that transaction and returns the Future from that submission, or cancels it if an exception was thrown and returns a failed future with that exception.
<D extends Datastore,E extends Exception> void	callInterruptiblyWithNewReadOnlyTransactionAndClose(Class<D> datastoreType, InterruptibleCheckedConsumer<TypedReadTransaction<D>,E> txConsumer) Invokes a function with a NEW ReadTransaction, and ensures that that transaction is closed.
<D extends Datastore,E extends Exception> void	callWithNewReadOnlyTransactionAndClose(Class<D> datastoreType, CheckedConsumer<TypedReadTransaction<D>,E> txConsumer) Invokes a function with a NEW ReadTransaction, and ensures that that transaction is closed.
<D extends Datastore,E extends Exception> com.google.common.util.concurrent.FluentFuture<? extends Object>	callWithNewReadWriteTransactionAndSubmit(Class<D> datastoreType, InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>,E> txConsumer) Invokes a consumer with a NEW ReadWriteTransaction, and then submits that transaction and returns the Future from that submission, or cancels it if an exception was thrown and returns a failed future with that exception.
<D extends Datastore,E extends Exception> com.google.common.util.concurrent.FluentFuture<? extends Object>	callWithNewWriteOnlyTransactionAndSubmit(Class<D> datastoreType, InterruptibleCheckedConsumer<TypedWriteTransaction<D>,E> txConsumer) Invokes a consumer with a NEW WriteTransaction, and then submits that transaction and returns the Future from that submission, or cancels it if an exception was thrown and returns a failed future with that exception.

Method Detail

applyInterruptiblyWithNewReadOnlyTransactionAndClose

<D extends Datastore,E extends Exception,R> R applyInterruptiblyWithNewReadOnlyTransactionAndClose(Class<D> datastoreType,
                                                                                                   InterruptibleCheckedFunction<TypedReadTransaction<D>,R,E> txFunction)
                                                                                            throws E extends Exception,
                                                                                                   InterruptedException

Invokes a function with a NEW TypedReadTransaction, and ensures that that transaction is closed. Thus when this method returns, that transaction is guaranteed to have been closed, and will never "leak" and waste memory.

The function must not itself attempt to close the transaction. (It can't directly, since TypedReadTransaction doesn't expose a close() method.)

The provided transaction is specific to the given logical datastore type and cannot be used for any other.

Parameters:

datastoreType - the Datastore type that will be accessed

txFunction - the InterruptibleCheckedFunction that needs a new read transaction

Returns:

the result of the function.

Throws:

E - if an error occurs.

InterruptedException - if the function is interrupted (this is passed through from the provided function).

E extends Exception

applyWithNewReadOnlyTransactionAndClose

<D extends Datastore,E extends Exception,R> R applyWithNewReadOnlyTransactionAndClose(Class<D> datastoreType,
                                                                                      CheckedFunction<TypedReadTransaction<D>,R,E> txFunction)
                                                                               throws E extends Exception

Invokes a function with a NEW TypedReadTransaction, and ensures that that transaction is closed. Thus when this method returns, that transaction is guaranteed to have been closed, and will never "leak" and waste memory.

The function must not itself attempt to close the transaction. (It can't directly, since TypedReadTransaction doesn't expose a close() method.)

The provided transaction is specific to the given logical datastore type and cannot be used for any other.

Parameters:

datastoreType - the Datastore type that will be accessed

txFunction - the InterruptibleCheckedFunction that needs a new read transaction

Returns:

the result of the function.

Throws:

E - if an error occurs.

E extends Exception

applyWithNewReadWriteTransactionAndSubmit

@CheckReturnValue
<D extends Datastore,E extends Exception,R> com.google.common.util.concurrent.FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(Class<D> datastoreType,
                                                                                                                                                          InterruptibleCheckedFunction<TypedReadWriteTransaction<D>,R,E> txFunction)

Invokes a function with a NEW ReadWriteTransaction, and then submits that transaction and returns the Future from that submission, or cancels it if an exception was thrown and returns a failed future with that exception. Thus when this method returns, that transaction is guaranteed to have been either submitted or cancelled, and will never "leak" and waste memory.

The function must not itself use WriteTransaction.cancel(), or WriteTransaction.commit() (it will throw an UnsupportedOperationException).

The provided transaction is specific to the given logical datastore type and cannot be used for any other.

This is an asynchronous API, like DataBroker's own; when returning from this method, the operation of the Transaction may well still be ongoing in the background, or pending; calling code therefore must handle the returned future, e.g. by passing it onwards (return), or by itself adding callback listeners to it using Futures' methods, or by transforming it into a CompletionStage (but better NOT by using the blocking Future.get() on it).

Parameters:

datastoreType - the Datastore type that will be accessed

txFunction - the InterruptibleCheckedFunction that needs a new read-write transaction

Returns:

the FluentFuture returned by WriteTransaction.commit(), or a failed future with an application specific exception (not from submit())

callInterruptiblyWithNewReadOnlyTransactionAndClose

<D extends Datastore,E extends Exception> void callInterruptiblyWithNewReadOnlyTransactionAndClose(Class<D> datastoreType,
                                                                                                   InterruptibleCheckedConsumer<TypedReadTransaction<D>,E> txConsumer)
                                                                                            throws E extends Exception,
                                                                                                   InterruptedException

Invokes a function with a NEW ReadTransaction, and ensures that that transaction is closed. Thus when this method returns, that transaction is guaranteed to have been closed, and will never "leak" and waste memory.

The function must not itself attempt to close the transaction. (It can't directly, since ReadTransaction doesn't expose a close() method.)

The provided transaction is specific to the given logical datastore type and cannot be used for any other.

Parameters:

datastoreType - the Datastore type that will be accessed

txConsumer - the InterruptibleCheckedFunction that needs a new read transaction

Throws:

E - if an error occurs.

InterruptedException - if the function is interrupted (this is passed through from the provided function).

E extends Exception

callWithNewReadOnlyTransactionAndClose

<D extends Datastore,E extends Exception> void callWithNewReadOnlyTransactionAndClose(Class<D> datastoreType,
                                                                                      CheckedConsumer<TypedReadTransaction<D>,E> txConsumer)
                                                                               throws E extends Exception

Invokes a function with a NEW ReadTransaction, and ensures that that transaction is closed. Thus when this method returns, that transaction is guaranteed to have been closed, and will never "leak" and waste memory.

The function must not itself attempt to close the transaction. (It can't directly, since ReadTransaction doesn't expose a close() method.)

The provided transaction is specific to the given logical datastore type and cannot be used for any other.

Parameters:

datastoreType - the Datastore type that will be accessed

txConsumer - the InterruptibleCheckedFunction that needs a new read transaction

Throws:

E - if an error occurs.

E extends Exception

callWithNewReadWriteTransactionAndSubmit

@CheckReturnValue
<D extends Datastore,E extends Exception> com.google.common.util.concurrent.FluentFuture<? extends Object> callWithNewReadWriteTransactionAndSubmit(Class<D> datastoreType,
                                                                                                                                                                      InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>,E> txConsumer)

Invokes a consumer with a NEW ReadWriteTransaction, and then submits that transaction and returns the Future from that submission, or cancels it if an exception was thrown and returns a failed future with that exception. Thus when this method returns, that transaction is guaranteed to have been either submitted or cancelled, and will never "leak" and waste memory.

The consumer should not (cannot) itself use WriteTransaction.cancel(), or WriteTransaction.commit() (it will throw an UnsupportedOperationException).

The provided transaction is specific to the given logical datastore type and cannot be used for any other.

This is an asynchronous API, like DataBroker's own; when returning from this method, the operation of the Transaction may well still be ongoing in the background, or pending; calling code therefore must handle the returned future, e.g. by passing it onwards (return), or by itself adding callback listeners to it using Futures' methods, or by transforming it into a CompletionStage (but better NOT by using the blocking Future.get() on it).

Parameters:

datastoreType - the Datastore type that will be accessed

txConsumer - the InterruptibleCheckedConsumer that needs a new read-write transaction

Returns:

the FluentFuture returned by WriteTransaction.commit(), or a failed future with an application specific exception (not from submit())

callWithNewWriteOnlyTransactionAndSubmit

@CheckReturnValue
<D extends Datastore,E extends Exception> com.google.common.util.concurrent.FluentFuture<? extends Object> callWithNewWriteOnlyTransactionAndSubmit(Class<D> datastoreType,
                                                                                                                                                                      InterruptibleCheckedConsumer<TypedWriteTransaction<D>,E> txConsumer)

Invokes a consumer with a NEW WriteTransaction, and then submits that transaction and returns the Future from that submission, or cancels it if an exception was thrown and returns a failed future with that exception. Thus when this method returns, that transaction is guaranteed to have been either submitted or cancelled, and will never "leak" and waste memory.

The consumer should not (cannot) itself use WriteTransaction.cancel(), or WriteTransaction.commit() (it will throw an UnsupportedOperationException).

The provided transaction is specific to the given logical datastore type and cannot be used for any other.

This is an asynchronous API, like DataBroker's own; when returning from this method, the operation of the Transaction may well still be ongoing in the background, or pending; calling code therefore must handle the returned future, e.g. by passing it onwards (return), or by itself adding callback listeners to it using Futures' methods, or by transforming it into a CompletionStage (but better NOT by using the blocking Future.get() on it).

Parameters:

datastoreType - the Datastore type that will be accessed

txConsumer - the InterruptibleCheckedConsumer that needs a new write only transaction

Returns:

the FluentFuture returned by WriteTransaction.commit(), or a failed future with an application specific exception (not from submit())