import akka.util.Timeout;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
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.netconf.sal.connect.util.RemoteDeviceId;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
return delegateWrite.cancel();
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return delegateWrite.commit(getIdentifier());
- }
-
@Override
public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.messages.transactions.PutRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.SubmitFailedReply;
import org.opendaylight.netconf.topology.singleton.messages.transactions.SubmitRequest;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
});
}
- public ListenableFuture<RpcResult<TransactionStatus>> commit(final Object identifier) {
- LOG.trace("{}: Commit", id);
-
- final CheckedFuture<Void, TransactionCommitFailedException> submit = submit(identifier);
- return Futures.transform(submit, new Function<Void, RpcResult<TransactionStatus>>() {
- @Nullable
- @Override
- public RpcResult<TransactionStatus> apply(@Nullable final Void input) {
- return RpcResultBuilder.success(TransactionStatus.SUBMITED).build();
- }
- });
- }
-
public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier identifier) {
Preconditions.checkState(opened.get(), "%s: Transaction was closed %s", id, identifier);
LOG.trace("{}: Delete {} via NETCONF: {}", id, store, identifier);
import akka.actor.ActorSystem;
import akka.util.Timeout;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
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.netconf.sal.connect.util.RemoteDeviceId;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
return proxyWriteAdapter.submit(getIdentifier());
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return proxyWriteAdapter.commit(getIdentifier());
- }
-
@Override
public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier identifier) {
proxyWriteAdapter.delete(store, identifier);
import akka.util.Timeout;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.config.util.xml.DocumentedException;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
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.netconf.topology.singleton.messages.transactions.SubmitReply;
import org.opendaylight.netconf.topology.singleton.messages.transactions.SubmitRequest;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
}
- @Test
- public void testCommit() throws Exception {
- final ListenableFuture<RpcResult<TransactionStatus>> submitFuture = tx.commit();
- masterActor.expectMsgClass(SubmitRequest.class);
- masterActor.reply(new SubmitReply());
- Assert.assertEquals(TransactionStatus.SUBMITED, submitFuture.get().getResult());
- }
-
@Test
public void testDelete() throws Exception {
tx.delete(STORE, PATH);
Assert.assertEquals(DocumentedException.ErrorType.APPLICATION, de.getErrorType());
}
}
-}
\ No newline at end of file
+}
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.messages.transactions.SubmitReply;
import org.opendaylight.netconf.topology.singleton.messages.transactions.SubmitRequest;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
}
}
- @Test
- public void testCommit() throws Exception {
- final ListenableFuture<RpcResult<TransactionStatus>> submitFuture = tx.commit();
- masterActor.expectMsgClass(SubmitRequest.class);
- masterActor.reply(new SubmitReply());
- Assert.assertEquals(TransactionStatus.SUBMITED, submitFuture.get().getResult());
- }
-
@Test
public void testDelete() throws Exception {
tx.delete(STORE, PATH);
submit.checkedGet();
}
-}
\ No newline at end of file
+}
import java.util.concurrent.CopyOnWriteArrayList;
import javax.annotation.Nullable;
import org.opendaylight.controller.config.util.xml.DocumentedException;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
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;
editStructure, Optional.of(ModifyAction.NONE), "delete");
}
- @Override
- public final ListenableFuture<RpcResult<TransactionStatus>> commit() {
+ protected final ListenableFuture<RpcResult<Void>> commitConfiguration() {
listeners.forEach(listener -> listener.onTransactionSubmitted(this));
checkNotFinished();
finished = true;
- final ListenableFuture<RpcResult<TransactionStatus>> result = performCommit();
- Futures.addCallback(result, new FutureCallback<RpcResult<TransactionStatus>>() {
+ final ListenableFuture<RpcResult<Void>> result = performCommit();
+ Futures.addCallback(result, new FutureCallback<RpcResult<Void>>() {
@Override
- public void onSuccess(@Nullable final RpcResult<TransactionStatus> result) {
+ public void onSuccess(@Nullable final RpcResult<Void> result) {
if (result != null && result.isSuccessful()) {
listeners.forEach(txListener -> txListener.onTransactionSuccessful(AbstractWriteTx.this));
} else {
return result;
}
- protected abstract ListenableFuture<RpcResult<TransactionStatus>> performCommit();
+ protected abstract ListenableFuture<RpcResult<Void>> performCommit();
private void checkEditable(final LogicalDatastoreType store) {
checkNotFinished();
DataContainerChild<?, ?> editStructure,
Optional<ModifyAction> defaultOperation, String operation);
- protected ListenableFuture<RpcResult<TransactionStatus>> resultsToTxStatus() {
- final SettableFuture<RpcResult<TransactionStatus>> transformed = SettableFuture.create();
+ protected ListenableFuture<RpcResult<Void>> resultsToTxStatus() {
+ final SettableFuture<RpcResult<Void>> transformed = SettableFuture.create();
Futures.addCallback(Futures.allAsList(resultsFutures), new FutureCallback<List<DOMRpcResult>>() {
@Override
});
if (!transformed.isDone()) {
- transformed.set(RpcResultBuilder.success(TransactionStatus.COMMITED).build());
+ transformed.set(RpcResultBuilder.<Void>success().build());
}
}
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
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.DOMDataReadTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
return delegateWriteTx.submit();
}
- @Override
- public ListenableFuture<RpcResult<TransactionStatus>> commit() {
- return delegateWriteTx.commit();
- }
-
@Override
public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(
final LogicalDatastoreType store, final YangInstanceIdentifier path) {
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
@Override
public synchronized CheckedFuture<Void, TransactionCommitFailedException> submit() {
- final ListenableFuture<Void> commitFutureAsVoid = Futures.transform(commit(),
- (Function<RpcResult<TransactionStatus>, Void>) input -> {
+ final ListenableFuture<Void> commitFutureAsVoid = Futures.transform(commitConfiguration(),
+ (Function<RpcResult<Void>, Void>) input -> {
Preconditions.checkArgument(input.isSuccessful() && input.getErrors().isEmpty(),
"Submit failed with errors: %s", input.getErrors());
return null;
}
@Override
- public synchronized ListenableFuture<RpcResult<TransactionStatus>> performCommit() {
+ public synchronized ListenableFuture<RpcResult<Void>> performCommit() {
resultsFutures.add(netOps.commit(new NetconfRpcFutureCallback("Commit", id)));
- final ListenableFuture<RpcResult<TransactionStatus>> txResult = resultsToTxStatus();
+ final ListenableFuture<RpcResult<Void>> txResult = resultsToTxStatus();
- Futures.addCallback(txResult, new FutureCallback<RpcResult<TransactionStatus>>() {
+ Futures.addCallback(txResult, new FutureCallback<RpcResult<Void>>() {
@Override
- public void onSuccess(@Nullable final RpcResult<TransactionStatus> result) {
+ public void onSuccess(@Nullable final RpcResult<Void> result) {
cleanupOnSuccess();
}
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfBaseOps;
@Override
public synchronized CheckedFuture<Void, TransactionCommitFailedException> submit() {
- final ListenableFuture<Void> commmitFutureAsVoid = Futures.transform(commit(),
- (Function<RpcResult<TransactionStatus>, Void>) input -> null, MoreExecutors.directExecutor());
+ final ListenableFuture<Void> commmitFutureAsVoid = Futures.transform(commitConfiguration(),
+ (Function<RpcResult<Void>, Void>) input -> null, MoreExecutors.directExecutor());
return Futures.makeChecked(commmitFutureAsVoid,
input -> new TransactionCommitFailedException("Submit of transaction " + getIdentifier() + " failed",
}
@Override
- public synchronized ListenableFuture<RpcResult<TransactionStatus>> performCommit() {
+ public synchronized ListenableFuture<RpcResult<Void>> performCommit() {
for (final Change change : changes) {
resultsFutures.add(change.execute(id, netOps, rollbackSupport));
}
verify(delegateWriteTx).submit();
}
- @Test
- public void commit() throws Exception {
- tx.commit();
- verify(delegateWriteTx).commit();
- }
-
@Test
public void cancel() throws Exception {
tx.cancel();
Assert.assertNotEquals(tx.getIdentifier(), tx2.getIdentifier());
}
-}
\ No newline at end of file
+}
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.sal.restconf.impl.BrokerFacade;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.RestconfImpl;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.Module;
// - we expecting problems with singletons ControllerContext as schemaContext holder
public void createConfigurationDataTest() throws UnsupportedEncodingException, ParseException {
initMocking();
- final RpcResult<TransactionStatus> rpcResult = new DummyRpcResult.Builder<TransactionStatus>().result(
- TransactionStatus.COMMITED).build();
-
when(brokerFacade.commitConfigurationDataPost((SchemaContext) null, any(YangInstanceIdentifier.class),
any(NormalizedNode.class), null, null))
.thenReturn(mock(CheckedFuture.class));