Add AsyncWriteTransaction.commit()

Equivalent to the recent md-sal API addition. The CommitInfo class
is re-used from md-sal. I also modified all implementations in the
controller to implement commit even though it's defaulted. As soon
as implementations in other projects do the same then we can
default submit().

Change-Id: I0801d5aa4c197177af838e7fbb71b7766a90e043
Signed-off-by: Tom Pantelis <tompantelis@gmail.com>

diff --git a/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/AbstractTracingWriteTransaction.java b/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/AbstractTracingWriteTransaction.java
index 9cc67ba29f92bb853aef4d7a96f53571157d6ca4..f7dd4d78fbdcae5ca308b356ff6084bc0e09aedf 100644 (file)
--- a/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/AbstractTracingWriteTransaction.java
+++ b/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/AbstractTracingWriteTransaction.java
@@ -9,6 +9,7 @@ package org.opendaylight.controller.md.sal.trace.dom.impl;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.CheckedFuture;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;


@@ -16,6 +17,7 @@ import java.util.Set;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;

+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.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 


@@ -100,6 +102,12 @@ abstract class AbstractTracingWriteTransaction implements DOMDataWriteTransactio
         return delegate.submit();
     }
 
         return delegate.submit();
     }
 

+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        logOps();
+        return delegate.commit();
+    }
+

     @Override
     public Object getIdentifier() {
         return delegate.getIdentifier();
     @Override
     public Object getIdentifier() {
         return delegate.getIdentifier();

diff --git a/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/TracingReadWriteTransaction.java b/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/TracingReadWriteTransaction.java
index 31287b090270a58897d937eb7cd9cdafb6179db9..6fbe58b4c5be6102d4d0c356ce15a59beb631845 100644 (file)
--- a/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/TracingReadWriteTransaction.java
+++ b/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/TracingReadWriteTransaction.java
@@ -9,6 +9,7 @@ package org.opendaylight.controller.md.sal.trace.dom.impl;
 
 import com.google.common.base.Optional;
 import com.google.common.util.concurrent.CheckedFuture;
 
 import com.google.common.base.Optional;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import java.util.Objects;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
 import java.util.Objects;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;


@@ -17,6 +18,7 @@ import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTracked;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedRegistry;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedTrait;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTracked;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedRegistry;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedTrait;

+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.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 


@@ -51,6 +53,12 @@ class TracingReadWriteTransaction
         return super.submit();
     }
 
         return super.submit();
     }
 

+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        closeTracker.removeFromTrackedRegistry();
+        return super.commit();
+    }
+

     @Override
     public boolean cancel() {
         closeTracker.removeFromTrackedRegistry();
     @Override
     public boolean cancel() {
         closeTracker.removeFromTrackedRegistry();

diff --git a/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/TracingWriteTransaction.java b/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/TracingWriteTransaction.java
index 18c61176e8e95f9849075a6d3443f509ebb67214..4d33a4601469da0a2ecf9b1806dac8a6a033d415 100644 (file)
--- a/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/TracingWriteTransaction.java
+++ b/opendaylight/md-sal/mdsal-trace/dom-impl/src/main/java/org/opendaylight/controller/md/sal/trace/dom/impl/TracingWriteTransaction.java
@@ -8,11 +8,13 @@
 package org.opendaylight.controller.md.sal.trace.dom.impl;
 
 import com.google.common.util.concurrent.CheckedFuture;
 package org.opendaylight.controller.md.sal.trace.dom.impl;
 
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTracked;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedRegistry;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedTrait;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTracked;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedRegistry;
 import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedTrait;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 
 class TracingWriteTransaction extends AbstractTracingWriteTransaction
         implements CloseTracked<TracingWriteTransaction> {
 
 class TracingWriteTransaction extends AbstractTracingWriteTransaction
         implements CloseTracked<TracingWriteTransaction> {


@@ -31,6 +33,12 @@ class TracingWriteTransaction extends AbstractTracingWriteTransaction
         return super.submit();
     }
 
         return super.submit();
     }
 

+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        closeTracker.removeFromTrackedRegistry();
+        return super.commit();
+    }
+

     @Override
     public boolean cancel() {
         closeTracker.removeFromTrackedRegistry();
     @Override
     public boolean cancel() {
         closeTracker.removeFromTrackedRegistry();

diff --git a/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/md/sal/binding/api/ForwardingReadWriteTransaction.java b/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/md/sal/binding/api/ForwardingReadWriteTransaction.java
index 756ed96a929c44abc09b8760f749a159fe998dbe..a21268d1952c0b45138b2655149bf92b42cbcd25 100644 (file)
--- a/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/md/sal/binding/api/ForwardingReadWriteTransaction.java
+++ b/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/md/sal/binding/api/ForwardingReadWriteTransaction.java
@@ -10,9 +10,11 @@ package org.opendaylight.controller.md.sal.binding.api;
 import com.google.common.base.Optional;
 import com.google.common.collect.ForwardingObject;
 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.base.Optional;
 import com.google.common.collect.ForwardingObject;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 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.TransactionCommitFailedException;
 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.TransactionCommitFailedException;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 


@@ -77,6 +79,11 @@ public class ForwardingReadWriteTransaction extends ForwardingObject implements
         return delegate.submit();
     }
 
         return delegate.submit();
     }
 

+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        return delegate.commit();
+    }
+

     @Override
     public void delete(LogicalDatastoreType store, InstanceIdentifier<?> path) {
         delegate.delete(store, path);
     @Override
     public void delete(LogicalDatastoreType store, InstanceIdentifier<?> path) {
         delegate.delete(store, path);

diff --git a/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/md/sal/binding/api/ForwardingWriteTransaction.java b/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/md/sal/binding/api/ForwardingWriteTransaction.java
index 8c10c6fafe7d503ef4af0fe5c22517e018a506b9..801732dd710fd8a79b0ae38f8edf80777925c3bf 100644 (file)
--- a/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/md/sal/binding/api/ForwardingWriteTransaction.java
+++ b/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/md/sal/binding/api/ForwardingWriteTransaction.java
@@ -9,8 +9,10 @@ package org.opendaylight.controller.md.sal.binding.api;
 
 import com.google.common.collect.ForwardingObject;
 import com.google.common.util.concurrent.CheckedFuture;
 
 import com.google.common.collect.ForwardingObject;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 


@@ -69,6 +71,11 @@ public class ForwardingWriteTransaction extends ForwardingObject implements Writ
         return delegate.submit();
     }
 
         return delegate.submit();
     }
 

+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        return delegate.commit();
+    }
+

     @Override
     public Object getIdentifier() {
         return delegate.getIdentifier();
     @Override
     public Object getIdentifier() {
         return delegate.getIdentifier();

diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractWriteTransaction.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractWriteTransaction.java
index eebd8367f3431ebee505b807d197b5c2e5c001a7..bb9c98e197c59058e6093a081c18beb1f3b714b9 100644 (file)
--- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractWriteTransaction.java
+++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/AbstractWriteTransaction.java
@@ -9,11 +9,11 @@ package org.opendaylight.controller.md.sal.binding.impl;
 
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;

-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;

 import java.util.Map.Entry;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import java.util.Map.Entry;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;

-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;

 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.Identifiable;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.Identifiable;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;


@@ -125,8 +125,8 @@ public abstract class AbstractWriteTransaction<T extends DOMDataWriteTransaction
         getDelegate().delete(store, normalized);
     }
 
         getDelegate().delete(store, normalized);
     }
 

-    protected final CheckedFuture<Void,TransactionCommitFailedException> doSubmit() {
-        return getDelegate().submit();
+    protected final FluentFuture<? extends CommitInfo> doCommit() {
+        return getDelegate().commit();

     }
 
     protected final boolean doCancel() {
     }
 
     protected final boolean doCancel() {

diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDOMTransactionChainAdapter.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDOMTransactionChainAdapter.java
index 7955dcdf16405674e8fda23df538b952bea9beec..3358c9ef1c0d1bca8f95e1609f76f749fcf8ea62 100644 (file)
--- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDOMTransactionChainAdapter.java
+++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDOMTransactionChainAdapter.java
@@ -8,9 +8,8 @@
 package org.opendaylight.controller.md.sal.binding.impl;
 
 import com.google.common.base.Preconditions;
 package org.opendaylight.controller.md.sal.binding.impl;
 
 import com.google.common.base.Preconditions;

-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.FutureCallback;

-import com.google.common.util.concurrent.Futures;

 import com.google.common.util.concurrent.MoreExecutors;
 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
 import com.google.common.util.concurrent.MoreExecutors;
 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;


@@ -19,12 +18,12 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
 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.AsyncTransaction;
 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.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.mdsal.common.api.CommitInfo;

 import org.opendaylight.yangtools.concepts.Delegator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.opendaylight.yangtools.concepts.Delegator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;


@@ -64,8 +63,8 @@ final class BindingDOMTransactionChainAdapter implements BindingTransactionChain
         return new BindingDOMReadWriteTransactionAdapter(delegateTx, codec) {
 
             @Override
         return new BindingDOMReadWriteTransactionAdapter(delegateTx, codec) {
 
             @Override

-            public CheckedFuture<Void, TransactionCommitFailedException> submit() {
-                return listenForFailure(this,super.submit());
+            public FluentFuture<? extends CommitInfo> commit() {
+                return listenForFailure(this, super.commit());

             }
 
         };
             }
 
         };


@@ -77,23 +76,23 @@ final class BindingDOMTransactionChainAdapter implements BindingTransactionChain
         return new BindingDOMWriteTransactionAdapter<DOMDataWriteTransaction>(delegateTx, codec) {
 
             @Override
         return new BindingDOMWriteTransactionAdapter<DOMDataWriteTransaction>(delegateTx, codec) {
 
             @Override

-            public CheckedFuture<Void,TransactionCommitFailedException> submit() {
-                return listenForFailure(this,super.submit());
+            public FluentFuture<? extends CommitInfo> commit() {
+                return listenForFailure(this, super.commit());

             }
 
         };
     }
 
             }
 
         };
     }
 

