netconf/tools/netconf-testtool/src/main/java/org/opendaylight/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.netconf.test.tool;
  10
  11 import static com.google.common.base.Preconditions.checkNotNull;
  12
  13 import ch.qos.logback.classic.Level;
  14 import com.google.common.base.Preconditions;
  15 import com.google.common.base.Stopwatch;
  16 import com.google.common.collect.Lists;
  17 import com.google.common.io.ByteStreams;
  18 import com.google.common.io.CharStreams;
  19 import com.google.common.io.Files;
  20 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  21 import java.io.File;
  22 import java.io.FileWriter;
  23 import java.io.IOException;
  24 import java.io.InputStream;
  25 import java.io.InputStreamReader;
  26 import java.nio.charset.StandardCharsets;
  27 import java.util.ArrayList;
  28 import java.util.Collections;
  29 import java.util.Comparator;
  30 import java.util.List;
  31 import java.util.concurrent.ExecutionException;
  32 import java.util.concurrent.ExecutorService;
  33 import java.util.concurrent.Executors;
  34 import java.util.concurrent.Future;
  35 import java.util.concurrent.TimeUnit;
  36 import javax.xml.bind.JAXBException;
  37 import org.apache.karaf.features.internal.model.ConfigFile;
  38 import org.apache.karaf.features.internal.model.Feature;
  39 import org.apache.karaf.features.internal.model.Features;
  40 import org.apache.karaf.features.internal.model.JaxbUtil;
  41 import org.opendaylight.netconf.test.tool.config.Configuration;
  42 import org.opendaylight.netconf.test.tool.config.ConfigurationBuilder;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45
  46 @SuppressFBWarnings("DM_DEFAULT_ENCODING")
  47 public final class Main {
  48     private static final Logger LOG = LoggerFactory.getLogger(Main.class);
  49
  50     private Main() {
  51
  52     }
  53
  54     @SuppressWarnings("checkstyle:IllegalCatch")
  55     @SuppressFBWarnings({"UW_UNCOND_WAIT", "WA_NOT_IN_LOOP"})
  56     public static void main(final String[] args) {
  57         final TesttoolParameters params = TesttoolParameters.parseArgs(args, TesttoolParameters.getParser());
  58         params.validate();
  59         final ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory
  60             .getLogger(Logger.ROOT_LOGGER_NAME);
  61         root.setLevel(params.debug ? Level.DEBUG : Level.INFO);
  62
  63         final Configuration configuration = new ConfigurationBuilder().from(params).build();
  64         final NetconfDeviceSimulator netconfDeviceSimulator = new NetconfDeviceSimulator(configuration);
  65         try {
  66             LOG.debug("Trying to start netconf test-tool with parameters {}", params);
  67             final List<Integer> openDevices = netconfDeviceSimulator.start();
  68             if (openDevices.size() == 0) {
  69                 LOG.error("Failed to start any simulated devices, exiting...");
  70                 System.exit(1);
  71             }
  72             if (params.controllerDestination != null) {
  73                 final ArrayList<ArrayList<Execution.DestToPayload>> allThreadsPayloads = params
  74                     .getThreadsPayloads(openDevices);
  75                 final ArrayList<Execution> executions = new ArrayList<>();
  76                 for (ArrayList<Execution.DestToPayload> payloads : allThreadsPayloads) {
  77                     executions.add(new Execution(params, payloads));
  78                 }
  79                 final ExecutorService executorService = Executors.newFixedThreadPool(params.threadAmount);
  80                 final Stopwatch time = Stopwatch.createStarted();
  81                 List<Future<Void>> futures = executorService.invokeAll(executions, params.timeOut, TimeUnit.SECONDS);
  82                 int threadNum = 0;
  83                 for (Future<Void> future : futures) {
  84                     threadNum++;
  85                     if (future.isCancelled()) {
  86                         LOG.info("{}. thread timed out.",threadNum);
  87                     } else {
  88                         try {
  89                             future.get();
  90                         } catch (final ExecutionException | InterruptedException e) {
  91                             LOG.info("{}. thread failed.", threadNum, e);
  92                         }
  93                     }
  94                 }
  95                 time.stop();
  96                 LOG.info("Time spent with configuration of devices: {}.",time);
  97             }
  98
  99             if (params.distroFolder != null) {
 100                 final ConfigGenerator configGenerator = new ConfigGenerator(params.distroFolder, openDevices);
 101                 final List<File> generated = configGenerator.generate(
 102                         params.ssh, params.generateConfigBatchSize,
 103                         params.generateConfigsTimeout, params.generateConfigsAddress,
 104                         params.devicesPerPort);
 105                 configGenerator.updateFeatureFile(generated);
 106                 configGenerator.changeLoadOrder();
 107             }
 108         } catch (RuntimeException | InterruptedException e) {
 109             LOG.error("Unhandled exception", e);
 110             netconfDeviceSimulator.close();
 111             System.exit(1);
 112         }
 113
 114         // Block main thread
 115         synchronized (netconfDeviceSimulator) {
 116             try {
 117                 netconfDeviceSimulator.wait();
 118             } catch (final InterruptedException e) {
 119                 throw new RuntimeException(e);
 120             }
 121         }
 122     }
 123
 124     static class ConfigGenerator {
 125         public static final String NETCONF_CONNECTOR_XML = "/99-netconf-connector-simulated.xml";
 126         public static final String SIM_DEVICE_SUFFIX = "-sim-device";
 127
 128         private static final String SIM_DEVICE_CFG_PREFIX = "simulated-devices_";
 129         private static final String ETC_KARAF_PATH = "etc/";
 130         private static final String ETC_OPENDAYLIGHT_KARAF_PATH = ETC_KARAF_PATH + "opendaylight/karaf/";
 131
 132         public static final String NETCONF_CONNECTOR_ALL_FEATURE = "odl-netconf-connector-all";
 133         private static final String ORG_OPS4J_PAX_URL_MVN_CFG = "org.ops4j.pax.url.mvn.cfg";
 134
 135         private final File configDir;
 136         private final List<Integer> openDevices;
 137         private final List<File> ncFeatureFiles;
 138         private final File etcDir;
 139         private final File loadOrderCfgFile;
 140
 141         ConfigGenerator(final File directory, final List<Integer> openDevices) {
 142             this.configDir = new File(directory, ETC_OPENDAYLIGHT_KARAF_PATH);
 143             this.etcDir = new File(directory, ETC_KARAF_PATH);
 144             this.loadOrderCfgFile = new File(etcDir, ORG_OPS4J_PAX_URL_MVN_CFG);
 145             this.ncFeatureFiles = getFeatureFile(directory, "features-netconf-connector", "xml");
 146             this.openDevices = openDevices;
 147         }
 148
 149         public List<File> generate(final boolean useSsh, final int batchSize,
 150                                    final int generateConfigsTimeout, final String address,
 151                                    final int devicesPerPort) {
 152             if (!configDir.exists()) {
 153                 Preconditions.checkState(configDir.mkdirs(), "Unable to create directory " + configDir);
 154             }
 155
 156             final File[] files = configDir.listFiles(pathname ->
 157                     !pathname.isDirectory() && pathname.getName().startsWith(SIM_DEVICE_CFG_PREFIX));
 158             if (files != null) {
 159                 for (final File file : files) {
 160                     Preconditions.checkState(file.delete(), "Unable to clean previous generated file %s", file);
 161                 }
 162             }
 163
 164             try (InputStream stream = Main.class.getResourceAsStream(NETCONF_CONNECTOR_XML)) {
 165                 checkNotNull(stream, "Cannot load %s", NETCONF_CONNECTOR_XML);
 166                 String configBlueprint = CharStreams.toString(new InputStreamReader(stream, StandardCharsets.UTF_8));
 167
 168                 final String before = configBlueprint.substring(0, configBlueprint.indexOf("<module>"));
 169                 final String middleBlueprint = configBlueprint.substring(
 170                     configBlueprint.indexOf("<module>"), configBlueprint.indexOf("</module>"));
 171                 final String after = configBlueprint.substring(
 172                     configBlueprint.indexOf("</module>") + "</module>".length());
 173
 174                 int connectorCount = 0;
 175                 Integer batchStart = null;
 176                 StringBuilder builder = new StringBuilder();
 177                 builder.append(before);
 178
 179                 final List<File> generatedConfigs = Lists.newArrayList();
 180
 181                 for (final Integer openDevice : openDevices) {
 182                     if (batchStart == null) {
 183                         batchStart = openDevice;
 184                     }
 185
 186                     for (int i = 0; i < devicesPerPort; i++) {
 187                         final String name = String.valueOf(openDevice)
 188                             + SIM_DEVICE_SUFFIX + (i == 0 ? "" : "-" + String.valueOf(i));
 189                         String configContent = String.format(
 190                             middleBlueprint, name, address, String.valueOf(openDevice), String.valueOf(!useSsh));
 191                         configContent = String.format(
 192                             "%s%s%d%s%n%s%n", configContent, "<connection-timeout-millis>",
 193                             generateConfigsTimeout, "</connection-timeout-millis>", "</module>");
 194
 195                         builder.append(configContent);
 196                         connectorCount++;
 197                         if (connectorCount == batchSize) {
 198                             builder.append(after);
 199                             final File to = new File(
 200                                 configDir, String.format(SIM_DEVICE_CFG_PREFIX + "%d-%d.xml", batchStart, openDevice));
 201                             generatedConfigs.add(to);
 202                             Files.asCharSink(to, StandardCharsets.UTF_8).write(builder.toString());
 203                             connectorCount = 0;
 204                             builder = new StringBuilder();
 205                             builder.append(before);
 206                             batchStart = null;
 207                         }
 208                     }
 209                 }
 210
 211                 // Write remaining
 212                 if (connectorCount != 0) {
 213                     builder.append(after);
 214                     final File to = new File(configDir, String.format(
 215                             SIM_DEVICE_CFG_PREFIX + "%d-%d.xml", batchStart, openDevices.get(openDevices.size() - 1)));
 216                     generatedConfigs.add(to);
 217                     Files.asCharSink(to, StandardCharsets.UTF_8).write(builder.toString());
 218                 }
 219
 220                 LOG.info("Config files generated in {}", configDir);
 221                 return generatedConfigs;
 222             } catch (final IOException e) {
 223                 throw new RuntimeException("Unable to generate config files", e);
 224             }
 225         }
 226
 227         public void updateFeatureFile(final List<File> generated) {
 228             for (final File fileFeatures : ncFeatureFiles) {
 229                 try {
 230                     final Features f =  JaxbUtil.unmarshal(fileFeatures.toURI().toString(), false);
 231
 232                     for (final Feature feature : f.getFeature()) {
 233                         if (NETCONF_CONNECTOR_ALL_FEATURE.equals(feature.getName())) {
 234                             //Clean all previously generated configFiles
 235                             feature.getConfigfile().clear();
 236
 237                             //Create new configFiles
 238                             for (final File gen : generated) {
 239                                 final ConfigFile cf = new ConfigFile();
 240
 241                                 final String generatedName = ETC_OPENDAYLIGHT_KARAF_PATH + gen.getName();
 242
 243                                 cf.setFinalname(generatedName);
 244                                 cf.setLocation("file:" + generatedName);
 245
 246                                 feature.getConfigfile().add(cf);
 247                             }
 248                         }
 249                     }
 250                     JaxbUtil.marshal(f, new FileWriter(fileFeatures));
 251                     LOG.info("Feature file {} updated", fileFeatures);
 252                 } catch (JAXBException | IOException e) {
 253                     throw new RuntimeException(e);
 254                 }
 255             }
 256         }
 257
 258         private static List<File> getFeatureFile(final File distroFolder, final String featureName,
 259                                                  final String suffix) {
 260             checkExistingDir(distroFolder, String.format("Folder %s does not exist", distroFolder));
 261
 262             final File systemDir = checkExistingDir(new File(distroFolder, "system"),
 263                 String.format("Folder %s does not contain a karaf distro, folder system is missing", distroFolder));
 264
 265             //check if beryllium path exists, if it doesnt check for lithium and fail/succeed after
 266             File netconfConnectorFeaturesParentDir = new File(systemDir, "org/opendaylight/netconf/" + featureName);
 267             if (!netconfConnectorFeaturesParentDir.exists() || !netconfConnectorFeaturesParentDir.isDirectory()) {
 268                 netconfConnectorFeaturesParentDir = checkExistingDir(new File(systemDir,
 269                     "org/opendaylight/controller/" + featureName),
 270                     String.format("Karaf distro in %s does not contain netconf-connector features", distroFolder));
 271             }
 272
 273             // Find newest version for features
 274             final File newestVersionDir = Collections.max(
 275                 Lists.newArrayList(netconfConnectorFeaturesParentDir.listFiles(File::isDirectory)),
 276                 Comparator.comparing(File::getName));
 277
 278             return Lists.newArrayList(newestVersionDir.listFiles(
 279                 pathname -> pathname.getName().contains(featureName)
 280                     && Files.getFileExtension(pathname.getName()).equals(suffix)));
 281         }
 282
 283         private static File checkExistingDir(final File folder, final String msg) {
 284             Preconditions.checkArgument(folder.exists(), msg);
 285             Preconditions.checkArgument(folder.isDirectory(), msg);
 286             return folder;
 287         }
 288
 289         public void changeLoadOrder() {
 290             try {
 291                 Files.write(ByteStreams.toByteArray(getClass().getResourceAsStream(
 292                     "/" + ORG_OPS4J_PAX_URL_MVN_CFG)), loadOrderCfgFile);
 293                 LOG.info("Load order changed to prefer local bundles/features by rewriting file {}", loadOrderCfgFile);
 294             } catch (IOException e) {
 295                 throw new RuntimeException("Unable to rewrite features file " + loadOrderCfgFile, e);
 296             }
 297         }
 298     }
 299 }