apps/netconf-topology-singleton/src/test/java/org/opendaylight/netconf/topology/singleton/impl/NetconfTopologyManagerTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.netconf.topology.singleton.impl;
   9
  10 import static org.awaitility.Awaitility.await;
  11 import static org.junit.Assert.assertEquals;
  12 import static org.mockito.ArgumentMatchers.any;
  13 import static org.mockito.Mockito.doNothing;
  14 import static org.mockito.Mockito.doReturn;
  15 import static org.mockito.Mockito.doThrow;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.reset;
  18 import static org.mockito.Mockito.spy;
  19 import static org.mockito.Mockito.times;
  20 import static org.mockito.Mockito.verify;
  21 import static org.mockito.Mockito.verifyNoMoreInteractions;
  22 import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.DELETE;
  23 import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.SUBTREE_MODIFIED;
  24 import static org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType.WRITE;
  25
  26 import akka.actor.ActorSystem;
  27 import akka.util.Timeout;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Objects;
  32 import java.util.Set;
  33 import java.util.concurrent.ExecutorService;
  34 import java.util.concurrent.TimeUnit;
  35 import java.util.function.Function;
  36 import org.junit.After;
  37 import org.junit.Before;
  38 import org.junit.Test;
  39 import org.junit.runner.RunWith;
  40 import org.mockito.ArgumentCaptor;
  41 import org.mockito.Mock;
  42 import org.mockito.junit.MockitoJUnitRunner;
  43 import org.opendaylight.aaa.encrypt.AAAEncryptionService;
  44 import org.opendaylight.mdsal.binding.api.DataBroker;
  45 import org.opendaylight.mdsal.binding.api.DataObjectModification;
  46 import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
  47 import org.opendaylight.mdsal.binding.api.DataTreeModification;
  48 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  49 import org.opendaylight.mdsal.binding.api.RpcProviderService;
  50 import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTest;
  51 import org.opendaylight.mdsal.binding.runtime.spi.BindingRuntimeHelpers;
  52 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  53 import org.opendaylight.mdsal.dom.api.DOMMountPointService;
  54 import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
  55 import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
  56 import org.opendaylight.netconf.client.NetconfClientFactory;
  57 import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
  58 import org.opendaylight.netconf.client.mdsal.impl.DefaultSchemaResourceManager;
  59 import org.opendaylight.netconf.common.NetconfTimer;
  60 import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
  61 import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
  62 import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
  63 import org.opendaylight.netconf.topology.spi.NetconfTopologySchemaAssembler;
  64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
  65 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  66 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  67 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev231121.NetconfNode;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev231121.NetconfNodeBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  71 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  72 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  75 import org.opendaylight.yangtools.concepts.Registration;
  76 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  77 import org.opendaylight.yangtools.yang.binding.KeyStep;
  78 import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
  79 import org.opendaylight.yangtools.yang.common.Uint16;
  80 import org.opendaylight.yangtools.yang.parser.impl.DefaultYangParserFactory;
  81
  82 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  83 public class NetconfTopologyManagerTest extends AbstractBaseSchemasTest {
  84     private static final Uint16 ACTOR_RESPONSE_WAIT_TIME = Uint16.TEN;
  85     private static final String TOPOLOGY_ID = "topologyID";
  86
  87     private NetconfTopologyManager netconfTopologyManager;
  88
  89     @Mock
  90     private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
  91     @Mock
  92     private Registration mockListenerReg;
  93     @Mock
  94     private Registration mockRpcReg;
  95     @Mock
  96     private NetconfTimer timer;
  97     @Mock
  98     private ExecutorService processingService;
  99     @Mock
 100     private ActorSystem actorSystem;
 101     @Mock
 102     private NetconfClientFactory clientFactory;
 103     @Mock
 104     private DOMMountPointService mountPointService;
 105     @Mock
 106     private AAAEncryptionService encryptionService;
 107     @Mock
 108     private DeviceActionFactory actionFactory;
 109     @Mock
 110     private RpcProviderService rpcProviderService;
 111     @Mock
 112     private NetconfClientConfigurationBuilderFactory builderFactory;
 113
 114     private NetconfTopologySchemaAssembler schemaAssembler;
 115     private DataBroker dataBroker;
 116
 117     private final Map<InstanceIdentifier<Node>, Function<NetconfTopologySetup, NetconfTopologyContext>>
 118             mockContextMap = new HashMap<>();
 119
 120     @Before
 121     public void setUp() throws Exception {
 122         schemaAssembler = new NetconfTopologySchemaAssembler(1, 1, 0, TimeUnit.SECONDS);
 123
 124         AbstractDataBrokerTest dataBrokerTest = new AbstractDataBrokerTest() {
 125             @Override
 126             protected Set<YangModuleInfo> getModuleInfos() throws Exception {
 127                 return Set.of(BindingRuntimeHelpers.getYangModuleInfo(NetworkTopology.class));
 128             }
 129         };
 130
 131         dataBrokerTest.setup();
 132         dataBroker = spy(dataBrokerTest.getDataBroker());
 133
 134         doNothing().when(mockListenerReg).close();
 135         doReturn(mockListenerReg).when(dataBroker).registerTreeChangeListener(any(), any());
 136         doReturn(mockRpcReg).when(rpcProviderService).registerRpcImplementations(any());
 137
 138         netconfTopologyManager = new NetconfTopologyManager(BASE_SCHEMAS, dataBroker, clusterSingletonServiceProvider,
 139                 timer, schemaAssembler, actorSystem, clientFactory, mountPointService, encryptionService,
 140                 rpcProviderService, actionFactory, new DefaultSchemaResourceManager(new DefaultYangParserFactory()),
 141                 builderFactory, TOPOLOGY_ID, Uint16.ZERO) {
 142             @Override
 143             protected NetconfTopologyContext newNetconfTopologyContext(final NetconfTopologySetup setup,
 144                 final ServiceGroupIdentifier serviceGroupIdent, final Timeout actorResponseWaitTime,
 145                 final DeviceActionFactory deviceActionFactory) {
 146                 assertEquals(ACTOR_RESPONSE_WAIT_TIME.toJava(), actorResponseWaitTime.duration().toSeconds());
 147                 return Objects.requireNonNull(mockContextMap.get(setup.getInstanceIdentifier()),
 148                         "No mock context for " + setup.getInstanceIdentifier()).apply(setup);
 149             }
 150         };
 151     }
 152
 153     @After
 154     public void after() {
 155         schemaAssembler.close();
 156     }
 157
 158     @Test
 159     public void testRegisterDataTreeChangeListener() throws Exception {
 160         await().atMost(5, TimeUnit.SECONDS).until(() -> {
 161             try (ReadTransaction readTx = dataBroker.newReadOnlyTransaction()) {
 162                 return readTx.exists(LogicalDatastoreType.OPERATIONAL,
 163                     NetconfTopologyUtils.createTopologyListPath(TOPOLOGY_ID)).get(3, TimeUnit.SECONDS);
 164             }
 165         });
 166
 167         // verify registration is called with right parameters
 168
 169         verify(dataBroker).registerTreeChangeListener(
 170                 DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, NetconfTopologyUtils
 171                         .createTopologyListPath(TOPOLOGY_ID).child(Node.class)), netconfTopologyManager);
 172
 173         netconfTopologyManager.close();
 174         verify(mockListenerReg).close();
 175
 176         netconfTopologyManager.close();
 177         verifyNoMoreInteractions(mockListenerReg);
 178     }
 179
 180     @SuppressWarnings("unchecked")
 181     @Test
 182     public void testOnDataTreeChanged() {
 183         // Notify of 2 created Node objects.
 184         final NodeId nodeId1 = new NodeId("node-id-1");
 185         final InstanceIdentifier<Node> nodeInstanceId1 = NetconfTopologyUtils.createTopologyNodeListPath(
 186                 new NodeKey(nodeId1), TOPOLOGY_ID);
 187
 188         final NodeId nodeId2 = new NodeId("node-id-2");
 189         final InstanceIdentifier<Node> nodeInstanceId2 = NetconfTopologyUtils.createTopologyNodeListPath(
 190                 new NodeKey(nodeId2), TOPOLOGY_ID);
 191
 192         final NetconfNode netconfNode1 = new NetconfNodeBuilder()
 193                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 194                 .setPort(new PortNumber(Uint16.valueOf(1111)))
 195                 .setActorResponseWaitTime(ACTOR_RESPONSE_WAIT_TIME)
 196                 .build();
 197         final Node node1 = new NodeBuilder().setNodeId(nodeId1).addAugmentation(netconfNode1).build();
 198
 199         final DataObjectModification<Node> dataObjectModification1 = mock(DataObjectModification.class);
 200         doReturn(WRITE).when(dataObjectModification1).modificationType();
 201         doReturn(node1).when(dataObjectModification1).dataAfter();
 202         doReturn(new KeyStep<>(Node.class, new NodeKey(nodeId1)))
 203                 .when(dataObjectModification1).step();
 204
 205         final NetconfNode netconfNode2 = new NetconfNodeBuilder()
 206                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 207                 .setPort(new PortNumber(Uint16.valueOf(2222)))
 208                 .setActorResponseWaitTime(ACTOR_RESPONSE_WAIT_TIME)
 209                 .build();
 210         final Node node2 = new NodeBuilder().setNodeId(nodeId2).addAugmentation(netconfNode2).build();
 211
 212         final DataObjectModification<Node> dataObjectModification2 = mock(DataObjectModification.class);
 213         doReturn(WRITE).when(dataObjectModification2).modificationType();
 214         doReturn(node2).when(dataObjectModification2).dataAfter();
 215         doReturn(new KeyStep<>(Node.class, new NodeKey(nodeId2))).when(dataObjectModification2).step();
 216
 217         final NetconfTopologyContext mockContext1 = mock(NetconfTopologyContext.class);
 218         mockContextMap.put(nodeInstanceId1, setup -> {
 219             assertEquals(node1, setup.getNode());
 220             assertEquals(TOPOLOGY_ID, setup.getTopologyId());
 221             return mockContext1;
 222         });
 223
 224         final NetconfTopologyContext mockContext2 = mock(NetconfTopologyContext.class);
 225         mockContextMap.put(nodeInstanceId2, setup -> {
 226             assertEquals(node2, setup.getNode());
 227             assertEquals(TOPOLOGY_ID, setup.getTopologyId());
 228             return mockContext2;
 229         });
 230
 231         final var mockClusterRegistration1 = mock(Registration.class);
 232         final var mockClusterRegistration2 = mock(Registration.class);
 233
 234         doReturn(mockClusterRegistration1).when(clusterSingletonServiceProvider)
 235                 .registerClusterSingletonService(mockContext1);
 236         doReturn(mockClusterRegistration2).when(clusterSingletonServiceProvider)
 237                 .registerClusterSingletonService(mockContext2);
 238
 239         netconfTopologyManager.onDataTreeChanged(List.of(
 240                 new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
 241                         nodeInstanceId1), dataObjectModification1),
 242                 new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
 243                         nodeInstanceId2), dataObjectModification2)));
 244
 245         verify(clusterSingletonServiceProvider).registerClusterSingletonService(mockContext1);
 246         verify(clusterSingletonServiceProvider).registerClusterSingletonService(mockContext2);
 247
 248         // Notify of Node 1 replaced and Node 2 subtree modified.
 249         mockContextMap.clear();
 250
 251         final NetconfNode updatedNetconfNode1 = new NetconfNodeBuilder(netconfNode1)
 252                 .setPort(new PortNumber(Uint16.valueOf(33333))).build();
 253         final Node updatedNode1 = new NodeBuilder().setNodeId(nodeId1).addAugmentation(updatedNetconfNode1).build();
 254
 255         doReturn(WRITE).when(dataObjectModification1).modificationType();
 256         doReturn(updatedNode1).when(dataObjectModification1).dataAfter();
 257
 258         doReturn(SUBTREE_MODIFIED).when(dataObjectModification2).modificationType();
 259         doReturn(node2).when(dataObjectModification2).dataAfter();
 260
 261         doNothing().when(mockContext1).refresh(any());
 262         doNothing().when(mockContext2).refresh(any());
 263
 264         netconfTopologyManager.onDataTreeChanged(List.of(
 265                 new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
 266                         nodeInstanceId1), dataObjectModification1),
 267                 new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
 268                         nodeInstanceId2), dataObjectModification2)));
 269
 270         ArgumentCaptor<NetconfTopologySetup> mockContext1Setup = ArgumentCaptor.forClass(NetconfTopologySetup.class);
 271         verify(mockContext1).refresh(mockContext1Setup.capture());
 272         assertEquals(updatedNode1, mockContext1Setup.getValue().getNode());
 273
 274         verify(mockContext2).refresh(any());
 275
 276         verifyNoMoreInteractions(clusterSingletonServiceProvider);
 277
 278         // Notify of Node 1 deleted.
 279         doReturn(DELETE).when(dataObjectModification1).modificationType();
 280
 281         netconfTopologyManager.onDataTreeChanged(List.of(
 282                 new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
 283                         nodeInstanceId1), dataObjectModification1)));
 284
 285         verify(mockClusterRegistration1).close();
 286         verify(mockContext1).close();
 287         verifyNoMoreInteractions(clusterSingletonServiceProvider, mockClusterRegistration2, mockContext2);
 288
 289         // Notify of Node 1 created again.
 290         reset(clusterSingletonServiceProvider);
 291
 292         final NetconfTopologyContext newMockContext1 = mock(NetconfTopologyContext.class);
 293         final var newMockClusterRegistration1 = mock(Registration.class);
 294
 295         doThrow(new RuntimeException("mock error")).doReturn(newMockClusterRegistration1)
 296                 .when(clusterSingletonServiceProvider).registerClusterSingletonService(newMockContext1);
 297
 298         doReturn(WRITE).when(dataObjectModification1).modificationType();
 299         doReturn(node1).when(dataObjectModification1).dataAfter();
 300
 301         mockContextMap.put(nodeInstanceId1, setup -> {
 302             assertEquals(node1, setup.getNode());
 303             assertEquals(TOPOLOGY_ID, setup.getTopologyId());
 304             return newMockContext1;
 305         });
 306
 307         netconfTopologyManager.onDataTreeChanged(List.of(
 308                 new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
 309                         nodeInstanceId1), dataObjectModification1)));
 310
 311         verify(clusterSingletonServiceProvider, times(2)).registerClusterSingletonService(newMockContext1);
 312         verifyNoMoreInteractions(mockClusterRegistration1, mockContext1, mockClusterRegistration2, mockContext2,
 313                 newMockContext1, newMockClusterRegistration1, clusterSingletonServiceProvider);
 314
 315         // Test close.
 316         netconfTopologyManager.close();
 317
 318         verify(newMockClusterRegistration1).close();
 319         verify(newMockContext1).close();
 320         verify(mockClusterRegistration2).close();
 321         verify(mockContext2).close();
 322
 323         netconfTopologyManager.close();
 324
 325         verifyNoMoreInteractions(mockClusterRegistration1, mockContext1, mockClusterRegistration2, mockContext2,
 326                 newMockContext1, newMockClusterRegistration1, clusterSingletonServiceProvider);
 327     }
 328
 329     @Test
 330     public void testClusterSingletonServiceRegistrationFailure() throws Exception {
 331         final NodeId nodeId = new NodeId("node-id");
 332         final InstanceIdentifier<Node> nodeInstanceId = NetconfTopologyUtils.createTopologyNodeListPath(
 333                 new NodeKey(nodeId), TOPOLOGY_ID);
 334
 335         final Node node = new NodeBuilder()
 336                 .setNodeId(nodeId)
 337                 .addAugmentation(new NetconfNodeBuilder()
 338                     .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 339                     .setPort(new PortNumber(Uint16.valueOf(10)))
 340                     .setActorResponseWaitTime(ACTOR_RESPONSE_WAIT_TIME)
 341                     .build())
 342                 .build();
 343
 344         final DataObjectModification<Node> dataObjectModification = mock(DataObjectModification.class);
 345         doReturn(WRITE).when(dataObjectModification).modificationType();
 346         doReturn(node).when(dataObjectModification).dataAfter();
 347         doReturn(new KeyStep<>(Node.class, new NodeKey(nodeId))).when(dataObjectModification).step();
 348
 349         final NetconfTopologyContext mockContext = mock(NetconfTopologyContext.class);
 350         mockContextMap.put(nodeInstanceId, setup -> mockContext);
 351
 352         doThrow(new RuntimeException("mock error")).when(clusterSingletonServiceProvider)
 353                 .registerClusterSingletonService(mockContext);
 354
 355         netconfTopologyManager.onDataTreeChanged(List.of(
 356                 new CustomTreeModification(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
 357                         nodeInstanceId), dataObjectModification)));
 358
 359         verify(clusterSingletonServiceProvider, times(3)).registerClusterSingletonService(mockContext);
 360         verify(mockContext).close();
 361         verifyNoMoreInteractions(mockListenerReg);
 362
 363         netconfTopologyManager.close();
 364         verifyNoMoreInteractions(mockContext);
 365     }
 366
 367     static class CustomTreeModification  implements DataTreeModification<Node> {
 368
 369         private final DataTreeIdentifier<Node> rootPath;
 370         private final DataObjectModification<Node> rootNode;
 371
 372         CustomTreeModification(final DataTreeIdentifier<Node> rootPath, final DataObjectModification<Node> rootNode) {
 373             this.rootPath = rootPath;
 374             this.rootNode = rootNode;
 375         }
 376
 377         @Override
 378         public DataTreeIdentifier<Node> getRootPath() {
 379             return rootPath;
 380         }
 381
 382         @Override
 383         public DataObjectModification<Node> getRootNode() {
 384             return rootNode;
 385         }
 386     }
 387 }