This is the next round of conversions, covering most of netconf.
Change-Id: Ic3caa8ed0879ad547940ff09d034adb5d6d6f687
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
private void writeDevice(final NodeId nodeId, final Device modifiedDevice) {
ReadWriteTransaction opTx = dataBroker.newReadWriteTransaction();
opTx.merge(LogicalDatastoreType.OPERATIONAL, buildDeviceInstanceIdentifier(nodeId), modifiedDevice);
- opTx.submit();
+ opTx.commit();
}
private static InstanceIdentifier<Device> buildDeviceInstanceIdentifier(final NodeId nodeId) {
.child(Device.class, device.key());
tx.merge(LogicalDatastoreType.OPERATIONAL, deviceIId, device);
- tx.submit();
+ tx.commit();
}
private AllowedDevices getDevices() {
}
if (numRemoved > 0) {
- opTx.submit();
+ opTx.commit();
}
}
.setSshHostKey(cfgDevice.getSshHostKey()).setUniqueId(cfgDevice.getUniqueId()).build();
tx.merge(LogicalDatastoreType.OPERATIONAL, deviceIID, cfgDevice);
- tx.submit();
+ tx.commit();
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.config.yang.netconf.mdsal.monitoring;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.verify;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Capabilities;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Sessions;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.Session;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.SessionBuilder;
-import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class MonitoringToMdsalWriterTest {
private static final InstanceIdentifier<NetconfState> INSTANCE_IDENTIFIER =
InstanceIdentifier.create(NetconfState.class);
- @Mock
- private CommitInfo info;
-
@Mock
private NetconfMonitoringService monitoring;
@Mock
doNothing().when(writeTransaction).put(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
doNothing().when(writeTransaction).delete(eq(LogicalDatastoreType.OPERATIONAL), any());
- doReturn(FluentFutures.immediateFluentFuture(info)).when(writeTransaction).commit();
+ doReturn(emptyFluentFuture()).when(writeTransaction).commit();
writer = new MonitoringToMdsalWriter(monitoring, dataBroker);
}
package org.opendaylight.controller.config.yang.netconf.mdsal.notification;
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.ExecutionException;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
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.mdsal.common.api.CommitInfo;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.notifications.NotificationRegistration;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.StreamNameType;
final WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.delete(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Netconf.class));
- Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void avoid) {
+ public void onSuccess(final CommitInfo info) {
LOG.debug("Streams cleared successfully");
}
tx.merge(LogicalDatastoreType.OPERATIONAL, streamIdentifier, stream, true);
try {
- tx.submit().checkedGet();
+ tx.commit().get();
LOG.debug("Stream %s registered successfully.", stream.getName());
- } catch (TransactionCommitFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Unable to register stream.", e);
}
}
tx.delete(LogicalDatastoreType.OPERATIONAL, streamIdentifier);
try {
- tx.submit().checkedGet();
+ tx.commit().get();
LOG.debug("Stream %s unregistered successfully.", stream);
- } catch (TransactionCommitFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Unable to unregister stream", e);
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.config.yang.netconf.mdsal.notification;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
-import com.google.common.util.concurrent.Futures;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
doNothing().when(tx).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
any(DataObject.class), anyBoolean());
doNothing().when(tx).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- doReturn(Futures.immediateCheckedFuture(null)).when(tx).submit();
+ doReturn(emptyFluentFuture()).when(tx).commit();
doReturn(tx).when(dataBroker).newWriteOnlyTransaction();
writer = new NotificationToMdsalWriter(notificationCollector, dataBroker);
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
import com.google.common.collect.ImmutableList;
import org.junit.Before;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.ModulesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.module.list.module.SubmoduleBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.YangIdentifier;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
private DataBroker dataBroker;
@Mock
private WriteTransaction writeTransaction;
- @Mock
- private CommitInfo info;
private SchemaServiceToMdsalWriter schemaServiceToMdsalWriter;
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
doNothing().when(writeTransaction).put(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
- doReturn(FluentFutures.immediateFluentFuture(info)).when(writeTransaction).commit();
+ doReturn(emptyFluentFuture()).when(writeTransaction).commit();
when(schemaService.registerSchemaContextListener(any())).thenReturn(
new ListenerRegistration<SchemaContextListener>() {
@Override
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.MockitoAnnotations.initMocks;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
import akka.actor.ActorSystem;
import akka.util.Timeout;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
-import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import scala.concurrent.duration.Duration;
public class RemoteDeviceConnectorImplTest {
private static final String TOPOLOGY_ID = "testing-topology";
private static final Timeout TIMEOUT = new Timeout(Duration.create(5, "seconds"));
- @Mock
- private CommitInfo info;
-
@Mock
private DataBroker dataBroker;
doReturn(writeTx).when(txChain).newWriteOnlyTransaction();
doNothing().when(writeTx).merge(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
doReturn("Some object").when(writeTx).getIdentifier();
- doReturn(FluentFutures.immediateFluentFuture(info)).when(writeTx).commit();
+ doReturn(emptyFluentFuture()).when(writeTx).commit();
builder = new NetconfTopologySetup.NetconfTopologySetupBuilder();
builder.setDataBroker(dataBroker);
builder.setRpcProviderRegistry(rpcProviderRegistry);
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
import static org.opendaylight.netconf.topology.singleton.impl.actors.ReadTransactionActorTestAdapter.NODE;
import static org.opendaylight.netconf.topology.singleton.impl.actors.ReadTransactionActorTestAdapter.PATH;
import static org.opendaylight.netconf.topology.singleton.impl.actors.ReadTransactionActorTestAdapter.STORE;
import org.junit.Test;
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.netconf.topology.singleton.messages.NormalizedNodeMessage;
import org.opendaylight.netconf.topology.singleton.messages.transactions.CancelRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.DeleteRequest;
@Test
public void testSubmit() {
- doReturn(FluentFutures.immediateFluentFuture(mock(CommitInfo.class))).when(mockWriteTx).commit();
+ doReturn(emptyFluentFuture()).when(mockWriteTx).commit();
actorRef.tell(new SubmitRequest(), probe.ref());
verify(mockWriteTx).commit();
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Futures;
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.dom.api.DOMMountPointService;
-import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
-import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
when(dataBroker.newWriteOnlyTransaction()).thenReturn(wtx);
doNothing().when(wtx)
.merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(DataObject.class));
- doReturn(FluentFutures.immediateFluentFuture(mock(CommitInfo.class))).when(wtx).commit();
+ doReturn(emptyFluentFuture()).when(wtx).commit();
topology.init();
//verify initialization of topology
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
id, writeTx.getIdentifier());
try {
- writeTx.submit().get();
+ writeTx.commit().get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("{}: Transaction(close) {} FAILED!", id, writeTx.getIdentifier(), e);
throw new IllegalStateException(id + " Transaction(close) not committed correctly", e);
LOG.trace("{}: Committing Transaction {}:{}", id, txType,
transaction.getIdentifier());
- Futures.addCallback(transaction.submit(), new FutureCallback<Void>() {
+ transaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.trace("{}: Transaction({}) {} SUCCESSFUL", id, txType,
transaction.getIdentifier());
}
}
@Override
- public void close() throws Exception {
+ public void close() {
removeDeviceConfiguration();
}
package org.opendaylight.netconf.sal.connect.util;
-import com.google.common.util.concurrent.CheckedFuture;
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 com.google.common.util.concurrent.SettableFuture;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import javax.annotation.Nullable;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
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.mdsal.common.api.CommitInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddKeystoreEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddKeystoreEntryOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddKeystoreEntryOutputBuilder;
final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, keystoreIid, keystore);
- final CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
-
try {
- submit.checkedGet();
+ writeTransaction.commit().get();
LOG.debug("init keystore done");
- } catch (TransactionCommitFailedException exception) {
+ } catch (InterruptedException | ExecutionException exception) {
LOG.error("Unable to initialize Netconf key-pair store.", exception);
}
}
final SettableFuture<RpcResult<RemoveKeystoreEntryOutput>> rpcResult = SettableFuture.create();
- final ListenableFuture<Void> submit = writeTransaction.submit();
- Futures.addCallback(submit, new FutureCallback<Void>() {
+ writeTransaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("remove-key-pair success. Input: {}");
rpcResult.set(RpcResultBuilder.success(new RemoveKeystoreEntryOutputBuilder().build()).build());
}
final SettableFuture<RpcResult<AddKeystoreEntryOutput>> rpcResult = SettableFuture.create();
- Futures.addCallback(writeTransaction.submit(), new FutureCallback<Void>() {
+ writeTransaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("add-key-pair success. Input: {}");
rpcResult.set(RpcResultBuilder.success(new AddKeystoreEntryOutputBuilder().build()).build());
}
final SettableFuture<RpcResult<AddTrustedCertificateOutput>> rpcResult = SettableFuture.create();
- Futures.addCallback(writeTransaction.submit(), new FutureCallback<Void>() {
+ writeTransaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("add-trusted-certificate success. Input: {}", input);
rpcResult.set(RpcResultBuilder.success(new AddTrustedCertificateOutputBuilder().build()).build());
}
final SettableFuture<RpcResult<RemoveTrustedCertificateOutput>> rpcResult = SettableFuture.create();
- Futures.addCallback(writeTransaction.submit(), new FutureCallback<Void>() {
+ writeTransaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("remove-trusted-certificate success. Input: {}", input);
rpcResult.set(RpcResultBuilder.success(new RemoveTrustedCertificateOutputBuilder().build()).build());
}
final SettableFuture<RpcResult<AddPrivateKeyOutput>> rpcResult = SettableFuture.create();
- Futures.addCallback(writeTransaction.submit(), new FutureCallback<Void>() {
+ writeTransaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("add-private-key success. Input: {}", input);
rpcResult.set(RpcResultBuilder.success(new AddPrivateKeyOutputBuilder().build()).build());
}
final SettableFuture<RpcResult<RemovePrivateKeyOutput>> rpcResult = SettableFuture.create();
- Futures.addCallback(writeTransaction.submit(), new FutureCallback<Void>() {
+ writeTransaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("remove-private-key success. Input: {}", input);
rpcResult.set(RpcResultBuilder.success(new RemovePrivateKeyOutputBuilder().build()).build());
}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
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 com.google.common.util.concurrent.SettableFuture;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.CreateDeviceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.CreateDeviceOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.CreateDeviceOutputBuilder;
final InstanceIdentifier<NetconfNode> niid = topologyPath.child(Node.class,
new NodeKey(nodeId)).augmentation(NetconfNode.class);
writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, niid, node, true);
- final ListenableFuture<Void> future = writeTransaction.submit();
- Futures.addCallback(future, new FutureCallback<Void>() {
+ writeTransaction.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.info("add-netconf-node RPC: Added netconf node successfully.");
futureResult.set(RpcResultBuilder.success(new CreateDeviceOutputBuilder().build()).build());
}
final WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
wtx.delete(LogicalDatastoreType.CONFIGURATION, niid);
- final ListenableFuture<Void> future = wtx.submit();
final SettableFuture<RpcResult<DeleteDeviceOutput>> rpcFuture = SettableFuture.create();
- Futures.addCallback(future, new FutureCallback<Void>() {
+ wtx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.info("delete-device RPC: Removed netconf node successfully.");
rpcFuture.set(RpcResultBuilder.success(new DeleteDeviceOutputBuilder().build()).build());
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.sal.connect.netconf.sal;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
-import com.google.common.util.concurrent.Futures;
import java.net.InetSocketAddress;
import org.junit.Before;
import org.junit.Test;
private DOMMountPointService mountPointService;
@Mock
private WriteTransaction writeTx;
+
private NetconfDeviceSalProvider provider;
@Before
doReturn(writeTx).when(chain).newWriteOnlyTransaction();
doNothing().when(writeTx).merge(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
doReturn("Some object").when(writeTx).getIdentifier();
- doReturn(Futures.immediateCheckedFuture(null)).when(writeTx).submit();
+ doReturn(emptyFluentFuture()).when(writeTx).commit();
provider = new NetconfDeviceSalProvider(new RemoteDeviceId("device1",
InetSocketAddress.createUnresolved("localhost", 17830)), mountPointService, dataBroker);
when(chain.newWriteOnlyTransaction()).thenReturn(tx);
- when(tx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(emptyFluentFuture()).when(tx).commit();
when(tx.getIdentifier()).thenReturn(tx);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.sal.connect.netconf.sal;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.net.InetSocketAddress;
import java.util.EnumMap;
@Test
public void testFailedDevice() throws Exception {
- doReturn(Futures.immediateCheckedFuture(null)).when(writeTx).submit();
+ doReturn(emptyFluentFuture()).when(writeTx).commit();
NetconfDeviceTopologyAdapter adapter = new NetconfDeviceTopologyAdapter(id, txChain);
adapter.setDeviceAsFailed(null);
@Test
public void testDeviceUpdate() throws Exception {
- doReturn(Futures.immediateCheckedFuture(null)).when(writeTx).submit();
+ doReturn(emptyFluentFuture()).when(writeTx).commit();
NetconfDeviceTopologyAdapter adapter = new NetconfDeviceTopologyAdapter(id, txChain);
adapter.updateDeviceData(true, new NetconfDeviceCapabilities());
DOMDataWriteTransaction wtx = domDataBroker.newWriteOnlyTransaction();
wtx.put(LogicalDatastoreType.OPERATIONAL, pathToAugmentedLeaf, augmentNode);
- wtx.submit().get(5, TimeUnit.SECONDS);
+ wtx.commit().get(5, TimeUnit.SECONDS);
adapter.updateDeviceData(true, new NetconfDeviceCapabilities());
Optional<NormalizedNode<?, ?>> testNode = domDataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, pathToAugmentedLeaf).checkedGet(2, TimeUnit.SECONDS);
+ .read(LogicalDatastoreType.OPERATIONAL, pathToAugmentedLeaf).get(2, TimeUnit.SECONDS);
assertEquals("Augmented node data should be still present after device update.", true, testNode.isPresent());
assertEquals("Augmented data should be the same as before update node.", dataTestId, testNode.get().getValue());
adapter.setDeviceAsFailed(null);
testNode = domDataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, pathToAugmentedLeaf).checkedGet(2, TimeUnit.SECONDS);
+ .read(LogicalDatastoreType.OPERATIONAL, pathToAugmentedLeaf).get(2, TimeUnit.SECONDS);
assertEquals("Augmented node data should be still present after device failed.", true, testNode.isPresent());
assertEquals("Augmented data should be the same as before failed device.",
@Test
public void testRemoveDeviceConfiguration() throws Exception {
- doReturn(Futures.immediateCheckedFuture(null)).when(writeTx).submit();
+ doReturn(emptyFluentFuture()).when(writeTx).commit();
NetconfDeviceTopologyAdapter adapter = new NetconfDeviceTopologyAdapter(id, txChain);
adapter.close();
verify(txChain, times(2)).newWriteOnlyTransaction();
verify(writeTx).delete(LogicalDatastoreType.OPERATIONAL, id.getTopologyBindingPath());
- verify(writeTx, times(2)).submit();
+ verify(writeTx, times(2)).commit();
}
}
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import java.net.InetSocketAddress;
+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.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.DOMRpcService;
import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.BaseSchema;
MockitoAnnotations.initMocks(this);
final CheckedFuture<DefaultDOMRpcResult, Exception> successFuture =
- Futures.immediateCheckedFuture(new DefaultDOMRpcResult(((NormalizedNode<?, ?>) null)));
+ Futures.immediateCheckedFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null));
doReturn(successFuture)
.doReturn(Futures.immediateFailedCheckedFuture(new IllegalStateException("Failed tx")))
}
@Test
- public void testDiscardChanges() {
+ public void testDiscardChanges() throws InterruptedException {
final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(SchemaContext.class)),
false);
- final CheckedFuture<Void, TransactionCommitFailedException> submitFuture = tx.submit();
try {
- submitFuture.checkedGet();
- } catch (final TransactionCommitFailedException e) {
+ tx.commit().get();
+ } catch (final ExecutionException e) {
// verify discard changes was sent
final InOrder inOrder = inOrder(rpc);
inOrder.verify(rpc).invokeRpc(toPath(NetconfMessageTransformUtil.NETCONF_LOCK_QNAME),
final CheckedFuture<DefaultDOMRpcResult, Exception> rpcErrorFuture = Futures.immediateCheckedFuture(
new DefaultDOMRpcResult(RpcResultBuilder.newError(RpcError.ErrorType.APPLICATION, "a", "m")));
- doReturn(Futures.immediateCheckedFuture(new DefaultDOMRpcResult(((NormalizedNode<?, ?>) null))))
+ doReturn(Futures.immediateCheckedFuture(new DefaultDOMRpcResult((NormalizedNode<?, ?>) null)))
.doReturn(rpcErrorFuture).when(rpc).invokeRpc(any(SchemaPath.class), any(NormalizedNode.class));
final WriteCandidateTx tx = new WriteCandidateTx(id, new NetconfBaseOps(rpc, mock(SchemaContext.class)),
false);
- final CheckedFuture<Void, TransactionCommitFailedException> submitFuture = tx.submit();
try {
- submitFuture.checkedGet();
- } catch (final TransactionCommitFailedException e) {
- return;
+ tx.commit().get();
+ fail("Submit should fail");
+ } catch (final ExecutionException e) {
+ // Intended
}
-
- fail("Submit should fail");
}
@Test
id, new NetconfBaseOps(rpc, BaseSchema.BASE_NETCONF_CTX_WITH_NOTIFICATIONS.getSchemaContext()), false);
tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
- tx.submit();
+ tx.commit();
// verify discard changes was sent
final InOrder inOrder = inOrder(rpc);
inOrder.verify(rpc).invokeRpc(toPath(NetconfMessageTransformUtil.NETCONF_LOCK_QNAME),
final TxListener listener = mock(TxListener.class);
tx.addListener(listener);
tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
- tx.submit();
+ tx.commit();
verify(listener).onTransactionSubmitted(tx);
verify(listener).onTransactionSuccessful(tx);
verify(listener, never()).onTransactionFailed(eq(tx), any());
final TxListener listener = mock(TxListener.class);
tx.addListener(listener);
tx.delete(LogicalDatastoreType.CONFIGURATION, yangIId);
- tx.submit();
+ tx.commit();
final ArgumentCaptor<Exception> excCaptor = ArgumentCaptor.forClass(Exception.class);
verify(listener).onTransactionSubmitted(tx);
verify(listener).onTransactionFailed(eq(tx), excCaptor.capture());
public void testChainFail() throws Exception {
final AbstractWriteTx writeTx = chain.newWriteOnlyTransaction();
verify(writeOnlyTx1).addListener(captor.capture());
- writeTx.submit();
+ writeTx.commit();
final TransactionCommitFailedException cause = new TransactionCommitFailedException("fail");
captor.getValue().onTransactionFailed(writeOnlyTx1, cause);
verify(registration1).close();
final AbstractWriteTx writeTx = chain.newWriteOnlyTransaction();
chain.close();
verify(writeOnlyTx1).addListener(captor.capture());
- writeTx.submit();
+ writeTx.commit();
captor.getValue().onTransactionSuccessful(writeOnlyTx1);
verify(registration1).close();
verify(listener).onTransactionChainSuccessful(chain);
final ArgumentCaptor<TxListener> captor1 = ArgumentCaptor.forClass(TxListener.class);
verify(writeOnlyTx1).addListener(captor1.capture());
//submit 1st tx
- writeTx1.submit();
+ writeTx1.commit();
captor1.getValue().onTransactionSubmitted(writeOnlyTx1);
//create 2nd tx
final ArgumentCaptor<TxListener> captor2 = ArgumentCaptor.forClass(TxListener.class);
verify(writeTx2).addListener(captor2.capture());
//submit 2nd tx
- writeTx2.submit();
+ writeTx2.commit();
captor2.getValue().onTransactionSubmitted(writeOnlyTx2);
//create 3rd tx
final ArgumentCaptor<TxListener> captor1 = ArgumentCaptor.forClass(TxListener.class);
verify(writeOnlyTx1).addListener(captor1.capture());
//submit 1st tx
- writeTx1.submit();
+ writeTx1.commit();
captor1.getValue().onTransactionSubmitted(writeOnlyTx1);
//create 2nd tx
final ArgumentCaptor<TxListener> captor2 = ArgumentCaptor.forClass(TxListener.class);
verify(writeTx2).addListener(captor2.capture());
//submit 2nd tx
- writeTx2.submit();
+ writeTx2.commit();
captor2.getValue().onTransactionSubmitted(writeOnlyTx2);
//create 3rd tx
//check, if both edits are called
verify(rpc, times(2)).invokeRpc(
eq(SchemaPath.create(true, NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_QNAME)), any());
- tx.submit().get();
+ tx.commit().get();
//check, if unlock is called
verify(rpc).invokeRpc(SchemaPath.create(true, NetconfMessageTransformUtil.NETCONF_COMMIT_QNAME),
NetconfMessageTransformUtil.COMMIT_RPC_CONTENT);
//check, if both edits are called
verify(rpc, times(2))
.invokeRpc(eq(SchemaPath.create(true, NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_QNAME)), any());
- tx.submit().get();
+ tx.commit().get();
//check, if unlock is called
verify(rpc).invokeRpc(SchemaPath.create(true, NetconfMessageTransformUtil.NETCONF_COMMIT_QNAME),
NetconfMessageTransformUtil.COMMIT_RPC_CONTENT);
//check, if no edit-config is called before submit
verify(rpc, never())
.invokeRpc(eq(SchemaPath.create(true, NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_QNAME)), any());
- tx.submit().get();
+ tx.commit().get();
//check, if both edits are called
verify(rpc, times(2))
.invokeRpc(eq(SchemaPath.create(true, NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_QNAME)), any());
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
import org.junit.Before;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
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.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.sal.connect.util.NetconfSalKeystoreService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.keystore.rev171017.AddPrivateKeyInput;
@Test
public void testAddPrivateKey() throws Exception {
- doReturn(Futures.<Void, TransactionCommitFailedException>immediateCheckedFuture(null)).when(writeTx).submit();
+ doReturn(emptyFluentFuture()).when(writeTx).commit();
NetconfSalKeystoreService keystoreService = new NetconfSalKeystoreService(dataBroker, encryptionService);
final AddPrivateKeyInput input = getPrivateKeyInput();
@Test
public void testAddTrustedCertificate() throws Exception {
- doReturn(Futures.<Void, TransactionCommitFailedException>immediateCheckedFuture(null)).when(writeTx).submit();
+ doReturn(emptyFluentFuture()).when(writeTx).commit();
NetconfSalKeystoreService keystoreService = new NetconfSalKeystoreService(dataBroker, encryptionService);
final AddTrustedCertificateInput input = getTrustedCertificateInput();
import com.google.common.base.Strings;
import com.google.common.collect.Iterables;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.io.File;
import java.util.ArrayList;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.ModulesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.ModulesStateBuilder;
tx.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ModulesState.class),
new ModulesStateBuilder().setModule(newModules).build());
- Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(@Nullable final CommitInfo result) {
LOG.debug("Modules state successfully populated with new modules");
}
new YangIdentifier(source.getSourceIdentifier().getName()),
RevisionUtils.fromYangCommon(source.getSourceIdentifier().getRevision()))));
- Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(@Nullable final Void result) {
+ public void onSuccess(@Nullable final CommitInfo result) {
LOG.debug("Modules state successfully updated.");
}
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
+import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
-import com.google.common.util.concurrent.Futures;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
org.opendaylight.yangtools.yang.common.Revision.of("2016-04-28")),
YangTextSchemaSource.class, PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
- when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(emptyFluentFuture()).when(writeTransaction).commit();
yangLibProvider.schemaSourceRegistered(list);
List<Module> newModulesList = new ArrayList<>();
verify(writeTransaction).merge(eq(LogicalDatastoreType.OPERATIONAL),
eq(InstanceIdentifier.create(ModulesState.class)),
eq(new ModulesStateBuilder().setModule(newModulesList).build()));
- verify(writeTransaction).submit();
+ verify(writeTransaction).commit();
}
@Test
YangTextSchemaSource.class, PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(emptyFluentFuture()).when(writeTransaction).commit();
yangLibProvider.schemaSourceRegistered(potentialSources);
verify(dataBroker).newWriteOnlyTransaction();
verify(writeTransaction).merge(eq(LogicalDatastoreType.OPERATIONAL),
eq(InstanceIdentifier.create(ModulesState.class)), modulesStateCaptor.capture());
assertEquals(modulesStateCaptor.getValue().getModule().size(), 1);
- verify(writeTransaction).submit();
+ verify(writeTransaction).commit();
}
@Test
doNothing().when(writeTransaction)
.delete(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
- when(writeTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ doReturn(emptyFluentFuture()).when(writeTransaction).commit();
PotentialSchemaSource<YangTextSchemaSource> yangUnregistererSource =
PotentialSchemaSource.create(
new ModuleKey(new YangIdentifier("unregistered-yang-schema-without-revision"),
RevisionUtils.emptyRevision()))));
- verify(writeTransaction).submit();
+ verify(writeTransaction).commit();
yangUnregistererSource =
PotentialSchemaSource.create(
new ModuleKey(new YangIdentifier("unregistered-yang-with-revision"),
new Revision(new RevisionIdentifier("2016-04-28"))))));
- verify(writeTransaction, times(2)).submit();
+ verify(writeTransaction, times(2)).commit();
}
}