2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.netconf.test.tool;
10 import static java.util.Objects.requireNonNullElseGet;
12 import com.google.common.collect.Collections2;
13 import com.google.common.collect.ImmutableList;
14 import com.google.common.util.concurrent.Futures;
15 import java.io.Closeable;
16 import java.io.IOException;
17 import java.net.InetAddress;
18 import java.net.ServerSocket;
19 import java.net.UnknownHostException;
20 import java.util.ArrayList;
21 import java.util.HashSet;
22 import java.util.List;
23 import java.util.Optional;
25 import java.util.concurrent.ExecutionException;
26 import java.util.stream.IntStream;
27 import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
28 import org.opendaylight.netconf.api.CapabilityURN;
29 import org.opendaylight.netconf.api.TransportConstants;
30 import org.opendaylight.netconf.common.impl.DefaultNetconfTimer;
31 import org.opendaylight.netconf.server.ServerTransportInitializer;
32 import org.opendaylight.netconf.server.api.SessionIdProvider;
33 import org.opendaylight.netconf.server.api.monitoring.BasicCapability;
34 import org.opendaylight.netconf.server.api.monitoring.Capability;
35 import org.opendaylight.netconf.server.api.monitoring.NetconfMonitoringService;
36 import org.opendaylight.netconf.server.api.monitoring.YangModuleCapability;
37 import org.opendaylight.netconf.server.api.operations.NetconfOperationServiceFactory;
38 import org.opendaylight.netconf.server.impl.DefaultSessionIdProvider;
39 import org.opendaylight.netconf.server.osgi.AggregatedNetconfOperationServiceFactory;
40 import org.opendaylight.netconf.shaded.sshd.server.auth.UserAuthFactory;
41 import org.opendaylight.netconf.shaded.sshd.server.auth.password.UserAuthPasswordFactory;
42 import org.opendaylight.netconf.shaded.sshd.server.auth.pubkey.UserAuthPublicKeyFactory;
43 import org.opendaylight.netconf.test.tool.config.Configuration;
44 import org.opendaylight.netconf.test.tool.customrpc.SettableOperationProvider;
45 import org.opendaylight.netconf.test.tool.monitoring.NetconfMonitoringOperationServiceFactory;
46 import org.opendaylight.netconf.test.tool.operations.DefaultOperationsCreator;
47 import org.opendaylight.netconf.test.tool.operations.OperationsProvider;
48 import org.opendaylight.netconf.test.tool.rpchandler.SettableOperationRpcProvider;
49 import org.opendaylight.netconf.test.tool.schemacache.SchemaSourceCache;
50 import org.opendaylight.netconf.transport.api.TransportStack;
51 import org.opendaylight.netconf.transport.api.UnsupportedConfigurationException;
52 import org.opendaylight.netconf.transport.ssh.SSHTransportStackFactory;
53 import org.opendaylight.netconf.transport.ssh.ServerFactoryManagerConfigurator;
54 import org.opendaylight.netconf.transport.tcp.TCPServer;
55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.server.rev231228.netconf.server.listen.stack.grouping.transport.ssh.ssh.TcpServerParametersBuilder;
59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.tcp.server.rev231228.TcpServerGrouping;
60 import org.opendaylight.yangtools.yang.common.Revision;
61 import org.opendaylight.yangtools.yang.common.Uint16;
62 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
63 import org.opendaylight.yangtools.yang.model.api.Module;
64 import org.opendaylight.yangtools.yang.model.api.ModuleLike;
65 import org.opendaylight.yangtools.yang.model.api.Submodule;
66 import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
67 import org.opendaylight.yangtools.yang.model.api.source.SourceRepresentation;
68 import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
69 import org.opendaylight.yangtools.yang.model.repo.fs.FilesystemSchemaSourceCache;
70 import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
71 import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceListener;
72 import org.opendaylight.yangtools.yang.model.spi.source.URLYangTextSource;
73 import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
74 import org.opendaylight.yangtools.yang.parser.rfc7950.repo.TextToIRTransformer;
75 import org.slf4j.Logger;
76 import org.slf4j.LoggerFactory;
78 public class NetconfDeviceSimulator implements Closeable {
79 private static final Logger LOG = LoggerFactory.getLogger(NetconfDeviceSimulator.class);
81 private final DefaultNetconfTimer timer = new DefaultNetconfTimer();
82 private final Configuration configuration;
83 private final List<TransportStack> servers;
84 private final SSHTransportStackFactory sshStackFactory;
85 private EffectiveModelContext schemaContext;
87 private boolean sendFakeSchema = false;
89 public NetconfDeviceSimulator(final Configuration configuration) {
90 this.configuration = configuration;
91 servers = new ArrayList<>(configuration.getDeviceCount());
92 sshStackFactory = new SSHTransportStackFactory("netconf-device-simulator-threads",
93 configuration.getThreadPoolSize());
96 private ServerTransportInitializer createTransportInitializer(final Set<Capability> capabilities,
97 final YangTextSourceExtension sourceProvider) {
98 final var transformedCapabilities = new HashSet<>(Collections2.transform(capabilities, input -> {
100 sendFakeSchema = false;
101 return new FakeCapability((YangModuleCapability) input);
106 transformedCapabilities.add(new BasicCapability(CapabilityURN.CANDIDATE));
107 final var monitoringService1 = new DummyMonitoringService(transformedCapabilities);
108 final var idProvider = new DefaultSessionIdProvider();
110 final var aggregatedNetconfOperationServiceFactory = createOperationServiceFactory(
111 sourceProvider, transformedCapabilities, monitoringService1, idProvider);
113 return new ServerTransportInitializer(new TesttoolNegotiationFactory(timer,
114 aggregatedNetconfOperationServiceFactory, idProvider,
115 configuration.getGenerateConfigsTimeout(), monitoringService1, configuration.getCapabilities()));
118 private NetconfOperationServiceFactory createOperationServiceFactory(
119 final YangTextSourceExtension sourceProvider,
120 final Set<Capability> transformedCapabilities, final NetconfMonitoringService monitoringService1,
121 final SessionIdProvider idProvider) {
122 final AggregatedNetconfOperationServiceFactory aggregatedNetconfOperationServiceFactory =
123 new AggregatedNetconfOperationServiceFactory();
125 final NetconfOperationServiceFactory operationProvider;
126 if (configuration.isMdSal()) {
127 LOG.info("using MdsalOperationProvider.");
128 operationProvider = new MdsalOperationProvider(
129 idProvider, transformedCapabilities, schemaContext, sourceProvider);
130 } else if (configuration.isXmlConfigurationProvided()) {
131 LOG.info("using SimulatedOperationProvider.");
132 operationProvider = new SimulatedOperationProvider(transformedCapabilities,
133 Optional.ofNullable(configuration.getNotificationFile()),
134 Optional.ofNullable(configuration.getInitialConfigXMLFile()));
135 } else if (configuration.isNotificationsSupported()) {
136 LOG.info("using SimulatedOperationProvider.");
137 operationProvider = new SimulatedOperationProvider(transformedCapabilities,
138 Optional.ofNullable(configuration.getNotificationFile()),
141 LOG.info("using OperationsProvider.");
142 operationProvider = new OperationsProvider(transformedCapabilities,
143 requireNonNullElseGet(configuration.getOperationsCreator(), DefaultOperationsCreator::new));
146 final NetconfMonitoringOperationServiceFactory monitoringService =
147 new NetconfMonitoringOperationServiceFactory(monitoringService1);
148 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(operationProvider);
149 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(monitoringService);
150 if (configuration.getRpcConfigFile() != null) {
151 final SettableOperationProvider settableService =
152 new SettableOperationProvider(configuration.getRpcConfigFile());
153 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(settableService);
155 final SettableOperationRpcProvider settableService =
156 new SettableOperationRpcProvider(configuration.getRpcHandler());
157 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(settableService);
159 return aggregatedNetconfOperationServiceFactory;
162 public List<Integer> start() {
163 final var proto = configuration.isSsh() ? "SSH" : "TCP";
164 LOG.info("Starting {}, {} simulated devices starting on port {}",
165 configuration.getDeviceCount(), proto, configuration.getStartingPort());
167 final var schemaRepo = new SharedSchemaRepository("netconf-simulator");
168 final var capabilities = parseSchemasToModuleCapabilities(schemaRepo);
169 final var transportInitializer = createTransportInitializer(capabilities,
170 sourceIdentifier -> schemaRepo.getSchemaSource(sourceIdentifier, YangTextSource.class));
172 final var ipAddress = getIpAddress(configuration);
173 final var startingPort = getStartingPort(configuration);
174 final var deviceCount = configuration.getDeviceCount();
175 final var ports = IntStream.range(startingPort, Math.min(startingPort + deviceCount, 65536))
176 .mapToObj(Integer::new).toList();
178 final var openDevices = new ArrayList<Integer>(ports.size());
179 final var configurator = configuration.isSsh() ? createServerFactoryManagerConfigurator(configuration) : null;
181 LOG.debug("Ports: {}", ports);
183 for (final int port : ports) {
185 final var connectParams = connectionParams(ipAddress, port);
186 final var serverFuture = configuration.isSsh()
187 ? sshStackFactory.listenServer(TransportConstants.SSH_SUBSYSTEM, transportInitializer,
188 connectParams, null, configurator)
189 : TCPServer.listen(transportInitializer, sshStackFactory.newServerBootstrap(), connectParams);
190 servers.add(serverFuture.get());
191 openDevices.add(port);
192 } catch (UnsupportedConfigurationException | InterruptedException | ExecutionException e) {
193 LOG.error("Could not start {} simulated device on port {}", proto, port, e);
198 final var first = openDevices.get(0);
199 final var last = openDevices.isEmpty() ? null : openDevices.get(openDevices.size() - 1);
200 if (openDevices.size() == configuration.getDeviceCount()) {
201 LOG.info("All simulated devices started successfully from port {} to {}", first, last);
202 } else if (openDevices.isEmpty()) {
203 LOG.warn("No simulated devices started.");
205 LOG.warn("Not all simulated devices started successfully. Started devices are on ports {} to {}",
211 private static ServerFactoryManagerConfigurator createServerFactoryManagerConfigurator(
212 final Configuration configuration) {
213 final var authProvider = configuration.getAuthProvider();
214 final var publicKeyAuthenticator = configuration.getPublickeyAuthenticator();
215 return factoryManager -> {
216 final var authFactoriesListBuilder = ImmutableList.<UserAuthFactory>builder();
217 authFactoriesListBuilder.add(new UserAuthPasswordFactory());
218 factoryManager.setPasswordAuthenticator(
219 (usr, pass, session) -> authProvider.authenticated(usr, pass));
220 if (publicKeyAuthenticator != null) {
221 final var factory = new UserAuthPublicKeyFactory();
222 factory.setSignatureFactories(factoryManager.getSignatureFactories());
223 authFactoriesListBuilder.add(factory);
224 factoryManager.setPublickeyAuthenticator(publicKeyAuthenticator);
226 factoryManager.setUserAuthFactories(authFactoriesListBuilder.build());
227 factoryManager.setKeyPairProvider(new VirtualKeyPairProvider());
231 private Set<Capability> parseSchemasToModuleCapabilities(final SharedSchemaRepository consumer) {
232 final Set<SourceIdentifier> loadedSources = new HashSet<>();
233 consumer.registerSchemaSourceListener(TextToIRTransformer.create(consumer, consumer));
234 consumer.registerSchemaSourceListener(new SchemaSourceListener() {
236 public void schemaSourceEncountered(final SourceRepresentation schemaSourceRepresentation) {
241 public void schemaSourceRegistered(final Iterable<PotentialSchemaSource<?>> potentialSchemaSources) {
242 for (final PotentialSchemaSource<?> potentialSchemaSource : potentialSchemaSources) {
243 loadedSources.add(potentialSchemaSource.getSourceIdentifier());
248 public void schemaSourceUnregistered(final PotentialSchemaSource<?> potentialSchemaSource) {
253 if (configuration.getSchemasDir() != null) {
254 LOG.info("Loading models from directory.");
255 final FilesystemSchemaSourceCache<YangTextSource> cache = new FilesystemSchemaSourceCache<>(
256 consumer, YangTextSource.class, configuration.getSchemasDir());
257 consumer.registerSchemaSourceListener(cache);
258 } else if (configuration.getModels() != null) {
259 LOG.info("Loading models from classpath.");
260 final SchemaSourceCache<YangTextSource> cache = new SchemaSourceCache<>(
261 consumer, YangTextSource.class, configuration.getModels());
262 consumer.registerSchemaSourceListener(cache);
264 LOG.info("Custom module loading skipped.");
267 configuration.getDefaultYangResources().forEach(r -> {
268 registerSource(consumer, r.resourcePath(), new SourceIdentifier(r.moduleName(), r.revision()));
272 //necessary for creating mdsal data stores and operations
273 schemaContext = consumer.createEffectiveModelContextFactory()
274 .createEffectiveModelContext(loadedSources).get();
275 } catch (final InterruptedException | ExecutionException e) {
276 throw new IllegalStateException(
277 "Cannot parse schema context. Please read stack trace and check YANG files in schema directory.", e);
280 final Set<Capability> capabilities = new HashSet<>();
282 for (final Module module : schemaContext.getModules()) {
283 for (final Submodule subModule : module.getSubmodules()) {
284 addModuleCapability(consumer, capabilities, subModule);
286 addModuleCapability(consumer, capabilities, module);
291 private static void addModuleCapability(final SharedSchemaRepository consumer, final Set<Capability> capabilities,
292 final ModuleLike module) {
293 final var moduleNamespace = module.getNamespace().toString();
294 final var moduleName = module.getName();
295 final var revision = module.getRevision().map(Revision::toString).orElse(null);
296 final var sourceId = new SourceIdentifier(moduleName, revision);
298 final String moduleContent;
300 moduleContent = consumer.getSchemaSource(sourceId, YangTextSource.class).get().read();
301 } catch (ExecutionException | InterruptedException | IOException e) {
302 throw new IllegalStateException(
303 "Cannot retrieve schema source for module " + sourceId + " from schema repository", e);
306 capabilities.add(new YangModuleCapability(moduleNamespace, moduleName, revision, moduleContent));
309 private static void registerSource(final SharedSchemaRepository consumer, final String resource,
310 final SourceIdentifier sourceId) {
311 consumer.registerSchemaSource(sourceIdentifier -> Futures.immediateFuture(
312 new URLYangTextSource(NetconfDeviceSimulator.class.getResource(resource))),
313 PotentialSchemaSource.create(sourceId, YangTextSource.class,
314 PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
317 private static IpAddress getIpAddress(final Configuration configuration) {
319 return IetfInetUtil.ipAddressFor(InetAddress.getByName(configuration.getIp()));
320 } catch (final UnknownHostException e) {
321 throw new IllegalArgumentException("Cannot resolve address " + configuration.getIp(), e);
325 private static int getStartingPort(final Configuration configuration) {
326 final int startingPort = configuration.getStartingPort();
327 if (startingPort > 0 && startingPort < 65536) {
330 // find available port
332 final var socket = new ServerSocket(0);
333 final int port = socket.getLocalPort();
336 } catch (IOException e) {
337 throw new IllegalStateException("Cannot find available port", e);
341 private static TcpServerGrouping connectionParams(final IpAddress address, final int port) {
342 return new TcpServerParametersBuilder().setLocalAddress(address)
343 .setLocalPort(new PortNumber(Uint16.valueOf(port))).build();
347 public void close() {
348 for (final var server : servers) {
350 server.shutdown().get();
351 } catch (InterruptedException | ExecutionException e) {
352 LOG.debug("Exception on simulated device shutdown", e);
355 sshStackFactory.close();