import io.netty.util.concurrent.FailedFuture;
import io.netty.util.concurrent.Future;
import java.net.InetSocketAddress;
-import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netconf.client.NetconfClientSession;
import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.netconf.topology.spi.NetconfNodeUtils;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.osgi.service.component.annotations.Activate;
private final SchemaResourceManager schemaRepositoryProvider;
private final DataBroker dataBroker;
private final DOMMountPointService mountService;
- private final AAAEncryptionService encryptionService;
- private final CredentialProvider credentialProvider;
- private final SslHandlerFactoryProvider sslHandlerFactoryProvider;
+ private final NetconfClientConfigurationBuilderFactory builderFactory;
protected CallHomeTopology topology;
final ScheduledThreadPool keepaliveExecutor, final ThreadPool processingExecutor,
final SchemaResourceManager schemaRepositoryProvider, final BaseNetconfSchemas baseSchemas,
final DataBroker dataBroker, final DOMMountPointService mountService,
- final AAAEncryptionService encryptionService, final CredentialProvider credentialProvider,
- final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
+ final NetconfClientConfigurationBuilderFactory builderFactory) {
this(topologyId, eventExecutor, keepaliveExecutor, processingExecutor, schemaRepositoryProvider, baseSchemas,
- dataBroker, mountService, encryptionService, credentialProvider, sslHandlerFactoryProvider, null);
+ dataBroker, mountService, builderFactory, null);
}
@Activate
@Reference(target = "(type=global-netconf-processing-executor)") final ThreadPool processingExecutor,
@Reference final SchemaResourceManager schemaRepositoryProvider,
@Reference final BaseNetconfSchemas baseSchemas, @Reference final DataBroker dataBroker,
- @Reference final DOMMountPointService mountService, @Reference final AAAEncryptionService encryptionService,
- @Reference final CredentialProvider credentialProvider,
- @Reference final SslHandlerFactoryProvider sslHandlerFactoryProvider,
+ @Reference final DOMMountPointService mountService,
+ @Reference final NetconfClientConfigurationBuilderFactory builderFactory,
@Reference final DeviceActionFactory deviceActionFactory) {
this(NetconfNodeUtils.DEFAULT_TOPOLOGY_NAME, eventExecutor, keepaliveExecutor, processingExecutor,
- schemaRepositoryProvider, baseSchemas, dataBroker, mountService, encryptionService, credentialProvider,
- sslHandlerFactoryProvider, deviceActionFactory);
+ schemaRepositoryProvider, baseSchemas, dataBroker, mountService, builderFactory, deviceActionFactory);
}
public CallHomeMountDispatcher(final String topologyId, final EventExecutor eventExecutor,
final ScheduledThreadPool keepaliveExecutor, final ThreadPool processingExecutor,
final SchemaResourceManager schemaRepositoryProvider, final BaseNetconfSchemas baseSchemas,
final DataBroker dataBroker, final DOMMountPointService mountService,
- final AAAEncryptionService encryptionService, final CredentialProvider credentialProvider,
- final SslHandlerFactoryProvider sslHandlerFactoryProvider, final DeviceActionFactory deviceActionFactory) {
+ final NetconfClientConfigurationBuilderFactory builderFactory,
+ final DeviceActionFactory deviceActionFactory) {
this.topologyId = topologyId;
this.eventExecutor = eventExecutor;
this.keepaliveExecutor = keepaliveExecutor;
this.baseSchemas = requireNonNull(baseSchemas);
this.dataBroker = dataBroker;
this.mountService = mountService;
- this.encryptionService = encryptionService;
- this.credentialProvider = requireNonNull(credentialProvider);
- this.sslHandlerFactoryProvider = requireNonNull(sslHandlerFactoryProvider);
+ this.builderFactory = requireNonNull(builderFactory);
}
@Override
@VisibleForTesting
void createTopology() {
topology = new CallHomeTopology(topologyId, this, eventExecutor, keepaliveExecutor, processingExecutor,
- schemaRepositoryProvider, dataBroker, mountService, encryptionService, baseSchemas,
- deviceActionFactory, credentialProvider, sslHandlerFactoryProvider);
+ schemaRepositoryProvider, dataBroker, mountService, builderFactory, baseSchemas, deviceActionFactory);
}
@VisibleForTesting
import com.google.common.annotations.VisibleForTesting;
import io.netty.util.concurrent.EventExecutor;
-import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.topology.spi.AbstractNetconfTopology;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
final ThreadPool processingExecutor, final SchemaResourceManager schemaRepositoryProvider,
final DataBroker dataBroker, final DOMMountPointService mountPointService,
- final AAAEncryptionService encryptionService, final BaseNetconfSchemas baseSchemas,
- final DeviceActionFactory deviceActionFactory, final CredentialProvider credentialProvider,
- final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
+ final NetconfClientConfigurationBuilderFactory builderFactory, final BaseNetconfSchemas baseSchemas,
+ final DeviceActionFactory deviceActionFactory) {
super(topologyId, clientDispatcher, eventExecutor, keepaliveExecutor, processingExecutor,
- schemaRepositoryProvider, dataBroker, mountPointService, encryptionService, deviceActionFactory,
- baseSchemas, credentialProvider, sslHandlerFactoryProvider);
+ schemaRepositoryProvider, dataBroker, mountPointService, builderFactory, deviceActionFactory,
+ baseSchemas);
}
void disconnectNode(final NodeId nodeId) {
import java.net.UnknownHostException;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
import org.opendaylight.netconf.client.conf.NetconfClientConfigurationBuilder;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
private CallHomeMountSessionManager mockSessMgr;
private CallHomeTopology mockTopology;
private CallHomeProtocolSessionContext mockProtoSess;
- private AAAEncryptionService mockEncryptionService;
+ private NetconfClientConfigurationBuilderFactory mockBuilderFactory;
private BaseNetconfSchemas mockBaseSchemas;
- private CredentialProvider mockCredentialProvider;
- private SslHandlerFactoryProvider mockSslHandlerFactoryProvider;
@Before
public void setup() {
mockSessMgr = mock(CallHomeMountSessionManager.class);
mockTopology = mock(CallHomeTopology.class);
mockProtoSess = mock(CallHomeProtocolSessionContext.class);
- mockEncryptionService = mock(AAAEncryptionService.class);
+ mockBuilderFactory = mock(NetconfClientConfigurationBuilderFactory .class);
mockBaseSchemas = mock(BaseNetconfSchemas.class);
- mockCredentialProvider = mock(CredentialProvider.class);
- mockSslHandlerFactoryProvider = mock(SslHandlerFactoryProvider.class);
instance = new CallHomeMountDispatcher(topologyId, mockExecutor, mockKeepAlive,
mockProcessingExecutor, mockSchemaRepoProvider, mockBaseSchemas, mockDataBroker, mockMount,
- mockEncryptionService, mockCredentialProvider, mockSslHandlerFactoryProvider) {
+ mockBuilderFactory) {
@Override
CallHomeMountSessionManager sessionManager() {
return mockSessMgr;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.topology.spi.AbstractNetconfTopology;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.netconf.topology.spi.NetconfNodeUtils;
import org.opendaylight.netconf.topology.spi.NetconfTopologyRPCProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNodeTopologyService;
@Reference final SchemaResourceManager schemaRepositoryProvider, @Reference final DataBroker dataBroker,
@Reference final DOMMountPointService mountPointService,
@Reference final AAAEncryptionService encryptionService,
+ @Reference final NetconfClientConfigurationBuilderFactory builderFactory,
@Reference final RpcProviderService rpcProviderService, @Reference final BaseNetconfSchemas baseSchemas,
- @Reference final CredentialProvider credentialProvider,
- @Reference final SslHandlerFactoryProvider sslHandlerFactoryProvider,
@Reference final DeviceActionFactory deviceActionFactory) {
this(NetconfNodeUtils.DEFAULT_TOPOLOGY_NAME, clientDispatcher, eventExecutor, keepaliveExecutor,
processingExecutor, schemaRepositoryProvider, dataBroker, mountPointService, encryptionService,
- rpcProviderService, baseSchemas, credentialProvider, sslHandlerFactoryProvider, deviceActionFactory);
+ builderFactory, rpcProviderService, baseSchemas, deviceActionFactory);
}
public NetconfTopologyImpl(final String topologyId, final NetconfClientDispatcher clientDispatcher,
final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
final ThreadPool processingExecutor, final SchemaResourceManager schemaRepositoryProvider,
final DataBroker dataBroker, final DOMMountPointService mountPointService,
- final AAAEncryptionService encryptionService, final RpcProviderService rpcProviderService,
- final BaseNetconfSchemas baseSchemas, final CredentialProvider credentialProvider,
- final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
+ final AAAEncryptionService encryptionService, final NetconfClientConfigurationBuilderFactory builderFactory,
+ final RpcProviderService rpcProviderService, final BaseNetconfSchemas baseSchemas) {
this(topologyId, clientDispatcher, eventExecutor, keepaliveExecutor, processingExecutor,
- schemaRepositoryProvider, dataBroker, mountPointService, encryptionService, rpcProviderService,
- baseSchemas, credentialProvider, sslHandlerFactoryProvider, null);
+ schemaRepositoryProvider, dataBroker, mountPointService, encryptionService, builderFactory,
+ rpcProviderService, baseSchemas, null);
}
@SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR",
final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
final ThreadPool processingExecutor, final SchemaResourceManager schemaRepositoryProvider,
final DataBroker dataBroker, final DOMMountPointService mountPointService,
- final AAAEncryptionService encryptionService, final RpcProviderService rpcProviderService,
- final BaseNetconfSchemas baseSchemas, final CredentialProvider credentialProvider,
- final SslHandlerFactoryProvider sslHandlerFactoryProvider, final DeviceActionFactory deviceActionFactory) {
+ final AAAEncryptionService encryptionService, final NetconfClientConfigurationBuilderFactory builderFactory,
+ final RpcProviderService rpcProviderService, final BaseNetconfSchemas baseSchemas,
+ final DeviceActionFactory deviceActionFactory) {
super(topologyId, clientDispatcher, eventExecutor, keepaliveExecutor, processingExecutor,
- schemaRepositoryProvider, dataBroker, mountPointService, encryptionService, deviceActionFactory,
- baseSchemas, credentialProvider, sslHandlerFactoryProvider);
+ schemaRepositoryProvider, dataBroker, mountPointService, builderFactory, deviceActionFactory, baseSchemas);
LOG.debug("Registering datastore listener");
dtclReg = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(
*/
package org.opendaylight.netconf.topology.impl;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
-import org.opendaylight.netconf.client.NetconfClientSessionListener;
-import org.opendaylight.netconf.client.SslHandlerFactory;
-import org.opendaylight.netconf.client.conf.NetconfClientConfiguration.NetconfClientProtocol;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.client.mdsal.impl.DefaultBaseNetconfSchemas;
-import org.opendaylight.netconf.topology.spi.AbstractNetconfTopology;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.parameters.Protocol.Name;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.parameters.ProtocolBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.LoginPasswordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.parser.api.YangParserException;
@Mock
private RpcProviderService rpcProviderService;
@Mock
- private CredentialProvider credentialProvider;
- @Mock
- private SslHandlerFactoryProvider sslHandlerFactoryProvider;
+ private NetconfClientConfigurationBuilderFactory builderFactory;
@Mock
private WriteTransaction wtx;
topology = new TestingNetconfTopologyImpl(TOPOLOGY_ID, mockedClientDispatcher, mockedEventExecutor,
mockedKeepaliveExecutor, mockedProcessingExecutor, mockedResourceManager, dataBroker, mountPointService,
- encryptionService, rpcProviderService, credentialProvider, sslHandlerFactoryProvider);
+ encryptionService, builderFactory, rpcProviderService);
//verify initialization of topology
verify(wtx).merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, new TopologyKey(new TopologyId(TOPOLOGY_ID))).build(),
verify(spyTopology, times(2)).ensureNode(nn.build());
}
- @Test
- public void testGetClientConfig() {
- final NetconfClientSessionListener sessionListener = mock(NetconfClientSessionListener.class);
- final NetconfNodeBuilder nodeBuilder = new NetconfNodeBuilder()
- .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
- .setPort(new PortNumber(Uint16.valueOf(9999)))
- .setReconnectOnChangedSchema(true)
- .setDefaultRequestTimeoutMillis(Uint32.valueOf(1000))
- .setBetweenAttemptsTimeoutMillis(Uint16.valueOf(100))
- .setKeepaliveDelay(Uint32.valueOf(1000))
- .setCredentials(new LoginPasswordBuilder().setUsername("testuser").setPassword("testpassword").build())
- .setMaxConnectionAttempts(Uint32.ZERO)
- .setSleepFactor(Decimal64.valueOf("1.5"))
- .setConnectionTimeoutMillis(Uint32.valueOf(20000));
-
- final var configuration = spyTopology.getClientConfig(nodeBuilder.setTcpOnly(true).build(), NODE_ID)
- .withSessionListener(sessionListener).build();
- assertEquals(NetconfClientProtocol.TCP, configuration.getProtocol());
- assertNotNull(configuration.getAuthHandler());
- assertNull(configuration.getSslHandlerFactory());
-
- final var configuration2 = spyTopology.getClientConfig(nodeBuilder.setTcpOnly(false).build(), NODE_ID)
- .withSessionListener(sessionListener).build();
- assertEquals(NetconfClientProtocol.SSH, configuration2.getProtocol());
- assertNotNull(configuration2.getAuthHandler());
- assertNull(configuration2.getSslHandlerFactory());
-
- final var configuration3 = spyTopology.getClientConfig(
- nodeBuilder.setProtocol(new ProtocolBuilder().setName(Name.SSH).build()).build(), NODE_ID)
- .withSessionListener(sessionListener).build();
- assertEquals(NetconfClientProtocol.SSH, configuration3.getProtocol());
- assertNotNull(configuration3.getAuthHandler());
- assertNull(configuration3.getSslHandlerFactory());
-
- final var sslHandlerFactory = mock(SslHandlerFactory.class);
- doReturn(sslHandlerFactory).when(sslHandlerFactoryProvider).getSslHandlerFactory(null);
-
- final var configuration4 = spyTopology.getClientConfig(
- nodeBuilder.setProtocol(new ProtocolBuilder().setName(Name.TLS).build()).build(), NODE_ID)
- .withSessionListener(sessionListener).build();
- assertEquals(NetconfClientProtocol.TLS, configuration4.getProtocol());
- assertNull(configuration4.getAuthHandler());
- assertSame(sslHandlerFactory, configuration4.getSslHandlerFactory());
- }
-
public static class TestingNetconfTopologyImpl extends NetconfTopologyImpl {
private static final BaseNetconfSchemas BASE_SCHEMAS;
}
public TestingNetconfTopologyImpl(final String topologyId, final NetconfClientDispatcher clientDispatcher,
- final EventExecutor eventExecutor,
- final ScheduledThreadPool keepaliveExecutor,
- final ThreadPool processingExecutor,
- final SchemaResourceManager schemaRepositoryProvider,
- final DataBroker dataBroker, final DOMMountPointService mountPointService,
- final AAAEncryptionService encryptionService,
- final RpcProviderService rpcProviderService,
- final CredentialProvider credentialProvider,
- final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
+ final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
+ final ThreadPool processingExecutor, final SchemaResourceManager schemaRepositoryProvider,
+ final DataBroker dataBroker, final DOMMountPointService mountPointService,
+ final AAAEncryptionService encryptionService,
+ final NetconfClientConfigurationBuilderFactory builderFactory,
+ final RpcProviderService rpcProviderService) {
super(topologyId, clientDispatcher, eventExecutor, keepaliveExecutor, processingExecutor,
- schemaRepositoryProvider, dataBroker, mountPointService, encryptionService, rpcProviderService,
- BASE_SCHEMAS, credentialProvider, sslHandlerFactoryProvider, null);
+ schemaRepositoryProvider, dataBroker, mountPointService, encryptionService, builderFactory,
+ rpcProviderService, BASE_SCHEMAS);
}
@Override
// No-op
}
}
-
- @Test
- public void hideCredentialsTest() {
- final String userName = "admin";
- final String password = "pa$$word";
- final Node node = new NodeBuilder()
- .addAugmentation(new NetconfNodeBuilder()
- .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
- .setPort(new PortNumber(Uint16.valueOf(9999)))
- .setReconnectOnChangedSchema(true)
- .setDefaultRequestTimeoutMillis(Uint32.valueOf(1000))
- .setBetweenAttemptsTimeoutMillis(Uint16.valueOf(100))
- .setKeepaliveDelay(Uint32.valueOf(1000))
- .setTcpOnly(false)
- .setProtocol(new ProtocolBuilder().setName(Name.TLS).build())
- .setCredentials(new LoginPasswordBuilder()
- .setUsername(userName)
- .setPassword(password)
- .build())
- .build())
- .setNodeId(NodeId.getDefaultInstance("junos"))
- .build();
- final String transformedNetconfNode = AbstractNetconfTopology.hideCredentials(node);
- assertTrue(transformedNetconfNode.contains("credentials=***"));
- assertFalse(transformedNetconfNode.contains(userName));
- assertFalse(transformedNetconfNode.contains(password));
- }
}
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-testkit_2.13</artifactId>
</dependency>
+ <dependency>
+ <groupId>com.guicedee.services</groupId>
+ <artifactId>javax.inject</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
</project>
import com.google.common.util.concurrent.ListenableFuture;
import io.netty.util.concurrent.EventExecutor;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.netconf.topology.spi.NetconfNodeUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNode;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
final ThreadPool processingExecutor, final SchemaResourceManager schemaManager,
final DataBroker dataBroker, final DOMMountPointService mountPointService,
- final AAAEncryptionService encryptionService, final DeviceActionFactory deviceActionFactory,
- final BaseNetconfSchemas baseSchemas, final Timeout actorResponseWaitTime,
- final ServiceGroupIdentifier serviceGroupIdent, final NetconfTopologySetup setup,
- final CredentialProvider credentialProvider, final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
+ final NetconfClientConfigurationBuilderFactory builderFactory,
+ final DeviceActionFactory deviceActionFactory, final BaseNetconfSchemas baseSchemas,
+ final Timeout actorResponseWaitTime, final ServiceGroupIdentifier serviceGroupIdent,
+ final NetconfTopologySetup setup) {
this.serviceGroupIdent = requireNonNull(serviceGroupIdent);
remoteDeviceId = NetconfNodeUtils.toRemoteDeviceId(setup.getNode().getNodeId(),
setup.getNode().augmentation(NetconfNode.class));
topologySingleton = new NetconfTopologySingletonImpl(topologyId, clientDispatcher,
eventExecutor, keepaliveExecutor, processingExecutor, schemaManager, dataBroker, mountPointService,
- encryptionService, deviceActionFactory, baseSchemas, remoteDeviceId, setup, actorResponseWaitTime,
- credentialProvider, sslHandlerFactoryProvider);
+ builderFactory, deviceActionFactory, baseSchemas, remoteDeviceId, setup, actorResponseWaitTime);
}
@VisibleForTesting
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.topology.singleton.api.NetconfTopologySingletonService;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup.NetconfTopologySetupBuilder;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.netconf.topology.spi.NetconfNodeUtils;
import org.opendaylight.netconf.topology.spi.NetconfTopologyRPCProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNode;
private final AAAEncryptionService encryptionService;
private final RpcProviderService rpcProviderService;
private final DeviceActionFactory deviceActionFactory;
- private final CredentialProvider credentialProvider;
- private final SslHandlerFactoryProvider sslHandlerFactoryProvider;
+ private final NetconfClientConfigurationBuilderFactory builderFactory;
private final SchemaResourceManager resourceManager;
private ListenerRegistration<NetconfTopologyManager> dataChangeListenerRegistration;
private Registration rpcReg;
+
public NetconfTopologyManager(final BaseNetconfSchemas baseSchemas, final DataBroker dataBroker,
final DOMRpcProviderService rpcProviderRegistry,
final DOMActionProviderService actionProviderService,
final RpcProviderService rpcProviderService,
final DeviceActionFactory deviceActionFactory,
final SchemaResourceManager resourceManager,
- final CredentialProvider credentialProvider,
- final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
+ final NetconfClientConfigurationBuilderFactory builderFactory) {
this.baseSchemas = requireNonNull(baseSchemas);
this.dataBroker = requireNonNull(dataBroker);
this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
actionProviderRegistry = requireNonNull(actionProviderService);
this.clusterSingletonServiceProvider = requireNonNull(clusterSingletonServiceProvider);
this.keepaliveExecutor = keepaliveExecutor;
- this.keepaliveExecutorService = keepaliveExecutor.getExecutor();
+ keepaliveExecutorService = keepaliveExecutor.getExecutor();
this.processingExecutor = processingExecutor;
- this.processingExecutorService = MoreExecutors.listeningDecorator(processingExecutor.getExecutor());
+ processingExecutorService = MoreExecutors.listeningDecorator(processingExecutor.getExecutor());
actorSystem = requireNonNull(actorSystemProvider).getActorSystem();
this.eventExecutor = requireNonNull(eventExecutor);
this.clientDispatcher = requireNonNull(clientDispatcher);
this.rpcProviderService = requireNonNull(rpcProviderService);
this.deviceActionFactory = requireNonNull(deviceActionFactory);
this.resourceManager = requireNonNull(resourceManager);
- this.credentialProvider = requireNonNull(credentialProvider);
- this.sslHandlerFactoryProvider = requireNonNull(sslHandlerFactoryProvider);
+ this.builderFactory = requireNonNull(builderFactory);
}
// Blueprint init method
setup.getEventExecutor(), keepaliveExecutor,
processingExecutor, resourceManager,
dataBroker, mountPointService,
- encryptionService, deviceActionFactory,
+ builderFactory, deviceActionFactory,
baseSchemas, actorResponseWaitTime,
- serviceGroupIdent, setup, credentialProvider, sslHandlerFactoryProvider);
+ serviceGroupIdent, setup);
}
@Override
.setSchemaResourceDTO(resourceManager.getSchemaResources(netconfNode.getSchemaCacheDirectory(),
deviceId))
.setIdleTimeout(writeTxIdleTimeout)
- .setEncryptionService(encryptionService)
- .setCredentialProvider(credentialProvider)
- .setSslHandlerFactoryProvider(sslHandlerFactoryProvider)
.build();
}
}
import akka.pattern.Patterns;
import akka.util.Timeout;
import io.netty.util.concurrent.EventExecutor;
-import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceHandler;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.topology.singleton.impl.actors.NetconfNodeActor;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
import org.opendaylight.netconf.topology.singleton.messages.RefreshSetupMasterActorData;
import org.opendaylight.netconf.topology.spi.AbstractNetconfTopology;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
final ThreadPool processingExecutor, final SchemaResourceManager schemaManager,
final DataBroker dataBroker, final DOMMountPointService mountPointService,
- final AAAEncryptionService encryptionService, final DeviceActionFactory deviceActionFactory,
- final BaseNetconfSchemas baseSchemas, final RemoteDeviceId remoteDeviceId,
- final NetconfTopologySetup setup, final Timeout actorResponseWaitTime,
- final CredentialProvider credentialProvider, final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
+ final NetconfClientConfigurationBuilderFactory builderFactory,
+ final DeviceActionFactory deviceActionFactory, final BaseNetconfSchemas baseSchemas,
+ final RemoteDeviceId remoteDeviceId, final NetconfTopologySetup setup,
+ final Timeout actorResponseWaitTime) {
super(topologyId, clientDispatcher, eventExecutor, keepaliveExecutor, processingExecutor, schemaManager,
- dataBroker, mountPointService, encryptionService, deviceActionFactory, baseSchemas, credentialProvider,
- sslHandlerFactoryProvider);
+ dataBroker, mountPointService, builderFactory, deviceActionFactory, baseSchemas);
this.remoteDeviceId = remoteDeviceId;
this.setup = setup;
this.actorResponseWaitTime = actorResponseWaitTime;
import io.netty.util.concurrent.EventExecutor;
import java.time.Duration;
import java.util.concurrent.ScheduledExecutorService;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.mdsal.NetconfDevice;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private final String topologyId;
private final NetconfDevice.SchemaResourcesDTO schemaResourceDTO;
private final Duration idleTimeout;
- private final AAAEncryptionService encryptionService;
private final BaseNetconfSchemas baseSchemas;
- private final @NonNull CredentialProvider credentialProvider;
- private final @NonNull SslHandlerFactoryProvider sslHandlerFactoryProvider;
NetconfTopologySetup(final NetconfTopologySetupBuilder builder) {
clusterSingletonServiceProvider = builder.getClusterSingletonServiceProvider();
topologyId = builder.getTopologyId();
schemaResourceDTO = builder.getSchemaResourceDTO();
idleTimeout = builder.getIdleTimeout();
- encryptionService = builder.getEncryptionService();
baseSchemas = builder.getBaseSchemas();
- credentialProvider = builder.getCredentialProvider();
- sslHandlerFactoryProvider = builder.getSslHandlerFactoryProvider();
}
public ClusterSingletonServiceProvider getClusterSingletonServiceProvider() {
return idleTimeout;
}
- public AAAEncryptionService getEncryptionService() {
- return encryptionService;
- }
-
- public @NonNull CredentialProvider getCredentialProvider() {
- return credentialProvider;
- }
-
- public @NonNull SslHandlerFactoryProvider getSslHandlerFactoryProvider() {
- return sslHandlerFactoryProvider;
- }
-
public BaseNetconfSchemas getBaseSchemas() {
return baseSchemas;
}
private NetconfClientDispatcher netconfClientDispatcher;
private NetconfDevice.SchemaResourcesDTO schemaResourceDTO;
private Duration idleTimeout;
- private AAAEncryptionService encryptionService;
private BaseNetconfSchemas baseSchemas;
- private CredentialProvider credentialProvider;
- private SslHandlerFactoryProvider sslHandlerFactoryProvider;
public NetconfTopologySetupBuilder() {
return idleTimeout;
}
- AAAEncryptionService getEncryptionService() {
- return encryptionService;
- }
-
- public NetconfTopologySetupBuilder setEncryptionService(final AAAEncryptionService encryptionService) {
- this.encryptionService = encryptionService;
- return this;
- }
-
- @NonNull CredentialProvider getCredentialProvider() {
- return requireNonNull(credentialProvider);
- }
-
- public NetconfTopologySetupBuilder setCredentialProvider(final CredentialProvider credentialProvider) {
- this.credentialProvider = credentialProvider;
- return this;
- }
-
- @NonNull SslHandlerFactoryProvider getSslHandlerFactoryProvider() {
- return requireNonNull(sslHandlerFactoryProvider);
- }
-
- public NetconfTopologySetupBuilder setSslHandlerFactoryProvider(
- final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
- this.sslHandlerFactoryProvider = sslHandlerFactoryProvider;
- return this;
- }
-
public static NetconfTopologySetupBuilder create() {
return new NetconfTopologySetupBuilder();
}
interface="org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager"/>
<reference id="baseSchemas"
interface="org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas"/>
- <reference id="credentialProvider"
- interface="org.opendaylight.netconf.client.mdsal.api.CredentialProvider"/>
- <reference id="sslHandlerFactoryProvider"
- interface="org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider"/>
+ <reference id="builderFactory"
+ interface="org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory"/>
<reference id="encryptionService"
interface="org.opendaylight.aaa.encrypt.AAAEncryptionService" />
<argument ref="rpcProvider" />
<argument ref="deviceActionFactory"/>
<argument ref="schemaManager"/>
- <argument ref="credentialProvider"/>
- <argument ref="sslHandlerFactoryProvider"/>
+ <argument ref="builderFactory"/>
</bean>
<service ref="netconfTopologyManager"
interface="org.opendaylight.netconf.topology.singleton.api.NetconfTopologySingletonService"/>
import org.opendaylight.netconf.topology.singleton.impl.utils.ClusteringRpcException;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
+import org.opendaylight.netconf.topology.spi.DefaultNetconfClientConfigurationBuilderFactory;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
private final SettableFuture<NetconfTopologyContext> slaveNetconfTopologyContextFuture = SettableFuture.create();
private TransactionChain slaveTxChain;
+ private NetconfClientConfigurationBuilderFactory builderFactory;
private final EventExecutor eventExecutor = GlobalEventExecutor.INSTANCE;
private final Config config = new ConfigBuilder().setWriteTransactionIdleTimeout(Uint16.ZERO).build();
private EffectiveModelContext deviceSchemaContext;
}
};
+ builderFactory = new DefaultNetconfClientConfigurationBuilderFactory(mockEncryptionService, credentialProvider,
+ sslHandlerFactoryProvider);
+
setupMaster();
setupSlave();
mockRpcProviderRegistry, mockActionProviderRegistry, masterClusterSingletonServiceProvider,
mockKeepaliveExecutor, mockThreadPool, mockMasterActorSystemProvider, eventExecutor,
mockClientDispatcher, TOPOLOGY_ID, config, masterMountPointService, mockEncryptionService,
- mockRpcProviderService, deviceActionFactory, resourceManager, credentialProvider,
- sslHandlerFactoryProvider) {
+ mockRpcProviderService, deviceActionFactory, resourceManager, builderFactory) {
@Override
protected NetconfTopologyContext newNetconfTopologyContext(final NetconfTopologySetup setup,
final ServiceGroupIdentifier serviceGroupIdent, final Timeout actorResponseWaitTime,
mockActionProviderRegistry, mockSlaveClusterSingletonServiceProvider, mockKeepaliveExecutor, mockThreadPool,
mockSlaveActorSystemProvider, eventExecutor, mockClientDispatcher, TOPOLOGY_ID, config,
slaveMountPointService, mockEncryptionService, mockRpcProviderService, deviceActionFactory,
- resourceManager, credentialProvider, sslHandlerFactoryProvider) {
+ resourceManager, builderFactory) {
@Override
protected NetconfTopologyContext newNetconfTopologyContext(final NetconfTopologySetup setup,
final ServiceGroupIdentifier serviceGroupIdent, final Timeout actorResponseWaitTime,
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult;
import org.opendaylight.netconf.client.mdsal.NetconfDevice.SchemaResourcesDTO;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Actions;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Rpcs;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.netconf.topology.singleton.impl.actors.NetconfNodeActor;
import org.opendaylight.netconf.topology.singleton.impl.utils.ClusteringActionException;
private EffectiveModelContext mockSchemaContext;
@Mock
private SchemaResourcesDTO schemaResourceDTO;
- @Mock
- private CredentialProvider credentialProvider;
- @Mock
- private SslHandlerFactoryProvider sslHandlerFactoryProvider;
@Before
public void setup() {
.setIdleTimeout(Duration.ofSeconds(1))
.setSchemaResourceDTO(schemaResourceDTO)
.setBaseSchemas(BASE_SCHEMAS)
- .setCredentialProvider(credentialProvider)
- .setSslHandlerFactoryProvider(sslHandlerFactoryProvider)
.build();
final Props props = NetconfNodeActor.props(setup, remoteDeviceId, TIMEOUT, mockMountPointService);
.setBaseSchemas(BASE_SCHEMAS)
.setSchemaResourceDTO(schemaResourceDTO)
.setActorSystem(system)
- .setCredentialProvider(credentialProvider)
- .setSslHandlerFactoryProvider(sslHandlerFactoryProvider)
.build();
masterRef.tell(new RefreshSetupMasterActorData(newSetup, newRemoteDeviceId), testKit.getRef());
.setSchemaResourceDTO(schemaResourceDTO2)
.setBaseSchemas(BASE_SCHEMAS)
.setActorSystem(system)
- .setCredentialProvider(credentialProvider)
- .setSslHandlerFactoryProvider(sslHandlerFactoryProvider)
.build();
final ActorRef slaveRef = system.actorOf(NetconfNodeActor.props(setup, remoteDeviceId, TIMEOUT,
.setSchemaResourceDTO(schemaResourceDTO2)
.setIdleTimeout(Duration.ofSeconds(1))
.setBaseSchemas(BASE_SCHEMAS)
- .setCredentialProvider(credentialProvider)
- .setSslHandlerFactoryProvider(sslHandlerFactoryProvider)
.build();
final Props props = NetconfNodeActor.props(setup, remoteDeviceId, TIMEOUT, mockMountPointService);
ActorRef actor = TestActorRef.create(system, props, "master_messages_2");
.setSchemaResourceDTO(schemaResourceDTO2)
.setActorSystem(system)
.setBaseSchemas(BASE_SCHEMAS)
- .setCredentialProvider(credentialProvider)
- .setSslHandlerFactoryProvider(sslHandlerFactoryProvider)
.build(), remoteDeviceId, TIMEOUT, mockMountPointService));
doReturn(Futures.immediateFuture(mockSchemaContext))
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.client.mdsal.NetconfDevice;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.NetconfDeviceSchemasResolver;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Actions;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Rpcs;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.netconf.topology.singleton.impl.actors.NetconfNodeActor;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
private NetconfDeviceSchemasResolver mockSchemasResolver;
@Mock
private EffectiveModelContextFactory mockSchemaContextFactory;
- @Mock
- private CredentialProvider credentialProvider;
- @Mock
- private SslHandlerFactoryProvider sslHandlerFactoryProvider;
private ActorSystem slaveSystem;
private ActorSystem masterSystem;
.setSchemaResourceDTO(new NetconfDevice.SchemaResourcesDTO(
masterSchemaRepository, masterSchemaRepository, mockSchemaContextFactory, mockSchemasResolver))
.setBaseSchemas(BASE_SCHEMAS)
- .setCredentialProvider(credentialProvider)
- .setSslHandlerFactoryProvider(sslHandlerFactoryProvider)
.build();
testMasterActorRef = TestActorRef.create(masterSystem, Props.create(TestMasterActor.class, masterSetup,
.setSchemaResourceDTO(new NetconfDevice.SchemaResourcesDTO(
slaveSchemaRepository, slaveSchemaRepository, mockSchemaContextFactory, mockSchemasResolver))
.setBaseSchemas(BASE_SCHEMAS)
- .setCredentialProvider(credentialProvider)
- .setSslHandlerFactoryProvider(sslHandlerFactoryProvider)
.build();
netconfNodeManager = new NetconfNodeManager(slaveSetup, DEVICE_ID, responseTimeout,
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
import org.opendaylight.netconf.client.mdsal.impl.DefaultSchemaResourceManager;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
+import org.opendaylight.netconf.topology.spi.NetconfClientConfigurationBuilderFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
final AAAEncryptionService encryptionService = mock(AAAEncryptionService.class);
final DeviceActionFactory deviceActionFactory = mock(DeviceActionFactory.class);
final RpcProviderService rpcProviderService = mock(RpcProviderService.class);
- final CredentialProvider credentialProvider = mock(CredentialProvider.class);
- final SslHandlerFactoryProvider sslHandlerFactoryProvider = mock(SslHandlerFactoryProvider.class);
+ final NetconfClientConfigurationBuilderFactory builderFactory =
+ mock(NetconfClientConfigurationBuilderFactory.class);
final Config config = new ConfigBuilder().setWriteTransactionIdleTimeout(Uint16.ZERO).build();
netconfTopologyManager = new NetconfTopologyManager(BASE_SCHEMAS, dataBroker, rpcProviderRegistry,
actionProviderRegistry, clusterSingletonServiceProvider, keepaliveExecutor, processingThreadPool,
actorSystemProvider, eventExecutor, clientDispatcher, TOPOLOGY_ID, config,
mountPointService, encryptionService, rpcProviderService, deviceActionFactory,
- new DefaultSchemaResourceManager(new DefaultYangParserFactory()), credentialProvider,
- sslHandlerFactoryProvider) {
+ new DefaultSchemaResourceManager(new DefaultYangParserFactory()), builderFactory) {
@Override
protected NetconfTopologyContext newNetconfTopologyContext(final NetconfTopologySetup setup,
final ServiceGroupIdentifier serviceGroupIdent, final Timeout actorResponseWaitTime,
<packaging>bundle</packaging>
<dependencies>
+ <dependency>
+ <groupId>com.guicedee.services</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-encrypt-service</artifactId>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-client-mdsal</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
+ </dependency>
<dependency>
<groupId>org.awaitility</groupId>
import com.google.common.util.concurrent.MoreExecutors;
import io.netty.util.concurrent.EventExecutor;
import java.util.HashMap;
-import java.util.List;
import java.util.concurrent.ExecutionException;
import org.checkerframework.checker.lock.qual.Holding;
-import org.opendaylight.aaa.encrypt.AAAEncryptionService;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
-import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
-import org.opendaylight.netconf.client.conf.NetconfClientConfigurationBuilder;
-import org.opendaylight.netconf.client.mdsal.DatastoreBackedPublicKeyAuth;
import org.opendaylight.netconf.client.mdsal.api.BaseNetconfSchemas;
-import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
import org.opendaylight.netconf.client.mdsal.api.DeviceActionFactory;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceHandler;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.api.SchemaResourceManager;
-import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
-import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
-import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.LoginPasswordHandler;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.parameters.Protocol.Name;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.Credentials;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.KeyAuth;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.LoginPw;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.LoginPwUnencrypted;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.optional.rev221225.NetconfNodeAugmentedOptional;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
private final NetconfClientDispatcher clientDispatcher;
private final EventExecutor eventExecutor;
private final DeviceActionFactory deviceActionFactory;
- private final CredentialProvider credentialProvider;
- private final SslHandlerFactoryProvider sslHandlerFactoryProvider;
private final SchemaResourceManager schemaManager;
private final BaseNetconfSchemas baseSchemas;
+ private final NetconfClientConfigurationBuilderFactory builderFactory;
protected final ScheduledThreadPool keepaliveExecutor;
protected final ListeningExecutorService processingExecutor;
protected final DataBroker dataBroker;
protected final DOMMountPointService mountPointService;
protected final String topologyId;
- protected final AAAEncryptionService encryptionService;
protected AbstractNetconfTopology(final String topologyId, final NetconfClientDispatcher clientDispatcher,
- final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
- final ThreadPool processingExecutor, final SchemaResourceManager schemaManager,
- final DataBroker dataBroker, final DOMMountPointService mountPointService,
- final AAAEncryptionService encryptionService,
- final DeviceActionFactory deviceActionFactory,
- final BaseNetconfSchemas baseSchemas,
- final CredentialProvider credentialProvider,
- final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
+ final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
+ final ThreadPool processingExecutor, final SchemaResourceManager schemaManager, final DataBroker dataBroker,
+ final DOMMountPointService mountPointService, final NetconfClientConfigurationBuilderFactory builderFactory,
+ final DeviceActionFactory deviceActionFactory, final BaseNetconfSchemas baseSchemas) {
this.topologyId = requireNonNull(topologyId);
this.clientDispatcher = clientDispatcher;
this.eventExecutor = eventExecutor;
this.deviceActionFactory = deviceActionFactory;
this.dataBroker = requireNonNull(dataBroker);
this.mountPointService = mountPointService;
- this.encryptionService = encryptionService;
+ this.builderFactory = requireNonNull(builderFactory);
this.baseSchemas = requireNonNull(baseSchemas);
- this.credentialProvider = requireNonNull(credentialProvider);
- this.sslHandlerFactoryProvider = requireNonNull(sslHandlerFactoryProvider);
// FIXME: this should be a put(), as we are initializing and will be re-populating the datastore with all the
// devices. Whatever has been there before should be nuked to properly re-align lifecycle.
final var deviceSalFacade = createSalFacade(deviceId, netconfNode.requireLockDatastore());
final var nodeHandler = new NetconfNodeHandler(clientDispatcher, eventExecutor, keepaliveExecutor.getExecutor(),
baseSchemas, schemaManager, processingExecutor, deviceActionFactory,
- deviceSalFacade, deviceId, nodeId, netconfNode, nodeOptional, getClientConfig(netconfNode, nodeId));
+ deviceSalFacade, deviceId, nodeId, netconfNode, nodeOptional,
+ builderFactory.createClientConfigurationBuilder(nodeId, netconfNode));
// ... record it ...
activeConnectors.put(nodeId, nodeHandler);
return new NetconfTopologyDeviceSalFacade(deviceId, mountPointService, lockDatastore, dataBroker);
}
- @VisibleForTesting
- public NetconfClientConfigurationBuilder getClientConfig(final NetconfNode node, final NodeId nodeId) {
- final var builder = NetconfClientConfigurationBuilder.create();
-
- final var protocol = node.getProtocol();
- if (node.requireTcpOnly()) {
- builder.withProtocol(NetconfClientConfiguration.NetconfClientProtocol.TCP)
- .withAuthHandler(getHandlerFromCredentials(node.getCredentials()));
- } else if (protocol == null || protocol.getName() == Name.SSH) {
- builder.withProtocol(NetconfClientConfiguration.NetconfClientProtocol.SSH)
- .withAuthHandler(getHandlerFromCredentials(node.getCredentials()));
- } else if (protocol.getName() == Name.TLS) {
- builder.withProtocol(NetconfClientConfiguration.NetconfClientProtocol.TLS)
- .withSslHandlerFactory(sslHandlerFactoryProvider.getSslHandlerFactory(protocol.getSpecification()));
- } else {
- throw new IllegalStateException("Unsupported protocol type: " + protocol.getName());
- }
-
- final var helloCapabilities = node.getOdlHelloMessageCapabilities();
- if (helloCapabilities != null) {
- builder.withOdlHelloCapabilities(List.copyOf(helloCapabilities.requireCapability()));
- }
-
- return builder
- .withName(nodeId.getValue())
- .withAddress(NetconfNodeUtils.toInetSocketAddress(node))
- .withConnectionTimeoutMillis(node.requireConnectionTimeoutMillis().toJava());
- }
-
- private AuthenticationHandler getHandlerFromCredentials(final Credentials credentials) {
- if (credentials
- instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430
- .credentials.credentials.LoginPassword loginPassword) {
- return new LoginPasswordHandler(loginPassword.getUsername(), loginPassword.getPassword());
- }
- if (credentials instanceof LoginPwUnencrypted unencrypted) {
- final var loginPassword = unencrypted.getLoginPasswordUnencrypted();
- return new LoginPasswordHandler(loginPassword.getUsername(), loginPassword.getPassword());
- }
- if (credentials instanceof LoginPw loginPw) {
- final var loginPassword = loginPw.getLoginPassword();
- return new LoginPasswordHandler(loginPassword.getUsername(),
- encryptionService.decrypt(loginPassword.getPassword()));
- }
- if (credentials instanceof KeyAuth keyAuth) {
- final var keyPair = keyAuth.getKeyBased();
- return new DatastoreBackedPublicKeyAuth(keyPair.getUsername(), keyPair.getKeyId(), credentialProvider,
- encryptionService);
- }
- throw new IllegalStateException("Unsupported credential type: " + credentials.getClass());
- }
-
/**
* Hiding of private credentials from node configuration (credentials data is replaced by asterisks).
*
* @return String representation of node configuration with credentials replaced by asterisks.
*/
@VisibleForTesting
- public static final String hideCredentials(final Node nodeConfiguration) {
+ static final String hideCredentials(final Node nodeConfiguration) {
final var netconfNodeAugmentation = nodeConfiguration.augmentation(NetconfNode.class);
final var nodeCredentials = netconfNodeAugmentation.getCredentials().toString();
final var nodeConfigurationString = nodeConfiguration.toString();
--- /dev/null
+/*
+ * Copyright (c) 2023 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netconf.topology.spi;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.List;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.aaa.encrypt.AAAEncryptionService;
+import org.opendaylight.netconf.client.conf.NetconfClientConfiguration.NetconfClientProtocol;
+import org.opendaylight.netconf.client.conf.NetconfClientConfigurationBuilder;
+import org.opendaylight.netconf.client.mdsal.DatastoreBackedPublicKeyAuth;
+import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
+import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.LoginPasswordHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.parameters.Protocol.Name;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.Credentials;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.KeyAuth;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.LoginPassword;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.LoginPw;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.LoginPwUnencrypted;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNode;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+
+/**
+ * Default implementation of NetconfClientConfigurationBuildFactory.
+ */
+@Component
+@Singleton
+public final class DefaultNetconfClientConfigurationBuilderFactory implements NetconfClientConfigurationBuilderFactory {
+ private final SslHandlerFactoryProvider sslHandlerFactoryProvider;
+ private final AAAEncryptionService encryptionService;
+ private final CredentialProvider credentialProvider;
+
+ @Inject
+ @Activate
+ public DefaultNetconfClientConfigurationBuilderFactory(
+ @Reference final AAAEncryptionService encryptionService,
+ @Reference final CredentialProvider credentialProvider,
+ @Reference final SslHandlerFactoryProvider sslHandlerFactoryProvider) {
+ this.encryptionService = requireNonNull(encryptionService);
+ this.credentialProvider = requireNonNull(credentialProvider);
+ this.sslHandlerFactoryProvider = requireNonNull(sslHandlerFactoryProvider);
+ }
+
+ @Override
+ public NetconfClientConfigurationBuilder createClientConfigurationBuilder(final NodeId nodeId,
+ final NetconfNode node) {
+ final var builder = NetconfClientConfigurationBuilder.create();
+
+ final var protocol = node.getProtocol();
+ if (node.requireTcpOnly()) {
+ builder.withProtocol(NetconfClientProtocol.TCP)
+ .withAuthHandler(getHandlerFromCredentials(node.getCredentials()));
+ } else if (protocol == null || protocol.getName() == Name.SSH) {
+ builder.withProtocol(NetconfClientProtocol.SSH)
+ .withAuthHandler(getHandlerFromCredentials(node.getCredentials()));
+ } else if (protocol.getName() == Name.TLS) {
+ builder.withProtocol(NetconfClientProtocol.TLS)
+ .withSslHandlerFactory(sslHandlerFactoryProvider.getSslHandlerFactory(protocol.getSpecification()));
+ } else {
+ throw new IllegalArgumentException("Unsupported protocol type: " + protocol.getName());
+ }
+
+ final var helloCapabilities = node.getOdlHelloMessageCapabilities();
+ if (helloCapabilities != null) {
+ builder.withOdlHelloCapabilities(List.copyOf(helloCapabilities.requireCapability()));
+ }
+
+ return builder
+ .withName(nodeId.getValue())
+ .withAddress(NetconfNodeUtils.toInetSocketAddress(node))
+ .withConnectionTimeoutMillis(node.requireConnectionTimeoutMillis().toJava());
+ }
+
+ private @NonNull AuthenticationHandler getHandlerFromCredentials(final Credentials credentials) {
+ if (credentials instanceof LoginPassword loginPassword) {
+ return new LoginPasswordHandler(loginPassword.getUsername(), loginPassword.getPassword());
+ } else if (credentials instanceof LoginPwUnencrypted unencrypted) {
+ final var loginPassword = unencrypted.getLoginPasswordUnencrypted();
+ return new LoginPasswordHandler(loginPassword.getUsername(), loginPassword.getPassword());
+ } else if (credentials instanceof LoginPw loginPw) {
+ final var loginPassword = loginPw.getLoginPassword();
+ return new LoginPasswordHandler(loginPassword.getUsername(),
+ encryptionService.decrypt(loginPassword.getPassword()));
+ } else if (credentials instanceof KeyAuth keyAuth) {
+ final var keyPair = keyAuth.getKeyBased();
+ return new DatastoreBackedPublicKeyAuth(keyPair.getUsername(), keyPair.getKeyId(), credentialProvider,
+ encryptionService);
+ } else {
+ throw new IllegalArgumentException("Unsupported credential type: " + credentials.getClass());
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2023 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netconf.topology.spi;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.netconf.client.conf.NetconfClientConfigurationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNode;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+
+/**
+ * Factory for creating {@link NetconfClientConfigurationBuilder}s.
+ */
+public interface NetconfClientConfigurationBuilderFactory {
+ /**
+ * Create a new {@link NetconfClientConfigurationBuilder} initialized based on configuration {@link NetconfNode}.
+ *
+ * @param nodeId A topology node identifier
+ * @param node A {@link NetconfNode}
+ * @return An initialized {@link NetconfClientConfigurationBuilder}
+ */
+ @NonNull NetconfClientConfigurationBuilder createClientConfigurationBuilder(@NonNull NodeId nodeId,
+ @NonNull NetconfNode node);
+}
--- /dev/null
+/*
+ * Copyright (c) 2023 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netconf.topology.spi;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.parameters.Protocol.Name;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.parameters.ProtocolBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.LoginPasswordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
+
+public class AbstractNetconfTopologyTest {
+ @Test
+ public void hideCredentialsTest() {
+ final String userName = "admin";
+ final String password = "pa$$word";
+ final Node node = new NodeBuilder()
+ .addAugmentation(new NetconfNodeBuilder()
+ .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
+ .setPort(new PortNumber(Uint16.valueOf(9999)))
+ .setReconnectOnChangedSchema(true)
+ .setDefaultRequestTimeoutMillis(Uint32.valueOf(1000))
+ .setBetweenAttemptsTimeoutMillis(Uint16.valueOf(100))
+ .setKeepaliveDelay(Uint32.valueOf(1000))
+ .setTcpOnly(false)
+ .setProtocol(new ProtocolBuilder().setName(Name.TLS).build())
+ .setCredentials(new LoginPasswordBuilder()
+ .setUsername(userName)
+ .setPassword(password)
+ .build())
+ .build())
+ .setNodeId(NodeId.getDefaultInstance("junos"))
+ .build();
+ final String transformedNetconfNode = AbstractNetconfTopology.hideCredentials(node);
+ assertTrue(transformedNetconfNode.contains("credentials=***"));
+ assertFalse(transformedNetconfNode.contains(userName));
+ assertFalse(transformedNetconfNode.contains(password));
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2023 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netconf.topology.spi;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.doReturn;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.aaa.encrypt.AAAEncryptionService;
+import org.opendaylight.netconf.client.NetconfClientSessionListener;
+import org.opendaylight.netconf.client.SslHandlerFactory;
+import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
+import org.opendaylight.netconf.client.conf.NetconfClientConfiguration.NetconfClientProtocol;
+import org.opendaylight.netconf.client.mdsal.api.CredentialProvider;
+import org.opendaylight.netconf.client.mdsal.api.SslHandlerFactoryProvider;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.parameters.Protocol.Name;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.parameters.ProtocolBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.credentials.credentials.LoginPasswordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev221225.NetconfNodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yangtools.yang.common.Decimal64;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
+
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
+public class DefaultNetconfClientConfigurationBuilderFactoryTest {
+ private static final NodeId NODE_ID = new NodeId("testing-node");
+
+ @Mock
+ private NetconfClientSessionListener sessionListener;
+ @Mock
+ private AAAEncryptionService encryptionService;
+ @Mock
+ private CredentialProvider credentialProvider;
+ @Mock
+ private SslHandlerFactoryProvider sslHandlerFactoryProvider;
+ @Mock
+ private SslHandlerFactory sslHandlerFactory;
+
+ private final NetconfNodeBuilder nodeBuilder = new NetconfNodeBuilder()
+ .setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
+ .setPort(new PortNumber(Uint16.valueOf(9999)))
+ .setReconnectOnChangedSchema(true)
+ .setDefaultRequestTimeoutMillis(Uint32.valueOf(1000))
+ .setBetweenAttemptsTimeoutMillis(Uint16.valueOf(100))
+ .setKeepaliveDelay(Uint32.valueOf(1000))
+ .setCredentials(new LoginPasswordBuilder().setUsername("testuser").setPassword("testpassword").build())
+ .setMaxConnectionAttempts(Uint32.ZERO)
+ .setSleepFactor(Decimal64.valueOf("1.5"))
+ .setConnectionTimeoutMillis(Uint32.valueOf(20000));
+
+ private DefaultNetconfClientConfigurationBuilderFactory factory;
+
+ @Before
+ public void before() {
+ doReturn(sslHandlerFactory).when(sslHandlerFactoryProvider).getSslHandlerFactory(null);
+
+ factory = new DefaultNetconfClientConfigurationBuilderFactory(encryptionService, credentialProvider,
+ sslHandlerFactoryProvider);
+ }
+
+ @Test
+ public void testDefault() {
+ final var config = createConfig(nodeBuilder.setTcpOnly(false).build());
+ assertEquals(NetconfClientProtocol.SSH, config.getProtocol());
+ assertNotNull(config.getAuthHandler());
+ assertNull(config.getSslHandlerFactory());
+ }
+
+ @Test
+ public void testSsh() {
+ final var config = createConfig(
+ nodeBuilder.setTcpOnly(false).setProtocol(new ProtocolBuilder().setName(Name.SSH).build()).build());
+ assertEquals(NetconfClientProtocol.SSH, config.getProtocol());
+ assertNotNull(config.getAuthHandler());
+ assertNull(config.getSslHandlerFactory());
+ }
+
+ @Test
+ public void testTcp() {
+ final var config = createConfig(nodeBuilder.setTcpOnly(true).build());
+ assertEquals(NetconfClientProtocol.TCP, config.getProtocol());
+ assertNotNull(config.getAuthHandler());
+ assertNull(config.getSslHandlerFactory());
+ }
+
+ @Test
+ public void testTls() {
+ final var config = createConfig(
+ nodeBuilder.setTcpOnly(false).setProtocol(new ProtocolBuilder().setName(Name.TLS).build()).build());
+ assertEquals(NetconfClientProtocol.TLS, config.getProtocol());
+ assertNull(config.getAuthHandler());
+ assertSame(sslHandlerFactory, config.getSslHandlerFactory());
+ }
+
+ private NetconfClientConfiguration createConfig(final NetconfNode netconfNode) {
+ return factory.createClientConfigurationBuilder(NODE_ID, netconfNode)
+ .withSessionListener(sessionListener)
+ .build();
+ }
+}
Code Review / netconf.git / commitdiff