netconf/netconf-topology/src/test/java/org/opendaylight/netconf/topology/AbstractNetconfTopologyTest.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;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertSame;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.junit.Assert.fail;
  15 import static org.mockito.Matchers.any;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.verify;
  18 import static org.mockito.Mockito.when;
  19
  20 import akka.actor.ActorContext;
  21 import akka.actor.ActorRef;
  22 import com.google.common.util.concurrent.ListenableFuture;
  23 import com.google.common.util.concurrent.MoreExecutors;
  24 import io.netty.util.concurrent.EventExecutor;
  25 import io.netty.util.concurrent.Future;
  26 import io.netty.util.concurrent.ImmediateEventExecutor;
  27 import io.netty.util.concurrent.SucceededFuture;
  28 import java.net.InetAddress;
  29 import java.net.InetSocketAddress;
  30 import java.net.UnknownHostException;
  31 import java.util.concurrent.ExecutionException;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.mockito.Mock;
  35 import org.mockito.MockitoAnnotations;
  36 import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
  37 import org.opendaylight.controller.config.threadpool.ThreadPool;
  38 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  39 import org.opendaylight.controller.sal.core.api.Broker;
  40 import org.opendaylight.netconf.client.NetconfClientDispatcher;
  41 import org.opendaylight.netconf.client.NetconfClientSessionListener;
  42 import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
  43 import org.opendaylight.netconf.client.conf.NetconfReconnectingClientConfiguration;
  44 import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
  45 import org.opendaylight.netconf.sal.connect.netconf.NetconfDevice;
  46 import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
  47 import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
  48 import org.opendaylight.netconf.sal.connect.netconf.sal.KeepaliveSalFacade;
  49 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
  50 import org.opendaylight.netconf.topology.pipeline.TopologyMountPointFacade;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Host;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.credentials.Credentials;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.credentials.credentials.LoginPasswordBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  60 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  61 import org.opendaylight.yangtools.yang.binding.DataContainer;
  62 import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
  63
  64 public class AbstractNetconfTopologyTest {
  65
  66     private static final NodeId NODE_ID = new NodeId("testing-node");
  67     private static final String TOPOLOGY_ID = "testing-topology";
  68
  69     @Mock
  70     private Broker mockedDataBroker;
  71
  72     @Mock
  73     private NetconfClientDispatcher mockedClientDispatcher;
  74
  75     @Mock
  76     private BindingAwareBroker mockedBindingAwareBroker;
  77
  78     @Mock
  79     private EventExecutor mockedEventExecutor;
  80
  81     @Mock
  82     private ScheduledThreadPool mockedKeepaliveExecutor;
  83
  84     @Mock
  85     private ThreadPool mockedProcessingExecutor;
  86
  87     @Mock
  88     private SchemaRepositoryProvider mockedSchemaRepositoryProvider;
  89
  90
  91     private TestingAbstractNetconfTopology topology;
  92
  93     @Before
  94     public void setUp() {
  95         MockitoAnnotations.initMocks(this);
  96
  97         when(mockedSchemaRepositoryProvider.getSharedSchemaRepository()).thenReturn(new SharedSchemaRepository("testingSharedSchemaRepo"));
  98         when(mockedProcessingExecutor.getExecutor()).thenReturn(MoreExecutors.newDirectExecutorService());
  99         Future<Void> future = new SucceededFuture<>(ImmediateEventExecutor.INSTANCE, null);
 100         when(mockedClientDispatcher.createReconnectingClient(any(NetconfReconnectingClientConfiguration.class))).thenReturn(future);
 101
 102         topology = new TestingAbstractNetconfTopology(TOPOLOGY_ID, mockedClientDispatcher, mockedBindingAwareBroker,
 103                 mockedDataBroker, mockedEventExecutor, mockedKeepaliveExecutor, mockedProcessingExecutor, mockedSchemaRepositoryProvider);
 104     }
 105
 106     @Test
 107     public void testCreateSalFacade() {
 108         NetconfNode testingNode = new NetconfNodeBuilder()
 109                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 110                 .setPort(new PortNumber(9999))
 111                 .setReconnectOnChangedSchema(true)
 112                 .setDefaultRequestTimeoutMillis(1000L)
 113                 .setBetweenAttemptsTimeoutMillis(100)
 114                 .build();
 115
 116         AbstractNetconfTopology.NetconfConnectorDTO connectorDTO = topology.createDeviceCommunicator(NODE_ID, testingNode);
 117         assertSame(connectorDTO.getFacade(), topology.getFacade());
 118     }
 119
 120     @Test
 121     public void testCreateKeepAliveSalFacade() {
 122         NetconfNode testingNode = new NetconfNodeBuilder()
 123                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 124                 .setPort(new PortNumber(9999))
 125                 .setReconnectOnChangedSchema(true)
 126                 .setDefaultRequestTimeoutMillis(1000L)
 127                 .setBetweenAttemptsTimeoutMillis(100)
 128                 .setKeepaliveDelay(1L)
 129                 .build();
 130
 131         AbstractNetconfTopology.NetconfConnectorDTO connectorDTO = topology.createDeviceCommunicator(NODE_ID, testingNode);
 132         assertTrue(connectorDTO.getFacade() instanceof KeepaliveSalFacade);
 133     }
 134
 135     @Test
 136     public void testSetupSchemaResourceDTO() {
 137         NetconfNode testingNode = new NetconfNodeBuilder()
 138                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 139                 .setPort(new PortNumber(9999))
 140                 .setReconnectOnChangedSchema(true)
 141                 .setDefaultRequestTimeoutMillis(1000L)
 142                 .setBetweenAttemptsTimeoutMillis(100)
 143                 .setKeepaliveDelay(1000L).build();
 144
 145         NetconfDevice.SchemaResourcesDTO resultDTO = topology.setupSchemaCacheDTO(NODE_ID, testingNode);
 146         SharedSchemaRepository repo = (SharedSchemaRepository) resultDTO.getSchemaRegistry();
 147         assertEquals(repo.getIdentifier(), "sal-netconf-connector");
 148
 149         testingNode = new NetconfNodeBuilder()
 150                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 151                 .setPort(new PortNumber(9999))
 152                 .setReconnectOnChangedSchema(true)
 153                 .setDefaultRequestTimeoutMillis(1000L)
 154                 .setBetweenAttemptsTimeoutMillis(100)
 155                 .setKeepaliveDelay(1000L)
 156                 .setSchemaCacheDirectory("test-directory")
 157                 .build();
 158
 159         resultDTO = topology.setupSchemaCacheDTO(NODE_ID, testingNode);
 160         repo = (SharedSchemaRepository) resultDTO.getSchemaRegistry();
 161         assertEquals(repo.getIdentifier(), "test-directory");
 162     }
 163
 164     @Test
 165     public void testGetClientConfig() throws UnknownHostException {
 166         NetconfClientSessionListener listener = mock(NetconfClientSessionListener.class);
 167         Host host = new Host(new IpAddress(new Ipv4Address("127.0.0.1")));
 168         PortNumber portNumber = new PortNumber(9999);
 169         NetconfNode testingNode = new NetconfNodeBuilder()
 170                 .setConnectionTimeoutMillis(1000L)
 171                 .setDefaultRequestTimeoutMillis(2000L)
 172                 .setHost(host)
 173                 .setPort(portNumber)
 174                 .setCredentials(new LoginPasswordBuilder().setUsername("testuser").setPassword("testpassword").build())
 175                 .setTcpOnly(true)
 176                 .build();
 177         NetconfReconnectingClientConfiguration defaultClientConfig = topology.getClientConfig(listener, testingNode);
 178
 179         assertEquals(defaultClientConfig.getConnectionTimeoutMillis().longValue(), 1000L);
 180         assertEquals(defaultClientConfig.getAddress(), new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 9999));
 181         assertSame(defaultClientConfig.getSessionListener(), listener);
 182         assertEquals(defaultClientConfig.getAuthHandler().getUsername(), "testuser");
 183         assertEquals(defaultClientConfig.getProtocol(), NetconfClientConfiguration.NetconfClientProtocol.TCP);
 184     }
 185
 186     @Test
 187     public void testGetClientConfigNotSupportedCredentialsFail() {
 188         NetconfClientSessionListener listener = mock(NetconfClientSessionListener.class);
 189         Host host = new Host(new IpAddress(new Ipv4Address("127.0.0.1")));
 190         PortNumber portNumber = new PortNumber(9999);
 191
 192         Credentials notSupportedCredentials = new Credentials() {
 193             @Override
 194             public Class<? extends DataContainer> getImplementedInterface() {
 195                 return Credentials.class;
 196             }
 197         };
 198
 199         NetconfNode testingNode = new NetconfNodeBuilder()
 200                 .setConnectionTimeoutMillis(1000L)
 201                 .setDefaultRequestTimeoutMillis(2000L)
 202                 .setHost(host)
 203                 .setPort(portNumber)
 204                 .setCredentials(notSupportedCredentials)
 205                 .setTcpOnly(true)
 206                 .build();
 207         try {
 208             topology.getClientConfig(listener, testingNode);
 209             fail("Exception expected here.");
 210         } catch(Exception e) {
 211             assertTrue(e instanceof IllegalStateException);
 212         }
 213     }
 214
 215     @Test
 216     public void testConnectNode() {
 217         NetconfNode testingNode = new NetconfNodeBuilder()
 218                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 219                 .setPort(new PortNumber(9999))
 220                 .setReconnectOnChangedSchema(true)
 221                 .setDefaultRequestTimeoutMillis(1000L)
 222                 .setBetweenAttemptsTimeoutMillis(100)
 223                 .setKeepaliveDelay(1000L)
 224                 .setTcpOnly(true)
 225                 .setCredentials(new LoginPasswordBuilder().setUsername("testuser").setPassword("testpassword").build())
 226                 .build();
 227         Node nd = mock(Node.class);
 228         when(nd.getAugmentation(NetconfNode.class)).thenReturn(testingNode);
 229         topology.connectNode(NODE_ID, nd);
 230         assertTrue(topology.activeConnectors.containsKey(NODE_ID));
 231     }
 232
 233     @Test
 234     public void testDisconnectNode() {
 235         NetconfNode testingNode = new NetconfNodeBuilder()
 236                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 237                 .setPort(new PortNumber(9999))
 238                 .setReconnectOnChangedSchema(true)
 239                 .setDefaultRequestTimeoutMillis(1000L)
 240                 .setBetweenAttemptsTimeoutMillis(100)
 241                 .setKeepaliveDelay(1000L)
 242                 .setTcpOnly(true)
 243                 .setCredentials(new LoginPasswordBuilder().setUsername("testuser").setPassword("testpassword").build())
 244                 .build();
 245         Node nd = mock(Node.class);
 246         when(nd.getAugmentation(NetconfNode.class)).thenReturn(testingNode);
 247         topology.connectNode(NODE_ID, nd);
 248         assertTrue(topology.activeConnectors.containsKey(NODE_ID));
 249         assertTrue(topology.disconnectNode(NODE_ID).isDone());
 250         assertTrue(!topology.activeConnectors.containsKey(NODE_ID));
 251         verify(topology.getFacade()).close();
 252     }
 253
 254     @Test
 255     public void testDisconnectNotConnectedNode() throws ExecutionException, InterruptedException {
 256         ListenableFuture disconnectFuture = topology.disconnectNode(NODE_ID);
 257         assertTrue(disconnectFuture.isDone());
 258         try {
 259             disconnectFuture.get();
 260             fail("Exception expected!");
 261         } catch(Exception e) {
 262             assertTrue(e instanceof ExecutionException);
 263             assertTrue(e.getCause() instanceof  IllegalStateException);
 264         }
 265     }
 266
 267     public static class TestingAbstractNetconfTopology extends AbstractNetconfTopology {
 268
 269         private RemoteDeviceHandler salFacade;
 270
 271         protected TestingAbstractNetconfTopology(String topologyId, NetconfClientDispatcher clientDispatcher,
 272                                                  BindingAwareBroker bindingAwareBroker, Broker domBroker,
 273                                                  EventExecutor eventExecutor, ScheduledThreadPool keepaliveExecutor,
 274                                                  ThreadPool processingExecutor,
 275                                                  SchemaRepositoryProvider schemaRepositoryProvider) {
 276             super(topologyId, clientDispatcher, bindingAwareBroker, domBroker, eventExecutor, keepaliveExecutor, processingExecutor, schemaRepositoryProvider);
 277             salFacade = mock(RemoteDeviceHandler.class);
 278         }
 279
 280         public RemoteDeviceHandler<NetconfSessionPreferences> getFacade() {
 281             return salFacade;
 282         }
 283
 284         @Override
 285         public void onSessionInitiated(BindingAwareBroker.ProviderContext session) {
 286
 287         }
 288
 289         @Override
 290         protected RemoteDeviceHandler<NetconfSessionPreferences> createSalFacade(RemoteDeviceId id, Broker domBroker, BindingAwareBroker bindingBroker) {
 291             return salFacade;
 292         }
 293
 294         @Override
 295         public TopologyMountPointFacade.ConnectionStatusListenerRegistration registerConnectionStatusListener(NodeId node, RemoteDeviceHandler<NetconfSessionPreferences> listener) {
 296             return null;
 297         }
 298
 299         @Override
 300         public void registerMountPoint(ActorContext context, NodeId nodeId) {
 301
 302         }
 303
 304         @Override
 305         public void registerMountPoint(ActorContext context, NodeId nodeId, ActorRef masterRef) {
 306
 307         }
 308
 309         @Override
 310         public void unregisterMountPoint(NodeId nodeId) {
 311
 312         }
 313     }
 314 }