Bug 9256: Add websocket server config knob for ip
[netconf.git] / netconf / tools / netconf-testtool / src / main / java / org / opendaylight / netconf / test / tool / TesttoolParameters.java
1 /*
2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8
9 package org.opendaylight.netconf.test.tool;
10
11 import static com.google.common.base.Preconditions.checkArgument;
12
13 import com.google.common.base.Preconditions;
14 import com.google.common.io.CharStreams;
15 import com.google.common.io.Files;
16 import java.io.BufferedReader;
17 import java.io.File;
18 import java.io.FileReader;
19 import java.io.IOException;
20 import java.io.InputStream;
21 import java.io.InputStreamReader;
22 import java.lang.reflect.Field;
23 import java.nio.charset.StandardCharsets;
24 import java.util.ArrayList;
25 import java.util.Arrays;
26 import java.util.Iterator;
27 import java.util.List;
28 import java.util.StringJoiner;
29 import java.util.concurrent.TimeUnit;
30 import java.util.regex.Matcher;
31 import java.util.regex.Pattern;
32 import net.sourceforge.argparse4j.ArgumentParsers;
33 import net.sourceforge.argparse4j.annotation.Arg;
34 import net.sourceforge.argparse4j.inf.ArgumentParser;
35 import net.sourceforge.argparse4j.inf.ArgumentParserException;
36
37 public class TesttoolParameters {
38
39     private static final String HOST_KEY = "{HOST}";
40     private static final String PORT_KEY = "{PORT}";
41     private static final String TCP_ONLY = "{TCP_ONLY}";
42     private static final String ADDRESS_PORT = "{ADDRESS:PORT}";
43     private static final String DEST =
44         "http://{ADDRESS:PORT}/restconf/config/network-topology:network-topology/topology/topology-netconf/";
45     private static final Pattern YANG_FILENAME_PATTERN = Pattern
46         .compile("(?<name>.*)@(?<revision>\\d{4}-\\d{2}-\\d{2})\\.yang");
47     private static final Pattern DATE_PATTERN = Pattern.compile("(\\d{4}-\\d{2}-\\d{2})");
48
49     private static final String RESOURCE = "/config-template.json";
50     @Arg(dest = "edit-content")
51     public File editContent;
52     @Arg(dest = "async")
53     public boolean async;
54     @Arg(dest = "thread-amount")
55     public int threadAmount;
56     @Arg(dest = "throttle")
57     public int throttle;
58     @Arg(dest = "auth")
59     public ArrayList<String> auth;
60     @Arg(dest = "controller-destination")
61     public String controllerDestination;
62     @Arg(dest = "schemas-dir")
63     public File schemasDir;
64     @Arg(dest = "devices-count")
65     public int deviceCount;
66     @Arg(dest = "devices-per-port")
67     public int devicesPerPort;
68     @Arg(dest = "starting-port")
69     public int startingPort;
70     @Arg(dest = "generate-config-connection-timeout")
71     public int generateConfigsTimeout;
72     @Arg(dest = "generate-config-address")
73     public String generateConfigsAddress;
74     @Arg(dest = "distro-folder")
75     public File distroFolder;
76     @Arg(dest = "generate-configs-batch-size")
77     public int generateConfigBatchSize;
78     @Arg(dest = "ssh")
79     public boolean ssh;
80     @Arg(dest = "exi")
81     public boolean exi;
82     @Arg(dest = "debug")
83     public boolean debug;
84     @Arg(dest = "notification-file")
85     public File notificationFile;
86     @Arg(dest = "md-sal")
87     public boolean mdSal;
88     @Arg(dest = "initial-config-xml-file")
89     public File initialConfigXMLFile;
90     @Arg(dest = "time-out")
91     public long timeOut;
92     private InputStream stream;
93
94     @Arg(dest = "ip")
95     public String ip;
96
97     @Arg(dest = "thread-pool-size")
98     public int threadPoolSize;
99     @Arg(dest = "rpc-config")
100     public File rpcConfig;
101
102     @SuppressWarnings("checkstyle:lineLength")
103     static ArgumentParser getParser() {
104         final ArgumentParser parser = ArgumentParsers.newArgumentParser("netconf testtool");
105
106         parser.description("netconf testtool");
107
108         parser.addArgument("--edit-content")
109                 .type(String.class)
110                 .dest("edit-content");
111
112         parser.addArgument("--async-requests")
113                 .type(Boolean.class)
114                 .setDefault(false)
115                 .dest("async");
116
117         parser.addArgument("--thread-amount")
118                 .type(Integer.class)
119                 .setDefault(1)
120                 .dest("thread-amount")
121                 .help("The number of threads to use for configuring devices.");
122
123         parser.addArgument("--throttle")
124                 .type(Integer.class)
125                 .setDefault(5000)
126                 .help("Maximum amount of async requests that can be open at a time, "
127                         + "with mutltiple threads this gets divided among all threads")
128                 .dest("throttle");
129
130         parser.addArgument("--auth")
131                 .nargs(2)
132                 .help("Username and password for HTTP basic authentication in order username password.")
133                 .dest("auth");
134
135         parser.addArgument("--controller-destination")
136                 .type(String.class)
137                 .help("Ip address and port of controller. Must be in following format <ip>:<port> "
138                         + "if available it will be used for spawning netconf connectors via topology configuration as "
139                         + "a part of URI. Example (http://<controller destination>/restconf/config/network-topology:network-topology/topology/topology-netconf/node/<node-id>)"
140                         + "otherwise it will just start simulated devices and skip the execution of PUT requests")
141                 .dest("controller-destination");
142
143         parser.addArgument("--device-count")
144                 .type(Integer.class)
145                 .setDefault(1)
146                 .help("Number of simulated netconf devices to spin. This is the number of actual ports open for the devices.")
147                 .dest("devices-count");
148
149         parser.addArgument("--devices-per-port")
150                 .type(Integer.class)
151                 .setDefault(1)
152                 .help("Amount of config files generated per port to spoof more devices then are actually running")
153                 .dest("devices-per-port");
154
155         parser.addArgument("--schemas-dir")
156                 .type(File.class)
157                 .help("Directory containing yang schemas to describe simulated devices. Some schemas e.g. netconf monitoring and inet types are included by default")
158                 .dest("schemas-dir");
159
160         parser.addArgument("--notification-file")
161                 .type(File.class)
162                 .help("Xml file containing notifications that should be sent to clients after create subscription is called")
163                 .dest("notification-file");
164
165         parser.addArgument("--initial-config-xml-file")
166                 .type(File.class)
167                 .help("Xml file containing initial simulatted configuration to be returned via get-config rpc")
168                 .dest("initial-config-xml-file");
169
170         parser.addArgument("--starting-port")
171                 .type(Integer.class)
172                 .setDefault(17830)
173                 .help("First port for simulated device. Each other device will have previous+1 port number")
174                 .dest("starting-port");
175
176         parser.addArgument("--generate-config-connection-timeout")
177                 .type(Integer.class)
178                 .setDefault((int) TimeUnit.MINUTES.toMillis(30))
179                 .help("Timeout to be generated in initial config files")
180                 .dest("generate-config-connection-timeout");
181
182         parser.addArgument("--generate-config-address")
183                 .type(String.class)
184                 .setDefault("127.0.0.1")
185                 .help("Address to be placed in generated configs")
186                 .dest("generate-config-address");
187
188         parser.addArgument("--generate-configs-batch-size")
189                 .type(Integer.class)
190                 .setDefault(1)
191                 .help("Number of connector configs per generated file")
192                 .dest("generate-configs-batch-size");
193
194         parser.addArgument("--distribution-folder")
195                 .type(File.class)
196                 .help("Directory where the karaf distribution for controller is located")
197                 .dest("distro-folder");
198
199         parser.addArgument("--ssh")
200                 .type(Boolean.class)
201                 .setDefault(true)
202                 .help("Whether to use ssh for transport or just pure tcp")
203                 .dest("ssh");
204
205         parser.addArgument("--exi")
206                 .type(Boolean.class)
207                 .setDefault(true)
208                 .help("Whether to use exi to transport xml content")
209                 .dest("exi");
210
211         parser.addArgument("--debug")
212                 .type(Boolean.class)
213                 .setDefault(false)
214                 .help("Whether to use debug log level instead of INFO")
215                 .dest("debug");
216
217         parser.addArgument("--md-sal")
218                 .type(Boolean.class)
219                 .setDefault(false)
220                 .help("Whether to use md-sal datastore instead of default simulated datastore.")
221                 .dest("md-sal");
222
223         parser.addArgument("--time-out")
224                 .type(long.class)
225                 .setDefault(20)
226                 .help("the maximum time in seconds for executing each PUT request")
227                 .dest("time-out");
228
229         parser.addArgument("-ip")
230                 .type(String.class)
231                 .setDefault("0.0.0.0")
232                 .help("Ip address which will be used for creating a socket address."
233                         + "It can either be a machine name, such as "
234                         + "java.sun.com, or a textual representation of its IP address.")
235                 .dest("ip");
236
237         parser.addArgument("--thread-pool-size")
238                 .type(Integer.class)
239                 .setDefault(8)
240                 .help("The number of threads to keep in the pool, when creating a device simulator. Even if they are idle.")
241                 .dest("thread-pool-size");
242         parser.addArgument("--rpc-config")
243                 .type(File.class)
244                 .help("Rpc config file. It can be used to define custom rpc behavior, or override the default one."
245                     + "Usable for testing buggy device behavior.")
246                 .dest("rpc-config");
247
248         return parser;
249     }
250
251     public static TesttoolParameters parseArgs(final String[] args, final ArgumentParser parser) {
252         final TesttoolParameters opt = new TesttoolParameters();
253         try {
254             parser.parseArgs(args, opt);
255             return opt;
256         } catch (final ArgumentParserException e) {
257             parser.handleError(e);
258         }
259
260         System.exit(1);
261         return null;
262     }
263
264     private static String modifyMessage(final StringBuilder payloadBuilder, final int payloadPosition, final int size) {
265         if (size == 1) {
266             return payloadBuilder.toString();
267         }
268
269         if (payloadPosition == 0) {
270             payloadBuilder.insert(payloadBuilder.toString().indexOf('{', 2), "[");
271             payloadBuilder.replace(payloadBuilder.length() - 1, payloadBuilder.length(), ",");
272         } else if (payloadPosition + 1 == size) {
273             payloadBuilder.delete(0, payloadBuilder.toString().indexOf(':') + 1);
274             payloadBuilder.insert(payloadBuilder.toString().indexOf('}', 2) + 1, "]");
275         } else {
276             payloadBuilder.delete(0, payloadBuilder.toString().indexOf(':') + 1);
277             payloadBuilder.replace(payloadBuilder.length() - 2, payloadBuilder.length() - 1, ",");
278             payloadBuilder.deleteCharAt(payloadBuilder.toString().lastIndexOf('}'));
279         }
280         return payloadBuilder.toString();
281     }
282
283     @SuppressWarnings("checkstyle:regexpSinglelineJava")
284     void validate() {
285         if (editContent == null) {
286             stream = TesttoolParameters.class.getResourceAsStream(RESOURCE);
287         } else {
288             Preconditions.checkArgument(!editContent.isDirectory(), "Edit content file is a dir");
289             Preconditions.checkArgument(editContent.canRead(), "Edit content file is unreadable");
290         }
291
292         if (controllerDestination != null) {
293             Preconditions.checkArgument(controllerDestination.contains(":"),
294                 "Controller Destination needs to be in a following format <ip>:<port>");
295             final String[] parts = controllerDestination.split(Pattern.quote(":"));
296             Preconditions.checkArgument(Integer.parseInt(parts[1]) > 0, "Port =< 0");
297         }
298
299         checkArgument(deviceCount > 0, "Device count has to be > 0");
300         checkArgument(startingPort > 1023, "Starting port has to be > 1023");
301         checkArgument(devicesPerPort > 0, "Atleast one device per port needed");
302
303         if (schemasDir != null) {
304             checkArgument(schemasDir.exists(), "Schemas dir has to exist");
305             checkArgument(schemasDir.isDirectory(), "Schemas dir has to be a directory");
306             checkArgument(schemasDir.canRead(), "Schemas dir has to be readable");
307
308             final List<File> files = Arrays.asList(schemasDir.listFiles());
309             for (final File file : files) {
310                 final Matcher matcher = YANG_FILENAME_PATTERN.matcher(file.getName());
311                 if (!matcher.matches()) {
312                     final BufferedReader reader;
313                     try {
314                         reader = new BufferedReader(new FileReader(file));
315                         String line = reader.readLine();
316                         while (!DATE_PATTERN.matcher(line).find()) {
317                             line = reader.readLine();
318                         }
319                         final Matcher m = DATE_PATTERN.matcher(line);
320
321                         if (m.find()) {
322                             String moduleName = file.getAbsolutePath();
323                             if (file.getName().endsWith(".yang")) {
324                                 moduleName = moduleName.substring(0, moduleName.length() - 5);
325                             }
326                             final String revision = m.group(1);
327                             final String correctName = moduleName + "@" + revision + ".yang";
328                             final File correctNameFile = new File(correctName);
329                             file.renameTo(correctNameFile);
330                         }
331                     } catch (final IOException e) {
332                         // print error to console (test tool is running from console)
333                         e.printStackTrace();
334                     }
335                 }
336             }
337         }
338         if (rpcConfig != null) {
339             checkArgument(rpcConfig.exists(), "Rpc config file has to exist");
340             checkArgument(!rpcConfig.isDirectory(), "Rpc config file can't be a directory");
341             checkArgument(rpcConfig.canRead(), "Rpc config file to be readable");
342         }
343     }
344
345     public ArrayList<ArrayList<Execution.DestToPayload>> getThreadsPayloads(final List<Integer> openDevices) {
346         final String editContentString;
347         try {
348             if (stream == null) {
349                 editContentString = Files.toString(editContent, StandardCharsets.UTF_8);
350             } else {
351                 editContentString = CharStreams.toString(new InputStreamReader(stream, StandardCharsets.UTF_8));
352             }
353         } catch (final IOException e) {
354             throw new IllegalArgumentException("Cannot read content of " + editContent);
355         }
356
357         int from;
358         int to;
359         Iterator<Integer> iterator;
360
361         final ArrayList<ArrayList<Execution.DestToPayload>> allThreadsPayloads = new ArrayList<>();
362         if (generateConfigBatchSize > 1) {
363
364             final int batchedRequests = openDevices.size() / generateConfigBatchSize;
365             final int batchedRequestsPerThread = batchedRequests / threadAmount;
366             final int leftoverBatchedRequests = (batchedRequests) % threadAmount;
367             final int leftoverRequests = openDevices.size() - (batchedRequests * generateConfigBatchSize);
368
369             final StringBuilder destBuilder = new StringBuilder(DEST);
370             destBuilder.replace(destBuilder.indexOf(ADDRESS_PORT),
371                 destBuilder.indexOf(ADDRESS_PORT) + ADDRESS_PORT.length(),
372                 controllerDestination);
373
374             for (int l = 0; l < threadAmount; l++) {
375                 from = l * (batchedRequests * batchedRequestsPerThread);
376                 to = from + (batchedRequests * batchedRequestsPerThread);
377                 iterator = openDevices.subList(from, to).iterator();
378                 allThreadsPayloads.add(createBatchedPayloads(batchedRequestsPerThread, iterator, editContentString,
379                     destBuilder.toString()));
380             }
381             ArrayList<Execution.DestToPayload> payloads = null;
382             if (leftoverBatchedRequests > 0) {
383                 from = threadAmount * (batchedRequests * batchedRequestsPerThread);
384                 to = from + (batchedRequests * batchedRequestsPerThread);
385                 iterator = openDevices.subList(from, to).iterator();
386                 payloads = createBatchedPayloads(leftoverBatchedRequests, iterator, editContentString,
387                     destBuilder.toString());
388             }
389             String payload = "";
390
391             for (int j = 0; j < leftoverRequests; j++) {
392                 from = openDevices.size() - leftoverRequests;
393                 to = openDevices.size();
394                 iterator = openDevices.subList(from, to).iterator();
395                 final StringBuilder payloadBuilder = new StringBuilder(
396                     prepareMessage(iterator.next(), editContentString));
397                 payload += modifyMessage(payloadBuilder, j, leftoverRequests);
398             }
399             if (leftoverRequests > 0 || leftoverBatchedRequests > 0) {
400
401                 if (payloads != null) {
402                     payloads.add(new Execution.DestToPayload(destBuilder.toString(), payload));
403                 }
404                 allThreadsPayloads.add(payloads);
405             }
406         } else {
407             final int requestPerThreads = openDevices.size() / threadAmount;
408             final int leftoverRequests = openDevices.size() % threadAmount;
409
410             for (int i = 0; i < threadAmount; i++) {
411                 from = i * requestPerThreads;
412                 to = from + requestPerThreads;
413                 iterator = openDevices.subList(from, to).iterator();
414                 allThreadsPayloads.add(createPayloads(iterator, editContentString));
415             }
416
417             if (leftoverRequests > 0) {
418                 from = (threadAmount) * requestPerThreads;
419                 to = from + leftoverRequests;
420                 iterator = openDevices.subList(from, to).iterator();
421                 allThreadsPayloads.add(createPayloads(iterator, editContentString));
422             }
423         }
424         return allThreadsPayloads;
425     }
426
427     private String prepareMessage(final int openDevice, final String editContentString) {
428         final StringBuilder messageBuilder = new StringBuilder(editContentString);
429
430         if (editContentString.contains(HOST_KEY)) {
431             messageBuilder.replace(messageBuilder.indexOf(HOST_KEY),
432                 messageBuilder.indexOf(HOST_KEY) + HOST_KEY.length(),
433                 generateConfigsAddress);
434         }
435         if (editContentString.contains(PORT_KEY)) {
436             while (messageBuilder.indexOf(PORT_KEY) != -1) {
437                 messageBuilder.replace(messageBuilder.indexOf(PORT_KEY),
438                     messageBuilder.indexOf(PORT_KEY) + PORT_KEY.length(),
439                     Integer.toString(openDevice));
440             }
441         }
442         if (editContentString.contains(TCP_ONLY)) {
443             messageBuilder.replace(messageBuilder.indexOf(TCP_ONLY),
444                 messageBuilder.indexOf(TCP_ONLY) + TCP_ONLY.length(),
445                 Boolean.toString(!ssh));
446         }
447         return messageBuilder.toString();
448     }
449
450     private ArrayList<Execution.DestToPayload> createPayloads(final Iterator<Integer> openDevices,
451                                                               final String editContentString) {
452         final ArrayList<Execution.DestToPayload> payloads = new ArrayList<>();
453
454         while (openDevices.hasNext()) {
455             final StringBuilder destBuilder = new StringBuilder(DEST);
456             destBuilder.replace(destBuilder.indexOf(ADDRESS_PORT),
457                 destBuilder.indexOf(ADDRESS_PORT) + ADDRESS_PORT.length(), controllerDestination);
458             payloads.add(new Execution.DestToPayload(
459                 destBuilder.toString(), prepareMessage(openDevices.next(), editContentString)));
460         }
461         return payloads;
462     }
463
464     private ArrayList<Execution.DestToPayload> createBatchedPayloads(final int batchedRequestsCount,
465             final Iterator<Integer> openDevices, final String editContentString, final String destination) {
466         final ArrayList<Execution.DestToPayload> payloads = new ArrayList<>();
467
468         for (int i = 0; i < batchedRequestsCount; i++) {
469             String payload = "";
470             for (int j = 0; j < generateConfigBatchSize; j++) {
471                 final StringBuilder payloadBuilder = new StringBuilder(
472                     prepareMessage(openDevices.next(), editContentString));
473                 payload += modifyMessage(payloadBuilder, j, generateConfigBatchSize);
474             }
475             payloads.add(new Execution.DestToPayload(destination, payload));
476         }
477         return payloads;
478     }
479
480     @Override
481     public String toString() {
482         final List<Field> fields = Arrays.asList(this.getClass().getDeclaredFields());
483         final StringJoiner joiner = new StringJoiner(", \n", "TesttoolParameters{", "}\n");
484         fields.stream()
485                 .filter(field -> field.getAnnotation(Arg.class) != null)
486                 .map(this::getFieldString)
487                 .forEach(joiner::add);
488         return joiner.toString();
489     }
490
491     private String getFieldString(final Field field) {
492         try {
493             return field.getName() + "='" + field.get(this) + "'";
494         } catch (final IllegalAccessException e) {
495             return field.getName() + "= UNKNOWN";
496         }
497     }
498 }