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