opendaylight/netconf/netconf-testtool/src/main/java/org/opendaylight/controller/netconf/test/tool/Main.java

   1 /*
   2  * Copyright (c) 2014 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.controller.netconf.test.tool;
  10
  11 import static com.google.common.base.Preconditions.checkArgument;
  12 import static com.google.common.base.Preconditions.checkNotNull;
  13 import static com.google.common.base.Preconditions.checkState;
  14
  15 import ch.qos.logback.classic.Level;
  16 import com.google.common.base.Charsets;
  17 import com.google.common.base.Preconditions;
  18 import com.google.common.collect.Lists;
  19 import com.google.common.io.ByteStreams;
  20 import com.google.common.io.CharStreams;
  21 import com.google.common.io.Files;
  22 import java.io.File;
  23 import java.io.FileFilter;
  24 import java.io.IOException;
  25 import java.io.InputStream;
  26 import java.io.InputStreamReader;
  27 import java.util.Collections;
  28 import java.util.Comparator;
  29 import java.util.List;
  30 import java.util.concurrent.TimeUnit;
  31 import net.sourceforge.argparse4j.ArgumentParsers;
  32 import net.sourceforge.argparse4j.annotation.Arg;
  33 import net.sourceforge.argparse4j.inf.ArgumentParser;
  34 import net.sourceforge.argparse4j.inf.ArgumentParserException;
  35 import org.opendaylight.controller.netconf.util.xml.XmlElement;
  36 import org.opendaylight.controller.netconf.util.xml.XmlUtil;
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39 import org.w3c.dom.Document;
  40 import org.w3c.dom.Element;
  41 import org.w3c.dom.Node;
  42 import org.w3c.dom.NodeList;
  43 import org.xml.sax.SAXException;
  44
  45 public final class Main {
  46
  47     private static final Logger LOG = LoggerFactory.getLogger(Main.class);
  48
  49     static class Params {
  50
  51         @Arg(dest = "schemas-dir")
  52         public File schemasDir;
  53
  54         @Arg(dest = "devices-count")
  55         public int deviceCount;
  56
  57         @Arg(dest = "starting-port")
  58         public int startingPort;
  59
  60         @Arg(dest = "generate-config-connection-timeout")
  61         public int generateConfigsTimeout;
  62
  63         @Arg(dest = "generate-config-address")
  64         public String generateConfigsAddress;
  65
  66         @Arg(dest = "distro-folder")
  67         public File distroFolder;
  68
  69         @Arg(dest = "generate-configs-batch-size")
  70         public int generateConfigBatchSize;
  71
  72         @Arg(dest = "ssh")
  73         public boolean ssh;
  74
  75         @Arg(dest = "exi")
  76         public boolean exi;
  77
  78         @Arg(dest = "debug")
  79         public boolean debug;
  80
  81         static ArgumentParser getParser() {
  82             final ArgumentParser parser = ArgumentParsers.newArgumentParser("netconf testool");
  83
  84             parser.description("Netconf device simulator. Detailed info can be found at https://wiki.opendaylight.org/view/OpenDaylight_Controller:Netconf:Testtool#Building_testtool");
  85
  86             parser.addArgument("--device-count")
  87                     .type(Integer.class)
  88                     .setDefault(1)
  89                     .type(Integer.class)
  90                     .help("Number of simulated netconf devices to spin")
  91                     .dest("devices-count");
  92
  93             parser.addArgument("--schemas-dir")
  94                     .type(File.class)
  95                     .help("Directory containing yang schemas to describe simulated devices. Some schemas e.g. netconf monitoring and inet types are included by default")
  96                     .dest("schemas-dir");
  97
  98             parser.addArgument("--starting-port")
  99                     .type(Integer.class)
 100                     .setDefault(17830)
 101                     .help("First port for simulated device. Each other device will have previous+1 port number")
 102                     .dest("starting-port");
 103
 104             parser.addArgument("--generate-config-connection-timeout")
 105                     .type(Integer.class)
 106                     .setDefault((int)TimeUnit.MINUTES.toMillis(30))
 107                     .help("Timeout to be generated in initial config files")
 108                     .dest("generate-config-connection-timeout");
 109
 110             parser.addArgument("--generate-config-address")
 111                     .type(String.class)
 112                     .setDefault("127.0.0.1")
 113                     .help("Address to be placed in generated configs")
 114                     .dest("generate-config-address");
 115
 116             parser.addArgument("--generate-configs-batch-size")
 117                     .type(Integer.class)
 118                     .setDefault(4000)
 119                     .help("Number of connector configs per generated file")
 120                     .dest("generate-configs-batch-size");
 121
 122             parser.addArgument("--distribution-folder")
 123                     .type(File.class)
 124                     .help("Directory where the karaf distribution for controller is located")
 125                     .dest("distro-folder");
 126
 127             parser.addArgument("--ssh")
 128                     .type(Boolean.class)
 129                     .setDefault(true)
 130                     .help("Whether to use ssh for transport or just pure tcp")
 131                     .dest("ssh");
 132
 133             parser.addArgument("--exi")
 134                     .type(Boolean.class)
 135                     .setDefault(true)
 136                     .help("Whether to use exi to transport xml content")
 137                     .dest("exi");
 138
 139             parser.addArgument("--debug")
 140                     .type(Boolean.class)
 141                     .setDefault(false)
 142                     .help("Whether to use debug log level instead of INFO")
 143                     .dest("debug");
 144
 145             return parser;
 146         }
 147
 148         void validate() {
 149             checkArgument(deviceCount > 0, "Device count has to be > 0");
 150             checkArgument(startingPort > 1024, "Starting port has to be > 1024");
 151
 152             if(schemasDir != null) {
 153                 checkArgument(schemasDir.exists(), "Schemas dir has to exist");
 154                 checkArgument(schemasDir.isDirectory(), "Schemas dir has to be a directory");
 155                 checkArgument(schemasDir.canRead(), "Schemas dir has to be readable");
 156             }
 157         }
 158     }
 159
 160     public static void main(final String[] args) {
 161         final Params params = parseArgs(args, Params.getParser());
 162         params.validate();
 163
 164         final ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
 165         root.setLevel(params.debug ? Level.DEBUG : Level.INFO);
 166
 167         final NetconfDeviceSimulator netconfDeviceSimulator = new NetconfDeviceSimulator();
 168         try {
 169             final List<Integer> openDevices = netconfDeviceSimulator.start(params);
 170             if(params.distroFolder != null) {
 171                 final ConfigGenerator configGenerator = new ConfigGenerator(params.distroFolder, openDevices);
 172                 final List<File> generated = configGenerator.generate(params.ssh, params.generateConfigBatchSize, params.generateConfigsTimeout, params.generateConfigsAddress);
 173                 configGenerator.updateFeatureFile(generated);
 174                 configGenerator.changeLoadOrder();
 175             }
 176         } catch (final Exception e) {
 177             LOG.error("Unhandled exception", e);
 178             netconfDeviceSimulator.close();
 179             System.exit(1);
 180         }
 181
 182         // Block main thread
 183         synchronized (netconfDeviceSimulator) {
 184             try {
 185                 netconfDeviceSimulator.wait();
 186             } catch (final InterruptedException e) {
 187                 throw new RuntimeException(e);
 188             }
 189         }
 190     }
 191
 192     private static Params parseArgs(final String[] args, final ArgumentParser parser) {
 193         final Params opt = new Params();
 194         try {
 195             parser.parseArgs(args, opt);
 196             return opt;
 197         } catch (final ArgumentParserException e) {
 198             parser.handleError(e);
 199         }
 200
 201         System.exit(1);
 202         return null;
 203     }
 204
 205     private static class ConfigGenerator {
 206         public static final String NETCONF_CONNECTOR_XML = "/initial/99-netconf-connector.xml";
 207         public static final String NETCONF_CONNECTOR_NAME = "controller-config";
 208         public static final String NETCONF_CONNECTOR_PORT = "1830";
 209         public static final String NETCONF_CONNECTOR_ADDRESS = "127.0.0.1";
 210         public static final String NETCONF_USE_SSH = "false";
 211         public static final String SIM_DEVICE_SUFFIX = "-sim-device";
 212
 213         private static final String SIM_DEVICE_CFG_PREFIX = "simulated-devices_";
 214         private static final String ETC_KARAF_PATH = "etc/";
 215         private static final String ETC_OPENDAYLIGHT_KARAF_PATH = ETC_KARAF_PATH + "opendaylight/karaf/";
 216
 217         public static final String NETCONF_CONNECTOR_ALL_FEATURE = "odl-netconf-connector-all";
 218         private static final String ORG_OPS4J_PAX_URL_MVN_CFG = "org.ops4j.pax.url.mvn.cfg";
 219
 220         private final File configDir;
 221         private final List<Integer> openDevices;
 222         private final File ncFeatureFile;
 223         private final File etcDir;
 224         private final File loadOrderCfgFile;
 225
 226         public ConfigGenerator(final File directory, final List<Integer> openDevices) {
 227             this.configDir = new File(directory, ETC_OPENDAYLIGHT_KARAF_PATH);
 228             this.etcDir = new File(directory, ETC_KARAF_PATH);
 229             this.loadOrderCfgFile = new File(etcDir, ORG_OPS4J_PAX_URL_MVN_CFG);
 230             this.ncFeatureFile = getFeatureFile(directory, "features-netconf-connector");
 231             this.openDevices = openDevices;
 232         }
 233
 234         public List<File> generate(final boolean useSsh, final int batchSize, final int generateConfigsTimeout, final String address) {
 235             if(configDir.exists() == false) {
 236                 Preconditions.checkState(configDir.mkdirs(), "Unable to create directory " + configDir);
 237             }
 238
 239             for (final File file : configDir.listFiles(new FileFilter() {
 240                 @Override
 241                 public boolean accept(final File pathname) {
 242                     return !pathname.isDirectory() && pathname.getName().startsWith(SIM_DEVICE_CFG_PREFIX);
 243                 }
 244             })) {
 245                 Preconditions.checkState(file.delete(), "Unable to clean previous generated file %s", file);
 246             }
 247
 248             try(InputStream stream = Main.class.getResourceAsStream(NETCONF_CONNECTOR_XML)) {
 249                 checkNotNull(stream, "Cannot load %s", NETCONF_CONNECTOR_XML);
 250                 String configBlueprint = CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8));
 251
 252                 checkState(configBlueprint.contains(NETCONF_CONNECTOR_NAME));
 253                 checkState(configBlueprint.contains(NETCONF_CONNECTOR_PORT));
 254                 checkState(configBlueprint.contains(NETCONF_USE_SSH));
 255                 checkState(configBlueprint.contains(NETCONF_CONNECTOR_ADDRESS));
 256                 configBlueprint = configBlueprint.replace(NETCONF_CONNECTOR_NAME, "%s");
 257                 configBlueprint = configBlueprint.replace(NETCONF_CONNECTOR_ADDRESS, "%s");
 258                 configBlueprint = configBlueprint.replace(NETCONF_CONNECTOR_PORT, "%s");
 259                 configBlueprint = configBlueprint.replace(NETCONF_USE_SSH, "%s");
 260
 261                 final String before = configBlueprint.substring(0, configBlueprint.indexOf("<module>"));
 262                 final String middleBlueprint = configBlueprint.substring(configBlueprint.indexOf("<module>"), configBlueprint.indexOf("</module>"));
 263                 final String after = configBlueprint.substring(configBlueprint.indexOf("</module>") + "</module>".length());
 264
 265                 int connectorCount = 0;
 266                 Integer batchStart = null;
 267                 StringBuilder b = new StringBuilder();
 268                 b.append(before);
 269
 270                 final List<File> generatedConfigs = Lists.newArrayList();
 271
 272                 for (final Integer openDevice : openDevices) {
 273                     if(batchStart == null) {
 274                         batchStart = openDevice;
 275                     }
 276
 277                     final String name = String.valueOf(openDevice) + SIM_DEVICE_SUFFIX;
 278                     String configContent = String.format(middleBlueprint, name, address, String.valueOf(openDevice), String.valueOf(!useSsh));
 279                     configContent = String.format("%s%s%d%s\n%s\n", configContent, "<connection-timeout-millis>", generateConfigsTimeout, "</connection-timeout-millis>", "</module>");
 280
 281                     b.append(configContent);
 282                     connectorCount++;
 283                     if(connectorCount == batchSize) {
 284                         b.append(after);
 285                         final File to = new File(configDir, String.format(SIM_DEVICE_CFG_PREFIX + "%d-%d.xml", batchStart, openDevice));
 286                         generatedConfigs.add(to);
 287                         Files.write(b.toString(), to, Charsets.UTF_8);
 288                         connectorCount = 0;
 289                         b = new StringBuilder();
 290                         b.append(before);
 291                         batchStart = null;
 292                     }
 293                 }
 294
 295                 // Write remaining
 296                 if(connectorCount != 0) {
 297                     b.append(after);
 298                     final File to = new File(configDir, String.format(SIM_DEVICE_CFG_PREFIX + "%d-%d.xml", batchStart, openDevices.get(openDevices.size() - 1)));
 299                     generatedConfigs.add(to);
 300                     Files.write(b.toString(), to, Charsets.UTF_8);
 301                 }
 302
 303                 LOG.info("Config files generated in {}", configDir);
 304                 return generatedConfigs;
 305             } catch (final IOException e) {
 306                 throw new RuntimeException("Unable to generate config files", e);
 307             }
 308         }
 309
 310
 311         public void updateFeatureFile(final List<File> generated) {
 312             // TODO karaf core contains jaxb for feature files, use that for modification
 313             try {
 314                 final Document document = XmlUtil.readXmlToDocument(Files.toString(ncFeatureFile, Charsets.UTF_8));
 315                 final NodeList childNodes = document.getDocumentElement().getChildNodes();
 316
 317                 for (int i = 0; i < childNodes.getLength(); i++) {
 318                     final Node item = childNodes.item(i);
 319                     if(item instanceof Element == false) {
 320                         continue;
 321                     }
 322                     if(item.getLocalName().equals("feature") ==false) {
 323                         continue;
 324                     }
 325
 326                     if(NETCONF_CONNECTOR_ALL_FEATURE.equals(((Element) item).getAttribute("name"))) {
 327                         final Element ncAllFeatureDefinition = (Element) item;
 328                         // Clean previous generated files
 329                         for (final XmlElement configfile : XmlElement.fromDomElement(ncAllFeatureDefinition).getChildElements("configfile")) {
 330                             ncAllFeatureDefinition.removeChild(configfile.getDomElement());
 331                         }
 332                         for (final File file : generated) {
 333                             final Element configfile = document.createElement("configfile");
 334                             configfile.setTextContent("file:" + ETC_OPENDAYLIGHT_KARAF_PATH + file.getName());
 335                             configfile.setAttribute("finalname", ETC_OPENDAYLIGHT_KARAF_PATH + file.getName());
 336                             ncAllFeatureDefinition.appendChild(configfile);
 337                         }
 338                     }
 339                 }
 340
 341                 Files.write(XmlUtil.toString(document), ncFeatureFile, Charsets.UTF_8);
 342                 LOG.info("Feature file {} updated", ncFeatureFile);
 343             } catch (final IOException e) {
 344                 throw new RuntimeException("Unable to load features file as a resource");
 345             } catch (final SAXException e) {
 346                 throw new RuntimeException("Unable to parse features file");
 347             }
 348         }
 349
 350
 351         private static File getFeatureFile(final File distroFolder, final String featureName) {
 352             checkExistingDir(distroFolder, String.format("Folder %s does not exist", distroFolder));
 353
 354             final File systemDir = checkExistingDir(new File(distroFolder, "system"), String.format("Folder %s does not contain a karaf distro, folder system is missing", distroFolder));
 355             final File netconfConnectorFeaturesParentDir = checkExistingDir(new File(systemDir, "org/opendaylight/controller/" + featureName), String.format("Karaf distro in %s does not contain netconf-connector features", distroFolder));
 356
 357             // Find newest version for features
 358             final File newestVersionDir = Collections.max(
 359                     Lists.newArrayList(netconfConnectorFeaturesParentDir.listFiles(new FileFilter() {
 360                         @Override
 361                         public boolean accept(final File pathname) {
 362                             return pathname.isDirectory();
 363                         }
 364                     })), new Comparator<File>() {
 365                         @Override
 366                         public int compare(final File o1, final File o2) {
 367                             return o1.getName().compareTo(o2.getName());
 368                         }
 369                     });
 370
 371             return newestVersionDir.listFiles(new FileFilter() {
 372                 @Override
 373                 public boolean accept(final File pathname) {
 374                     return pathname.getName().contains(featureName);
 375                 }
 376             })[0];
 377         }
 378
 379         private static File checkExistingDir(final File folder, final String msg) {
 380             Preconditions.checkArgument(folder.exists(), msg);
 381             Preconditions.checkArgument(folder.isDirectory(), msg);
 382             return folder;
 383         }
 384
 385         public void changeLoadOrder() {
 386             try {
 387                 Files.write(ByteStreams.toByteArray(getClass().getResourceAsStream("/" +ORG_OPS4J_PAX_URL_MVN_CFG)), loadOrderCfgFile);
 388                 LOG.info("Load order changed to prefer local bundles/features by rewriting file {}", loadOrderCfgFile);
 389             } catch (IOException e) {
 390                 throw new RuntimeException("Unable to rewrite features file " + loadOrderCfgFile, e);
 391             }
 392         }
 393     }
 394 }