-    private CheckedFuture<Void, TransactionCommitFailedException> listenForFailure(
-            final WriteTransaction tx, final CheckedFuture<Void, TransactionCommitFailedException> future) {
-        Futures.addCallback(future, new FutureCallback<Void>() {
+    private FluentFuture<? extends CommitInfo> listenForFailure(
+            final WriteTransaction tx, final FluentFuture<? extends CommitInfo> future) {
+        future.addCallback(new FutureCallback<CommitInfo>() {

             @Override
             public void onFailure(final Throwable ex) {
                 failTransactionChain(tx,ex);
             }
 
             @Override
             @Override
             public void onFailure(final Throwable ex) {
                 failTransactionChain(tx,ex);
             }
 
             @Override

-            public void onSuccess(final Void result) {
+            public void onSuccess(final CommitInfo result) {

                 // Intentionally NOOP
             }
         }, MoreExecutors.directExecutor());
                 // Intentionally NOOP
             }
         }, MoreExecutors.directExecutor());

diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDOMWriteTransactionAdapter.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDOMWriteTransactionAdapter.java
index c6c9c9f63b86831dd943c08abe4d8aa7b0b0ca5f..142ad4a628ecd37b5ef287d81d16cd9b4a57a790 100644 (file)
--- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDOMWriteTransactionAdapter.java
+++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingDOMWriteTransactionAdapter.java
@@ -8,6 +8,8 @@
 package org.opendaylight.controller.md.sal.binding.impl;
 
 import com.google.common.util.concurrent.CheckedFuture;
 package org.opendaylight.controller.md.sal.binding.impl;
 
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.MoreExecutors;

 import java.util.ArrayList;
 import java.util.List;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import java.util.ArrayList;
 import java.util.List;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;


@@ -16,6 +18,9 @@ import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFaile
 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException;
 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException;
 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;

+import org.opendaylight.controller.md.sal.dom.broker.impl.TransactionCommitFailedExceptionMapper;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.MappingCheckedFuture;

 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;


@@ -68,7 +73,13 @@ class BindingDOMWriteTransactionAdapter<T extends DOMDataWriteTransaction> exten
 
     @Override
     public CheckedFuture<Void,TransactionCommitFailedException> submit() {
 
     @Override
     public CheckedFuture<Void,TransactionCommitFailedException> submit() {

-        return doSubmit();
+        return MappingCheckedFuture.create(commit().transform(ignored -> null,
+                MoreExecutors.directExecutor()), TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
+    }
+
+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        return doCommit();

     }
 
     @Override
     }
 
     @Override

diff --git a/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/CrossBrokerMountPointTest.java b/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/CrossBrokerMountPointTest.java
index 74c0ade8aa37d4c70b20fd49dc84b96114ae28a0..314ee4be707bc2675e1c873789b731eccf31410c 100644 (file)
--- a/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/CrossBrokerMountPointTest.java
+++ b/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/CrossBrokerMountPointTest.java
@@ -13,6 +13,7 @@ import static org.junit.Assert.assertTrue;
 
 import com.google.common.base.Optional;
 import com.google.common.util.concurrent.CheckedFuture;
 
 import com.google.common.base.Optional;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.Collections;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.Collections;


@@ -38,6 +39,7 @@ import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
 import org.opendaylight.controller.sal.binding.test.util.BindingBrokerTestFactory;
 import org.opendaylight.controller.sal.binding.test.util.BindingTestContext;
 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
 import org.opendaylight.controller.sal.binding.test.util.BindingBrokerTestFactory;
 import org.opendaylight.controller.sal.binding.test.util.BindingTestContext;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.of.migration.test.model.rev150210.List11SimpleAugment;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.of.migration.test.model.rev150210.TllComplexAugment;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.of.migration.test.model.rev150210.aug.grouping.List1;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.of.migration.test.model.rev150210.List11SimpleAugment;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.of.migration.test.model.rev150210.TllComplexAugment;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.of.migration.test.model.rev150210.aug.grouping.List1;


@@ -201,6 +203,10 @@ public class CrossBrokerMountPointTest {
                             throw new UnsupportedOperationException();
                         }
 
                             throw new UnsupportedOperationException();
                         }
 

+                        @Override
+                        public FluentFuture<? extends CommitInfo> commit() {
+                            throw new UnsupportedOperationException();
+                        }

                     };
                 }
 
                     };
                 }
 

diff --git a/opendaylight/md-sal/sal-common-api/pom.xml b/opendaylight/md-sal/sal-common-api/pom.xml
index 9d3e2b17ad521d23097064edd3dd42479fa7724d..9c8a30377141777ccd7e8de8aa77392ea59d759f 100644 (file)
--- a/opendaylight/md-sal/sal-common-api/pom.xml
+++ b/opendaylight/md-sal/sal-common-api/pom.xml
@@ -30,6 +30,10 @@
       <groupId>org.opendaylight.yangtools</groupId>
       <artifactId>yang-data-api</artifactId>
     </dependency>
       <groupId>org.opendaylight.yangtools</groupId>
       <artifactId>yang-data-api</artifactId>
     </dependency>

+    <dependency>
+      <groupId>org.opendaylight.mdsal</groupId>
+      <artifactId>mdsal-common-api</artifactId>
+    </dependency>

     <dependency>
       <groupId>org.apache.commons</groupId>
       <artifactId>commons-lang3</artifactId>
     <dependency>
       <groupId>org.apache.commons</groupId>
       <artifactId>commons-lang3</artifactId>

diff --git a/opendaylight/md-sal/sal-common-api/src/main/java/org/opendaylight/controller/md/sal/common/api/data/AsyncWriteTransaction.java b/opendaylight/md-sal/sal-common-api/src/main/java/org/opendaylight/controller/md/sal/common/api/data/AsyncWriteTransaction.java
index 51bb1db40bdcb078b77b1a970f256f23b28742b2..79f80a3f0577e1ce2fd28486497652a982ee7381 100644 (file)
--- a/opendaylight/md-sal/sal-common-api/src/main/java/org/opendaylight/controller/md/sal/common/api/data/AsyncWriteTransaction.java
+++ b/opendaylight/md-sal/sal-common-api/src/main/java/org/opendaylight/controller/md/sal/common/api/data/AsyncWriteTransaction.java
@@ -8,7 +8,12 @@
 package org.opendaylight.controller.md.sal.common.api.data;
 
 import com.google.common.util.concurrent.CheckedFuture;
 package org.opendaylight.controller.md.sal.common.api.data;
 
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;

+import com.google.common.util.concurrent.MoreExecutors;
+import javax.annotation.CheckReturnValue;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.yangtools.concepts.Path;
 
 /**
 import org.opendaylight.yangtools.concepts.Path;
 
 /**


@@ -330,6 +335,43 @@ public interface AsyncWriteTransaction<P extends Path<P>, D> extends AsyncTransa
      *
      * @throws IllegalStateException
      *             if the transaction is not new
      *
      * @throws IllegalStateException
      *             if the transaction is not new

+     * @deprecated Use {@link #commit()} instead.

      */
      */

+    @Deprecated

     CheckedFuture<Void,TransactionCommitFailedException> submit();
     CheckedFuture<Void,TransactionCommitFailedException> submit();

