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.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
getDelegate().delete(store, normalized);
}
- protected final CheckedFuture<Void,TransactionCommitFailedException> doSubmit() {
- return getDelegate().submit();
+ protected final @NonNull FluentFuture<? extends @NonNull CommitInfo> doCommit() {
+ return getDelegate().commit();
}
protected final boolean doCancel() {
package org.opendaylight.mdsal.binding.dom.adapter;
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.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.BindingTransactionChain;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.AsyncTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.TransactionChain;
import org.opendaylight.mdsal.common.api.TransactionChainListener;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
return new BindingDOMWriteTransactionAdapter<DOMDataTreeWriteTransaction>(delegateTx, codec) {
@Override
- public CheckedFuture<Void,TransactionCommitFailedException> submit() {
- return listenForFailure(this,super.submit());
+ public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ return listenForFailure(this, super.commit());
}
};
return new BindingDOMReadWriteTransactionAdapter(delegateTx, codec) {
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return listenForFailure(this,super.submit());
+ public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ return listenForFailure(this, super.commit());
}
-
};
}
return future;
}
+
private void failTransactionChain(final WriteTransaction tx, final Throwable throwable) {
/*
* We asume correct state change for underlaying transaction
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
@Override
- public CheckedFuture<Void,TransactionCommitFailedException> submit() {
- return doSubmit();
+ public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ return doCommit();
}
@Override
public boolean cancel() {
return doCancel();
}
-}
\ No newline at end of file
+}
createAndVerifyTop(listener);
- putTx(BAR_PATH, BAR_DATA).submit().get();
+ putTx(BAR_PATH, BAR_DATA).commit().get();
final DataObjectModification<Top> afterBarPutEvent
= Iterables.getOnlyElement(listener.nextEvent()).getRootNode();
verifyModification(afterBarPutEvent, TOP_ARGUMENT, ModificationType.SUBTREE_MODIFIED);
assertNotNull(barPutMod);
verifyModification(barPutMod, BAR_ARGUMENT, ModificationType.WRITE);
- deleteTx(BAR_PATH).submit().get();
+ deleteTx(BAR_PATH).commit().get();
final DataObjectModification<Top> afterBarDeleteEvent
= Iterables.getOnlyElement(listener.nextEvent()).getRootNode();
verifyModification(afterBarDeleteEvent, TOP_ARGUMENT, ModificationType.SUBTREE_MODIFIED);
LogicalDatastoreType.OPERATIONAL, TOP_PATH.child(TopLevelList.class));
dataBrokerImpl.registerDataTreeChangeListener(wildcard, listener);
- putTx(TOP_PATH, TOP_INITIAL_DATA).submit().get();
+ putTx(TOP_PATH, TOP_INITIAL_DATA).commit().get();
final DataTreeModification<TopLevelList> fooWriteEvent = Iterables.getOnlyElement(listener.nextEvent());
assertEquals(FOO_PATH, fooWriteEvent.getRootPath().getRootIdentifier());
verifyModification(fooWriteEvent.getRootNode(), FOO_ARGUMENT, ModificationType.WRITE);
- putTx(BAR_PATH, BAR_DATA).submit().get();
+ putTx(BAR_PATH, BAR_DATA).commit().get();
final DataTreeModification<TopLevelList> barWriteEvent = Iterables.getOnlyElement(listener.nextEvent());
assertEquals(BAR_PATH, barWriteEvent.getRootPath().getRootIdentifier());
verifyModification(barWriteEvent.getRootNode(), BAR_ARGUMENT, ModificationType.WRITE);
- deleteTx(BAR_PATH).submit().get();
+ deleteTx(BAR_PATH).commit().get();
final DataTreeModification<TopLevelList> barDeleteEvent = Iterables.getOnlyElement(listener.nextEvent());
assertEquals(BAR_PATH, barDeleteEvent.getRootPath().getRootIdentifier());
verifyModification(barDeleteEvent.getRootNode(), BAR_ARGUMENT, ModificationType.DELETE);
@Test
public void testWildcardedListListenerWithPreexistingData() throws Exception {
- putTx(TOP_PATH, TOP_INITIAL_DATA).submit().get();
+ putTx(TOP_PATH, TOP_INITIAL_DATA).commit().get();
final EventCapturingListener<TopLevelList> listener = new EventCapturingListener<>();
final DataTreeIdentifier<TopLevelList> wildcard = DataTreeIdentifier.create(
}
private void createAndVerifyTop(final EventCapturingListener<Top> listener) throws Exception {
- putTx(TOP_PATH,TOP_INITIAL_DATA).submit().get();
+ putTx(TOP_PATH,TOP_INITIAL_DATA).commit().get();
final Collection<DataTreeModification<Top>> events = listener.nextEvent();
assertFalse("Non empty collection should be received.",events.isEmpty());
public void testTinyIntDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, TINY_INT_NODE_PATH, new TinyIntContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<TinyIntContainer> tinyIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testSmallIntDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, SMALL_INT_NODE_PATH, new SmallIntContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<SmallIntContainer> smallIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testNormalIntDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, NORMAL_INT_NODE_PATH, new NormalIntContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<NormalIntContainer> normalIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testBigIntDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, BIG_INT_NODE_PATH, new BigIntContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<BigIntContainer> bigIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testTinyUintDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, TINY_UINT_NODE_PATH, new TinyUintContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<TinyUintContainer> tinyUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testSmallUintDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, SMALL_UINT_NODE_PATH, new SmallUintContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<SmallUintContainer> smallUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testNormalUintDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, NORMAL_UINT_NODE_PATH, new NormalUintContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<NormalUintContainer> normalUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testBigUintDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, BIG_UINT_NODE_PATH, new BigUintContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<BigUintContainer> bigUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testDecimalDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, DECIMAL_NODE_PATH, new DecimalContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<DecimalContainer> decimalContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testStringDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, STRING_NODE_PATH, new StringContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<StringContainer> stringContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testBooleanDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, BOOLEAN_NODE_PATH, new BooleanContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<BooleanContainer> booleanContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testEnumerationDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, ENUM_NODE_PATH, new EnumContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<EnumContainer> enumContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testBitsDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, BITS_NODE_PATH, new BitsContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<BitsContainer> bitsContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testBinaryDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, BINARY_NODE_PATH, new BinaryContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<BinaryContainer> binaryContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
public void testIdentityrefDefaultValue() throws ExecutionException, InterruptedException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, IDENTITYREF_NODE_PATH, new IdentityrefContainerBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<IdentityrefContainer> identityrefContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
.addChild(ImmutableNodes.leafNode(FOO_QNAME, "bar"))
.build())
.build());
- domTx.submit().get();
+ domTx.commit().get();
final ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);
verify(listener).onDataTreeChanged(captor.capture());
.addChild(ImmutableNodes.leafNode(FOO_QNAME, "bar"))
.build())
.build());
- domTx.submit().get();
+ domTx.commit().get();
final ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);
verify(listener).onDataTreeChanged(captor.capture());
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(CONFIGURATION, ADDRESSABLE_CASE, new AddressableBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);
verify(listener).onDataTreeChanged(captor.capture());
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(CONFIGURATION, ADDRESSABLE_CONTAINER.child(AddressableChild.class),
new AddressableChildBuilder().build());
- writeTx.submit().get();
+ writeTx.commit().get();
final ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);
verify(listener).onDataTreeChanged(captor.capture());
domTx.put(CONFIGURATION, YangInstanceIdentifier.create(UNADDRESSABLE_CONTAINER_NID)
.node(QName.create(UnaddressableCont.QNAME, "baz")),
ImmutableNodes.leafNode(BAZ_QNAME, "baz"));
- domTx.submit().get();
+ domTx.commit().get();
final ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);
verify(listener).onDataTreeChanged(captor.capture());
.withChildValue("foo")
.build())
.build());
- domTx.submit().get();
+ domTx.commit().get();
final ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);
verify(listener).onDataTreeChanged(captor.capture());
final DOMDataTreeWriteTransaction domTx = getDomBroker().newWriteOnlyTransaction();
domTx.put(CONFIGURATION, YangInstanceIdentifier.create(new NodeIdentifier(qname)),
ImmutableNodes.containerNode(qname));
- domTx.submit().get();
+ domTx.commit().get();
final ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);
verify(listener).onDataTreeChanged(captor.capture());
.withNodeIdentifier(CHOICE_CONTAINER_NID)
.withChild(Builders.choiceBuilder().withNodeIdentifier(CHOICE_NID).build())
.build());
- domTx.submit().get();
+ domTx.commit().get();
final ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);
verify(listener).onDataTreeChanged(captor.capture());
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, TOP_PATH, new TopBuilder().build());
writeTx.put(LogicalDatastoreType.OPERATIONAL, NODE_PATH, NODE);
- writeTx.submit().get();
+ writeTx.commit().get();
}
@Test
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, NODE_PATH, NODE,true);
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<Top> topNode = readTx.read(LogicalDatastoreType.OPERATIONAL, TOP_PATH).get();
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.merge(LogicalDatastoreType.OPERATIONAL, NODE_PATH, NODE,true);
- writeTx.submit().get();
+ writeTx.commit().get();
final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
final Optional<Top> topNode = readTx.read(LogicalDatastoreType.OPERATIONAL, TOP_PATH).get();
WriteTransaction initialTx = getDataBroker().newWriteOnlyTransaction();
put(initialTx, OPERATIONAL, ExampleYangObjects.topEmpty());
put(initialTx, OPERATIONAL, ExampleYangObjects.topLevelList());
- initialTx.submit().checkedGet();
+ initialTx.commit().get();
ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
InstanceIdentifier<Top> id = InstanceIdentifier.create(Top.class);
public void testAugmentableExtensionWithDataBroker() throws Exception {
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
put(writeTx, OPERATIONAL, ExampleYangObjects.topLevelList());
- writeTx.submit().checkedGet();
+ writeTx.commit().get();
ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
InstanceIdentifier<Top> id = InstanceIdentifier.create(Top.class);
import com.google.common.annotations.Beta;
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.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.javav2.api.BindingTransactionChain;
import org.opendaylight.mdsal.binding.javav2.api.ReadTransaction;
import org.opendaylight.mdsal.binding.javav2.api.WriteTransaction;
import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
import org.opendaylight.mdsal.common.api.AsyncReadWriteTransaction;
import org.opendaylight.mdsal.common.api.AsyncTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.TransactionChain;
import org.opendaylight.mdsal.common.api.TransactionChainListener;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
return new BindingDOMWriteTransactionAdapter<DOMDataTreeWriteTransaction>(delegateTx, codec) {
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return listenForFailure(this, super.submit());
+ public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ return listenForFailure(this, super.commit());
}
};
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.transaction;
import com.google.common.annotations.Beta;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.javav2.api.WriteTransaction;
import org.opendaylight.mdsal.binding.javav2.dom.adapter.spi.AbstractWriteTransaction;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
/**
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return doSubmit();
+ public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ return doCommit();
}
@Override
public boolean cancel() {
return doCancel();
}
-}
\ No newline at end of file
+}
import com.google.common.annotations.Beta;
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.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.javav2.spec.base.IdentifiableItem;
import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
getDelegate().delete(store, normalized);
}
- protected final CheckedFuture<Void, TransactionCommitFailedException> doSubmit() {
- return getDelegate().submit();
+ protected final @NonNull FluentFuture<? extends @NonNull CommitInfo> doCommit() {
+ return getDelegate().commit();
}
protected final boolean doCancel() {
package org.opendaylight.mdsal.binding.javav2.dom.adapter.test;
+import java.util.concurrent.ExecutionException;
import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.mdsal.binding.javav2.api.WriteTransaction;
import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.gen.javav2.urn.test.rev170627.data.MyCont;
import org.opendaylight.mdsal.gen.javav2.urn.test.rev170627.dto.MyContBuilder;
@Ignore
@Test
- public void testMyContLeafNode() throws TransactionCommitFailedException {
+ public void testMyContLeafNode() throws InterruptedException, ExecutionException {
final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
final MyContBuilder hello = new MyContBuilder().setMyLeaf("hello");
writeTx.put(LogicalDatastoreType.OPERATIONAL, MY_CONT_NODE_PATH, hello.build());
- writeTx.submit().checkedGet();
+ writeTx.commit().get();
}
}
import javax.annotation.CheckReturnValue;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Path;
+import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
/**
* Write transaction provides mutation capabilities for a data tree.
* Submits this transaction to be asynchronously applied to update the logical data tree. The
* returned CheckedFuture conveys the result of applying the data changes.
*
- * <p>
- * <b>Note:</b> It is strongly recommended to process the CheckedFuture result in an
- * asynchronous manner rather than using the blocking get() method. See example usage below.
- *
- * <p>
- * This call logically seals the transaction, which prevents the client from further changing
- * 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.
- * <h3>Example usage:</h3>
- *
- * <pre>
- * private void doWrite(final int tries) {
- * WriteTransaction writeTx = dataBroker.newWriteOnlyTransaction();
- * MyDataObject data = ...;
- * InstanceIdentifier<MyDataObject> path = ...;
- * writeTx.put(LogicalDatastoreType.OPERATIONAL, path, data);
- * Futures.addCallback(writeTx.submit(), new FutureCallback<Void>() {
- * public void onSuccess(Void result) {
- * // succeeded
- * }
- * public void onFailure(Throwable t) {
- * if(t instanceof OptimisticLockFailedException) {
- * if(( tries - 1) > 0 ) {
- * // do retry
- * doWrite(tries - 1);
- * } else {
- * // out of retries
- * }
- * } else {
- * // failed due to another type of TransactionCommitFailedException.
- * }
- * });
- * }
- * ...
- * doWrite(2);
- * </pre>
- *
- * <h2>Failure scenarios</h2>
- *
- * <p>
- * Transaction may fail because of multiple reasons, such as
- * <ul>
- * <li>Another transaction finished earlier and modified the same node in a non-compatible way
- * (see below). In this case the returned future will fail with an
- * {@link OptimisticLockFailedException}. It is the responsibility of the caller to create a new
- * transaction and submit the same modification again in order to update data tree.
- * <i><b>Warning</b>: In most cases, retrying after an OptimisticLockFailedException will result
- * in a high probability of success. However, there are scenarios, albeit unusual, where any
- * number of retries will not succeed. Therefore it is strongly recommended to limit the number
- * of retries (2 or 3) to avoid an endless loop.</i></li>
- * <li>Data change introduced by this transaction did not pass validation by commit handlers or
- * data was incorrectly structured. Returned future will fail with a
- * {@link DataValidationFailedException}. User should not retry to create new transaction with
- * same data, since it probably will fail again.</li>
- * </ul>
- *
- * <h3>Change compatibility</h3>
- * There are several sets of changes which could be considered incompatible between two
- * transactions which are derived from same initial state. Rules for conflict detection applies
- * recursively for each subtree level.
- *
- * <h4>Change compatibility of leafs, leaf-list items</h4>
- * Following table shows state changes and failures between two concurrent transactions, which
- * are based on same initial state, Tx 1 completes successfully before Tx 2 is submitted.
- *
- * <table summary="Change compatibility of leaf values">
- * <tr>
- * <th>Initial state</th>
- * <th>Tx 1</th>
- * <th>Tx 2</th>
- * <th>Result</th>
- * </tr>
- * <tr>
- * <td>Empty</td>
- * <td>put(A,1)</td>
- * <td>put(A,2)</td>
- * <td>Tx 2 will fail, state is A=1</td>
- * </tr>
- * <tr>
- * <td>Empty</td>
- * <td>put(A,1)</td>
- * <td>merge(A,2)</td>
- * <td>A=2</td>
- * </tr>
- *
- * <tr>
- * <td>Empty</td>
- * <td>merge(A,1)</td>
- * <td>put(A,2)</td>
- * <td>Tx 2 will fail, state is A=1</td>
- * </tr>
- * <tr>
- * <td>Empty</td>
- * <td>merge(A,1)</td>
- * <td>merge(A,2)</td>
- * <td>A=2</td>
- * </tr>
- *
- *
- * <tr>
- * <td>A=0</td>
- * <td>put(A,1)</td>
- * <td>put(A,2)</td>
- * <td>Tx 2 will fail, A=1</td>
- * </tr>
- * <tr>
- * <td>A=0</td>
- * <td>put(A,1)</td>
- * <td>merge(A,2)</td>
- * <td>A=2</td>
- * </tr>
- * <tr>
- * <td>A=0</td>
- * <td>merge(A,1)</td>
- * <td>put(A,2)</td>
- * <td>Tx 2 will fail, A=1</td>
- * </tr>
- * <tr>
- * <td>A=0</td>
- * <td>merge(A,1)</td>
- * <td>merge(A,2)</td>
- * <td>A=2</td>
- * </tr>
- *
- * <tr>
- * <td>A=0</td>
- * <td>delete(A)</td>
- * <td>put(A,2)</td>
- * <td>Tx 2 will fail, A does not exists</td>
- * </tr>
- * <tr>
- * <td>A=0</td>
- * <td>delete(A)</td>
- * <td>merge(A,2)</td>
- * <td>A=2</td>
- * </tr>
- * </table>
- *
- * <h4>Change compatibility of subtrees</h4>
- * Following table shows state changes and failures between two concurrent transactions, which
- * are based on same initial state, Tx 1 completes successfully before Tx 2 is submitted.
- *
- * <table summary="Change compatibility of containers">
- * <tr>
- * <th>Initial state</th>
- * <th>Tx 1</th>
- * <th>Tx 2</th>
- * <th>Result</th>
- * </tr>
- *
- * <tr>
- * <td>Empty</td>
- * <td>put(TOP,[])</td>
- * <td>put(TOP,[])</td>
- * <td>Tx 2 will fail, state is TOP=[]</td>
- * </tr>
- * <tr>
- * <td>Empty</td>
- * <td>put(TOP,[])</td>
- * <td>merge(TOP,[])</td>
- * <td>TOP=[]</td>
- * </tr>
- *
- * <tr>
- * <td>Empty</td>
- * <td>put(TOP,[FOO=1])</td>
- * <td>put(TOP,[BAR=1])</td>
- * <td>Tx 2 will fail, state is TOP=[FOO=1]</td>
- * </tr>
- * <tr>
- * <td>Empty</td>
- * <td>put(TOP,[FOO=1])</td>
- * <td>merge(TOP,[BAR=1])</td>
- * <td>TOP=[FOO=1,BAR=1]</td>
- * </tr>
- *
- * <tr>
- * <td>Empty</td>
- * <td>merge(TOP,[FOO=1])</td>
- * <td>put(TOP,[BAR=1])</td>
- * <td>Tx 2 will fail, state is TOP=[FOO=1]</td>
- * </tr>
- * <tr>
- * <td>Empty</td>
- * <td>merge(TOP,[FOO=1])</td>
- * <td>merge(TOP,[BAR=1])</td>
- * <td>TOP=[FOO=1,BAR=1]</td>
- * </tr>
- *
- * <tr>
- * <td>TOP=[]</td>
- * <td>put(TOP,[FOO=1])</td>
- * <td>put(TOP,[BAR=1])</td>
- * <td>Tx 2 will fail, state is TOP=[FOO=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>put(TOP,[FOO=1])</td>
- * <td>merge(TOP,[BAR=1])</td>
- * <td>state is TOP=[FOO=1,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>merge(TOP,[FOO=1])</td>
- * <td>put(TOP,[BAR=1])</td>
- * <td>Tx 2 will fail, state is TOP=[FOO=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>merge(TOP,[FOO=1])</td>
- * <td>merge(TOP,[BAR=1])</td>
- * <td>state is TOP=[FOO=1,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>delete(TOP)</td>
- * <td>put(TOP,[BAR=1])</td>
- * <td>Tx 2 will fail, state is empty store</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>delete(TOP)</td>
- * <td>merge(TOP,[BAR=1])</td>
- * <td>state is TOP=[BAR=1]</td>
- * </tr>
- *
- * <tr>
- * <td>TOP=[]</td>
- * <td>put(TOP/FOO,1)</td>
- * <td>put(TOP/BAR,1])</td>
- * <td>state is TOP=[FOO=1,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>put(TOP/FOO,1)</td>
- * <td>merge(TOP/BAR,1)</td>
- * <td>state is TOP=[FOO=1,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>merge(TOP/FOO,1)</td>
- * <td>put(TOP/BAR,1)</td>
- * <td>state is TOP=[FOO=1,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>merge(TOP/FOO,1)</td>
- * <td>merge(TOP/BAR,1)</td>
- * <td>state is TOP=[FOO=1,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>delete(TOP)</td>
- * <td>put(TOP/BAR,1)</td>
- * <td>Tx 2 will fail, state is empty store</td>
- * </tr>
- * <tr>
- * <td>TOP=[]</td>
- * <td>delete(TOP)</td>
- * <td>merge(TOP/BAR,1]</td>
- * <td>Tx 2 will fail, state is empty store</td>
- * </tr>
- *
- * <tr>
- * <td>TOP=[FOO=1]</td>
- * <td>put(TOP/FOO,2)</td>
- * <td>put(TOP/BAR,1)</td>
- * <td>state is TOP=[FOO=2,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[FOO=1]</td>
- * <td>put(TOP/FOO,2)</td>
- * <td>merge(TOP/BAR,1)</td>
- * <td>state is TOP=[FOO=2,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[FOO=1]</td>
- * <td>merge(TOP/FOO,2)</td>
- * <td>put(TOP/BAR,1)</td>
- * <td>state is TOP=[FOO=2,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[FOO=1]</td>
- * <td>merge(TOP/FOO,2)</td>
- * <td>merge(TOP/BAR,1)</td>
- * <td>state is TOP=[FOO=2,BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[FOO=1]</td>
- * <td>delete(TOP/FOO)</td>
- * <td>put(TOP/BAR,1)</td>
- * <td>state is TOP=[BAR=1]</td>
- * </tr>
- * <tr>
- * <td>TOP=[FOO=1]</td>
- * <td>delete(TOP/FOO)</td>
- * <td>merge(TOP/BAR,1]</td>
- * <td>state is TOP=[BAR=1]</td>
- * </tr>
- * </table>
- *
- *
- * <h3>Examples of failure scenarios</h3>
- *
- * <h4>Conflict of two transactions</h4>
- * This example illustrates two concurrent transactions, which derived from same initial state
- * of data tree and proposes conflicting modifications.
- *
- * <pre>
- * txA = broker.newWriteTransaction(); // allocates new transaction, data tree is empty
- * txB = broker.newWriteTransaction(); // allocates new transaction, data tree is empty
- * txA.put(CONFIGURATION, PATH, A); // writes to PATH value A
- * txB.put(CONFIGURATION, PATH, B) // writes to PATH value B
- * ListenableFuture futureA = txA.submit(); // transaction A is sealed and submitted
- * ListenebleFuture futureB = txB.submit(); // transaction B is sealed and submitted
- * </pre>
- * Commit of transaction A will be processed asynchronously and data tree will be updated to
- * contain value <code>A</code> for <code>PATH</code>. Returned {@link ListenableFuture} will
- * successfully complete once state is applied to data tree.
- * Commit of Transaction B will fail, because previous transaction also modified path in a
- * concurrent way. The state introduced by transaction B will not be applied. Returned
- * {@link ListenableFuture} object will fail with {@link OptimisticLockFailedException}
- * exception, which indicates to client that concurrent transaction prevented the submitted
- * transaction from being applied. <br>
- *
* @return a CheckFuture containing the result of the commit. 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
*/
@Deprecated
@CheckReturnValue
- CheckedFuture<Void, TransactionCommitFailedException> submit();
+ default CheckedFuture<Void, TransactionCommitFailedException> submit() {
+ return MappingCheckedFuture.create(commit().transform(ignored -> null, MoreExecutors.directExecutor()),
+ SUBMIT_EXCEPTION_MAPPER);
+ }
/**
* Submits this transaction to be asynchronously applied to update the logical data tree. The returned
* @throws IllegalStateException if the transaction is already submitted or was canceled.
*/
@CheckReturnValue
- default @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
- return FluentFuture.from(submit()).transformAsync((ignored) -> CommitInfo.emptyFluentFuture(),
- MoreExecutors.directExecutor());
- }
+ @NonNull FluentFuture<? extends @NonNull CommitInfo> commit();
+
+ /**
+ * This only exists for reuse by the deprecated {@link #submit} method and is not intended for general use.
+ */
+ @Deprecated
+ ExceptionMapper<TransactionCommitFailedException> SUBMIT_EXCEPTION_MAPPER =
+ new ExceptionMapper<TransactionCommitFailedException>("submit", TransactionCommitFailedException.class) {
+ @Override
+ protected TransactionCommitFailedException newWithCause(String message, Throwable cause) {
+ return new TransactionCommitFailedException(message, cause);
+ }
+ };
}
package org.opendaylight.mdsal.dom.broker;
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.Map.Entry;
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.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
protected abstract Object newTransactionIdentifier();
/**
- * User-supplied implementation of {@link DOMDataTreeWriteTransaction#submit()} for transaction.
+ * User-supplied implementation of {@link DOMDataTreeWriteTransaction#commit()} for transaction.
*
*<p>
- * Callback invoked when {@link DOMDataTreeWriteTransaction#submit()} is invoked on transaction
+ * Callback invoked when {@link DOMDataTreeWriteTransaction#commit()} is invoked on transaction
* created by this factory.
*
- * @param transaction Transaction on which {@link DOMDataTreeWriteTransaction#submit()} was invoked.
+ * @param transaction Transaction on which {@link DOMDataTreeWriteTransaction#commit()} 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, the Future fails with a
- * {@link TransactionCommitFailedException}.
+ * @return a FluentFuture. if commit coordination on cohorts finished successfully,
+ * a CommitInfo is returned from the Future, On failure,
+ * the Future fails with a {@link TransactionCommitFailedException}.
*/
- protected abstract CheckedFuture<Void,TransactionCommitFailedException> submit(
- DOMDataTreeWriteTransaction transaction,
+ protected abstract FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction transaction,
Collection<DOMStoreThreePhaseCommitCohort> cohorts);
/**
* - backing subtransaction is selected by {@link LogicalDatastoreType},
* {@link DOMStoreWriteTransaction#delete(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)}
* is invoked on selected subtransaction.
- * <li> {@link DOMDataTreeWriteTransaction#submit()} - results in invoking
+ * <li> {@link DOMDataTreeWriteTransaction#commit()} - results in invoking
* {@link DOMStoreWriteTransaction#ready()}, gathering all resulting cohorts and then invoking
- * finalized implementation callback {@link #submit(DOMDataTreeWriteTransaction, Collection)} with
+ * finalized implementation callback {@link #commit(DOMDataTreeWriteTransaction, Collection)} with
* transaction which was commited and gathered results.</li>
* </ul>
*
import java.util.Collection;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
* Implementation of blocking three-phase commit-coordination tasks without
* support of cancellation.
*/
-final class CommitCoordinationTask implements Callable<Void> {
+final class CommitCoordinationTask implements Callable<CommitInfo> {
private enum Phase {
CAN_COMMIT,
PRE_COMMIT,
}
@Override
- public Void call() throws TransactionCommitFailedException {
+ public CommitInfo call() throws TransactionCommitFailedException {
final long startTime = commitStatTracker != null ? System.nanoTime() : 0;
Phase phase = Phase.CAN_COMMIT;
commitBlocking();
LOG.debug("Transaction {}: doCommit completed", tx.getIdentifier());
- return null;
+ return CommitInfo.empty();
} catch (final TransactionCommitFailedException e) {
LOG.warn("Tx: {} Error during phase {}, starting Abort", tx.getIdentifier(), phase, e);
abortBlocking(e);
package org.opendaylight.mdsal.dom.broker;
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.Futures;
import com.google.common.util.concurrent.MoreExecutors;
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.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit(
- final DOMDataTreeWriteTransaction transaction, final Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
+ protected FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction transaction,
+ 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);
- Futures.addCallback(ret, new FutureCallback<Void>() {
+ Futures.addCallback(ret, new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
transactionCompleted();
}
package org.opendaylight.mdsal.dom.broker;
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 java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
}
@Override
- @SuppressWarnings("checkstyle:illegalcatch")
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
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;
+ FluentFuture<? extends CommitInfo> ret;
try {
for (final DOMStoreWriteTransaction txn : txns) {
cohorts.add(txn.ready());
}
- ret = impl.submit(this, cohorts);
+ ret = impl.commit(this, cohorts);
} 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;
package org.opendaylight.mdsal.dom.broker;
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.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.RejectedExecutionException;
+import org.opendaylight.mdsal.common.api.CommitInfo;
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.spi.store.DOMStore;
}
@Override
- protected CheckedFuture<Void,TransactionCommitFailedException> submit(
- final DOMDataTreeWriteTransaction transaction,
+ protected FluentFuture<? extends CommitInfo> commit(final DOMDataTreeWriteTransaction transaction,
final Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
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<CommitInfo> commitFuture = null;
try {
commitFuture = executor.submit(new CommitCoordinationTask(transaction, cohorts,
commitStatsTracker));
} catch (RejectedExecutionException e) {
LOG.error("The commit executor's queue is full - submit task was rejected. \n"
+ executor, e);
- return Futures.immediateFailedCheckedFuture(
+ return FluentFuture.from(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 FluentFuture.from(commitFuture);
}
}
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.common.api.AsyncTransaction;
+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.dom.api.DOMDataTreeCursorAwareTransaction;
private final CachedDataTreeService cachedDataTreeService;
private TransactionChainWriteTransaction writeTx;
private TransactionChainReadTransaction readTx;
- private ListenableFuture<Void> writeTxSubmitFuture;
+ private ListenableFuture<? extends CommitInfo> writeTxCommitFuture;
private boolean finished = false;
public ShardedDOMTransactionChainAdapter(final Object txChainIdentifier,
checkWriteTxClosed();
readTx = new TransactionChainReadTransaction(newTransactionIdentifier(),
new ShardedDOMReadTransactionAdapter(newTransactionIdentifier(), dataTreeService),
- writeTxSubmitFuture, this);
+ writeTxCommitFuture, this);
return readTx;
}
ShardedDOMReadWriteTransactionAdapter adapter = new ShardedDOMReadWriteTransactionAdapter(
newTransactionIdentifier(), cachedDataTreeService);
TransactionChainReadWriteTransaction readWriteTx = new TransactionChainReadWriteTransaction(
- newTransactionIdentifier(), adapter, adapter.getReadAdapter(), writeTxSubmitFuture, this);
+ newTransactionIdentifier(), adapter, adapter.getReadAdapter(), writeTxCommitFuture, this);
writeTx = readWriteTx;
return readWriteTx;
checkReadTxClosed();
checkWriteTxClosed();
- Futures.addCallback(writeTxSubmitFuture, new FutureCallback<Void>() {
+ Futures.addCallback(writeTxCommitFuture, new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(@Nullable final CommitInfo result) {
txChainListener.onTransactionChainSuccessful(ShardedDOMTransactionChainAdapter.this);
}
readTx = null;
}
- public void closeWriteTransaction(final ListenableFuture<Void> submitFuture) {
- writeTxSubmitFuture = submitFuture;
+ public void closeWriteTransaction(final ListenableFuture<? extends CommitInfo> commitFuture) {
+ writeTxCommitFuture = commitFuture;
writeTx = null;
}
package org.opendaylight.mdsal.dom.broker;
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.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCursorAwareTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeProducer;
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
+ public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
checkRunning();
LOG.debug("{}: Submitting transaction", txIdentifier);
if (!initialized) {
// not even initialized just seal this transaction and
// return immediate future
finished = true;
- return Futures.immediateCheckedFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
// First we need to close cursors
cursorMap.values().forEach(DOMDataTreeWriteCursor::close);
closeProducers();
finished = true;
- return Futures.makeChecked(
- Futures.transform(aggregatedSubmit, input -> input.get(0), MoreExecutors.directExecutor()),
- TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
+ return FluentFuture.from(Futures.transform(aggregatedSubmit,
+ unused -> CommitInfo.empty(), MoreExecutors.directExecutor()));
}
@Override
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import javax.annotation.Nullable;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
public class TransactionChainReadTransaction implements DOMDataTreeReadTransaction {
private final DOMDataTreeReadTransaction delegateReadTx;
- private final ListenableFuture<Void> previousWriteTxFuture;
+ private final ListenableFuture<? extends CommitInfo> previousWriteTxFuture;
private final Object identifier;
private final ShardedDOMTransactionChainAdapter txChain;
TransactionChainReadTransaction(final Object txIdentifier, final DOMDataTreeReadTransaction delegateReadTx,
- final ListenableFuture<Void> previousWriteTxFuture,
+ final ListenableFuture<? extends CommitInfo> previousWriteTxFuture,
final ShardedDOMTransactionChainAdapter txChain) {
this.delegateReadTx = delegateReadTx;
this.previousWriteTxFuture = previousWriteTxFuture;
final YangInstanceIdentifier path) {
final SettableFuture<Optional<NormalizedNode<?, ?>>> readResult = SettableFuture.create();
- Futures.addCallback(previousWriteTxFuture, new FutureCallback<Void>() {
+ Futures.addCallback(previousWriteTxFuture, new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(@Nullable final CommitInfo result) {
Futures.addCallback(delegateReadTx.read(store, path),
new FutureCallback<Optional<NormalizedNode<?, ?>>>() {
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
TransactionChainReadWriteTransaction(final Object identifier,
final DOMDataTreeReadWriteTransaction delegateWriteTx, final DOMDataTreeReadTransaction delegateReadTx,
- final ListenableFuture<Void> previousWriteTxFuture, final ShardedDOMTransactionChainAdapter txChain) {
+ final ListenableFuture<? extends CommitInfo> previousWriteTxFuture,
+ final ShardedDOMTransactionChainAdapter txChain) {
super(identifier, delegateWriteTx, txChain);
readTx = new TransactionChainReadTransaction(identifier, delegateReadTx, previousWriteTxFuture, txChain);
}
package org.opendaylight.mdsal.dom.broker;
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.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- final CheckedFuture<Void, TransactionCommitFailedException> writeResultFuture = delegateTx.submit();
- Futures.addCallback(writeResultFuture, new FutureCallback<Void>() {
+ public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ final FluentFuture<? extends CommitInfo> writeResultFuture = delegateTx.commit();
+ Futures.addCallback(writeResultFuture, new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(@Nullable final CommitInfo result) {
// NOOP
}
*/
writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- writeTx.submit().get();
+ writeTx.commit().get();
final Optional<NormalizedNode<?, ?>> afterCommitRead = domBroker.newReadOnlyTransaction()
.read(OPERATIONAL, TestModel.TEST_PATH).get();
}
@Test(expected = TransactionCommitFailedException.class)
- public void testRejectedCommit() throws Exception {
+ @SuppressWarnings({"checkstyle:AvoidHidingCauseException", "checkstyle:IllegalThrows"})
+ public void testRejectedCommit() throws Throwable {
commitExecutor.delegate = Mockito.mock(ExecutorService.class);
Mockito.doThrow(new RejectedExecutionException("mock"))
.when(commitExecutor.delegate).execute(Mockito.any(Runnable.class));
final DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- writeTx.submit().checkedGet(5, TimeUnit.SECONDS);
+ try {
+ writeTx.commit().get(5, TimeUnit.SECONDS);
+ } catch (ExecutionException e) {
+ throw e.getCause();
+ }
}
@SuppressWarnings("checkstyle:IllegalCatch")
public void run() {
try {
- writeTx.submit();
+ writeTx.commit();
} catch (final Throwable e) {
caughtEx.set(e);
}
assertNotNull(((SerializedDOMDataBroker) domBroker).getCommitStatsTracker());
writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- writeTx.submit().get();
+ writeTx.commit().get();
assertFalse(writeTx.cancel());
assertEquals(false, domBroker.newReadOnlyTransaction().exists(CONFIGURATION, TestModel.TEST_PATH).get());
writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
writeTx.delete(OPERATIONAL, TestModel.TEST_PATH);
- writeTx.submit().get();
+ writeTx.commit().get();
assertEquals(false, domBroker.newReadOnlyTransaction().exists(OPERATIONAL, TestModel.TEST_PATH).get());
assertTrue(domBroker.newWriteOnlyTransaction().cancel());
writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
writeTx.merge(OPERATIONAL, TestModel.TEST_PATH, testContainer);
- writeTx.submit().get();
+ writeTx.commit().get();
assertEquals(Boolean.TRUE, domBroker.newReadOnlyTransaction().exists(OPERATIONAL, TestModel.TEST_PATH).get());
assertEquals(Boolean.TRUE, domBroker.newReadOnlyTransaction().read(OPERATIONAL, TestModel.TEST_PATH).get()
.get().toString().contains(testContainer.toString()));
final DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
- writeTx.submit();
+ writeTx.commit();
latch.await(5, TimeUnit.SECONDS);
DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
- writeTx.submit().get();
+ writeTx.commit().get();
final TestDataTreeListener listener = new TestDataTreeListener(latch);
final ListenerRegistration<TestDataTreeListener> listenerReg =
dataTreeChangeService.registerDataTreeChangeListener(ROOT_DATA_TREE_ID, listener);
writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER_2);
- writeTx.submit();
+ writeTx.commit();
latch.await(5, TimeUnit.SECONDS);
DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
- writeTx.submit().get();
+ writeTx.commit().get();
final TestDataTreeListener listener = new TestDataTreeListener(latch);
final ListenerRegistration<TestDataTreeListener> listenerReg =
writeTx = domBroker.newWriteOnlyTransaction();
writeTx.delete(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
- writeTx.submit();
+ writeTx.commit();
latch.await(5, TimeUnit.SECONDS);
DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
- writeTx.submit().get();
+ writeTx.commit().get();
final TestDataTreeListener listener = new TestDataTreeListener(latch);
final ListenerRegistration<TestDataTreeListener> listenerReg =
writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.OUTER_LIST_PATH, OUTER_LIST_2);
- writeTx.submit();
+ writeTx.commit();
latch.await(5, TimeUnit.SECONDS);
DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
- writeTx.submit().get();
+ writeTx.commit().get();
final TestDataTreeListener listener = new TestDataTreeListener(latch);
final ListenerRegistration<TestDataTreeListener> listenerReg =
writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER_2);
- writeTx.submit().get();
+ writeTx.commit().get();
latch.await(1, TimeUnit.SECONDS);
DOMDataTreeWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
- writeTx.submit().get();
+ writeTx.commit().get();
final TestDataTreeListener listener = new TestDataTreeListener(latch);
final ListenerRegistration<TestDataTreeListener> listenerReg =
outerListEntry2);
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.OUTER_LIST_PATH.node(outerListEntryId3),
outerListEntry3);
- writeTx.submit();
+ writeTx.commit();
latch.await(5, TimeUnit.SECONDS);
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.Collections;
+import java.util.concurrent.ExecutionException;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
}
@Test
- public void readyRuntimeExceptionAndCancel() {
+ public void readyRuntimeExceptionAndCancel() throws InterruptedException {
RuntimeException thrown = new RuntimeException();
doThrow(thrown).when(domStoreWriteTransaction).ready();
DOMForwardedWriteTransaction<DOMStoreWriteTransaction> domForwardedWriteTransaction =
new Object(),
Collections.singletonMap(LogicalDatastoreType.OPERATIONAL, domStoreWriteTransaction),
abstractDOMForwardedTransactionFactory);
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture = domForwardedWriteTransaction.submit();
+ FluentFuture<? extends CommitInfo> submitFuture = domForwardedWriteTransaction.commit();
try {
- submitFuture.checkedGet();
+ submitFuture.get();
Assert.fail("TransactionCommitFailedException expected");
- } catch (TransactionCommitFailedException e) {
- assertTrue(e.getCause() == thrown);
+ } catch (ExecutionException e) {
+ assertTrue(e.getCause() instanceof TransactionCommitFailedException);
+ assertTrue(e.getCause().getCause() == thrown);
domForwardedWriteTransaction.cancel();
}
}
@Test
- public void submitRuntimeExceptionAndCancel() {
+ public void submitRuntimeExceptionAndCancel() throws InterruptedException {
RuntimeException thrown = new RuntimeException();
doReturn(null).when(domStoreWriteTransaction).ready();
- doThrow(thrown).when(abstractDOMForwardedTransactionFactory).submit(any(), any());
+ doThrow(thrown).when(abstractDOMForwardedTransactionFactory).commit(any(), any());
DOMForwardedWriteTransaction<DOMStoreWriteTransaction> domForwardedWriteTransaction =
new DOMForwardedWriteTransaction<>(
new Object(),
Collections.singletonMap(LogicalDatastoreType.OPERATIONAL, domStoreWriteTransaction),
abstractDOMForwardedTransactionFactory);
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture = domForwardedWriteTransaction.submit();
+ FluentFuture<? extends CommitInfo> submitFuture = domForwardedWriteTransaction.commit();
try {
- submitFuture.checkedGet();
+ submitFuture.get();
Assert.fail("TransactionCommitFailedException expected");
- } catch (TransactionCommitFailedException e) {
- assertTrue(e.getCause() == thrown);
+ } catch (ExecutionException e) {
+ assertTrue(e.getCause() instanceof TransactionCommitFailedException);
+ assertTrue(e.getCause().getCause() == thrown);
domForwardedWriteTransaction.cancel();
}
}
-}
\ No newline at end of file
+}
import java.util.concurrent.TimeoutException;
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
* First transaction is marked as ready, we are able to allocate chained
* transactions.
*/
- final ListenableFuture<Void> firstWriteTxFuture = firstTx.submit();
+ final ListenableFuture<? extends CommitInfo> firstWriteTxFuture = firstTx.commit();
/**
* We alocate chained transaction - read transaction.
/**
* third transaction is sealed and commited.
*/
- final ListenableFuture<Void> thirdDeleteTxFuture = thirdDeleteTx.submit();
- assertCommitSuccessful(thirdDeleteTxFuture);
+ assertCommitSuccessful(thirdDeleteTx.commit());
/**
* We close transaction chain.
return tx;
}
- private static void assertCommitSuccessful(final ListenableFuture<Void> future)
+ private static void assertCommitSuccessful(final ListenableFuture<? extends CommitInfo> firstWriteTxFuture)
throws InterruptedException, ExecutionException {
- future.get();
+ firstWriteTxFuture.get();
}
private static void assertTestContainerExists(final DOMDataTreeReadTransaction readTx)
new ShardedDOMTransactionChainAdapter(identifier, dataTreeService, chainListener);
writeTransaction = transactionChainAdapter.newWriteOnlyTransaction();
writeTransaction.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- assertNotNull(writeTransaction.submit());
+ assertNotNull(writeTransaction.commit());
assertFalse(writeTransaction.cancel());
transactionChainAdapter.closeWriteTransaction(Futures.immediateFuture(null));
- assertNotNull(transactionChainAdapter.newWriteOnlyTransaction().submit());
+ assertNotNull(transactionChainAdapter.newWriteOnlyTransaction().commit());
DOMDataTreeReadTransaction readTransaction = transactionChainAdapter.newReadOnlyTransaction();
assertNotNull(readTransaction);
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import org.junit.Test;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
final String identifier = "testIdent";
final DOMDataTreeReadTransaction readTransaction = mock(DOMDataTreeReadTransaction.class);
final ShardedDOMTransactionChainAdapter chainAdapter = mock(ShardedDOMTransactionChainAdapter.class);
- ListenableFuture<Void> previousWriteTxFuture = Futures.immediateFuture(null);
+ ListenableFuture<? extends CommitInfo> previousWriteTxFuture = Futures.immediateFuture(null);
TransactionChainReadTransaction transactionChainReadTransaction =
new TransactionChainReadTransaction(identifier, readTransaction, previousWriteTxFuture, chainAdapter);
assertNotNull(transactionChainReadTransaction.read(
LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY));
}
-}
\ No newline at end of file
+}
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import org.junit.Test;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
transactionChainWriteTransaction.delete(any(), any());
verify(writeTransaction).delete(any(), any());
- CheckedFuture<Void, TransactionCommitFailedException> writeResult = Futures.immediateCheckedFuture(null);
- doReturn(writeResult).when(writeTransaction).submit();
- assertEquals(writeResult, transactionChainWriteTransaction.submit());
+ ListenableFuture<? extends CommitInfo> writeResult = Futures.immediateFuture(null);
+ doReturn(writeResult).when(writeTransaction).commit();
+ assertEquals(writeResult, transactionChainWriteTransaction.commit());
- writeResult = Futures.immediateFailedCheckedFuture(mock(TransactionCommitFailedException.class));
+ writeResult = Futures.immediateFailedFuture(mock(TransactionCommitFailedException.class));
doNothing().when(chainAdapter).transactionFailed(any(), any());
- doReturn(writeResult).when(writeTransaction).submit();
- assertEquals(writeResult, transactionChainWriteTransaction.submit());
+ doReturn(writeResult).when(writeTransaction).commit();
+ assertEquals(writeResult, transactionChainWriteTransaction.commit());
}
-}
\ No newline at end of file
+}
package org.opendaylight.mdsal.dom.spi;
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.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return delegate().submit();
+ public FluentFuture<? extends CommitInfo> commit() {
+ return delegate().commit();
}
-
}
this.delete(null, null);
verify(domDataTreeWriteTransaction).delete(null, null);
- doReturn(null).when(domDataTreeWriteTransaction).submit();
- this.submit();
- verify(domDataTreeWriteTransaction).submit();
+ doReturn(null).when(domDataTreeWriteTransaction).commit();
+ this.commit();
+ verify(domDataTreeWriteTransaction).commit();
doReturn(false).when(domDataTreeWriteTransaction).cancel();
this.cancel();
protected DOMDataTreeWriteTransaction delegate() {
return domDataTreeWriteTransaction;
}
-}
\ No newline at end of file
+}
Code Review / mdsal.git / commitdiff