X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-dom-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fdom%2Fbroker%2Fimpl%2FPingPongTransactionChain.java;h=6d661f1b83075c07de624f347caf8822adb288df;hb=3859df9beca8f13f1ff2b2744ed3470a1715bec3;hp=4a6ea67ebdfa531b48363a6934b39ed3dfb568b3;hpb=4ef15f7a7e3fb5bcaa6a3202d268a5c945e0aa71;p=controller.git diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongTransactionChain.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongTransactionChain.java index 4a6ea67ebd..6d661f1b83 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongTransactionChain.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongTransactionChain.java @@ -7,34 +7,34 @@ */ package org.opendaylight.controller.md.sal.dom.broker.impl; +import static com.google.common.base.Preconditions.checkState; +import static com.google.common.base.Verify.verify; +import static java.util.Objects.requireNonNull; + import com.google.common.base.Optional; -import com.google.common.base.Preconditions; -import com.google.common.base.Verify; import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import com.google.common.util.concurrent.FutureCallback; -import com.google.common.util.concurrent.Futures; -import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.MoreExecutors; import java.util.AbstractMap.SimpleImmutableEntry; import java.util.Map.Entry; import java.util.concurrent.CancellationException; import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; -import javax.annotation.Nonnull; -import javax.annotation.concurrent.GuardedBy; -import org.opendaylight.controller.md.sal.common.api.TransactionStatus; +import org.checkerframework.checker.lock.qual.GuardedBy; +import org.checkerframework.checker.lock.qual.Holding; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; import org.opendaylight.controller.md.sal.common.api.data.TransactionChain; import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain; import org.opendaylight.controller.md.sal.dom.spi.ForwardingDOMDataReadWriteTransaction; -import org.opendaylight.yangtools.yang.common.RpcResult; +import org.opendaylight.mdsal.common.api.CommitInfo; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.slf4j.Logger; @@ -58,6 +58,7 @@ import org.slf4j.LoggerFactory; * counts as an outstanding transaction and the user may not allocate multiple * read-only transactions at the same time. */ +@Deprecated public final class PingPongTransactionChain implements DOMTransactionChain { private static final Logger LOG = LoggerFactory.getLogger(PingPongTransactionChain.class); private final TransactionChainListener listener; @@ -100,7 +101,7 @@ public final class PingPongTransactionChain implements DOMTransactionChain { private volatile PingPongTransaction inflightTx; PingPongTransactionChain(final DOMDataBroker broker, final TransactionChainListener listener) { - this.listener = Preconditions.checkNotNull(listener); + this.listener = requireNonNull(listener); this.delegate = broker.createTransactionChain(new TransactionChainListener() { @Override public void onTransactionChainFailed(final TransactionChain chain, @@ -166,7 +167,7 @@ public final class PingPongTransactionChain implements DOMTransactionChain { } private synchronized PingPongTransaction slowAllocateTransaction() { - Preconditions.checkState(shutdownTx == null, "Transaction chain %s has been shut down", this); + checkState(shutdownTx == null, "Transaction chain %s has been shut down", this); if (deadTx != null) { throw new IllegalStateException( @@ -195,7 +196,7 @@ public final class PingPongTransactionChain implements DOMTransactionChain { return slowAllocateTransaction(); } - // Fast path: reuse current transaction. We will check failures and similar on submit(). + // Fast path: reuse current transaction. We will check failures and similar on commit(). if (!LOCKED_UPDATER.compareAndSet(this, null, oldTx)) { // Ouch. Delegate chain has not detected a duplicate transaction allocation. This is the best we can do. oldTx.getTransaction().cancel(); @@ -211,7 +212,7 @@ public final class PingPongTransactionChain implements DOMTransactionChain { * this method has completed executing. Also inflightTx may be updated outside * the lock, hence we need to re-check. */ - @GuardedBy("this") + @Holding("this") private void processIfReady() { if (inflightTx == null) { final PingPongTransaction tx = READY_UPDATER.getAndSet(this, null); @@ -227,8 +228,8 @@ public final class PingPongTransactionChain implements DOMTransactionChain { * * @param tx Transaction which needs processing. */ - @GuardedBy("this") - private void processTransaction(@Nonnull final PingPongTransaction tx) { + @Holding("this") + private void processTransaction(final @NonNull PingPongTransaction tx) { if (failed) { LOG.debug("Cancelling transaction {}", tx); tx.getTransaction().cancel(); @@ -240,9 +241,9 @@ public final class PingPongTransactionChain implements DOMTransactionChain { LOG.warn("Submitting transaction {} while {} is still running", tx, inflightTx); } - Futures.addCallback(tx.getTransaction().submit(), new FutureCallback() { + tx.getTransaction().commit().addCallback(new FutureCallback() { @Override - public void onSuccess(final Void result) { + public void onSuccess(final CommitInfo result) { transactionSuccessful(tx, result); } @@ -276,7 +277,7 @@ public final class PingPongTransactionChain implements DOMTransactionChain { */ private synchronized void processNextTransaction(final PingPongTransaction tx) { final boolean success = INFLIGHT_UPDATER.compareAndSet(this, tx, null); - Preconditions.checkState(success, "Completed transaction %s while %s was submitted", tx, inflightTx); + checkState(success, "Completed transaction %s while %s was submitted", tx, inflightTx); final PingPongTransaction nextTx = READY_UPDATER.getAndSet(this, null); if (nextTx != null) { @@ -288,7 +289,7 @@ public final class PingPongTransactionChain implements DOMTransactionChain { } } - void transactionSuccessful(final PingPongTransaction tx, final Void result) { + void transactionSuccessful(final PingPongTransaction tx, final CommitInfo result) { LOG.debug("Transaction {} completed successfully", tx); tx.onSuccess(result); @@ -302,10 +303,10 @@ public final class PingPongTransactionChain implements DOMTransactionChain { processNextTransaction(tx); } - void readyTransaction(@Nonnull final PingPongTransaction tx) { + void readyTransaction(final @NonNull PingPongTransaction tx) { // First mark the transaction as not locked. final boolean lockedMatch = LOCKED_UPDATER.compareAndSet(this, tx, null); - Preconditions.checkState(lockedMatch, "Attempted to submit transaction %s while we have %s", tx, lockedTx); + checkState(lockedMatch, "Attempted to submit transaction %s while we have %s", tx, lockedTx); LOG.debug("Transaction {} unlocked", tx); /* @@ -313,7 +314,7 @@ public final class PingPongTransactionChain implements DOMTransactionChain { * or a background transaction completion callback. */ final boolean success = READY_UPDATER.compareAndSet(this, null, tx); - Preconditions.checkState(success, "Transaction %s collided on ready state", tx, readyTx); + checkState(success, "Transaction %s collided on ready state", tx, readyTx); LOG.debug("Transaction {} readied", tx); /* @@ -341,7 +342,7 @@ public final class PingPongTransactionChain implements DOMTransactionChain { synchronized void cancelTransaction(final PingPongTransaction tx, final DOMDataReadWriteTransaction frontendTx) { // Attempt to unlock the operation. final boolean lockedMatch = LOCKED_UPDATER.compareAndSet(this, tx, null); - Verify.verify(lockedMatch, "Cancelling transaction %s collided with locked transaction %s", tx, lockedTx); + verify(lockedMatch, "Cancelling transaction %s collided with locked transaction %s", tx, lockedTx); // Cancel the backend transaction, so we do not end up leaking it. final boolean backendCancelled = tx.getTransaction().cancel(); @@ -377,12 +378,11 @@ public final class PingPongTransactionChain implements DOMTransactionChain { @Override public synchronized void close() { final PingPongTransaction notLocked = lockedTx; - Preconditions - .checkState(notLocked == null, "Attempted to close chain with outstanding transaction %s", notLocked); + checkState(notLocked == null, "Attempted to close chain with outstanding transaction %s", notLocked); // This is not reliable, but if we observe it to be null and the process has already completed, // the backend transaction chain will throw the appropriate error. - Preconditions.checkState(shutdownTx == null, "Attempted to close an already-closed chain"); + checkState(shutdownTx == null, "Attempted to close an already-closed chain"); // This may be a reaction to our failure callback, in that case the backend is already shutdown if (deadTx != null) { @@ -452,18 +452,11 @@ public final class PingPongTransactionChain implements DOMTransactionChain { } @Override - public CheckedFuture submit() { - readyTransaction(tx); - isOpen = false; - return tx.getSubmitFuture(); - } - - @Deprecated - @Override - public ListenableFuture> commit() { + public FluentFuture commit() { readyTransaction(tx); isOpen = false; - return tx.getCommitFuture(); + return FluentFuture.from(tx.getCommitFuture()).transformAsync( + ignored -> CommitInfo.emptyFluentFuture(), MoreExecutors.directExecutor()); } @Override