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.netconf.api.CapabilityURN;
28 import org.opendaylight.netconf.api.TransportConstants;
29 import org.opendaylight.netconf.common.impl.DefaultNetconfTimer;
30 import org.opendaylight.netconf.server.ServerTransportInitializer;
31 import org.opendaylight.netconf.server.api.SessionIdProvider;
32 import org.opendaylight.netconf.server.api.monitoring.BasicCapability;
33 import org.opendaylight.netconf.server.api.monitoring.Capability;
34 import org.opendaylight.netconf.server.api.monitoring.NetconfMonitoringService;
35 import org.opendaylight.netconf.server.api.monitoring.YangModuleCapability;
36 import org.opendaylight.netconf.server.api.operations.NetconfOperationServiceFactory;
37 import org.opendaylight.netconf.server.impl.DefaultSessionIdProvider;
38 import org.opendaylight.netconf.server.osgi.AggregatedNetconfOperationServiceFactory;
39 import org.opendaylight.netconf.shaded.sshd.server.auth.UserAuthFactory;
40 import org.opendaylight.netconf.shaded.sshd.server.auth.password.UserAuthPasswordFactory;
41 import org.opendaylight.netconf.shaded.sshd.server.auth.pubkey.UserAuthPublicKeyFactory;
42 import org.opendaylight.netconf.test.tool.config.Configuration;
43 import org.opendaylight.netconf.test.tool.customrpc.SettableOperationProvider;
44 import org.opendaylight.netconf.test.tool.monitoring.NetconfMonitoringOperationServiceFactory;
45 import org.opendaylight.netconf.test.tool.operations.DefaultOperationsCreator;
46 import org.opendaylight.netconf.test.tool.operations.OperationsProvider;
47 import org.opendaylight.netconf.test.tool.rpchandler.SettableOperationRpcProvider;
48 import org.opendaylight.netconf.test.tool.schemacache.SchemaSourceCache;
49 import org.opendaylight.netconf.transport.api.TransportStack;
50 import org.opendaylight.netconf.transport.api.UnsupportedConfigurationException;
51 import org.opendaylight.netconf.transport.ssh.SSHTransportStackFactory;
52 import org.opendaylight.netconf.transport.ssh.ServerFactoryManagerConfigurator;
53 import org.opendaylight.netconf.transport.tcp.TCPServer;
54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
57 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;
58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.tcp.server.rev231228.TcpServerGrouping;
59 import org.opendaylight.yangtools.yang.common.Revision;
60 import org.opendaylight.yangtools.yang.common.Uint16;
61 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
62 import org.opendaylight.yangtools.yang.model.api.Module;
63 import org.opendaylight.yangtools.yang.model.api.ModuleLike;
64 import org.opendaylight.yangtools.yang.model.api.Submodule;
65 import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
66 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
67 import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
68 import org.opendaylight.yangtools.yang.model.repo.fs.FilesystemSchemaSourceCache;
69 import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
70 import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceListener;
71 import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
72 import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
73 import org.opendaylight.yangtools.yang.parser.rfc7950.repo.TextToIRTransformer;
74 import org.slf4j.Logger;
75 import org.slf4j.LoggerFactory;
77 public class NetconfDeviceSimulator implements Closeable {
78 private static final Logger LOG = LoggerFactory.getLogger(NetconfDeviceSimulator.class);
80 private final DefaultNetconfTimer timer = new DefaultNetconfTimer();
81 private final Configuration configuration;
82 private final List<TransportStack> servers;
83 private final SSHTransportStackFactory sshStackFactory;
84 private EffectiveModelContext schemaContext;
86 private boolean sendFakeSchema = false;
88 public NetconfDeviceSimulator(final Configuration configuration) {
89 this.configuration = configuration;
90 servers = new ArrayList<>(configuration.getDeviceCount());
91 sshStackFactory = new SSHTransportStackFactory("netconf-device-simulator-threads",
92 configuration.getThreadPoolSize());
95 private ServerTransportInitializer createTransportInitializer(final Set<Capability> capabilities,
96 final SchemaSourceProvider<YangTextSchemaSource> sourceProvider) {
97 final var transformedCapabilities = new HashSet<>(Collections2.transform(capabilities, input -> {
99 sendFakeSchema = false;
100 return new FakeCapability((YangModuleCapability) input);
105 transformedCapabilities.add(new BasicCapability(CapabilityURN.CANDIDATE));
106 final var monitoringService1 = new DummyMonitoringService(transformedCapabilities);
107 final var idProvider = new DefaultSessionIdProvider();
109 final var aggregatedNetconfOperationServiceFactory = createOperationServiceFactory(
110 sourceProvider, transformedCapabilities, monitoringService1, idProvider);
112 return new ServerTransportInitializer(new TesttoolNegotiationFactory(timer,
113 aggregatedNetconfOperationServiceFactory, idProvider,
114 configuration.getGenerateConfigsTimeout(), monitoringService1, configuration.getCapabilities()));
117 private NetconfOperationServiceFactory createOperationServiceFactory(
118 final SchemaSourceProvider<YangTextSchemaSource> sourceProvider,
119 final Set<Capability> transformedCapabilities, final NetconfMonitoringService monitoringService1,
120 final SessionIdProvider idProvider) {
121 final AggregatedNetconfOperationServiceFactory aggregatedNetconfOperationServiceFactory =
122 new AggregatedNetconfOperationServiceFactory();
124 final NetconfOperationServiceFactory operationProvider;
125 if (configuration.isMdSal()) {
126 LOG.info("using MdsalOperationProvider.");
127 operationProvider = new MdsalOperationProvider(
128 idProvider, transformedCapabilities, schemaContext, sourceProvider);
129 } else if (configuration.isXmlConfigurationProvided()) {
130 LOG.info("using SimulatedOperationProvider.");
131 operationProvider = new SimulatedOperationProvider(transformedCapabilities,
132 Optional.ofNullable(configuration.getNotificationFile()),
133 Optional.ofNullable(configuration.getInitialConfigXMLFile()));
134 } else if (configuration.isNotificationsSupported()) {
135 LOG.info("using SimulatedOperationProvider.");
136 operationProvider = new SimulatedOperationProvider(transformedCapabilities,
137 Optional.ofNullable(configuration.getNotificationFile()),
140 LOG.info("using OperationsProvider.");
141 operationProvider = new OperationsProvider(transformedCapabilities,
142 requireNonNullElseGet(configuration.getOperationsCreator(), DefaultOperationsCreator::new));
145 final NetconfMonitoringOperationServiceFactory monitoringService =
146 new NetconfMonitoringOperationServiceFactory(monitoringService1);
147 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(operationProvider);
148 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(monitoringService);
149 if (configuration.getRpcConfigFile() != null) {
150 final SettableOperationProvider settableService =
151 new SettableOperationProvider(configuration.getRpcConfigFile());
152 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(settableService);
154 final SettableOperationRpcProvider settableService =
155 new SettableOperationRpcProvider(configuration.getRpcHandler());
156 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(settableService);
158 return aggregatedNetconfOperationServiceFactory;
161 public List<Integer> start() {
162 final var proto = configuration.isSsh() ? "SSH" : "TCP";
163 LOG.info("Starting {}, {} simulated devices starting on port {}",
164 configuration.getDeviceCount(), proto, configuration.getStartingPort());
166 final var schemaRepo = new SharedSchemaRepository("netconf-simulator");
167 final var capabilities = parseSchemasToModuleCapabilities(schemaRepo);
168 final var transportInitializer = createTransportInitializer(capabilities,
169 sourceIdentifier -> schemaRepo.getSchemaSource(sourceIdentifier, YangTextSchemaSource.class));
171 final var ipAddress = getIpAddress(configuration);
172 final var startingPort = getStartingPort(configuration);
173 final var deviceCount = configuration.getDeviceCount();
174 final var ports = IntStream.range(startingPort, Math.min(startingPort + deviceCount, 65536))
175 .mapToObj(Integer::new).toList();
177 final var openDevices = new ArrayList<Integer>(ports.size());
178 final var configurator = configuration.isSsh() ? createServerFactoryManagerConfigurator(configuration) : null;
180 LOG.debug("Ports: {}", ports);
182 for (final int port : ports) {
184 final var connectParams = connectionParams(ipAddress, port);
185 final var serverFuture = configuration.isSsh()
186 ? sshStackFactory.listenServer(TransportConstants.SSH_SUBSYSTEM, transportInitializer,
187 connectParams, null, configurator)
188 : TCPServer.listen(transportInitializer, sshStackFactory.newServerBootstrap(), connectParams);
189 servers.add(serverFuture.get());
190 openDevices.add(port);
191 } catch (UnsupportedConfigurationException | InterruptedException | ExecutionException e) {
192 LOG.error("Could not start {} simulated device on port {}", proto, port, e);
197 final var first = openDevices.get(0);
198 final var last = openDevices.isEmpty() ? null : openDevices.get(openDevices.size() - 1);
199 if (openDevices.size() == configuration.getDeviceCount()) {
200 LOG.info("All simulated devices started successfully from port {} to {}", first, last);
201 } else if (openDevices.isEmpty()) {
202 LOG.warn("No simulated devices started.");
204 LOG.warn("Not all simulated devices started successfully. Started devices are on ports {} to {}",
210 private static ServerFactoryManagerConfigurator createServerFactoryManagerConfigurator(
211 final Configuration configuration) {
212 final var authProvider = configuration.getAuthProvider();
213 final var publicKeyAuthenticator = configuration.getPublickeyAuthenticator();
214 return factoryManager -> {
215 final var authFactoriesListBuilder = ImmutableList.<UserAuthFactory>builder();
216 authFactoriesListBuilder.add(new UserAuthPasswordFactory());
217 factoryManager.setPasswordAuthenticator(
218 (usr, pass, session) -> authProvider.authenticated(usr, pass));
219 if (publicKeyAuthenticator != null) {
220 final var factory = new UserAuthPublicKeyFactory();
221 factory.setSignatureFactories(factoryManager.getSignatureFactories());
222 authFactoriesListBuilder.add(factory);
223 factoryManager.setPublickeyAuthenticator(publicKeyAuthenticator);
225 factoryManager.setUserAuthFactories(authFactoriesListBuilder.build());
226 factoryManager.setKeyPairProvider(new VirtualKeyPairProvider());
230 private Set<Capability> parseSchemasToModuleCapabilities(final SharedSchemaRepository consumer) {
231 final Set<SourceIdentifier> loadedSources = new HashSet<>();
232 consumer.registerSchemaSourceListener(TextToIRTransformer.create(consumer, consumer));
233 consumer.registerSchemaSourceListener(new SchemaSourceListener() {
235 public void schemaSourceEncountered(final SchemaSourceRepresentation schemaSourceRepresentation) {
240 public void schemaSourceRegistered(final Iterable<PotentialSchemaSource<?>> potentialSchemaSources) {
241 for (final PotentialSchemaSource<?> potentialSchemaSource : potentialSchemaSources) {
242 loadedSources.add(potentialSchemaSource.getSourceIdentifier());
247 public void schemaSourceUnregistered(final PotentialSchemaSource<?> potentialSchemaSource) {
252 if (configuration.getSchemasDir() != null) {
253 LOG.info("Loading models from directory.");
254 final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(
255 consumer, YangTextSchemaSource.class, configuration.getSchemasDir());
256 consumer.registerSchemaSourceListener(cache);
257 } else if (configuration.getModels() != null) {
258 LOG.info("Loading models from classpath.");
259 final SchemaSourceCache<YangTextSchemaSource> cache = new SchemaSourceCache<>(
260 consumer, YangTextSchemaSource.class, configuration.getModels());
261 consumer.registerSchemaSourceListener(cache);
263 LOG.info("Custom module loading skipped.");
266 configuration.getDefaultYangResources().forEach(r -> {
267 registerSource(consumer, r.resourcePath(), new SourceIdentifier(r.moduleName(), r.revision()));
271 //necessary for creating mdsal data stores and operations
272 schemaContext = consumer.createEffectiveModelContextFactory()
273 .createEffectiveModelContext(loadedSources).get();
274 } catch (final InterruptedException | ExecutionException e) {
275 throw new IllegalStateException(
276 "Cannot parse schema context. Please read stack trace and check YANG files in schema directory.", e);
279 final Set<Capability> capabilities = new HashSet<>();
281 for (final Module module : schemaContext.getModules()) {
282 for (final Submodule subModule : module.getSubmodules()) {
283 addModuleCapability(consumer, capabilities, subModule);
285 addModuleCapability(consumer, capabilities, module);
290 private static void addModuleCapability(final SharedSchemaRepository consumer, final Set<Capability> capabilities,
291 final ModuleLike module) {
292 final var moduleNamespace = module.getNamespace().toString();
293 final var moduleName = module.getName();
294 final var revision = module.getRevision().map(Revision::toString).orElse(null);
295 final var sourceId = new SourceIdentifier(moduleName, revision);
297 final String moduleContent;
299 moduleContent = consumer.getSchemaSource(sourceId, YangTextSchemaSource.class).get().read();
300 } catch (ExecutionException | InterruptedException | IOException e) {
301 throw new IllegalStateException(
302 "Cannot retrieve schema source for module " + sourceId + " from schema repository", e);
305 capabilities.add(new YangModuleCapability(moduleNamespace, moduleName, revision, moduleContent));
308 private static void registerSource(final SharedSchemaRepository consumer, final String resource,
309 final SourceIdentifier sourceId) {
310 consumer.registerSchemaSource(sourceIdentifier -> Futures.immediateFuture(
311 YangTextSchemaSource.forResource(NetconfDeviceSimulator.class, resource)),
312 PotentialSchemaSource.create(sourceId, YangTextSchemaSource.class,
313 PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
316 private static IpAddress getIpAddress(final Configuration configuration) {
318 return IetfInetUtil.ipAddressFor(InetAddress.getByName(configuration.getIp()));
319 } catch (final UnknownHostException e) {
320 throw new IllegalArgumentException("Cannot resolve address " + configuration.getIp(), e);
324 private static int getStartingPort(final Configuration configuration) {
325 final int startingPort = configuration.getStartingPort();
326 if (startingPort > 0 && startingPort < 65536) {
329 // find available port
331 final var socket = new ServerSocket(0);
332 final int port = socket.getLocalPort();
335 } catch (IOException e) {
336 throw new IllegalStateException("Cannot find available port", e);
340 private static TcpServerGrouping connectionParams(final IpAddress address, final int port) {
341 return new TcpServerParametersBuilder().setLocalAddress(address)
342 .setLocalPort(new PortNumber(Uint16.valueOf(port))).build();
346 public void close() {
347 for (final var server : servers) {
349 server.shutdown().get();
350 } catch (InterruptedException | ExecutionException e) {
351 LOG.debug("Exception on simulated device shutdown", e);
354 sshStackFactory.close();