lttng/org.eclipse.tracecompass.lttng2.control.ui.tests/stubs/org/eclipse/tracecompass/internal/lttng2/control/stubs/shells/LTTngToolsFileShell.java

   1 /**********************************************************************
   2  * Copyright (c) 2012, 2015 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Bernd Hufmann - Initial API and implementation
  11  *   Markus Schorn - Bug 448058: Use org.eclipse.remote in favor of RSE
  12  **********************************************************************/
  13 package org.eclipse.tracecompass.internal.lttng2.control.stubs.shells;
  14
  15 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  16
  17 import java.io.BufferedReader;
  18 import java.io.DataInputStream;
  19 import java.io.FileInputStream;
  20 import java.io.IOException;
  21 import java.io.InputStreamReader;
  22 import java.util.ArrayList;
  23 import java.util.Collection;
  24 import java.util.HashMap;
  25 import java.util.Iterator;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.regex.Matcher;
  29 import java.util.regex.Pattern;
  30
  31 import org.eclipse.core.commands.ExecutionException;
  32 import org.eclipse.core.runtime.IProgressMonitor;
  33 import org.eclipse.jdt.annotation.NonNull;
  34 import org.eclipse.tracecompass.internal.tmf.remote.core.stubs.shells.TestCommandShell;
  35 import org.eclipse.tracecompass.tmf.remote.core.shell.ICommandInput;
  36 import org.eclipse.tracecompass.tmf.remote.core.shell.ICommandOutputListener;
  37 import org.eclipse.tracecompass.tmf.remote.core.shell.ICommandResult;
  38
  39 @SuppressWarnings("javadoc")
  40 public class LTTngToolsFileShell extends TestCommandShell {
  41
  42     // ------------------------------------------------------------------------
  43     // CONSTANTS
  44     // ------------------------------------------------------------------------
  45     private final static String SCENARIO_KEY = "<SCENARIO>";
  46     private final static String SCENARIO_END_KEY = "</SCENARIO>";
  47     private final static String INPUT_KEY = "<COMMAND_INPUT>";
  48     private final static String INPUT_END_KEY = "</COMMAND_INPUT>";
  49     private final static String RESULT_KEY = "<COMMAND_RESULT>";
  50     private final static String OUTPUT_KEY = "<COMMAND_OUTPUT>";
  51     private final static String OUTPUT_END_KEY = "</COMMAND_OUTPUT>";
  52     private final static String ERROR_OUTPUT_KEY = "<COMMAND_ERROR_OUTPUT>";
  53     private final static String ERROR_OUTPUT_END_KEY = "</COMMAND_ERROR_OUTPUT>";
  54     private final static String COMMENT_KEY = "#.*";
  55
  56     private final static Pattern LTTNG_LIST_SESSION_PATTERN = Pattern.compile("lttng\\s+list\\s+(.+)");
  57     private final static String LTTNG_LIST_PROVIDER_PATTERN = "lttng\\s+list\\s+(-u|-k)";
  58
  59     private final static Pattern LTTNG_LIST_SESSION_MI_PATTERN = Pattern.compile("lttng\\s+--mi xml\\s+list\\s+(.+)");
  60     private final static String LTTNG_LIST_PROVIDER_MI_PATTERN = "lttng\\s+--mi xml\\s+list\\s+(-u|-k)";
  61
  62     // ------------------------------------------------------------------------
  63     // Attributes
  64     // ------------------------------------------------------------------------
  65     private String fScenariofile;
  66     private String fScenario;
  67
  68     private final Map<String, Map<String, ICommandResult>> fScenarioMap = new HashMap<>();
  69     private final Map<String, Integer> fSessionNameMap = new HashMap<>();
  70
  71     /**
  72      * Parse a scenario file with the format:
  73      *
  74      * <pre>
  75      * &lt;SCENARIO&gt;
  76      * ScenarioName
  77      *
  78      * &lt;COMMAND_INPUT&gt;
  79      * Command
  80      * &lt;/COMMAND_INPUT&gt;
  81      *
  82      * &lt;COMMAND_RESULT&gt;
  83      * CommandResult
  84      * &lt;/COMMAND_RESULT&gt;
  85      *
  86      * &lt;COMMAND_OUTPUT&gt;
  87      * CommandOutput
  88      * &lt;COMMAND_ERROR_OUTPUT&gt;
  89      * CommandErrorOutput
  90      * &lt;/COMMAND_ERROR_OUTPUT&gt;
  91      * &lt;/COMMAND_OUTPUT&gt;
  92      *
  93      * &lt;/SCENARIO&gt;
  94      *
  95      * Where: ScenarioName - is the scenario name
  96      *        Command - the command line string
  97      *        CommandResult - the result integer of the command (0 for success, 1 for failure)
  98      *        CommandOutput - the command output string (multi-line possible)
  99      *        CommandErrorOutput - the command error output string (multi-line possible)
 100      *
 101      * Note: 1) There can be many scenarios per file
 102      *       2) There can be many (Command-CommandResult-CommandOutput) triples per scenario
 103      * 3) Lines starting with # will be ignored (comments)
 104      *
 105      * <pre>
 106      * @param scenariofile - path to scenario file
 107      */
 108     public synchronized void loadScenarioFile(String scenariofile) {
 109         fScenariofile = scenariofile;
 110
 111         // clean up map
 112         Collection<Map<String, ICommandResult>> values = fScenarioMap.values();
 113         for (Iterator<Map<String, ICommandResult>> iterator = values.iterator(); iterator.hasNext();) {
 114             Map<String, ICommandResult> map = iterator.next();
 115             map.clear();
 116         }
 117         fScenarioMap.clear();
 118
 119         // load from file
 120
 121         // Open the file
 122         try (FileInputStream fstream = new FileInputStream(fScenariofile);
 123                 DataInputStream in = new DataInputStream(fstream);
 124                 BufferedReader br = new BufferedReader(new InputStreamReader(in));) {
 125             String strLine;
 126
 127             // Read File Line by Line
 128
 129             // Temporary map for generating instance numbers for lttng list
 130             // <session> commands.
 131             // The numbers are per scenario.
 132             Map<String, Integer> tmpSessionNameMap = new HashMap<>();
 133             while ((strLine = br.readLine()) != null) {
 134
 135                 // Ignore comments
 136                 if (isComment(strLine)) {
 137                     continue;
 138                 }
 139
 140                 if (SCENARIO_KEY.equals(strLine)) {
 141                     // scenario start
 142
 143                     // Ignore comments
 144                     strLine = br.readLine();
 145                     while (isComment(strLine)) {
 146                         strLine = br.readLine();
 147                     }
 148
 149                     String scenario = strLine;
 150                     Map<String, ICommandResult> commandMap = new HashMap<>();
 151                     fScenarioMap.put(scenario, commandMap);
 152                     List<String> output = null;
 153                     List<String> errorOutput = null;
 154                     String input = null;
 155                     boolean inOutput = false;
 156                     boolean inErrorOutput = false;
 157                     int result = 0;
 158                     tmpSessionNameMap.clear();
 159                     while ((strLine = br.readLine()) != null) {
 160                         // Ignore comments
 161                         if (isComment(strLine)) {
 162                             continue;
 163                         }
 164
 165                         if (SCENARIO_END_KEY.equals(strLine)) {
 166                             // Scenario is finished
 167                             break;
 168                         }
 169                         if (INPUT_KEY.equals(strLine)) {
 170                             strLine = br.readLine();
 171                             // Ignore comments
 172                             while (isComment(strLine)) {
 173                                 strLine = br.readLine();
 174                             }
 175                             // Read command
 176                             input = strLine;
 177
 178                             // Handle instances of 'lttng list
 179                             // <session"-command
 180                             Matcher matcher = LTTNG_LIST_SESSION_PATTERN.matcher(strLine);
 181                             Matcher miMatcher = LTTNG_LIST_SESSION_MI_PATTERN.matcher(strLine);
 182                             if (matcher.matches() && !input.matches(LTTNG_LIST_PROVIDER_PATTERN)) {
 183                                 String sessionName = matcher.group(1).trim();
 184                                 input += updateSessionMap(tmpSessionNameMap, input, sessionName);
 185                             } else if (miMatcher.matches() && !input.matches(LTTNG_LIST_PROVIDER_MI_PATTERN)) {
 186                                 String sessionName = miMatcher.group(1).trim();
 187                                 input += updateSessionMap(tmpSessionNameMap, input, sessionName);
 188                             }
 189                         } else if (INPUT_END_KEY.equals(strLine)) {
 190                             // Initialize output array
 191                             output = new ArrayList<>();
 192                             errorOutput = new ArrayList<>();
 193                         } else if (RESULT_KEY.equals(strLine)) {
 194                             strLine = br.readLine();
 195                             // Ignore comments
 196                             while (isComment(strLine)) {
 197                                 strLine = br.readLine();
 198                             }
 199                             // Save result value
 200                             result = Integer.parseInt(strLine);
 201                         } else if (OUTPUT_END_KEY.equals(strLine)) {
 202                             // Save output/result in command map
 203                             if (output != null && errorOutput != null) {
 204                                 commandMap.put(input, createCommandResult(result,
 205                                         checkNotNull(output.toArray(new @NonNull String[output.size()])),
 206                                         checkNotNull(errorOutput.toArray(new @NonNull String[errorOutput.size()]))));
 207                             }
 208                             inOutput = false;
 209                         } else if (OUTPUT_KEY.equals(strLine)) {
 210                             // first line of output
 211                             inOutput = true;
 212                         } else if (ERROR_OUTPUT_KEY.equals(strLine)) {
 213                             // first line of output
 214                             inErrorOutput = true;
 215                         } else if (ERROR_OUTPUT_END_KEY.equals(strLine)) {
 216                             inErrorOutput = false;
 217                         } else if (inOutput) {
 218                             while (isComment(strLine)) {
 219                                 strLine = br.readLine();
 220                             }
 221                             // lines of output/error output
 222                             if (errorOutput != null && inErrorOutput) {
 223                                 errorOutput.add(strLine);
 224                             } else if (output != null) {
 225                                 output.add(strLine);
 226                             }
 227                         }
 228                         // else {
 229                         // if (RESULT_END_KEY.equals(strLine)) {
 230                         // nothing to do
 231                         // }
 232                     }
 233                 }
 234             }
 235         } catch (IOException e) {
 236             e.printStackTrace();
 237         }
 238     }
 239
 240     private static String updateSessionMap(Map<String, Integer> tmpSessionNameMap, String input, String sessionName) {
 241         Integer i = tmpSessionNameMap.get(sessionName);
 242         if (i != null) {
 243             i++;
 244         } else {
 245             i = 0;
 246         }
 247         tmpSessionNameMap.put(sessionName, i);
 248         return String.valueOf(i);
 249     }
 250
 251     // Set the scenario to consider in executeCommand()
 252     public synchronized void setScenario(String scenario) {
 253         fScenario = scenario;
 254         fSessionNameMap.clear();
 255         if (!fScenarioMap.containsKey(fScenario)) {
 256             throw new IllegalArgumentException();
 257         }
 258     }
 259
 260     @Override
 261     public synchronized ICommandResult executeCommand(ICommandInput command, IProgressMonitor monitor) throws ExecutionException {
 262         return executeCommand(command, monitor, null);
 263     }
 264
 265     @Override
 266     public synchronized ICommandResult executeCommand(ICommandInput command, IProgressMonitor monitor, ICommandOutputListener listener) throws ExecutionException {
 267         Map<String, ICommandResult> commands = checkNotNull(fScenarioMap.get(fScenario));
 268         String commandLine = command.toString();
 269         String fullCommand = commandLine;
 270
 271         Matcher matcher = LTTNG_LIST_SESSION_PATTERN.matcher(commandLine);
 272         Matcher miMatcher = LTTNG_LIST_SESSION_MI_PATTERN.matcher(commandLine);
 273         if (matcher.matches() && !commandLine.matches(LTTNG_LIST_PROVIDER_PATTERN)) {
 274             String sessionName = matcher.group(1).trim();
 275             fullCommand += updateSessionMap(fSessionNameMap, fullCommand, sessionName);
 276         } else if (miMatcher.matches() && !commandLine.matches(LTTNG_LIST_PROVIDER_MI_PATTERN)) {
 277             String sessionName = miMatcher.group(1).trim();
 278             fullCommand += updateSessionMap(fSessionNameMap, fullCommand, sessionName);
 279         }
 280
 281         if (commands.containsKey(fullCommand)) {
 282             return checkNotNull(commands.get(fullCommand));
 283         }
 284
 285         @NonNull String[] output = new @NonNull String[1];
 286         output[0] = String.valueOf("Command not found");
 287         ICommandResult result = createCommandResult(1, output, output);
 288         return result;
 289     }
 290
 291     // ------------------------------------------------------------------------
 292     // Helper methods
 293     // ------------------------------------------------------------------------
 294
 295     private static boolean isComment(String line) {
 296         if (line == null) {
 297             throw new RuntimeException("line is null");
 298         }
 299         return line.matches(COMMENT_KEY);
 300     }
 301 }