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.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
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.mdsal.common.api.CommitInfo;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
delegate.delete(store, yiid);
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- logOps();
- return delegate.submit();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
logOps();
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 org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
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;
return delegate.exists(store, yiid);
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- closeTracker.removeFromTrackedRegistry();
- return super.submit();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
closeTracker.removeFromTrackedRegistry();
*/
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;
this.closeTracker = new CloseTrackedTrait<>(writeTransactionsRegistry, this);
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- closeTracker.removeFromTrackedRegistry();
- return super.submit();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
closeTracker.removeFromTrackedRegistry();
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.mdsal.common.api.CommitInfo;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
delegate.merge(store, path, data, createMissingParents);
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return delegate.submit();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
return delegate.commit();
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.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.mdsal.common.api.CommitInfo;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
return delegate.cancel();
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return delegate.submit();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
return delegate.commit();
*/
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 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.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;
doDelete(store, path);
}
- @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() {
return doCommit();
*/
package org.opendaylight.controller.md.sal.binding.impl.test;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import com.google.common.base.Optional;
import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.Top;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.TopBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList;
private static final TopLevelList NODE = new TopLevelListBuilder().setKey(TOP_LIST_KEY).build();
@Test
- public void test() throws InterruptedException, ExecutionException {
+ @Deprecated
+ public void testSubmit() throws InterruptedException, ExecutionException, TimeoutException {
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, TOP_PATH, new TopBuilder().build());
writeTx.put(LogicalDatastoreType.OPERATIONAL, NODE_PATH, NODE);
- writeTx.submit().get();
+ writeTx.submit().get(5, TimeUnit.SECONDS);
+
+ ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
+ Optional<TopLevelList> listNode = readTx.read(LogicalDatastoreType.OPERATIONAL, NODE_PATH).get();
+ assertTrue("List node must exists after commit", listNode.isPresent());
+ assertEquals("List node", NODE, listNode.get());
+ }
+
+ @Test
+ public void testCommit() throws InterruptedException, ExecutionException, TimeoutException {
+ WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.OPERATIONAL, TOP_PATH, new TopBuilder().build());
+ writeTx.put(LogicalDatastoreType.OPERATIONAL, NODE_PATH, NODE);
+ writeTx.commit().get(5, TimeUnit.SECONDS);
+
+ ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
+ Optional<TopLevelList> listNode = readTx.read(LogicalDatastoreType.OPERATIONAL, NODE_PATH).get();
+ assertTrue("List node must exists after commit", listNode.isPresent());
+ assertEquals("List node", NODE, listNode.get());
}
@Test
- public void testPutCreateParentsSuccess()
- throws TransactionCommitFailedException, InterruptedException, ExecutionException {
+ public void testPutCreateParentsSuccess() throws InterruptedException, ExecutionException, TimeoutException {
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, NODE_PATH, NODE,true);
- writeTx.submit().checkedGet();
+ writeTx.commit().get(5, TimeUnit.SECONDS);
ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
Optional<Top> topNode = readTx.read(LogicalDatastoreType.OPERATIONAL, TOP_PATH).get();
}
@Test
- public void testMergeCreateParentsSuccess()
- throws TransactionCommitFailedException, InterruptedException, ExecutionException {
+ public void testMergeCreateParentsSuccess() throws InterruptedException, ExecutionException, TimeoutException {
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.merge(LogicalDatastoreType.OPERATIONAL, NODE_PATH, NODE,true);
- writeTx.submit().checkedGet();
+ writeTx.commit().get(5, TimeUnit.SECONDS);
ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
Optional<Top> topNode = readTx.read(LogicalDatastoreType.OPERATIONAL, TOP_PATH).get();
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.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.DOMDataBrokerExtension;
import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener;
throw new UnsupportedOperationException();
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- throw new UnsupportedOperationException();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
throw new UnsupportedOperationException();
import javax.annotation.CheckReturnValue;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.MappingCheckedFuture;
import org.opendaylight.yangtools.concepts.Path;
+import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
/**
* Write transaction provides mutation capabilities for a data tree.
*/
@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 committed 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);
+ }
+ };
}
import com.google.common.collect.ImmutableMap.Builder;
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.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import javax.annotation.Nonnull;
* @author Thomas Pantelis
*/
public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMDataBroker {
- private static final ExceptionMapper<TransactionCommitFailedException> SUBMIT_EX_MAPPER =
- new ExceptionMapper<TransactionCommitFailedException>("submit", TransactionCommitFailedException.class) {
+ private static final ExceptionMapper<TransactionCommitFailedException> COMMIT_EX_MAPPER =
+ new ExceptionMapper<TransactionCommitFailedException>("commit", TransactionCommitFailedException.class) {
@Override
protected TransactionCommitFailedException newWithCause(String message, Throwable cause) {
if (cause instanceof org.opendaylight.mdsal.common.api.OptimisticLockFailedException) {
final org.opendaylight.mdsal.common.api.AsyncTransaction<?, ?> transaction, final Throwable cause) {
listener.onTransactionChainFailed(legacyChain.get(),
(AsyncTransaction) () -> transaction.getIdentifier(),
- cause instanceof Exception ? SUBMIT_EX_MAPPER.apply((Exception)cause) : cause);
+ cause instanceof Exception ? COMMIT_EX_MAPPER.apply((Exception)cause) : cause);
}
@Override
return writeDelegate().cancel();
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return MappingCheckedFuture.create(writeDelegate().submit(), SUBMIT_EX_MAPPER);
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
- return writeDelegate().commit();
+ final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
+ writeDelegate().commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(CommitInfo result) {
+ resultFuture.set(result);
+ }
+
+ @Override
+ public void onFailure(Throwable ex) {
+ if (ex instanceof Exception) {
+ resultFuture.setException(COMMIT_EX_MAPPER.apply((Exception)ex));
+ } else {
+ resultFuture.setException(ex);
+ }
+ }
+ }, MoreExecutors.directExecutor());
+
+ return resultFuture;
}
}
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.ExecutionException;
import java.util.concurrent.TimeUnit;
-import org.eclipse.jdt.annotation.NonNull;
+import java.util.concurrent.TimeoutException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
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;
tx.delete(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
verify(mockWriteTx).delete(TestModel.TEST_PATH);
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture = tx.submit();
- submitFuture.get(5, TimeUnit.SECONDS);
+ tx.commit().get(5, TimeUnit.SECONDS);
InOrder inOrder = inOrder(mockCommitCohort);
inOrder.verify(mockCommitCohort).canCommit();
try {
tx = adapter.newWriteOnlyTransaction();
tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
- submitFuture = tx.submit();
- submitFuture.checkedGet(5, TimeUnit.SECONDS);
+ commit(tx);
fail("Expected OptimisticLockFailedException");
} catch (OptimisticLockFailedException e) {
assertEquals("getMessage", errorMsg, e.getMessage());
try {
tx = adapter.newWriteOnlyTransaction();
tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
- submitFuture = tx.submit();
- submitFuture.checkedGet(5, TimeUnit.SECONDS);
+ commit(tx);
fail("Expected TransactionCommitFailedException");
} catch (TransactionCommitFailedException e) {
assertEquals("getMessage", errorMsg, e.getMessage());
try {
tx = adapter.newWriteOnlyTransaction();
tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
- submitFuture = tx.submit();
- submitFuture.checkedGet(5, TimeUnit.SECONDS);
+ commit(tx);
fail("Expected TransactionCommitFailedException");
} catch (TransactionCommitFailedException e) {
assertEquals("getCause type", DataStoreUnavailableException.class, e.getCause().getClass());
try {
tx = adapter.newWriteOnlyTransaction();
tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
- submitFuture = tx.submit();
- submitFuture.checkedGet(5, TimeUnit.SECONDS);
+ commit(tx);
fail("Expected TransactionCommitFailedException");
} catch (TransactionCommitFailedException e) {
assertEquals("getCause", cause, e.getCause());
tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
verify(mockReadWriteTx).write(TestModel.TEST_PATH, dataNode);
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture = tx.submit();
- submitFuture.get(5, TimeUnit.SECONDS);
+ tx.commit().get(5, TimeUnit.SECONDS);
InOrder inOrder = inOrder(mockCommitCohort);
inOrder.verify(mockCommitCohort).canCommit();
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
verify(mockWriteTx).write(TestModel.TEST_PATH, dataNode);
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture = writeTx.submit();
- submitFuture.get(5, TimeUnit.SECONDS);
+ writeTx.commit().get(5, TimeUnit.SECONDS);
InOrder inOrder = inOrder(mockCommitCohort);
inOrder.verify(mockCommitCohort).canCommit();
try {
writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
- writeTx.submit().checkedGet(5, TimeUnit.SECONDS);
+ commit(writeTx);
fail("Expected TransactionCommitFailedException");
} catch (TransactionCommitFailedException e) {
// expected
}
@Test
- public void testCommit() throws Exception {
+ @Deprecated
+ public void testSubmit() 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);
+ tx.submit().get(5, TimeUnit.SECONDS);
InOrder inOrder = inOrder(mockCommitCohort);
inOrder.verify(mockCommitCohort).canCommit();
inOrder.verify(mockCommitCohort).preCommit();
inOrder.verify(mockCommitCohort).commit();
+
+ String errorMsg = "mock OptimisticLockFailedException";
+ Throwable cause = new ConflictingModificationAppliedException(TestModel.TEST_PATH, "mock");
+ doReturn(Futures.immediateFailedFuture(new org.opendaylight.mdsal.common.api.TransactionCommitFailedException(
+ errorMsg, cause))).when(mockCommitCohort).canCommit();
+
+ try {
+ tx = adapter.newWriteOnlyTransaction();
+ tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
+ commit(tx);
+ fail("Expected TransactionCommitFailedException");
+ } catch (TransactionCommitFailedException e) {
+ assertEquals("getMessage", errorMsg, e.getMessage());
+ assertEquals("getCause", cause, e.getCause());
+ }
+ }
+
+ @SuppressWarnings("checkstyle:AvoidHidingCauseException")
+ private static void commit(DOMDataWriteTransaction tx)
+ throws TransactionCommitFailedException, InterruptedException, TimeoutException {
+ try {
+ tx.commit().get(5, TimeUnit.SECONDS);
+ } catch (ExecutionException e) {
+ assertTrue("Expected TransactionCommitFailedException. Actual: " + e.getCause(),
+ e.getCause() instanceof TransactionCommitFailedException);
+ throw (TransactionCommitFailedException)e.getCause();
+ }
}
private interface TestDOMStore extends DistributedDataStoreInterface, DOMStoreTreeChangePublisher,
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.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.Future;
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.TransactionCommitFailedException;
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;
return future.cancel(false);
}
- @Override
- 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));
return frontendTransaction;
}
- ListenableFuture<CommitInfo> getSubmitFuture() {
+ ListenableFuture<CommitInfo> getCommitFuture() {
return future;
}
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.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;
return tx.getTransaction();
}
- @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;
- return FluentFuture.from(tx.getSubmitFuture()).transformAsync(
+ return FluentFuture.from(tx.getCommitFuture()).transformAsync(
ignored -> CommitInfo.emptyFluentFuture(), MoreExecutors.directExecutor());
}
import javax.annotation.concurrent.NotThreadSafe;
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.DOMDataReadOnlyTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
writeTxDelegate.delete(store, path);
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return writeTxDelegate.submit();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
return writeTxDelegate.commit();
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 org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
delegateTx.delete(LegacyShardedDOMDataBrokerAdapterUtils.translateDataStoreType(store), path);
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return Futures.makeChecked(delegateTx.submit(), TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
return delegateTx.commit();
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.After;
import org.junit.Before;
}
@Test(timeout = 10000)
- public void testTransactionCommit() throws InterruptedException, ExecutionException {
+ public void testTransactionCommit() throws InterruptedException, ExecutionException, TimeoutException {
DOMDataReadWriteTransaction writeTx = domBroker.newReadWriteTransaction();
assertNotNull(writeTx);
.read(OPERATIONAL, TestModel.TEST_PATH);
assertTrue(writeTxContainer.get().isPresent());
- writeTx.submit().get();
+ writeTx.commit().get(5, TimeUnit.SECONDS);
+
+ Optional<NormalizedNode<?, ?>> afterCommitRead = domBroker.newReadOnlyTransaction()
+ .read(OPERATIONAL, TestModel.TEST_PATH).get();
+ assertTrue(afterCommitRead.isPresent());
+ }
+
+ @Test(timeout = 10000)
+ @Deprecated
+ public void testTransactionSubmit() throws InterruptedException, ExecutionException, TimeoutException {
+
+ DOMDataReadWriteTransaction writeTx = domBroker.newReadWriteTransaction();
+ assertNotNull(writeTx);
+ /**
+ *
+ * Writes /test in writeTx
+ *
+ */
+ writeTx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
+
+ /**
+ * Reads /test from writeTx Read should return container.
+ *
+ */
+ ListenableFuture<Optional<NormalizedNode<?, ?>>> writeTxContainer = writeTx
+ .read(OPERATIONAL, TestModel.TEST_PATH);
+ assertTrue(writeTxContainer.get().isPresent());
+
+ writeTx.submit().get(5, TimeUnit.SECONDS);
Optional<NormalizedNode<?, ?>> afterCommitRead = domBroker.newReadOnlyTransaction()
.read(OPERATIONAL, TestModel.TEST_PATH).get();
}
@Test(expected = TransactionCommitFailedException.class)
- public void testRejectedCommit() throws Exception {
+ @SuppressWarnings({"checkstyle:IllegalThrows", "checkstyle:AvoidHidingCauseException"})
+ public void testRejectedCommit() throws Throwable {
commitExecutor.delegate = Mockito.mock(ExecutorService.class);
Mockito.doThrow(new RejectedExecutionException("mock")).when(commitExecutor.delegate)
DOMDataReadWriteTransaction writeTx = domBroker.newReadWriteTransaction();
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();
+ }
}
/**
caughtCommitEx.set(throwable);
commitCompletedLatch.countDown();
}
- });
+ }, MoreExecutors.directExecutor());
super.onDataChanged(change);
}
DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
writeTx.put(OPERATIONAL, TestModel.TEST2_PATH, ImmutableNodes.containerNode(TestModel.TEST2_QNAME));
try {
- writeTx.submit().get();
+ writeTx.commit().get();
} catch (ExecutionException e) {
caughtCommitEx.set(e.getCause());
} catch (Exception e) {
final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
new Thread(() -> {
try {
- writeTx.submit();
+ writeTx.commit();
} catch (Throwable e) {
caughtEx.set(e);
}
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;
delegate().delete(store, path);
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return delegate().submit();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
return delegate().commit();
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.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 org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
delegate().delete(store, path);
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return delegate().submit();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
return delegate().commit();