+
+    /**
+     * Submits this transaction to be asynchronously applied to update the logical data tree. The returned
+     * {@link FluentFuture} conveys the result of applying the data changes.
+     *
+     * <p>
+     * This call logically seals the transaction, which prevents the client from further changing the data tree using
+     * this transaction. Any subsequent calls to <code>put(LogicalDatastoreType, Path, Object)</code>,
+     * <code>merge(LogicalDatastoreType, Path, Object)</code>, <code>delete(LogicalDatastoreType, Path)</code> will fail
+     * with {@link IllegalStateException}. The transaction is marked as submitted and enqueued into the data store
+     * back-end for processing.
+     *
+     * <p>
+     * Whether or not the commit is successful is determined by versioning of the data tree and validation of registered
+     * commit participants if the transaction changes the data tree.
+     *
+     * <p>
+     * The effects of a successful commit of data depends on listeners and commit participants that are registered with
+     * the data broker.
+     *
+     * <p>
+     * A successful commit produces implementation-specific {@link CommitInfo} structure, which is used to communicate
+     * post-condition information to the caller. Such information can contain commit-id, timing information or any
+     * other information the implementation wishes to share.
+     *
+     * @return a FluentFuture containing the result of the commit information. The Future blocks until the commit
+     *         operation is complete. A successful commit returns nothing. On failure, the Future will fail with a
+     *         {@link TransactionCommitFailedException} or an exception derived from TransactionCommitFailedException.
+     * @throws IllegalStateException if the transaction is already committed or was canceled.
+     */
+    @CheckReturnValue
+    default @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+        return FluentFuture.from(submit()).transformAsync(ignored -> CommitInfo.emptyFluentFuture(),
+            MoreExecutors.directExecutor());
+    }

 }
 }

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransaction.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransaction.java
index 2082ad2078635b3cc490bc1f2faf912bef590768..c109165c1f24a565456d3eeb73170f957b1dc592 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransaction.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransaction.java
@@ -11,14 +11,18 @@ package org.opendaylight.controller.cluster.databroker;
 import com.google.common.base.MoreObjects.ToStringHelper;
 import com.google.common.base.Preconditions;
 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.base.MoreObjects.ToStringHelper;
 import com.google.common.base.Preconditions;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.Futures;

+import com.google.common.util.concurrent.MoreExecutors;

 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;

+import org.opendaylight.mdsal.common.api.MappingCheckedFuture;

 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.broker.TransactionCommitFailedExceptionMapper;
 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.broker.TransactionCommitFailedExceptionMapper;


@@ -125,24 +129,30 @@ public abstract class AbstractDOMBrokerWriteTransaction<T extends DOMStoreWriteT
     }
 
     @Override
     }
 
     @Override

