Package org.opendaylight.genius.infra

Interface ManagedTransactionFactory

All Known Subinterfaces:

ManagedNewTransactionRunner, ManagedTransactionChain

All Known Implementing Classes:

ManagedNewTransactionRunnerImpl, RetryingManagedNewTransactionRunner

public interface ManagedTransactionFactory

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

Method Summary

Modifier and Type	Method	Description
<D extends Datastore,E extends java.lang.Exception,R> R	applyWithNewReadOnlyTransactionAndClose(java.lang.Class<D> datastoreType, org.opendaylight.infrautils.utils.function.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 java.lang.Exception,R> com.google.common.util.concurrent.FluentFuture<R>	applyWithNewReadWriteTransactionAndSubmit(java.lang.Class<D> datastoreType, org.opendaylight.infrautils.utils.function.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 java.lang.Exception> void	callWithNewReadOnlyTransactionAndClose(java.lang.Class<D> datastoreType, org.opendaylight.infrautils.utils.function.InterruptibleCheckedConsumer<TypedReadTransaction<D>,E> txConsumer)	Invokes a function with a NEW ReadTransaction, and ensures that that transaction is closed.
<D extends Datastore,E extends java.lang.Exception> com.google.common.util.concurrent.FluentFuture<java.lang.Void>	callWithNewReadWriteTransactionAndSubmit(java.lang.Class<D> datastoreType, org.opendaylight.infrautils.utils.function.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 java.lang.Exception> com.google.common.util.concurrent.FluentFuture<java.lang.Void>	callWithNewWriteOnlyTransactionAndSubmit(java.lang.Class<D> datastoreType, org.opendaylight.infrautils.utils.function.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

applyWithNewReadOnlyTransactionAndClose

<D extends Datastore,E extends java.lang.Exception,R> R applyWithNewReadOnlyTransactionAndClose(java.lang.Class<D> datastoreType,
                                                                                                            org.opendaylight.infrautils.utils.function.InterruptibleCheckedFunction<TypedReadTransaction<D>,R,E> txFunction)
                                                                                                     throws E extends java.lang.Exception,
                                                                                                            java.lang.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.

java.lang.InterruptedException - if the transaction is interrupted.

E extends java.lang.Exception

applyWithNewReadWriteTransactionAndSubmit

@CheckReturnValue
<D extends Datastore,E extends java.lang.Exception,R> com.google.common.util.concurrent.FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(java.lang.Class<D> datastoreType,
                                                                                                                                                              org.opendaylight.infrautils.utils.function.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 AsyncWriteTransaction.cancel(), or AsyncWriteTransaction.submit() (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 using ListenableFutures.toCompletionStage(ListenableFuture) and chaining on that, or at the very least simply by using ListenableFutures.addErrorLogging(ListenableFuture, org.slf4j.Logger, String) (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 ListenableFuture returned by AsyncWriteTransaction.submit(), or a failed future with an application specific exception (not from submit())

callWithNewReadOnlyTransactionAndClose

<D extends Datastore,E extends java.lang.Exception> void callWithNewReadOnlyTransactionAndClose(java.lang.Class<D> datastoreType,
                                                                                                      org.opendaylight.infrautils.utils.function.InterruptibleCheckedConsumer<TypedReadTransaction<D>,E> txConsumer)
                                                                                               throws E extends java.lang.Exception,
                                                                                                      java.lang.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.

java.lang.InterruptedException - if the transaction is interrupted.

E extends java.lang.Exception

callWithNewReadWriteTransactionAndSubmit

@CheckReturnValue
<D extends Datastore,E extends java.lang.Exception> com.google.common.util.concurrent.FluentFuture<java.lang.Void> callWithNewReadWriteTransactionAndSubmit(java.lang.Class<D> datastoreType,
                                                                                                                                                                  org.opendaylight.infrautils.utils.function.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 AsyncWriteTransaction.cancel(), or AsyncWriteTransaction.submit() (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 using ListenableFutures.toCompletionStage(ListenableFuture) and chaining on that, or at the very least simply by using ListenableFutures.addErrorLogging(ListenableFuture, org.slf4j.Logger, String) (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 ListenableFuture returned by AsyncWriteTransaction.submit(), or a failed future with an application specific exception (not from submit())

callWithNewWriteOnlyTransactionAndSubmit

@CheckReturnValue
<D extends Datastore,E extends java.lang.Exception> com.google.common.util.concurrent.FluentFuture<java.lang.Void> callWithNewWriteOnlyTransactionAndSubmit(java.lang.Class<D> datastoreType,
                                                                                                                                                                  org.opendaylight.infrautils.utils.function.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 AsyncWriteTransaction.cancel(), or AsyncWriteTransaction.submit() (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 using ListenableFutures.toCompletionStage(ListenableFuture) and chaining on that, or at the very least simply by using ListenableFutures.addErrorLogging(ListenableFuture, org.slf4j.Logger, String) (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 ListenableFuture returned by AsyncWriteTransaction.submit(), or a failed future with an application specific exception (not from submit())