netconf/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.mockito.MockitoAnnotations.initMocks;
  23 import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.DELETE;
  24 import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.SUBTREE_MODIFIED;
  25 import static org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType.WRITE;
  26
  27 import akka.util.Timeout;
  28 import com.google.common.base.Optional;
  29 import com.google.common.collect.ImmutableSet;
  30 import io.netty.util.concurrent.EventExecutor;
  31 import java.util.Arrays;
  32 import java.util.HashMap;
  33 import java.util.Map;
  34 import java.util.Objects;
  35 import java.util.Set;
  36 import java.util.concurrent.ExecutorService;
  37 import java.util.concurrent.TimeUnit;
  38 import java.util.function.Function;
  39 import javax.annotation.Nonnull;
  40 import org.junit.Before;
  41 import org.junit.Test;
  42 import org.mockito.ArgumentCaptor;
  43 import org.mockito.Mock;
  44 import org.opendaylight.aaa.encrypt.AAAEncryptionService;
  45 import org.opendaylight.controller.cluster.ActorSystemProvider;
  46 import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
  47 import org.opendaylight.controller.config.threadpool.ThreadPool;
  48 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  49 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
  50 import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
  51 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
  52 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  53 import org.opendaylight.controller.md.sal.binding.test.ConstantSchemaAbstractDataBrokerTest;
  54 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  55 import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
  56 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  57 import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
  58 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
  59 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
  60 import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
  61 import org.opendaylight.netconf.client.NetconfClientDispatcher;
  62 import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
  63 import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
  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.rev150114.NetconfNode;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.topology.singleton.config.rev170419.Config;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.topology.singleton.config.rev170419.ConfigBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  75 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  76 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  78 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  79 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  80 import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
  81
  82 public class NetconfTopologyManagerTest {
  83     private static final int ACTOR_RESPONSE_WAIT_TIME = 10;
  84     private static final String TOPOLOGY_ID = "topologyID";
  85
  86     private NetconfTopologyManager netconfTopologyManager;
  87
  88     @Mock
  89     private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
  90
  91     @Mock
  92     private ListenerRegistration<?> mockListenerReg;
  93
  94     private DataBroker dataBroker;
  95
  96     private final Map<InstanceIdentifier<Node>, Function<NetconfTopologySetup, NetconfTopologyContext>>
  97             mockContextMap = new HashMap<>();
  98
  99     @Before
 100     public void setUp() throws Exception {
 101         initMocks(this);
 102
 103         ConstantSchemaAbstractDataBrokerTest dataBrokerTest = new ConstantSchemaAbstractDataBrokerTest(false) {
 104             @Override
 105             protected Set<YangModuleInfo> getModuleInfos() throws Exception {
 106                 return ImmutableSet.of(BindingReflections.getModuleInfo(NetworkTopology.class),
 107                         BindingReflections.getModuleInfo(Topology.class));
 108             }
 109         };
 110
 111         dataBrokerTest.setup();
 112         dataBroker = spy(dataBrokerTest.getDataBroker());
 113
 114         final RpcProviderRegistry rpcProviderRegistry = mock(RpcProviderRegistry.class);
 115         final ScheduledThreadPool keepaliveExecutor = mock(ScheduledThreadPool.class);
 116         final ThreadPool processingThreadPool = mock(ThreadPool.class);
 117         final ExecutorService processingService = mock(ExecutorService.class);
 118         doReturn(processingService).when(processingThreadPool).getExecutor();
 119         final ActorSystemProvider actorSystemProvider = mock(ActorSystemProvider.class);
 120         final EventExecutor eventExecutor = mock(EventExecutor.class);
 121         final NetconfClientDispatcher clientDispatcher = mock(NetconfClientDispatcher.class);
 122         final DOMMountPointService mountPointService = mock(DOMMountPointService.class);
 123         final AAAEncryptionService encryptionService = mock(AAAEncryptionService.class);
 124
 125         final Config config = new ConfigBuilder().setWriteTransactionIdleTimeout(0).build();
 126         netconfTopologyManager = new NetconfTopologyManager(dataBroker, rpcProviderRegistry,
 127                 clusterSingletonServiceProvider, keepaliveExecutor, processingThreadPool,
 128                 actorSystemProvider, eventExecutor, clientDispatcher, TOPOLOGY_ID, config,
 129                 mountPointService, encryptionService) {
 130             @Override
 131             protected NetconfTopologyContext newNetconfTopologyContext(final NetconfTopologySetup setup,
 132                     final ServiceGroupIdentifier serviceGroupIdent, final Timeout actorResponseWaitTime) {
 133                 assertEquals(ACTOR_RESPONSE_WAIT_TIME, actorResponseWaitTime.duration().toSeconds());
 134                 return Objects.requireNonNull(mockContextMap.get(setup.getInstanceIdentifier()),
 135                         "No mock context for " + setup.getInstanceIdentifier()).apply(setup);
 136             }
 137         };
 138
 139         doNothing().when(mockListenerReg).close();
 140         doReturn(mockListenerReg).when(dataBroker).registerDataTreeChangeListener(any(), any());
 141     }
 142
 143     @Test
 144     public void testRegisterDataTreeChangeListener() throws Exception {
 145
 146         netconfTopologyManager.init();
 147
 148         await().atMost(5, TimeUnit.SECONDS).until(() -> {
 149             ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
 150             Optional<Topology> config = readTx.read(LogicalDatastoreType.CONFIGURATION,
 151                     NetconfTopologyUtils.createTopologyListPath(TOPOLOGY_ID)).get(3, TimeUnit.SECONDS);
 152             Optional<Topology> oper = readTx.read(LogicalDatastoreType.OPERATIONAL,
 153                     NetconfTopologyUtils.createTopologyListPath(TOPOLOGY_ID)).get(3, TimeUnit.SECONDS);
 154             return config.isPresent() && oper.isPresent();
 155         });
 156
 157         // verify registration is called with right parameters
 158
 159         verify(dataBroker).registerDataTreeChangeListener(
 160                 new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, NetconfTopologyUtils
 161                         .createTopologyListPath(TOPOLOGY_ID).child(Node.class)), netconfTopologyManager);
 162
 163         netconfTopologyManager.close();
 164         verify(mockListenerReg).close();
 165
 166         netconfTopologyManager.close();
 167         verifyNoMoreInteractions(mockListenerReg);
 168     }
 169
 170     @SuppressWarnings("unchecked")
 171     @Test
 172     public void testOnDataTreeChanged() throws Exception {
 173
 174         // Notify of 2 created Node objects.
 175
 176         final NodeId nodeId1 = new NodeId("node-id-1");
 177         final InstanceIdentifier<Node> nodeInstanceId1 = NetconfTopologyUtils.createTopologyNodeListPath(
 178                 new NodeKey(nodeId1), TOPOLOGY_ID);
 179
 180         final NodeId nodeId2 = new NodeId("node-id-2");
 181         final InstanceIdentifier<Node> nodeInstanceId2 = NetconfTopologyUtils.createTopologyNodeListPath(
 182                 new NodeKey(nodeId2), TOPOLOGY_ID);
 183
 184         final NetconfNode netconfNode1 = new NetconfNodeBuilder()
 185                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 186                 .setPort(new PortNumber(1111))
 187                 .setActorResponseWaitTime(ACTOR_RESPONSE_WAIT_TIME)
 188                 .build();
 189         final Node node1 = new NodeBuilder().setNodeId(nodeId1).addAugmentation(NetconfNode.class,
 190                 netconfNode1).build();
 191
 192         final DataObjectModification<Node> dataObjectModification1 = mock(DataObjectModification.class);
 193         doReturn(WRITE).when(dataObjectModification1).getModificationType();
 194         doReturn(node1).when(dataObjectModification1).getDataAfter();
 195         doReturn(InstanceIdentifier.IdentifiableItem.of(Node.class, new NodeKey(nodeId1)))
 196                 .when(dataObjectModification1).getIdentifier();
 197
 198         final NetconfNode netconfNode2 = new NetconfNodeBuilder()
 199                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 200                 .setPort(new PortNumber(2222))
 201                 .setActorResponseWaitTime(ACTOR_RESPONSE_WAIT_TIME)
 202                 .build();
 203         final Node node2 = new NodeBuilder().setNodeId(nodeId2).addAugmentation(NetconfNode.class,
 204                 netconfNode2).build();
 205
 206         final DataObjectModification<Node> dataObjectModification2 = mock(DataObjectModification.class);
 207         doReturn(WRITE).when(dataObjectModification2).getModificationType();
 208         doReturn(node2).when(dataObjectModification2).getDataAfter();
 209         doReturn(InstanceIdentifier.IdentifiableItem.of(Node.class, new NodeKey(nodeId2)))
 210                 .when(dataObjectModification2).getIdentifier();
 211
 212         final NetconfTopologyContext mockContext1 = mock(NetconfTopologyContext.class);
 213         mockContextMap.put(nodeInstanceId1, setup -> {
 214             assertEquals(node1, setup.getNode());
 215             assertEquals(TOPOLOGY_ID, setup.getTopologyId());
 216             return mockContext1;
 217         });
 218
 219         final NetconfTopologyContext mockContext2 = mock(NetconfTopologyContext.class);
 220         mockContextMap.put(nodeInstanceId2, setup -> {
 221             assertEquals(node2, setup.getNode());
 222             assertEquals(TOPOLOGY_ID, setup.getTopologyId());
 223             return mockContext2;
 224         });
 225
 226         ClusterSingletonServiceRegistration mockClusterRegistration1 = mock(ClusterSingletonServiceRegistration.class);
 227         ClusterSingletonServiceRegistration mockClusterRegistration2 = mock(ClusterSingletonServiceRegistration.class);
 228
 229         doReturn(mockClusterRegistration1).when(clusterSingletonServiceProvider)
 230                 .registerClusterSingletonService(mockContext1);
 231         doReturn(mockClusterRegistration2).when(clusterSingletonServiceProvider)
 232                 .registerClusterSingletonService(mockContext2);
 233
 234         netconfTopologyManager.onDataTreeChanged(Arrays.asList(
 235                 new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
 236                         nodeInstanceId1), dataObjectModification1),
 237                 new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
 238                         nodeInstanceId2), dataObjectModification2)));
 239
 240         verify(clusterSingletonServiceProvider).registerClusterSingletonService(mockContext1);
 241         verify(clusterSingletonServiceProvider).registerClusterSingletonService(mockContext2);
 242
 243         // Notify of Node 1 replaced and Node 2 subtree modified.
 244
 245         mockContextMap.clear();
 246
 247         final NetconfNode updatedNetconfNode1 = new NetconfNodeBuilder(netconfNode1)
 248                 .setPort(new PortNumber(33333)).build();
 249         final Node updatedNode1 = new NodeBuilder().setNodeId(nodeId1).addAugmentation(NetconfNode.class,
 250                 updatedNetconfNode1).build();
 251
 252         doReturn(WRITE).when(dataObjectModification1).getModificationType();
 253         doReturn(node1).when(dataObjectModification1).getDataBefore();
 254         doReturn(updatedNode1).when(dataObjectModification1).getDataAfter();
 255
 256         doReturn(SUBTREE_MODIFIED).when(dataObjectModification2).getModificationType();
 257         doReturn(node2).when(dataObjectModification2).getDataBefore();
 258         doReturn(node2).when(dataObjectModification2).getDataAfter();
 259
 260         doNothing().when(mockContext1).refresh(any());
 261         doNothing().when(mockContext2).refresh(any());
 262
 263         netconfTopologyManager.onDataTreeChanged(Arrays.asList(
 264                 new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
 265                         nodeInstanceId1), dataObjectModification1),
 266                 new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
 267                         nodeInstanceId2), dataObjectModification2)));
 268
 269         ArgumentCaptor<NetconfTopologySetup> mockContext1Setup = ArgumentCaptor.forClass(NetconfTopologySetup.class);
 270         verify(mockContext1).refresh(mockContext1Setup.capture());
 271         assertEquals(updatedNode1, mockContext1Setup.getValue().getNode());
 272
 273         verify(mockContext2).refresh(any());
 274
 275         verifyNoMoreInteractions(clusterSingletonServiceProvider);
 276
 277         // Notify of Node 1 deleted.
 278
 279         doReturn(DELETE).when(dataObjectModification1).getModificationType();
 280         doReturn(updatedNode1).when(dataObjectModification1).getDataBefore();
 281         doReturn(null).when(dataObjectModification1).getDataAfter();
 282
 283         netconfTopologyManager.onDataTreeChanged(Arrays.asList(
 284                 new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
 285                         nodeInstanceId1), dataObjectModification1)));
 286
 287         verify(mockClusterRegistration1).close();
 288         verify(mockContext1).close();
 289         verifyNoMoreInteractions(clusterSingletonServiceProvider, mockClusterRegistration2, mockContext2);
 290
 291         // Notify of Node 1 created again.
 292
 293         reset(clusterSingletonServiceProvider);
 294
 295         final NetconfTopologyContext newMockContext1 = mock(NetconfTopologyContext.class);
 296         final ClusterSingletonServiceRegistration newMockClusterRegistration1 =
 297                 mock(ClusterSingletonServiceRegistration.class);
 298
 299         doThrow(new RuntimeException("mock error")).doReturn(newMockClusterRegistration1)
 300                 .when(clusterSingletonServiceProvider).registerClusterSingletonService(newMockContext1);
 301
 302         doReturn(WRITE).when(dataObjectModification1).getModificationType();
 303         doReturn(null).when(dataObjectModification1).getDataBefore();
 304         doReturn(node1).when(dataObjectModification1).getDataAfter();
 305
 306         mockContextMap.put(nodeInstanceId1, setup -> {
 307             assertEquals(node1, setup.getNode());
 308             assertEquals(TOPOLOGY_ID, setup.getTopologyId());
 309             return newMockContext1;
 310         });
 311
 312         netconfTopologyManager.onDataTreeChanged(Arrays.asList(
 313                 new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
 314                         nodeInstanceId1), dataObjectModification1)));
 315
 316         verify(clusterSingletonServiceProvider, times(2)).registerClusterSingletonService(newMockContext1);
 317
 318         verifyNoMoreInteractions(mockClusterRegistration1, mockContext1, mockClusterRegistration2, mockContext2,
 319                 newMockContext1, newMockClusterRegistration1, clusterSingletonServiceProvider);
 320
 321         // Test close.
 322
 323         netconfTopologyManager.close();
 324
 325         verify(newMockClusterRegistration1).close();
 326         verify(newMockContext1).close();
 327         verify(mockClusterRegistration2).close();
 328         verify(mockContext2).close();
 329
 330         netconfTopologyManager.close();
 331
 332         verifyNoMoreInteractions(mockClusterRegistration1, mockContext1, mockClusterRegistration2, mockContext2,
 333                 newMockContext1, newMockClusterRegistration1, clusterSingletonServiceProvider);
 334     }
 335
 336     @Test
 337     public void testClusterSingletonServiceRegistrationFailure() throws Exception {
 338         final NodeId nodeId = new NodeId("node-id");
 339         final InstanceIdentifier<Node> nodeInstanceId = NetconfTopologyUtils.createTopologyNodeListPath(
 340                 new NodeKey(nodeId), TOPOLOGY_ID);
 341
 342         final NetconfNode netconfNode = new NetconfNodeBuilder()
 343                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 344                 .setPort(new PortNumber(10))
 345                 .setActorResponseWaitTime(ACTOR_RESPONSE_WAIT_TIME).build();
 346         final Node node = new NodeBuilder().setNodeId(nodeId).addAugmentation(NetconfNode.class,
 347                 netconfNode).build();
 348
 349         final DataObjectModification<Node> dataObjectModification = mock(DataObjectModification.class);
 350         doReturn(WRITE).when(dataObjectModification).getModificationType();
 351         doReturn(node).when(dataObjectModification).getDataAfter();
 352         doReturn(InstanceIdentifier.IdentifiableItem.of(Node.class, new NodeKey(nodeId)))
 353                 .when(dataObjectModification).getIdentifier();
 354
 355         final NetconfTopologyContext mockContext = mock(NetconfTopologyContext.class);
 356         mockContextMap.put(nodeInstanceId, setup -> mockContext);
 357
 358         doThrow(new RuntimeException("mock error")).when(clusterSingletonServiceProvider)
 359                 .registerClusterSingletonService(mockContext);
 360
 361         netconfTopologyManager.init();
 362
 363         netconfTopologyManager.onDataTreeChanged(Arrays.asList(
 364                 new CustomTreeModification(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
 365                         nodeInstanceId), dataObjectModification)));
 366
 367         verify(clusterSingletonServiceProvider, times(3)).registerClusterSingletonService(mockContext);
 368         verify(mockContext).close();
 369         verifyNoMoreInteractions(mockListenerReg);
 370
 371         netconfTopologyManager.close();
 372         verifyNoMoreInteractions(mockContext);
 373     }
 374
 375     static class CustomTreeModification  implements DataTreeModification<Node> {
 376
 377         private final DataTreeIdentifier<Node> rootPath;
 378         private final DataObjectModification<Node> rootNode;
 379
 380         CustomTreeModification(final DataTreeIdentifier<Node> rootPath, final DataObjectModification<Node> rootNode) {
 381             this.rootPath = rootPath;
 382             this.rootNode = rootNode;
 383         }
 384
 385         @Nonnull
 386         @Override
 387         public DataTreeIdentifier<Node> getRootPath() {
 388             return rootPath;
 389         }
 390
 391         @Nonnull
 392         @Override
 393         public DataObjectModification<Node> getRootNode() {
 394             return rootNode;
 395         }
 396     }
 397 }