-    @SuppressWarnings("checkstyle:illegalcatch")

     public CheckedFuture<Void, TransactionCommitFailedException> submit() {
     public CheckedFuture<Void, TransactionCommitFailedException> submit() {

+        return MappingCheckedFuture.create(commit().transform(ignored -> null,
+                MoreExecutors.directExecutor()), TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
+    }
+
+    @Override
+    @SuppressWarnings("checkstyle:IllegalCatch")
+    public FluentFuture<? extends CommitInfo> commit() {

         final AbstractDOMTransactionFactory<?> impl = IMPL_UPDATER.getAndSet(this, null);
         checkRunning(impl);
 
         final Collection<T> txns = getSubtransactions();
         final Collection<DOMStoreThreePhaseCommitCohort> cohorts = new ArrayList<>(txns.size());
 
         final AbstractDOMTransactionFactory<?> impl = IMPL_UPDATER.getAndSet(this, null);
         checkRunning(impl);
 
         final Collection<T> txns = getSubtransactions();
         final Collection<DOMStoreThreePhaseCommitCohort> cohorts = new ArrayList<>(txns.size());
 

-        CheckedFuture<Void, TransactionCommitFailedException> ret;
+        FluentFuture<? extends CommitInfo> ret;

         try {
             for (final T txn : txns) {
                 cohorts.add(txn.ready());
             }
 
         try {
             for (final T txn : txns) {
                 cohorts.add(txn.ready());
             }
 

-            ret = impl.submit(this, cohorts);
+            ret = impl.commit(this, cohorts);

         } catch (RuntimeException e) {
         } catch (RuntimeException e) {

-            ret = Futures.immediateFailedCheckedFuture(
-                    TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER.apply(e));
+            ret = FluentFuture.from(Futures.immediateFailedFuture(
+                    TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER.apply(e)));

         }
         FUTURE_UPDATER.lazySet(this, ret);
         return ret;
         }
         FUTURE_UPDATER.lazySet(this, ret);
         return ret;

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/AbstractDOMTransactionFactory.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/AbstractDOMTransactionFactory.java
index f80ea9400d6f2d967ce52b439aa8591c71580f06..91ca744f763173834a84003423a88fdde06e58f5 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/AbstractDOMTransactionFactory.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/AbstractDOMTransactionFactory.java
@@ -9,13 +9,13 @@
 package org.opendaylight.controller.cluster.databroker;
 
 import com.google.common.base.Preconditions;
 package org.opendaylight.controller.cluster.databroker;
 
 import com.google.common.base.Preconditions;

-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;

 import java.util.Collection;
 import java.util.EnumMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.Collection;
 import java.util.EnumMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;

-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;

 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;


@@ -48,8 +48,8 @@ public abstract class AbstractDOMTransactionFactory<T extends DOMStoreTransactio
      * @param cohorts the associated cohorts
      * @return a resulting Future
      */
      * @param cohorts the associated cohorts
      * @return a resulting Future
      */

-    protected abstract CheckedFuture<Void,TransactionCommitFailedException> submit(
-            DOMDataTreeWriteTransaction transaction, Collection<DOMStoreThreePhaseCommitCohort> cohorts);
+    protected abstract FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction transaction,
+            Collection<DOMStoreThreePhaseCommitCohort> cohorts);

 
     /**
      * Creates a new read-only transaction.
 
     /**
      * Creates a new read-only transaction.

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBroker.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBroker.java
index 043a26ca1708c6585744a26671d78f3f17904504..1199fbf7bca4a4c5f60485690b4e82eb37ca062f 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBroker.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBroker.java
@@ -14,7 +14,7 @@ import static org.opendaylight.mdsal.dom.broker.TransactionCommitFailedException
 import com.google.common.annotations.Beta;
 import com.google.common.base.Preconditions;
 import com.google.common.util.concurrent.AbstractFuture;
 import com.google.common.annotations.Beta;
 import com.google.common.base.Preconditions;
 import com.google.common.util.concurrent.AbstractFuture;

-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.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;


@@ -27,9 +27,9 @@ import java.util.Map;
 import java.util.concurrent.Executor;
 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
 import org.opendaylight.controller.cluster.datastore.exceptions.ShardLeaderNotRespondingException;
 import java.util.concurrent.Executor;
 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
 import org.opendaylight.controller.cluster.datastore.exceptions.ShardLeaderNotRespondingException;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.mdsal.common.api.DataStoreUnavailableException;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.DataStoreUnavailableException;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;

-import org.opendaylight.mdsal.common.api.MappingCheckedFuture;

 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.broker.TransactionCommitFailedExceptionMapper;
 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.broker.TransactionCommitFailedExceptionMapper;


@@ -77,7 +77,7 @@ public class ConcurrentDOMDataBroker extends AbstractDOMBroker {
     }
 
     @Override
     }
 
     @Override

-    protected CheckedFuture<Void, TransactionCommitFailedException> submit(
+    protected FluentFuture<? extends CommitInfo> commit(

             final DOMDataTreeWriteTransaction transaction, final Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
 
         Preconditions.checkArgument(transaction != null, "Transaction must not be null.");
             final DOMDataTreeWriteTransaction transaction, final Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
 
         Preconditions.checkArgument(transaction != null, "Transaction must not be null.");


@@ -85,7 +85,7 @@ public class ConcurrentDOMDataBroker extends AbstractDOMBroker {
         LOG.debug("Tx: {} is submitted for execution.", transaction.getIdentifier());
 
         if (cohorts.isEmpty()) {
         LOG.debug("Tx: {} is submitted for execution.", transaction.getIdentifier());
 
         if (cohorts.isEmpty()) {

-            return Futures.immediateCheckedFuture(null);
+            return CommitInfo.emptyFluentFuture();

         }
 
         final AsyncNotifyingSettableFuture clientSubmitFuture =
         }
 
         final AsyncNotifyingSettableFuture clientSubmitFuture =


@@ -93,7 +93,8 @@ public class ConcurrentDOMDataBroker extends AbstractDOMBroker {
 
         doCanCommit(clientSubmitFuture, transaction, cohorts);
 
 
         doCanCommit(clientSubmitFuture, transaction, cohorts);
 

-        return MappingCheckedFuture.create(clientSubmitFuture, COMMIT_ERROR_MAPPER);
+        return FluentFuture.from(clientSubmitFuture).transform(ignored -> CommitInfo.empty(),
+                MoreExecutors.directExecutor());

     }
 
     private void doCanCommit(final AsyncNotifyingSettableFuture clientSubmitFuture,
     }
 
     private void doCanCommit(final AsyncNotifyingSettableFuture clientSubmitFuture,

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/DOMBrokerTransactionChain.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/DOMBrokerTransactionChain.java
index 2eabe79d5146fa3ffa379d9303fb69d18e2f6a69..2a0faee039835a5f9f227ce6b0348f0a94e2962a 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/DOMBrokerTransactionChain.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/DOMBrokerTransactionChain.java
@@ -9,18 +9,17 @@
 package org.opendaylight.controller.cluster.databroker;
 
 import com.google.common.base.Preconditions;
 package org.opendaylight.controller.cluster.databroker;
 
 import com.google.common.base.Preconditions;

-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.FutureCallback;

-import com.google.common.util.concurrent.Futures;

 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.TransactionChainListener;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.TransactionChainListener;

-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;

 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;


@@ -80,17 +79,17 @@ final class DOMBrokerTransactionChain extends AbstractDOMTransactionFactory<DOMS
     }
 
     @Override
     }
 
     @Override

-    public CheckedFuture<Void, TransactionCommitFailedException> submit(
+    public FluentFuture<? extends CommitInfo> commit(

             final DOMDataTreeWriteTransaction transaction, final Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
         checkNotFailed();
         checkNotClosed();
 
             final DOMDataTreeWriteTransaction transaction, final Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
         checkNotFailed();
         checkNotClosed();
 

-        final CheckedFuture<Void, TransactionCommitFailedException> ret = broker.submit(transaction, cohorts);
+        final FluentFuture<? extends CommitInfo> ret = broker.commit(transaction, cohorts);

 
         COUNTER_UPDATER.incrementAndGet(this);
 
         COUNTER_UPDATER.incrementAndGet(this);

-        Futures.addCallback(ret, new FutureCallback<Void>() {
+        ret.addCallback(new FutureCallback<CommitInfo>() {

             @Override
             @Override

-            public void onSuccess(final Void result) {
+            public void onSuccess(final CommitInfo result) {

                 transactionCompleted();
             }
 
                 transactionCompleted();
             }
 

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/compat/LegacyDOMDataBrokerAdapter.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/compat/LegacyDOMDataBrokerAdapter.java
index b3df0c36bbc2200339b31cda5662f9f544f18faf..d1a4078fd84789206d7966c469b073b50f9569ea 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/compat/LegacyDOMDataBrokerAdapter.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/databroker/compat/LegacyDOMDataBrokerAdapter.java
@@ -15,6 +15,7 @@ import com.google.common.collect.ForwardingObject;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMap.Builder;
 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMap.Builder;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
 import javax.annotation.Nonnull;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
 import javax.annotation.Nonnull;


@@ -40,6 +41,7 @@ import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeCommitCohortRegistr
 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
 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.api.DOMDataTreeIdentifier;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.mdsal.common.api.MappingCheckedFuture;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohort;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistration;
 import org.opendaylight.mdsal.common.api.MappingCheckedFuture;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohort;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistration;


@@ -300,6 +302,11 @@ public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMD
         public CheckedFuture<Void, TransactionCommitFailedException> submit() {
             return MappingCheckedFuture.create(writeDelegate().submit(), SUBMIT_EX_MAPPER);
         }
         public CheckedFuture<Void, TransactionCommitFailedException> submit() {
             return MappingCheckedFuture.create(writeDelegate().submit(), SUBMIT_EX_MAPPER);
         }

+
+        @Override
+        public FluentFuture<? extends CommitInfo> commit() {
+            return writeDelegate().commit();
+        }

     }
 
     private static class DOMDataReadOnlyTransactionAdapter implements DOMDataReadOnlyTransaction {
     }
 
     private static class DOMDataReadOnlyTransactionAdapter implements DOMDataReadOnlyTransaction {

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransactionTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransactionTest.java
index 5263ab67fa52f4783b093f52f0886f590c85a2b0..1ad1b345efc233ab1beed7f7b02e6be543be369d 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransactionTest.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransactionTest.java
@@ -74,7 +74,7 @@ public class AbstractDOMBrokerWriteTransactionTest {
     @Test
     public void submitRuntimeExceptionAndCancel() {
         RuntimeException thrown = new RuntimeException();
     @Test
     public void submitRuntimeExceptionAndCancel() {
         RuntimeException thrown = new RuntimeException();

-        doThrow(thrown).when(abstractDOMTransactionFactory).submit(any(), any());
+        doThrow(thrown).when(abstractDOMTransactionFactory).commit(any(), any());

         AbstractDOMBrokerWriteTransactionTestImpl abstractDOMBrokerWriteTransactionTestImpl
                 = new AbstractDOMBrokerWriteTransactionTestImpl();
 
         AbstractDOMBrokerWriteTransactionTestImpl abstractDOMBrokerWriteTransactionTestImpl
                 = new AbstractDOMBrokerWriteTransactionTestImpl();
 

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBrokerTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBrokerTest.java
index ca255c82501da2a9ed4f1dfd4fc0802f253ea68e..acf08eb1d9e50fffea8dcf7470464cf6fe05a301 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBrokerTest.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBrokerTest.java
@@ -23,6 +23,7 @@ import static org.mockito.Mockito.verify;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableMap;
 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.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;


@@ -48,6 +49,7 @@ import org.mockito.InOrder;
 import org.mockito.stubbing.Answer;
 import org.opendaylight.controller.cluster.datastore.DistributedDataStore;
 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
 import org.mockito.stubbing.Answer;
 import org.opendaylight.controller.cluster.datastore.DistributedDataStore;
 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.mdsal.common.api.DataStoreUnavailableException;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.TransactionChainListener;
 import org.opendaylight.mdsal.common.api.DataStoreUnavailableException;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.TransactionChainListener;


@@ -61,6 +63,7 @@ import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;

+import org.opendaylight.mdsal.dom.broker.TransactionCommitFailedExceptionMapper;

 import org.opendaylight.mdsal.dom.spi.store.DOMStore;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
 import org.opendaylight.mdsal.dom.spi.store.DOMStore;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;


@@ -135,13 +138,14 @@ public class ConcurrentDOMDataBrokerTest {
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).preCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).commit();
 
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).preCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).commit();
 

-        ListenableFuture<Void> future = coordinator.submit(transaction, Arrays.asList(mockCohort1, mockCohort2));
+        ListenableFuture<? extends CommitInfo> future =
+                coordinator.commit(transaction, Arrays.asList(mockCohort1, mockCohort2));

 
         final CountDownLatch doneLatch = new CountDownLatch(1);
         final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
 
         final CountDownLatch doneLatch = new CountDownLatch(1);
         final AtomicReference<Throwable> caughtEx = new AtomicReference<>();

-        Futures.addCallback(future, new FutureCallback<Void>() {
+        Futures.addCallback(future, new FutureCallback<CommitInfo>() {

             @Override
             @Override

-            public void onSuccess(final Void result) {
+            public void onSuccess(final CommitInfo result) {

                 doneLatch.countDown();
             }
 
                 doneLatch.countDown();
             }
 


@@ -184,21 +188,22 @@ public class ConcurrentDOMDataBrokerTest {
         doReturn(Futures.immediateFuture(false)).when(mockCohort3).canCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
 
         doReturn(Futures.immediateFuture(false)).when(mockCohort3).canCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
 

-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        ListenableFuture<? extends CommitInfo> future = coordinator.commit(

                 transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
 
         assertFailure(future, null, mockCohort1, mockCohort2, mockCohort3);
     }
 
                 transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
 
         assertFailure(future, null, mockCohort1, mockCohort2, mockCohort3);
     }
 

-    private static void assertFailure(final CheckedFuture<Void, TransactionCommitFailedException> future,
+    private static void assertFailure(final ListenableFuture<?> future,

             final Exception expCause, final DOMStoreThreePhaseCommitCohort... mockCohorts)
                     throws Exception {
         try {
             final Exception expCause, final DOMStoreThreePhaseCommitCohort... mockCohorts)
                     throws Exception {
         try {

-            future.checkedGet(5, TimeUnit.SECONDS);
+            future.get(5, TimeUnit.SECONDS);

             fail("Expected TransactionCommitFailedException");
             fail("Expected TransactionCommitFailedException");

-        } catch (TransactionCommitFailedException e) {
+        } catch (ExecutionException e) {
+            TransactionCommitFailedException tcf = TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER.apply(e);

             if (expCause != null) {
             if (expCause != null) {

-                assertSame("Expected cause", expCause.getClass(), e.getCause().getClass());
+                assertSame("Expected cause", expCause.getClass(), tcf.getCause().getClass());

             }
 
             InOrder inOrder = inOrder((Object[])mockCohorts);
             }
 
             InOrder inOrder = inOrder((Object[])mockCohorts);


@@ -219,7 +224,7 @@ public class ConcurrentDOMDataBrokerTest {
         doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
 
         doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
 

-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(

                 transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         assertFailure(future, cause, mockCohort1, mockCohort2);
                 transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         assertFailure(future, cause, mockCohort1, mockCohort2);


@@ -234,7 +239,7 @@ public class ConcurrentDOMDataBrokerTest {
         doReturn(Futures.immediateFailedFuture(rootCause)).when(mockCohort2).canCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
 
         doReturn(Futures.immediateFailedFuture(rootCause)).when(mockCohort2).canCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
 

-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(

             transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         assertFailure(future, cause, mockCohort1, mockCohort2);
             transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         assertFailure(future, cause, mockCohort1, mockCohort2);


@@ -257,7 +262,7 @@ public class ConcurrentDOMDataBrokerTest {
                 .when(mockCohort3).preCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
 
                 .when(mockCohort3).preCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
 

-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(

                 transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
 
         assertFailure(future, cause, mockCohort1, mockCohort2, mockCohort3);
                 transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
 
         assertFailure(future, cause, mockCohort1, mockCohort2, mockCohort3);


@@ -283,7 +288,7 @@ public class ConcurrentDOMDataBrokerTest {
                 .when(mockCohort3).commit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
 
                 .when(mockCohort3).commit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
 

-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(

                 transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
 
         assertFailure(future, cause, mockCohort1, mockCohort2, mockCohort3);
                 transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
 
         assertFailure(future, cause, mockCohort1, mockCohort2, mockCohort3);


@@ -299,7 +304,7 @@ public class ConcurrentDOMDataBrokerTest {
         doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
 
         doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
         doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
 

-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(

                 transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         assertFailure(future, cause, mockCohort1, mockCohort2);
                 transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         assertFailure(future, cause, mockCohort1, mockCohort2);


@@ -443,11 +448,11 @@ public class ConcurrentDOMDataBrokerTest {
                 LogicalDatastoreType.OPERATIONAL, operationalDomStore, LogicalDatastoreType.CONFIGURATION,
                 configDomStore), futureExecutor) {
             @Override
                 LogicalDatastoreType.OPERATIONAL, operationalDomStore, LogicalDatastoreType.CONFIGURATION,
                 configDomStore), futureExecutor) {
             @Override

-            public CheckedFuture<Void, TransactionCommitFailedException> submit(DOMDataTreeWriteTransaction writeTx,
+            public FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction writeTx,

                     Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
                 commitCohorts.addAll(cohorts);
                 latch.countDown();
                     Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
                 commitCohorts.addAll(cohorts);
                 latch.countDown();

-                return super.submit(writeTx, cohorts);
+                return super.commit(writeTx, cohorts);

             }
         }) {
             DOMDataTreeReadWriteTransaction domDataReadWriteTransaction = dataBroker.newReadWriteTransaction();
             }
         }) {
             DOMDataTreeReadWriteTransaction domDataReadWriteTransaction = dataBroker.newReadWriteTransaction();


@@ -490,11 +495,11 @@ public class ConcurrentDOMDataBrokerTest {
                 configDomStore), futureExecutor) {
             @Override
             @SuppressWarnings("checkstyle:hiddenField")
                 configDomStore), futureExecutor) {
             @Override
             @SuppressWarnings("checkstyle:hiddenField")

-            public CheckedFuture<Void, TransactionCommitFailedException> submit(DOMDataTreeWriteTransaction writeTx,
+            public FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction writeTx,

                     Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
                 commitCohorts.addAll(cohorts);
                 latch.countDown();
                     Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
                 commitCohorts.addAll(cohorts);
                 latch.countDown();

-                return super.submit(writeTx, cohorts);
+                return super.commit(writeTx, cohorts);

             }
         }) {
             DOMDataTreeReadWriteTransaction domDataReadWriteTransaction = dataBroker.newReadWriteTransaction();
             }
         }) {
             DOMDataTreeReadWriteTransaction domDataReadWriteTransaction = dataBroker.newReadWriteTransaction();

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/compat/LegacyDOMDataBrokerAdapterTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/compat/LegacyDOMDataBrokerAdapterTest.java
index f90879214dd13d378e17fd61387552f88a8fa7aa..b6e7682b1a1d6e1b48c3043398b4719b86b1a80a 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/compat/LegacyDOMDataBrokerAdapterTest.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/compat/LegacyDOMDataBrokerAdapterTest.java
@@ -24,11 +24,13 @@ import static org.mockito.Mockito.verify;
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.concurrent.TimeUnit;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.concurrent.TimeUnit;

+import org.eclipse.jdt.annotation.NonNull;

 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;


@@ -57,6 +59,7 @@ import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeCommitCohortRegistr
 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
 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.api.DOMDataTreeIdentifier;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohort;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistration;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohort;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistration;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;


@@ -452,6 +455,22 @@ public class LegacyDOMDataBrokerAdapterTest {
         verify(mockConfigStore).registerChangeListener(TestModel.TEST_PATH, listener, DataChangeScope.ONE);
     }
 
         verify(mockConfigStore).registerChangeListener(TestModel.TEST_PATH, listener, DataChangeScope.ONE);
     }
 

+    @Test
+    public void testCommit() throws Exception {
+        DOMDataWriteTransaction tx = adapter.newWriteOnlyTransaction();
+
+        tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
+        verify(mockWriteTx).write(TestModel.TEST_PATH, dataNode);
+
+        @NonNull FluentFuture<? extends @NonNull CommitInfo> commitFuture = tx.commit();
+        commitFuture.get(5, TimeUnit.SECONDS);
+
+        InOrder inOrder = inOrder(mockCommitCohort);
+        inOrder.verify(mockCommitCohort).canCommit();
+        inOrder.verify(mockCommitCohort).preCommit();
+        inOrder.verify(mockCommitCohort).commit();
+    }
+

     private interface TestDOMStore extends DistributedDataStoreInterface, DOMStoreTreeChangePublisher,
             org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry {
     }
     private interface TestDOMStore extends DistributedDataStoreInterface, DOMStoreTreeChangePublisher,
             org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry {
     }

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/AbstractDOMForwardedTransactionFactory.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/AbstractDOMForwardedTransactionFactory.java
index 4bb71978699f5a1aa6fc84cad9cd12a2df259036..e3099969c0aa249cbcd5ca18cd06920b3da802e5 100644 (file)
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/AbstractDOMForwardedTransactionFactory.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/AbstractDOMForwardedTransactionFactory.java
@@ -8,7 +8,8 @@
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;

-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.base.Supplier;
+import com.google.common.util.concurrent.ListenableFuture;

 import java.util.Collection;
 import java.util.EnumMap;
 import java.util.Map;
 import java.util.Collection;
 import java.util.EnumMap;
 import java.util.Map;


@@ -64,26 +65,25 @@ abstract class AbstractDOMForwardedTransactionFactory<T extends DOMStoreTransact
     protected abstract Object newTransactionIdentifier();
 
     /**
     protected abstract Object newTransactionIdentifier();
 
     /**

-     * User-supplied implementation of {@link DOMDataWriteTransaction#submit()}
+     * User-supplied implementation of {@link DOMDataWriteTransaction#commit()}

      * for transaction.
      *
      * <p>
      * for transaction.
      *
      * <p>

-     * Callback invoked when {@link DOMDataWriteTransaction#submit()} is invoked
+     * Callback invoked when {@link DOMDataWriteTransaction#commit()} is invoked

      * on transaction created by this factory.
      *
      * @param transaction
      * on transaction created by this factory.
      *
      * @param transaction

-     *            Transaction on which {@link DOMDataWriteTransaction#submit()}
+     *            Transaction on which {@link DOMDataWriteTransaction#commit()}

      *            was invoked.
      * @param cohorts
      *            Iteratable of cohorts for subtransactions associated with
      *            the transaction being committed.
      *            was invoked.
      * @param cohorts
      *            Iteratable of cohorts for subtransactions associated with
      *            the transaction being committed.

-     * @return a CheckedFuture. if commit coordination on cohorts finished successfully,
-     *         nothing is returned from the Future, On failure,
+     * @return a ListenableFuture. if commit coordination on cohorts finished successfully,
+     *         a CommitInfo is returned from the Future, On failure,

      *         the Future fails with a {@link TransactionCommitFailedException}.
      */
      *         the Future fails with a {@link TransactionCommitFailedException}.
      */

-    protected abstract CheckedFuture<Void,
-            TransactionCommitFailedException>
-                submit(DOMDataWriteTransaction transaction, Collection<DOMStoreThreePhaseCommitCohort> cohorts);
+    protected abstract <T> ListenableFuture<T> commit(DOMDataWriteTransaction transaction,
+            Collection<DOMStoreThreePhaseCommitCohort> cohorts, Supplier<T> futureValueSupplier);

 
     /**
      * Creates a new composite read-only transaction
 
     /**
      * Creates a new composite read-only transaction


@@ -142,11 +142,10 @@ abstract class AbstractDOMForwardedTransactionFactory<T extends DOMStoreTransact
      * {@link DOMStoreWriteTransaction#delete(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)} is
      * invoked on
      * selected subtransaction.
      * {@link DOMStoreWriteTransaction#delete(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)} is
      * invoked on
      * selected subtransaction.

-     * </li><li> {@link DOMDataWriteTransaction#submit()} - results in invoking
+     * </li><li> {@link DOMDataWriteTransaction#commit()} - results in invoking

      * {@link DOMStoreWriteTransaction#ready()}, gathering all resulting cohorts
      * and then invoking finalized implementation callback
      * {@link DOMStoreWriteTransaction#ready()}, gathering all resulting cohorts
      * and then invoking finalized implementation callback

-     * {@link #submit(DOMDataWriteTransaction, Collection)} with transaction which
-     * was commited and gathered results.
+     * {@link #commit} with transaction which was commited and gathered results.

      * </li>
      * </ul>
      *
      * </li>
      * </ul>
      *


@@ -207,11 +206,10 @@ abstract class AbstractDOMForwardedTransactionFactory<T extends DOMStoreTransact
      * {@link DOMStoreWriteTransaction#delete(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)} is
      * invoked on
      * selected subtransaction.
      * {@link DOMStoreWriteTransaction#delete(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)} is
      * invoked on
      * selected subtransaction.

-     * <li> {@link DOMDataWriteTransaction#submit()} - results in invoking
+     * <li> {@link DOMDataWriteTransaction#commit()} - results in invoking

      * {@link DOMStoreWriteTransaction#ready()}, gathering all resulting cohorts
      * and then invoking finalized implementation callback
      * {@link DOMStoreWriteTransaction#ready()}, gathering all resulting cohorts
      * and then invoking finalized implementation callback

-     * {@link #submit(DOMDataWriteTransaction, Collection)} with transaction which
-     * was committed and gathered results.
+     * {@link #commit} with transaction which was committed and gathered results.

      * <li>
      * </ul>
      *
      * <li>
      * </ul>
      *

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/CommitCoordinationTask.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/CommitCoordinationTask.java
index 37f33aabeed7610ec0a6fce481dbfe108f702193..810f09a8c71eef625248221eaad62d53fc7e12d3 100644 (file)
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/CommitCoordinationTask.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/CommitCoordinationTask.java
@@ -9,6 +9,7 @@
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;

+import com.google.common.base.Supplier;

 import com.google.common.base.Throwables;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.base.Throwables;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;


@@ -26,7 +27,7 @@ import org.slf4j.LoggerFactory;
  * Implementation of blocking three-phase commit-coordination tasks without
  * support of cancellation.
  */
  * Implementation of blocking three-phase commit-coordination tasks without
  * support of cancellation.
  */

-final class CommitCoordinationTask implements Callable<Void> {
+final class CommitCoordinationTask<T> implements Callable<T> {

     private enum Phase {
         canCommit,
         preCommit,
     private enum Phase {
         canCommit,
         preCommit,


@@ -37,17 +38,20 @@ final class CommitCoordinationTask implements Callable<Void> {
     private final Collection<DOMStoreThreePhaseCommitCohort> cohorts;
     private final DurationStatisticsTracker commitStatTracker;
     private final DOMDataWriteTransaction tx;
     private final Collection<DOMStoreThreePhaseCommitCohort> cohorts;
     private final DurationStatisticsTracker commitStatTracker;
     private final DOMDataWriteTransaction tx;

+    private final Supplier<T> futureValueSupplier;

 
     CommitCoordinationTask(final DOMDataWriteTransaction transaction,
             final Collection<DOMStoreThreePhaseCommitCohort> cohorts,
 
     CommitCoordinationTask(final DOMDataWriteTransaction transaction,
             final Collection<DOMStoreThreePhaseCommitCohort> cohorts,

-            final DurationStatisticsTracker commitStatTracker) {
+            final DurationStatisticsTracker commitStatTracker,
+            final Supplier<T> futureValueSupplier) {

         this.tx = Preconditions.checkNotNull(transaction, "transaction must not be null");
         this.cohorts = Preconditions.checkNotNull(cohorts, "cohorts must not be null");
         this.commitStatTracker = commitStatTracker;
         this.tx = Preconditions.checkNotNull(transaction, "transaction must not be null");
         this.cohorts = Preconditions.checkNotNull(cohorts, "cohorts must not be null");
         this.commitStatTracker = commitStatTracker;

+        this.futureValueSupplier = futureValueSupplier;

     }
 
     @Override
     }
 
     @Override

-    public Void call() throws TransactionCommitFailedException {
+    public T call() throws TransactionCommitFailedException {

         final long startTime = commitStatTracker != null ? System.nanoTime() : 0;
 
         Phase phase = Phase.canCommit;
         final long startTime = commitStatTracker != null ? System.nanoTime() : 0;
 
         Phase phase = Phase.canCommit;


@@ -65,7 +69,7 @@ final class CommitCoordinationTask implements Callable<Void> {
             commitBlocking();
 
             LOG.debug("Transaction {}: doCommit completed", tx.getIdentifier());
             commitBlocking();
 
             LOG.debug("Transaction {}: doCommit completed", tx.getIdentifier());

-            return null;
+            return futureValueSupplier.get();

         } catch (final TransactionCommitFailedException e) {
             LOG.warn("Tx: {} Error during phase {}, starting Abort", tx.getIdentifier(), phase, e);
             abortBlocking(e);
         } catch (final TransactionCommitFailedException e) {
             LOG.warn("Tx: {} Error during phase {}, starting Abort", tx.getIdentifier(), phase, e);
             abortBlocking(e);

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMDataBrokerTransactionChainImpl.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMDataBrokerTransactionChainImpl.java
index c7eaef51fe753ceb84802e41171070c5dfe89ca8..4c131e1ea39fc91ce782a14d093b1e1ed1ad68c7 100755 (executable)
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMDataBrokerTransactionChainImpl.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMDataBrokerTransactionChainImpl.java
@@ -9,9 +9,11 @@
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;

-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.base.Supplier;

 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 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.Collection;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;


@@ -19,7 +21,6 @@ import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 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.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;


@@ -83,19 +84,17 @@ final class DOMDataBrokerTransactionChainImpl extends
     }
 
     @Override
     }
 
     @Override

-    public CheckedFuture<Void, TransactionCommitFailedException> submit(final DOMDataWriteTransaction transaction,
-                                                                        final
-                                                                        Collection<DOMStoreThreePhaseCommitCohort>
-                                                                                cohorts) {
+    public <T> ListenableFuture<T> commit(final DOMDataWriteTransaction transaction,
+            final Collection<DOMStoreThreePhaseCommitCohort> cohorts, final Supplier<T> futureValueSupplier) {

         checkNotFailed();
         checkNotClosed();
 
         checkNotFailed();
         checkNotClosed();
 

-        final CheckedFuture<Void, TransactionCommitFailedException> ret = broker.submit(transaction, cohorts);
+        final ListenableFuture<T> ret = broker.commit(transaction, cohorts, futureValueSupplier);

 
         COUNTER_UPDATER.incrementAndGet(this);
 
         COUNTER_UPDATER.incrementAndGet(this);

-        Futures.addCallback(ret, new FutureCallback<Void>() {
+        Futures.addCallback(ret, new FutureCallback<T>() {

             @Override
             @Override

-            public void onSuccess(final Void result) {
+            public void onSuccess(final T result) {

                 transactionCompleted();
             }
 
                 transactionCompleted();
             }
 


@@ -103,7 +102,7 @@ final class DOMDataBrokerTransactionChainImpl extends
             public void onFailure(final Throwable throwable) {
                 transactionFailed(transaction, throwable);
             }
             public void onFailure(final Throwable throwable) {
                 transactionFailed(transaction, throwable);
             }

-        });
+        }, MoreExecutors.directExecutor());

 
         return ret;
     }
 
         return ret;
     }

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMForwardedWriteTransaction.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMForwardedWriteTransaction.java
index 68940fde5d52f66a7c95aac8849f1b5da4e3c613..5c312cc92d0d174792fac5ad92975045b0bed90e 100644 (file)
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMForwardedWriteTransaction.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMForwardedWriteTransaction.java
@@ -8,8 +8,11 @@
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;

+import com.google.common.base.Supplier;

 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.Futures;

+import com.google.common.util.concurrent.ListenableFuture;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Map;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Map;


@@ -20,6 +23,8 @@ import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFaile
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;

+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.MappingCheckedFuture;

 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.slf4j.Logger;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.slf4j.Logger;


@@ -68,7 +73,7 @@ class DOMForwardedWriteTransaction<T extends DOMStoreWriteTransaction> extends
 
     /**
      * Future task of transaction commit. It starts off as null, but is
 
     /**
      * Future task of transaction commit. It starts off as null, but is

-     * set appropriately on {@link #submit()} and {@link #cancel()} via
+     * set appropriately on {@link #commit()} and {@link #cancel()} via

      * {@link AtomicReferenceFieldUpdater#lazySet(Object, Object)}.
      *
      * <p>
      * {@link AtomicReferenceFieldUpdater#lazySet(Object, Object)}.
      *
      * <p>


@@ -126,24 +131,34 @@ class DOMForwardedWriteTransaction<T extends DOMStoreWriteTransaction> extends
     }
 
     @Override
     }
 
     @Override

-    @SuppressWarnings("checkstyle:illegalcatch")

     public CheckedFuture<Void, TransactionCommitFailedException> submit() {
     public CheckedFuture<Void, TransactionCommitFailedException> submit() {

+        return MappingCheckedFuture.create(doCommit(() -> null),
+                TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
+    }
+
+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        return FluentFuture.from(doCommit(CommitInfo::empty));
+    }
+
+    @SuppressWarnings("checkstyle:IllegalCatch")
+    private <V> ListenableFuture<V> doCommit(Supplier<V> futureValueSupplier) {

         final AbstractDOMForwardedTransactionFactory<?> impl = IMPL_UPDATER.getAndSet(this, null);
         checkRunning(impl);
 
         final Collection<T> txns = getSubtransactions();
         final Collection<DOMStoreThreePhaseCommitCohort> cohorts = new ArrayList<>(txns.size());
 
         final AbstractDOMForwardedTransactionFactory<?> impl = IMPL_UPDATER.getAndSet(this, null);
         checkRunning(impl);
 
         final Collection<T> txns = getSubtransactions();
         final Collection<DOMStoreThreePhaseCommitCohort> cohorts = new ArrayList<>(txns.size());
 

-        CheckedFuture<Void, TransactionCommitFailedException> ret;
+        ListenableFuture<V> ret;

         try {
             for (DOMStoreWriteTransaction txn : txns) {
                 cohorts.add(txn.ready());
             }
 
         try {
             for (DOMStoreWriteTransaction txn : txns) {
                 cohorts.add(txn.ready());
             }
 

-            ret = impl.submit(this, cohorts);
+            ret = impl.commit(this, cohorts, futureValueSupplier);

         } catch (RuntimeException e) {
         } catch (RuntimeException e) {

-            ret = Futures.immediateFailedCheckedFuture(
-                    TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER.apply(e));
+            ret = FluentFuture.from(Futures.immediateFailedFuture(
+                    TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER.apply(e)));

         }
         FUTURE_UPDATER.lazySet(this, ret);
         return ret;
         }
         FUTURE_UPDATER.lazySet(this, ret);
         return ret;

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongFuture.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongFuture.java
deleted file mode 100644 (file)
index 63aba6e..0000000
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongFuture.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.md.sal.dom.broker.impl;
-
-import com.google.common.util.concurrent.AbstractCheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-
-/**
- * A {@link java.util.concurrent.Future} used to report the status of an future
- * {@link java.util.concurrent.Future}.
- */
-final class PingPongFuture extends AbstractCheckedFuture<Void, TransactionCommitFailedException> {
-    protected PingPongFuture(final ListenableFuture<Void> delegate) {
-        super(delegate);
-    }
-
-    @Override
-    protected TransactionCommitFailedException mapException(final Exception exception) {
-        final Throwable cause = exception.getCause();
-        if (cause instanceof TransactionCommitFailedException) {
-            return (TransactionCommitFailedException) cause;
-        } else {
-            return new TransactionCommitFailedException(exception.getMessage(), cause);
-        }
-    }
-}
-

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongTransaction.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongTransaction.java
index aa8f3e18c068cc5b1161dd60c7b833d9b7590b8b..fad3c1cd1a9842334441f0ca636c9bad24bd1cb1 100644 (file)
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongTransaction.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/PingPongTransaction.java
@@ -10,27 +10,25 @@ package org.opendaylight.controller.md.sal.dom.broker.impl;
 import com.google.common.base.MoreObjects;
 import com.google.common.base.MoreObjects.ToStringHelper;
 import com.google.common.base.Preconditions;
 import com.google.common.base.MoreObjects;
 import com.google.common.base.MoreObjects.ToStringHelper;
 import com.google.common.base.Preconditions;

-import com.google.common.util.concurrent.CheckedFuture;

 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.FutureCallback;

+import com.google.common.util.concurrent.ListenableFuture;

 import com.google.common.util.concurrent.SettableFuture;
 import com.google.common.util.concurrent.SettableFuture;

-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;

 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 
 /**
  * Transaction context. Tracks the relationship with the backend transaction.
  * We never leak this class to the user and have it implement the {@link FutureCallback}
  * interface so we have a simple way of propagating the result.
  */
 
 /**
  * Transaction context. Tracks the relationship with the backend transaction.
  * We never leak this class to the user and have it implement the {@link FutureCallback}
  * interface so we have a simple way of propagating the result.
  */

-final class PingPongTransaction implements FutureCallback<Void> {
-    private final CheckedFuture<Void, TransactionCommitFailedException> submitFuture;
+final class PingPongTransaction implements FutureCallback<CommitInfo> {

     private final DOMDataReadWriteTransaction delegate;
     private final DOMDataReadWriteTransaction delegate;

-    private final SettableFuture<Void> future;
+    private final SettableFuture<CommitInfo> future;

     private DOMDataReadWriteTransaction frontendTransaction;
 
     PingPongTransaction(final DOMDataReadWriteTransaction delegate) {
         this.delegate = Preconditions.checkNotNull(delegate);
         future = SettableFuture.create();
     private DOMDataReadWriteTransaction frontendTransaction;
 
     PingPongTransaction(final DOMDataReadWriteTransaction delegate) {
         this.delegate = Preconditions.checkNotNull(delegate);
         future = SettableFuture.create();

-        submitFuture = new PingPongFuture(future);

     }
 
     DOMDataReadWriteTransaction getTransaction() {
     }
 
     DOMDataReadWriteTransaction getTransaction() {


@@ -41,12 +39,12 @@ final class PingPongTransaction implements FutureCallback<Void> {
         return frontendTransaction;
     }
 
         return frontendTransaction;
     }
 

-    CheckedFuture<Void, TransactionCommitFailedException> getSubmitFuture() {
-        return submitFuture;
+    ListenableFuture<CommitInfo> getSubmitFuture() {
+        return future;

     }
 
     @Override
     }
 
     @Override

-    public void onSuccess(final Void result) {
+    public void onSuccess(final CommitInfo result) {

         future.set(result);
     }
 
         future.set(result);
     }
 

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 c8027d00f7a964b7f6fc1bf21161737656ee8f60..8cda1d53f9678baa5145789dd8f82978fa1796dd 100644 (file)
--- 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
@@ -11,8 +11,8 @@ 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.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.FutureCallback;

-import com.google.common.util.concurrent.Futures;

 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.AbstractMap.SimpleImmutableEntry;
 import java.util.Map.Entry;
 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.AbstractMap.SimpleImmutableEntry;
 import java.util.Map.Entry;


@@ -32,6 +32,8 @@ 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.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.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.MappingCheckedFuture;

 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.slf4j.Logger;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.slf4j.Logger;


@@ -192,7 +194,7 @@ public final class PingPongTransactionChain implements DOMTransactionChain {
             return slowAllocateTransaction();
         }
 
             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();
         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();


@@ -237,9 +239,9 @@ public final class PingPongTransactionChain implements DOMTransactionChain {
             LOG.warn("Submitting transaction {} while {} is still running", tx, inflightTx);
         }
 
             LOG.warn("Submitting transaction {} while {} is still running", tx, inflightTx);
         }
 

-        Futures.addCallback(tx.getTransaction().submit(), new FutureCallback<Void>() {
+        tx.getTransaction().commit().addCallback(new FutureCallback<CommitInfo>() {

             @Override
             @Override

-            public void onSuccess(final Void result) {
+            public void onSuccess(final CommitInfo result) {

                 transactionSuccessful(tx, result);
             }
 
                 transactionSuccessful(tx, result);
             }
 


@@ -285,7 +287,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);
         LOG.debug("Transaction {} completed successfully", tx);
 
         tx.onSuccess(result);


@@ -450,9 +452,16 @@ public final class PingPongTransactionChain implements DOMTransactionChain {
 
             @Override
             public CheckedFuture<Void, TransactionCommitFailedException> submit() {
 
             @Override
             public CheckedFuture<Void, TransactionCommitFailedException> submit() {

+                return MappingCheckedFuture.create(commit().transform(ignored -> null,
+                        MoreExecutors.directExecutor()), TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
+            }
+
+            @Override
+            public FluentFuture<? extends CommitInfo> commit() {

                 readyTransaction(tx);
                 isOpen = false;
                 readyTransaction(tx);
                 isOpen = false;

-                return tx.getSubmitFuture();
+                return FluentFuture.from(tx.getSubmitFuture()).transformAsync(
+                    ignored -> CommitInfo.emptyFluentFuture(), MoreExecutors.directExecutor());

             }
 
             @Override
             }
 
             @Override

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/SerializedDOMDataBroker.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/SerializedDOMDataBroker.java
index 3bb5d5f8bfddbc03d2903e9f02bd0420b1045ff9..db6192b348e12775f5aae0c42606aa84f7741d14 100644 (file)
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/SerializedDOMDataBroker.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/SerializedDOMDataBroker.java
@@ -9,7 +9,7 @@
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;
 package org.opendaylight.controller.md.sal.dom.broker.impl;
 
 import com.google.common.base.Preconditions;

-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.base.Supplier;

 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;


@@ -21,7 +21,6 @@ import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFaile
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.sal.core.spi.data.DOMStore;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.sal.core.spi.data.DOMStore;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;

-import org.opendaylight.mdsal.common.api.MappingCheckedFuture;

 import org.opendaylight.yangtools.util.DurationStatisticsTracker;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.opendaylight.yangtools.util.DurationStatisticsTracker;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;


@@ -63,23 +62,22 @@ public class SerializedDOMDataBroker extends AbstractDOMDataBroker {
     }
 
     @Override
     }
 
     @Override

-    protected CheckedFuture<Void, TransactionCommitFailedException> submit(final DOMDataWriteTransaction transaction,
-                                                                           final
-                                                                           Collection<DOMStoreThreePhaseCommitCohort>
-                                                                                   cohorts) {
+    protected <T> ListenableFuture<T> commit(final DOMDataWriteTransaction transaction,
+            final Collection<DOMStoreThreePhaseCommitCohort> cohorts, final Supplier<T> futureValueSupplier) {

         Preconditions.checkArgument(transaction != null, "Transaction must not be null.");
         Preconditions.checkArgument(cohorts != null, "Cohorts must not be null.");
         LOG.debug("Tx: {} is submitted for execution.", transaction.getIdentifier());
 
         Preconditions.checkArgument(transaction != null, "Transaction must not be null.");
         Preconditions.checkArgument(cohorts != null, "Cohorts must not be null.");
         LOG.debug("Tx: {} is submitted for execution.", transaction.getIdentifier());
 

-        ListenableFuture<Void> commitFuture = null;
+        ListenableFuture<T> commitFuture;

         try {
         try {

-            commitFuture = executor.submit(new CommitCoordinationTask(transaction, cohorts, commitStatsTracker));
+            commitFuture = executor.submit(new CommitCoordinationTask<>(transaction, cohorts, commitStatsTracker,
+                    futureValueSupplier));

         } catch (RejectedExecutionException e) {
             LOG.error("The commit executor's queue is full - submit task was rejected. \n" + executor, e);
         } catch (RejectedExecutionException e) {
             LOG.error("The commit executor's queue is full - submit task was rejected. \n" + executor, e);

-            return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException(
+            commitFuture = Futures.immediateFailedFuture(new TransactionCommitFailedException(

                     "Could not submit the commit task - the commit queue capacity has been exceeded.", e));
         }
 
                     "Could not submit the commit task - the commit queue capacity has been exceeded.", e));
         }
 

-        return MappingCheckedFuture.create(commitFuture, TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
+        return commitFuture;

     }
 }
     }
 }

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/legacy/sharded/adapter/ShardedDOMDataBrokerDelegatingReadWriteTransaction.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/legacy/sharded/adapter/ShardedDOMDataBrokerDelegatingReadWriteTransaction.java
index 3eab7237923daa18f4d3fe4e774e8b8cb21ee39c..380f9d5c8e3d5623ea89e36cea6359df90440ac2 100644 (file)
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/legacy/sharded/adapter/ShardedDOMDataBrokerDelegatingReadWriteTransaction.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/legacy/sharded/adapter/ShardedDOMDataBrokerDelegatingReadWriteTransaction.java
@@ -17,6 +17,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 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.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;


@@ -32,6 +33,7 @@ import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFaile
 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.DOMDataReadOnlyTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;

+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.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;


@@ -111,6 +113,11 @@ class ShardedDOMDataBrokerDelegatingReadWriteTransaction implements DOMDataReadW
         return writeTxDelegate.submit();
     }
 
         return writeTxDelegate.submit();
     }
 

+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        return writeTxDelegate.commit();
+    }
+

     @Override
     public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
                                                                                    final YangInstanceIdentifier path) {
     @Override
     public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
                                                                                    final YangInstanceIdentifier path) {

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/legacy/sharded/adapter/ShardedDOMDataBrokerDelegatingWriteTransaction.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/legacy/sharded/adapter/ShardedDOMDataBrokerDelegatingWriteTransaction.java
index e72d9e01fa7c7edf0a5c8f547f3445c5d8ead679..7ff6728e6af36c14856742f987d196a6d989f4f0 100644 (file)
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/legacy/sharded/adapter/ShardedDOMDataBrokerDelegatingWriteTransaction.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/legacy/sharded/adapter/ShardedDOMDataBrokerDelegatingWriteTransaction.java
@@ -11,11 +11,13 @@ package org.opendaylight.controller.md.sal.dom.broker.impl.legacy.sharded.adapte
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.util.concurrent.CheckedFuture;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import com.google.common.util.concurrent.Futures;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.broker.impl.TransactionCommitFailedExceptionMapper;
 import com.google.common.util.concurrent.Futures;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.broker.impl.TransactionCommitFailedExceptionMapper;

+import org.opendaylight.mdsal.common.api.CommitInfo;

 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;


@@ -57,6 +59,11 @@ class ShardedDOMDataBrokerDelegatingWriteTransaction implements DOMDataWriteTran
         return Futures.makeChecked(delegateTx.submit(), TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
     }
 
         return Futures.makeChecked(delegateTx.submit(), TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
     }
 

+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        return delegateTx.commit();
+    }
+

     @Override
     public Object getIdentifier() {
         return txIdentifier;
     @Override
     public Object getIdentifier() {
         return txIdentifier;

diff --git a/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMForwardedWriteTransactionTest.java b/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMForwardedWriteTransactionTest.java
index 9e76b6bfa20b31f2be03f05b4732fa615fef51b9..f98ff6e14f5f3ca8b2b8bc02b6cd3194badaf5b9 100644 (file)
--- a/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMForwardedWriteTransactionTest.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMForwardedWriteTransactionTest.java
@@ -58,7 +58,7 @@ public class DOMForwardedWriteTransactionTest {
     public void submitRuntimeExceptionAndCancel() {
         RuntimeException thrown = new RuntimeException();
         doReturn(null).when(domStoreWriteTransaction).ready();
     public void submitRuntimeExceptionAndCancel() {
         RuntimeException thrown = new RuntimeException();
         doReturn(null).when(domStoreWriteTransaction).ready();

-        doThrow(thrown).when(abstractDOMForwardedTransactionFactory).submit(any(), any());
+        doThrow(thrown).when(abstractDOMForwardedTransactionFactory).commit(any(), any(), any());

         DOMForwardedWriteTransaction<DOMStoreWriteTransaction> domForwardedWriteTransaction =
                 new DOMForwardedWriteTransaction<>(
                     new Object(),
         DOMForwardedWriteTransaction<DOMStoreWriteTransaction> domForwardedWriteTransaction =
                 new DOMForwardedWriteTransaction<>(
                     new Object(),


@@ -73,4 +73,4 @@ public class DOMForwardedWriteTransactionTest {
             domForwardedWriteTransaction.cancel();
         }
     }
             domForwardedWriteTransaction.cancel();
         }
     }

-}
\ No newline at end of file
+}

diff --git a/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadWriteTransaction.java b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadWriteTransaction.java
index ea2bb9554335c17ba43dc53655e529652c88b1a4..7f450a421e3d2fbb7cfb7d3576399a90d505a351 100644 (file)
--- a/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadWriteTransaction.java
+++ b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadWriteTransaction.java
@@ -10,11 +10,13 @@ package org.opendaylight.controller.md.sal.dom.spi;
 import com.google.common.base.Optional;
 import com.google.common.collect.ForwardingObject;
 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.base.Optional;
 import com.google.common.collect.ForwardingObject;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import javax.annotation.Nonnull;
 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.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
 import javax.annotation.Nonnull;
 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.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;

+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.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 


@@ -70,4 +72,9 @@ public abstract class ForwardingDOMDataReadWriteTransaction extends ForwardingOb
     public CheckedFuture<Void, TransactionCommitFailedException> submit() {
         return delegate().submit();
     }
     public CheckedFuture<Void, TransactionCommitFailedException> submit() {
         return delegate().submit();
     }

+
+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        return delegate().commit();
+    }

 }
 }

diff --git a/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataWriteTransaction.java b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataWriteTransaction.java
index 807ea51daf5931447b92c1abd9d5129bddb0d8a5..474c151503dc7bdbe5868dbf1d624bd8fe1c8ff4 100644 (file)
--- a/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataWriteTransaction.java
+++ b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataWriteTransaction.java
@@ -9,10 +9,12 @@ package org.opendaylight.controller.md.sal.dom.spi;
 
 import com.google.common.collect.ForwardingObject;
 import com.google.common.util.concurrent.CheckedFuture;
 
 import com.google.common.collect.ForwardingObject;
 import com.google.common.util.concurrent.CheckedFuture;

+import com.google.common.util.concurrent.FluentFuture;

 import javax.annotation.Nonnull;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import javax.annotation.Nonnull;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;

+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.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 


@@ -55,4 +57,9 @@ public abstract class ForwardingDOMDataWriteTransaction extends ForwardingObject
     public CheckedFuture<Void, TransactionCommitFailedException> submit() {
         return delegate().submit();
     }
     public CheckedFuture<Void, TransactionCommitFailedException> submit() {
         return delegate().submit();
     }

+
+    @Override
+    public FluentFuture<? extends CommitInfo> commit() {
+        return delegate().commit();
+    }

 }
 }