2 * Copyright (c) 2017 Red Hat, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.mdsal.binding.util;
10 import static java.util.Objects.requireNonNull;
12 import com.google.common.annotations.Beta;
13 import com.google.common.util.concurrent.FluentFuture;
14 import java.util.function.Function;
15 import javax.annotation.CheckReturnValue;
16 import javax.inject.Inject;
17 import org.opendaylight.mdsal.binding.api.DataBroker;
18 import org.opendaylight.mdsal.binding.api.Transaction;
19 import org.opendaylight.mdsal.binding.api.TransactionChain;
20 import org.opendaylight.mdsal.binding.api.TransactionChainListener;
21 import org.opendaylight.mdsal.binding.api.WriteTransaction;
22 import org.opendaylight.mdsal.common.api.CommitInfo;
23 import org.slf4j.Logger;
24 import org.slf4j.LoggerFactory;
27 * Implementation of {@link ManagedNewTransactionRunner}. This is based on {@link ManagedTransactionFactoryImpl} but
28 * re-implements operations based on read-write transactions to cancel transactions which don't end up making any
29 * changes to the datastore.
32 // Do *NOT* mark this as @Singleton, because users choose their implementation
33 public class ManagedNewTransactionRunnerImpl extends ManagedTransactionFactoryImpl<DataBroker>
34 implements ManagedNewTransactionRunner {
36 private static final Logger LOG = LoggerFactory.getLogger(ManagedNewTransactionRunnerImpl.class);
39 public ManagedNewTransactionRunnerImpl(final DataBroker broker) {
40 // Early check to ensure the error message is understandable for the caller
41 super(requireNonNull(broker, "broker must not be null"));
44 // This is overridden to use this class’s commit method
47 public <D extends Datastore, E extends Exception, R> FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(
48 final Class<D> datastoreType,
49 final InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txFunction) {
50 return super.applyWithNewTransactionAndSubmit(datastoreType, getTransactionFactory()::newReadWriteTransaction,
51 WriteTrackingTypedReadWriteTransactionImpl::new, txFunction::apply, this::commit);
55 public <R> R applyWithNewTransactionChainAndClose(final Function<ManagedTransactionChain, R> chainConsumer) {
56 try (TransactionChain realTxChain = getTransactionFactory().createTransactionChain(
57 new TransactionChainListener() {
59 public void onTransactionChainFailed(TransactionChain chain, Transaction transaction, Throwable cause) {
60 LOG.error("Error handling a transaction chain", cause);
64 public void onTransactionChainSuccessful(TransactionChain chain) {
68 return chainConsumer.apply(new ManagedTransactionChainImpl(realTxChain));
72 // This is overridden to use this class’s commit method
75 public <D extends Datastore, E extends Exception> FluentFuture<? extends Object>
76 callWithNewReadWriteTransactionAndSubmit(final Class<D> datastoreType,
77 final InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>, E> txConsumer) {
78 return callWithNewTransactionAndSubmit(datastoreType, getTransactionFactory()::newReadWriteTransaction,
79 WriteTrackingTypedReadWriteTransactionImpl::new, txConsumer::accept, this::commit);
82 // This is overridden to use this class’s commit method
85 public <D extends Datastore, E extends Exception> FluentFuture<? extends Object>
86 callWithNewWriteOnlyTransactionAndSubmit(final Class<D> datastoreType,
87 final InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txConsumer) {
88 return super.callWithNewTransactionAndSubmit(datastoreType, getTransactionFactory()::newWriteOnlyTransaction,
89 WriteTrackingTypedWriteTransactionImpl::new, txConsumer::accept, this::commit);
93 private FluentFuture<? extends CommitInfo> commit(final WriteTransaction realTx,
94 final WriteTrackingTransaction wrappedTx) {
95 if (wrappedTx.isWritten()) {
96 // The transaction contains changes, commit it
97 return realTx.commit();
99 // The transaction only handled reads, cancel it
101 return CommitInfo.emptyFluentFuture();