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 io.netty.util.HashedWheelTimer;
16 import java.io.Closeable;
17 import java.io.IOException;
18 import java.net.InetAddress;
19 import java.net.ServerSocket;
20 import java.net.UnknownHostException;
21 import java.util.ArrayList;
22 import java.util.HashSet;
23 import java.util.List;
24 import java.util.Optional;
26 import java.util.concurrent.ExecutionException;
27 import java.util.stream.IntStream;
28 import org.opendaylight.netconf.api.CapabilityURN;
29 import org.opendaylight.netconf.server.NetconfServerFactoryImpl;
30 import org.opendaylight.netconf.server.NetconfServerSessionNegotiatorFactory;
31 import org.opendaylight.netconf.server.ServerChannelInitializer;
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.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.rev230417.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.rev230417.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 HashedWheelTimer hashedWheelTimer;
81 private final Configuration configuration;
82 private final List<TransportStack> servers;
83 private final SSHTransportStackFactory sshTransportStackFactory;
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 sshTransportStackFactory = new SSHTransportStackFactory("netconf-device-simulator-threads",
92 configuration.getThreadPoolSize());
93 hashedWheelTimer = new HashedWheelTimer();
96 private ServerChannelInitializer createServerChannelInitializer(final Set<Capability> capabilities,
97 final SchemaSourceProvider<YangTextSchemaSource> sourceProvider) {
99 final Set<Capability> transformedCapabilities = new HashSet<>(Collections2.transform(capabilities, input -> {
100 if (sendFakeSchema) {
101 sendFakeSchema = false;
102 return new FakeCapability((YangModuleCapability) input);
107 transformedCapabilities.add(new BasicCapability(CapabilityURN.CANDIDATE));
108 final NetconfMonitoringService monitoringService1 = new DummyMonitoringService(transformedCapabilities);
109 final SessionIdProvider idProvider = new DefaultSessionIdProvider();
111 final NetconfOperationServiceFactory aggregatedNetconfOperationServiceFactory = createOperationServiceFactory(
112 sourceProvider, transformedCapabilities, monitoringService1, idProvider);
114 final Set<String> serverCapabilities = configuration.getCapabilities();
116 final NetconfServerSessionNegotiatorFactory serverNegotiatorFactory = new TesttoolNegotiationFactory(
117 hashedWheelTimer, aggregatedNetconfOperationServiceFactory, idProvider,
118 configuration.getGenerateConfigsTimeout(),
119 monitoringService1, serverCapabilities);
121 return new ServerChannelInitializer(serverNegotiatorFactory);
124 private NetconfOperationServiceFactory createOperationServiceFactory(
125 final SchemaSourceProvider<YangTextSchemaSource> sourceProvider,
126 final Set<Capability> transformedCapabilities, final NetconfMonitoringService monitoringService1,
127 final SessionIdProvider idProvider) {
128 final AggregatedNetconfOperationServiceFactory aggregatedNetconfOperationServiceFactory =
129 new AggregatedNetconfOperationServiceFactory();
131 final NetconfOperationServiceFactory operationProvider;
132 if (configuration.isMdSal()) {
133 LOG.info("using MdsalOperationProvider.");
134 operationProvider = new MdsalOperationProvider(
135 idProvider, transformedCapabilities, schemaContext, sourceProvider);
136 } else if (configuration.isXmlConfigurationProvided()) {
137 LOG.info("using SimulatedOperationProvider.");
138 operationProvider = new SimulatedOperationProvider(transformedCapabilities,
139 Optional.ofNullable(configuration.getNotificationFile()),
140 Optional.ofNullable(configuration.getInitialConfigXMLFile()));
141 } else if (configuration.isNotificationsSupported()) {
142 LOG.info("using SimulatedOperationProvider.");
143 operationProvider = new SimulatedOperationProvider(transformedCapabilities,
144 Optional.ofNullable(configuration.getNotificationFile()),
147 LOG.info("using OperationsProvider.");
148 operationProvider = new OperationsProvider(transformedCapabilities,
149 requireNonNullElseGet(configuration.getOperationsCreator(), DefaultOperationsCreator::new));
152 final NetconfMonitoringOperationServiceFactory monitoringService =
153 new NetconfMonitoringOperationServiceFactory(monitoringService1);
154 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(operationProvider);
155 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(monitoringService);
156 if (configuration.getRpcConfigFile() != null) {
157 final SettableOperationProvider settableService =
158 new SettableOperationProvider(configuration.getRpcConfigFile());
159 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(settableService);
161 final SettableOperationRpcProvider settableService =
162 new SettableOperationRpcProvider(configuration.getRpcHandler());
163 aggregatedNetconfOperationServiceFactory.onAddNetconfOperationServiceFactory(settableService);
165 return aggregatedNetconfOperationServiceFactory;
168 public List<Integer> start() {
169 final var proto = configuration.isSsh() ? "SSH" : "TCP";
170 LOG.info("Starting {}, {} simulated devices starting on port {}",
171 configuration.getDeviceCount(), proto, configuration.getStartingPort());
173 final var schemaRepo = new SharedSchemaRepository("netconf-simulator");
174 final var capabilities = parseSchemasToModuleCapabilities(schemaRepo);
175 final var serverChannelInitializer = createServerChannelInitializer(capabilities,
176 sourceIdentifier -> schemaRepo.getSchemaSource(sourceIdentifier, YangTextSchemaSource.class));
177 final var serverFactory = new NetconfServerFactoryImpl(serverChannelInitializer, sshTransportStackFactory);
179 final var ipAddress = getIpAddress(configuration);
180 final var startingPort = getStartingPort(configuration);
181 final var deviceCount = configuration.getDeviceCount();
182 final var ports = IntStream.range(startingPort, Math.min(startingPort + deviceCount, 65536))
183 .mapToObj(Integer::new).toList();
185 final var openDevices = new ArrayList<Integer>(ports.size());
186 final var configurator = configuration.isSsh() ? createServerFactoryManagerConfigurator(configuration) : null;
188 LOG.debug("Ports: {}", ports);
190 for (final int port : ports) {
192 final var connectParams = connectionParams(ipAddress, port);
193 final var serverFuture = configuration.isSsh()
194 ? serverFactory.createSshServer(connectParams, null, configurator)
195 : serverFactory.createTcpServer(connectParams);
196 servers.add(serverFuture.get());
197 openDevices.add(port);
198 } catch (UnsupportedConfigurationException | InterruptedException | ExecutionException e) {
199 LOG.error("Could not start {} simulated device on port {}", proto, port, e);
204 final var first = openDevices.get(0);
205 final var last = openDevices.isEmpty() ? null : openDevices.get(openDevices.size() - 1);
206 if (openDevices.size() == configuration.getDeviceCount()) {
207 LOG.info("All simulated devices started successfully from port {} to {}", first, last);
208 } else if (openDevices.isEmpty()) {
209 LOG.warn("No simulated devices started.");
211 LOG.warn("Not all simulated devices started successfully. Started devices are on ports {} to {}",
217 private static ServerFactoryManagerConfigurator createServerFactoryManagerConfigurator(
218 final Configuration configuration) {
219 final var authProvider = configuration.getAuthProvider();
220 final var publicKeyAuthenticator = configuration.getPublickeyAuthenticator();
221 return factoryManager -> {
222 final var authFactoriesListBuilder = ImmutableList.<UserAuthFactory>builder();
223 authFactoriesListBuilder.add(new UserAuthPasswordFactory());
224 factoryManager.setPasswordAuthenticator(
225 (usr, pass, session) -> authProvider.authenticated(usr, pass));
226 if (publicKeyAuthenticator != null) {
227 final var factory = new UserAuthPublicKeyFactory();
228 factory.setSignatureFactories(factoryManager.getSignatureFactories());
229 authFactoriesListBuilder.add(factory);
230 factoryManager.setPublickeyAuthenticator(publicKeyAuthenticator);
232 factoryManager.setUserAuthFactories(authFactoriesListBuilder.build());
233 factoryManager.setKeyPairProvider(new VirtualKeyPairProvider());
237 private Set<Capability> parseSchemasToModuleCapabilities(final SharedSchemaRepository consumer) {
238 final Set<SourceIdentifier> loadedSources = new HashSet<>();
239 consumer.registerSchemaSourceListener(TextToIRTransformer.create(consumer, consumer));
240 consumer.registerSchemaSourceListener(new SchemaSourceListener() {
242 public void schemaSourceEncountered(final SchemaSourceRepresentation schemaSourceRepresentation) {
247 public void schemaSourceRegistered(final Iterable<PotentialSchemaSource<?>> potentialSchemaSources) {
248 for (final PotentialSchemaSource<?> potentialSchemaSource : potentialSchemaSources) {
249 loadedSources.add(potentialSchemaSource.getSourceIdentifier());
254 public void schemaSourceUnregistered(final PotentialSchemaSource<?> potentialSchemaSource) {
259 if (configuration.getSchemasDir() != null) {
260 LOG.info("Loading models from directory.");
261 final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(
262 consumer, YangTextSchemaSource.class, configuration.getSchemasDir());
263 consumer.registerSchemaSourceListener(cache);
264 } else if (configuration.getModels() != null) {
265 LOG.info("Loading models from classpath.");
266 final SchemaSourceCache<YangTextSchemaSource> cache = new SchemaSourceCache<>(
267 consumer, YangTextSchemaSource.class, configuration.getModels());
268 consumer.registerSchemaSourceListener(cache);
270 LOG.info("Custom module loading skipped.");
273 configuration.getDefaultYangResources().forEach(r -> {
274 registerSource(consumer, r.resourcePath(), new SourceIdentifier(r.moduleName(), r.revision()));
278 //necessary for creating mdsal data stores and operations
279 schemaContext = consumer.createEffectiveModelContextFactory()
280 .createEffectiveModelContext(loadedSources).get();
281 } catch (final InterruptedException | ExecutionException e) {
282 throw new IllegalStateException(
283 "Cannot parse schema context. Please read stack trace and check YANG files in schema directory.", e);
286 final Set<Capability> capabilities = new HashSet<>();
288 for (final Module module : schemaContext.getModules()) {
289 for (final Submodule subModule : module.getSubmodules()) {
290 addModuleCapability(consumer, capabilities, subModule);
292 addModuleCapability(consumer, capabilities, module);
297 private static void addModuleCapability(final SharedSchemaRepository consumer, final Set<Capability> capabilities,
298 final ModuleLike module) {
299 final var moduleNamespace = module.getNamespace().toString();
300 final var moduleName = module.getName();
301 final var revision = module.getRevision().map(Revision::toString).orElse(null);
302 final var sourceId = new SourceIdentifier(moduleName, revision);
304 final String moduleContent;
306 moduleContent = consumer.getSchemaSource(sourceId, YangTextSchemaSource.class).get().read();
307 } catch (ExecutionException | InterruptedException | IOException e) {
308 throw new IllegalStateException(
309 "Cannot retrieve schema source for module " + sourceId + " from schema repository", e);
312 capabilities.add(new YangModuleCapability(moduleNamespace, moduleName, revision, moduleContent));
315 private static void registerSource(final SharedSchemaRepository consumer, final String resource,
316 final SourceIdentifier sourceId) {
317 consumer.registerSchemaSource(sourceIdentifier -> Futures.immediateFuture(
318 YangTextSchemaSource.forResource(NetconfDeviceSimulator.class, resource)),
319 PotentialSchemaSource.create(sourceId, YangTextSchemaSource.class,
320 PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
323 private static IpAddress getIpAddress(final Configuration configuration) {
325 return IetfInetUtil.ipAddressFor(InetAddress.getByName(configuration.getIp()));
326 } catch (final UnknownHostException e) {
327 throw new IllegalArgumentException("Cannot resolve address " + configuration.getIp(), e);
331 private static int getStartingPort(final Configuration configuration) {
332 final int startingPort = configuration.getStartingPort();
333 if (startingPort > 0 && startingPort < 65536) {
336 // find available port
338 final var socket = new ServerSocket(0);
339 final int port = socket.getLocalPort();
342 } catch (IOException e) {
343 throw new IllegalStateException("Cannot find available port", e);
347 private static TcpServerGrouping connectionParams(final IpAddress address, final int port) {
348 return new TcpServerParametersBuilder().setLocalAddress(address)
349 .setLocalPort(new PortNumber(Uint16.valueOf(port))).build();
353 public void close() {
354 for (final var server : servers) {
356 server.shutdown().get();
357 } catch (InterruptedException | ExecutionException e) {
358 LOG.debug("Exception on simulated device shutdown", e);
361 sshTransportStackFactory.close();