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