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                 .setSchemaless(false)
 115                 .build();
 116
 117         AbstractNetconfTopology.NetconfConnectorDTO connectorDTO = topology.createDeviceCommunicator(NODE_ID, testingNode);
 118         assertSame(connectorDTO.getFacade(), topology.getFacade());
 119     }
 120
 121     @Test
 122     public void testCreateKeepAliveSalFacade() {
 123         NetconfNode testingNode = new NetconfNodeBuilder()
 124                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 125                 .setPort(new PortNumber(9999))
 126                 .setReconnectOnChangedSchema(true)
 127                 .setDefaultRequestTimeoutMillis(1000L)
 128                 .setBetweenAttemptsTimeoutMillis(100)
 129                 .setKeepaliveDelay(1L)
 130                 .setSchemaless(false)
 131                 .build();
 132
 133         AbstractNetconfTopology.NetconfConnectorDTO connectorDTO = topology.createDeviceCommunicator(NODE_ID, testingNode);
 134         assertTrue(connectorDTO.getFacade() instanceof KeepaliveSalFacade);
 135     }
 136
 137     @Test
 138     public void testSetupSchemaResourceDTO() {
 139         NetconfNode testingNode = new NetconfNodeBuilder()
 140                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 141                 .setPort(new PortNumber(9999))
 142                 .setReconnectOnChangedSchema(true)
 143                 .setDefaultRequestTimeoutMillis(1000L)
 144                 .setBetweenAttemptsTimeoutMillis(100)
 145                 .setKeepaliveDelay(1000L).build();
 146
 147         NetconfDevice.SchemaResourcesDTO resultDTO = topology.setupSchemaCacheDTO(NODE_ID, testingNode);
 148         SharedSchemaRepository repo = (SharedSchemaRepository) resultDTO.getSchemaRegistry();
 149         assertEquals(repo.getIdentifier(), "sal-netconf-connector");
 150
 151         testingNode = new NetconfNodeBuilder()
 152                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 153                 .setPort(new PortNumber(9999))
 154                 .setReconnectOnChangedSchema(true)
 155                 .setDefaultRequestTimeoutMillis(1000L)
 156                 .setBetweenAttemptsTimeoutMillis(100)
 157                 .setKeepaliveDelay(1000L)
 158                 .setSchemaCacheDirectory("test-directory")
 159                 .build();
 160
 161         resultDTO = topology.setupSchemaCacheDTO(NODE_ID, testingNode);
 162         repo = (SharedSchemaRepository) resultDTO.getSchemaRegistry();
 163         assertEquals(repo.getIdentifier(), "test-directory");
 164     }
 165
 166     @Test
 167     public void testGetClientConfig() throws UnknownHostException {
 168         NetconfClientSessionListener listener = mock(NetconfClientSessionListener.class);
 169         Host host = new Host(new IpAddress(new Ipv4Address("127.0.0.1")));
 170         PortNumber portNumber = new PortNumber(9999);
 171         NetconfNode testingNode = new NetconfNodeBuilder()
 172                 .setConnectionTimeoutMillis(1000L)
 173                 .setDefaultRequestTimeoutMillis(2000L)
 174                 .setHost(host)
 175                 .setPort(portNumber)
 176                 .setCredentials(new LoginPasswordBuilder().setUsername("testuser").setPassword("testpassword").build())
 177                 .setTcpOnly(true)
 178                 .build();
 179         NetconfReconnectingClientConfiguration defaultClientConfig = topology.getClientConfig(listener, testingNode);
 180
 181         assertEquals(defaultClientConfig.getConnectionTimeoutMillis().longValue(), 1000L);
 182         assertEquals(defaultClientConfig.getAddress(), new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 9999));
 183         assertSame(defaultClientConfig.getSessionListener(), listener);
 184         assertEquals(defaultClientConfig.getAuthHandler().getUsername(), "testuser");
 185         assertEquals(defaultClientConfig.getProtocol(), NetconfClientConfiguration.NetconfClientProtocol.TCP);
 186     }
 187
 188     @Test
 189     public void testGetClientConfigNotSupportedCredentialsFail() {
 190         NetconfClientSessionListener listener = mock(NetconfClientSessionListener.class);
 191         Host host = new Host(new IpAddress(new Ipv4Address("127.0.0.1")));
 192         PortNumber portNumber = new PortNumber(9999);
 193
 194         Credentials notSupportedCredentials = new Credentials() {
 195             @Override
 196             public Class<? extends DataContainer> getImplementedInterface() {
 197                 return Credentials.class;
 198             }
 199         };
 200
 201         NetconfNode testingNode = new NetconfNodeBuilder()
 202                 .setConnectionTimeoutMillis(1000L)
 203                 .setDefaultRequestTimeoutMillis(2000L)
 204                 .setHost(host)
 205                 .setPort(portNumber)
 206                 .setCredentials(notSupportedCredentials)
 207                 .setTcpOnly(true)
 208                 .build();
 209         try {
 210             topology.getClientConfig(listener, testingNode);
 211             fail("Exception expected here.");
 212         } catch(Exception e) {
 213             assertTrue(e instanceof IllegalStateException);
 214         }
 215     }
 216
 217     @Test
 218     public void testConnectNode() {
 219         NetconfNode testingNode = new NetconfNodeBuilder()
 220                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 221                 .setPort(new PortNumber(9999))
 222                 .setReconnectOnChangedSchema(true)
 223                 .setDefaultRequestTimeoutMillis(1000L)
 224                 .setBetweenAttemptsTimeoutMillis(100)
 225                 .setKeepaliveDelay(1000L)
 226                 .setTcpOnly(true)
 227                 .setSchemaless(false)
 228                 .setCredentials(new LoginPasswordBuilder().setUsername("testuser").setPassword("testpassword").build())
 229                 .build();
 230         Node nd = mock(Node.class);
 231         when(nd.getAugmentation(NetconfNode.class)).thenReturn(testingNode);
 232         topology.connectNode(NODE_ID, nd);
 233         assertTrue(topology.activeConnectors.containsKey(NODE_ID));
 234     }
 235
 236     @Test
 237     public void testDisconnectNode() {
 238         NetconfNode testingNode = new NetconfNodeBuilder()
 239                 .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
 240                 .setPort(new PortNumber(9999))
 241                 .setReconnectOnChangedSchema(true)
 242                 .setDefaultRequestTimeoutMillis(1000L)
 243                 .setBetweenAttemptsTimeoutMillis(100)
 244                 .setKeepaliveDelay(1000L)
 245                 .setTcpOnly(true)
 246                 .setSchemaless(false)
 247                 .setCredentials(new LoginPasswordBuilder().setUsername("testuser").setPassword("testpassword").build())
 248                 .build();
 249         Node nd = mock(Node.class);
 250         when(nd.getAugmentation(NetconfNode.class)).thenReturn(testingNode);
 251         topology.connectNode(NODE_ID, nd);
 252         assertTrue(topology.activeConnectors.containsKey(NODE_ID));
 253         assertTrue(topology.disconnectNode(NODE_ID).isDone());
 254         assertTrue(!topology.activeConnectors.containsKey(NODE_ID));
 255         verify(topology.getFacade()).close();
 256     }
 257
 258     @Test
 259     public void testDisconnectNotConnectedNode() throws ExecutionException, InterruptedException {
 260         ListenableFuture disconnectFuture = topology.disconnectNode(NODE_ID);
 261         assertTrue(disconnectFuture.isDone());
 262         try {
 263             disconnectFuture.get();
 264             fail("Exception expected!");
 265         } catch(Exception e) {
 266             assertTrue(e instanceof ExecutionException);
 267             assertTrue(e.getCause() instanceof  IllegalStateException);
 268         }
 269     }
 270
 271     public static class TestingAbstractNetconfTopology extends AbstractNetconfTopology {
 272
 273         private RemoteDeviceHandler salFacade;
 274
 275         protected TestingAbstractNetconfTopology(String topologyId, NetconfClientDispatcher clientDispatcher,
 276                                                  BindingAwareBroker bindingAwareBroker, Broker domBroker,
 277                                                  EventExecutor eventExecutor, ScheduledThreadPool keepaliveExecutor,
 278                                                  ThreadPool processingExecutor,
 279                                                  SchemaRepositoryProvider schemaRepositoryProvider) {
 280             super(topologyId, clientDispatcher, bindingAwareBroker, domBroker, eventExecutor, keepaliveExecutor, processingExecutor, schemaRepositoryProvider);
 281             salFacade = mock(RemoteDeviceHandler.class);
 282         }
 283
 284         public RemoteDeviceHandler<NetconfSessionPreferences> getFacade() {
 285             return salFacade;
 286         }
 287
 288         @Override
 289         public void onSessionInitiated(BindingAwareBroker.ProviderContext session) {
 290
 291         }
 292
 293         @Override
 294         protected RemoteDeviceHandler<NetconfSessionPreferences> createSalFacade(RemoteDeviceId id, Broker domBroker, BindingAwareBroker bindingBroker) {
 295             return salFacade;
 296         }
 297
 298         @Override
 299         public TopologyMountPointFacade.ConnectionStatusListenerRegistration registerConnectionStatusListener(NodeId node, RemoteDeviceHandler<NetconfSessionPreferences> listener) {
 300             return null;
 301         }
 302
 303         @Override
 304         public void registerMountPoint(ActorContext context, NodeId nodeId) {
 305
 306         }
 307
 308         @Override
 309         public void registerMountPoint(ActorContext context, NodeId nodeId, ActorRef masterRef) {
 310
 311         }
 312
 313         @Override
 314         public void unregisterMountPoint(NodeId nodeId) {
 315
 316         }
 317     }
 318 }