getCommandTrie() {
return mCommandTrie;
}
/**
* Return a new LineReader, or {@code null} if an IOException occurs. Note that this function
* must be static so that we can run it before the superclass constructor.
*/
protected static LineReader getReader() {
try {
if (sConsoleStream == null) {
final LineReader reader =
LineReaderBuilder.builder()
.appName(APPNAME)
.terminal(TerminalBuilder.builder().system(true).dumb(true).build())
.completer(
new ConfigCompleter(
ConfigurationFactory.getInstance().getConfigList()))
.history(new DefaultHistory())
.build();
sConsoleStream = new ConsoleReaderOutputStream(reader);
System.setOut(new PrintStream(sConsoleStream, true));
}
return sConsoleStream.getConsoleReader();
} catch (IOException e) {
System.err.format("Failed to initialize LineReader: %s\n", e.getMessage());
return null;
}
}
protected Console() {
this(getReader());
}
/**
* Create a {@link Console} with provided console reader. Also, set up console command handling.
*
* Exposed for unit testing
*/
Console(LineReader reader) {
super("TfConsole");
mConsoleStartTime = System.currentTimeMillis();
mConsoleReader = reader;
List genericHelp = new LinkedList();
Map commandHelp = new LinkedHashMap();
addDefaultCommands(mCommandTrie, genericHelp, commandHelp);
setCustomCommands(mCommandTrie, genericHelp, commandHelp);
generateHelpListings(mCommandTrie, genericHelp, commandHelp);
}
void setCommandScheduler(ICommandScheduler scheduler) {
mScheduler = scheduler;
}
void setKeyStoreFactory(IKeyStoreFactory factory) {
mKeyStoreFactory = factory;
}
/**
* Register shutdown signals.
*
* TSTP signal for quitting tradefed which waits all invocation finish. TERM signal for
* killing tradefed. We use TSTP and INT because these two signals are not used by JVM.
*/
void registerShutdownSignals() {
Signal.handle(
new Signal("TSTP"),
new SignalHandler() {
@Override
public void handle(Signal sig) {
CLog.logAndDisplay(
LogLevel.INFO,
String.format("Received signal %s. Quit.", sig.getName()));
new QuitRunnable().run(new CaptureList());
}
});
Signal.handle(
new Signal("TERM"),
new SignalHandler() {
@Override
public void handle(Signal sig) {
CLog.logAndDisplay(
LogLevel.INFO,
String.format("Received signal %s. Kill.", sig.getName()));
new ForceQuitRunnable().run(new CaptureList());
}
});
}
/**
* A customization point that subclasses can use to alter which commands are available in the
* console.
*
*
Implementations should modify the {@code genericHelp} and {@code commandHelp} variables to
* document what functionality they may have added, modified, or removed.
*
* @param trie The {@link RegexTrie} to add the commands to
* @param genericHelp A {@link List} of lines to print when the user runs the "help" command
* with no arguments.
* @param commandHelp A {@link Map} containing documentation for any new commands that may have
* been added. The key is a regular expression to use as a key for {@link RegexTrie}. The
* value should be a String containing the help text to print for that command.
*/
protected void setCustomCommands(
RegexTrie trie, List genericHelp, Map commandHelp) {
// Meant to be overridden by subclasses
}
/**
* Generate help listings based on the contents of {@code genericHelp} and {@code commandHelp}.
*
* @param trie The {@link RegexTrie} to add the commands to
* @param genericHelp A {@link List} of lines to print when the user runs the "help" command
* with no arguments.
* @param commandHelp A {@link Map} containing documentation for any new commands that may have
* been added. The key is a regular expression to use as a key for {@link RegexTrie}. The
* value should be a String containing the help text to print for that command.
*/
void generateHelpListings(
RegexTrie trie, List genericHelp, Map commandHelp) {
final String genHelpString = getGenericHelpString(genericHelp);
final ArgRunnable genericHelpRunnable =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
printLine(genHelpString);
}
};
trie.put(genericHelpRunnable, HELP_PATTERN);
StringBuilder allHelpBuilder = new StringBuilder();
// Add help entries for everything listed in the commandHelp map
for (Map.Entry helpPair : commandHelp.entrySet()) {
final String key = helpPair.getKey();
final String helpText = helpPair.getValue();
trie.put(
new Runnable() {
@Override
public void run() {
printLine(helpText);
}
},
HELP_PATTERN,
key);
allHelpBuilder.append(helpText);
allHelpBuilder.append(LINE_SEPARATOR);
}
final String allHelpText = allHelpBuilder.toString();
trie.put(
new Runnable() {
@Override
public void run() {
printLine(allHelpText);
}
},
HELP_PATTERN,
"all");
// Add a generic "not found" help message for everything else
trie.put(
new ArgRunnable() {
@Override
public void run(CaptureList args) {
// Command will be the only capture in the second argument
// (first argument is helpPattern)
printLine(
String.format(
"No help for '%s'; command is unknown or undocumented",
args.get(1).get(0)));
genericHelpRunnable.run(args);
}
},
HELP_PATTERN,
null);
// Add a fallback input handler
trie.put(
new ArgRunnable() {
@Override
public void run(CaptureList args) {
if (args.isEmpty()) {
// User hit with a blank line
return;
}
// Command will be the only capture in the first argument
printLine(String.format("Unknown command: '%s'", args.get(0).get(0)));
genericHelpRunnable.run(args);
}
},
(Pattern) null);
}
/**
* Return the generic help string to display
*
* @param genericHelp a list of {@link String} representing the generic help to be aggregated.
*/
protected String getGenericHelpString(List genericHelp) {
return ArrayUtil.join(LINE_SEPARATOR, genericHelp);
}
/**
* A utility function to return the arguments that were passed to an {@link ArgRunnable}. In
* particular, it expects all first-level elements of {@code cl} after {@code argIdx} to be
* singleton {@link List}s. It will then coalesce the first element of each of those singleton
* {@link List}s as a single {@link List}.
*
* @param argIdx The zero-based index of the first argument.
* @param cl The {@link CaptureList} of arguments that was passed to the {@link ArgRunnable}
* @return A flattened {@link List} of arguments that were passed to the {@link ArgRunnable}
* @throws IllegalArgumentException if the data isn't formatted as expected
* @throws IndexOutOfBoundsException if {@code argIdx} isn't consistent with {@code cl}
*/
static List getFlatArgs(int argIdx, CaptureList cl) {
if (argIdx < 0 || argIdx >= cl.size()) {
throw new IndexOutOfBoundsException(
String.format("argIdx is %d, cl size is %d", argIdx, cl.size()));
}
List flat = new ArrayList(cl.size() - argIdx);
ListIterator> iter = cl.listIterator(argIdx);
while (iter.hasNext()) {
List single = iter.next();
int len = single.size();
if (len != 1) {
throw new IllegalArgumentException(
String.format(
"Expected a singleton List, but got a List with %d elements: %s",
len, single.toString()));
}
flat.add(single.get(0));
}
return flat;
}
/** Utility function to actually parse and execute a command file. */
void runCmdfile(String cmdfileName, List extraArgs) {
try {
mScheduler.addCommandFile(cmdfileName, extraArgs);
} catch (ConfigurationException e) {
printLine(String.format("Failed to run %s: %s", cmdfileName, e));
if (mScheduler.shouldShutdownOnCmdfileError()) {
printLine("shutdownOnCmdFileError is enabled, stopping TF");
mScheduler.shutdown();
}
reportProtoResults(e);
}
}
private void reportProtoResults(Exception e) {
String protoRes = System.getenv(AutomatedReporters.PROTO_REPORTING_FILE);
if (protoRes == null) {
printLine(
String.format(
"No %s specified to output results",
AutomatedReporters.PROTO_REPORTING_FILE));
return;
}
if (new File(protoRes).exists()) {
printLine(String.format("File %s already exists", protoRes));
return;
}
FileProtoResultReporter reporter = new FileProtoResultReporter();
reporter.setOutputFile(new File(protoRes));
reporter.setDelimitedOutput(false);
reporter.invocationStarted(new InvocationContext());
FailureDescription failure =
TestInvocation.createFailureFromException(e, FailureStatus.INFRA_FAILURE);
reporter.invocationFailed(failure);
reporter.invocationEnded(0L);
}
/**
* Add commands to create the default Console experience
*
* Adds relevant documentation to {@code genericHelp} and {@code commandHelp}.
*
* @param trie The {@link RegexTrie} to add the commands to
* @param genericHelp A {@link List} of lines to print when the user runs the "help" command
* with no arguments.
* @param commandHelp A {@link Map} containing documentation for any new commands that may have
* been added. The key is a regular expression to use as a key for {@link RegexTrie}. The
* value should be a String containing the help text to print for that command.
*/
void addDefaultCommands(
RegexTrie trie, List genericHelp, Map commandHelp) {
// Help commands
genericHelp.add(
"Enter 'q' or 'exit' to exit. Use '--wait-for-command|-c' to exit only after all"
+ " commands have executed.");
genericHelp.add("Enter 'kill' to attempt to forcibly exit, by shutting down adb");
genericHelp.add("");
genericHelp.add("Enter 'help all' to see all embedded documentation at once.");
genericHelp.add("");
genericHelp.add("Enter 'help list' for help with 'list' commands");
genericHelp.add("Enter 'help run' for help with 'run' commands");
genericHelp.add("Enter 'help invocation' for help with 'invocation' commands");
genericHelp.add("Enter 'help dump' for help with 'dump' commands");
genericHelp.add("Enter 'help set' for help with 'set' commands");
genericHelp.add("Enter 'help remove' for help with 'remove' commands");
genericHelp.add("Enter 'help debug' for help with 'debug' commands");
genericHelp.add("Enter 'version' to get the current version of Tradefed");
commandHelp.put(
LIST_PATTERN,
String.format(
"%s help:"
+ LINE_SEPARATOR
+ "\ti[nvocations] List all invocation threads"
+ LINE_SEPARATOR
+ "\td[evices] List all detected or known devices"
+ LINE_SEPARATOR
+ "\td[devices] all List all devices including placeholders"
+ LINE_SEPARATOR
+ "\tc[ommands] List all commands currently waiting to"
+ " be executed"
+ LINE_SEPARATOR
+ "\tc[ommands] [pattern] List all commands matching the pattern"
+ " and currently waiting to be executed"
+ LINE_SEPARATOR
+ "\tconfigs List all known configurations"
+ LINE_SEPARATOR,
LIST_PATTERN));
commandHelp.put(
DUMP_PATTERN,
String.format(
"%s help:"
+ LINE_SEPARATOR
+ "\ts[tack] Dump the stack traces of all threads"
+ LINE_SEPARATOR
+ "\tl[ogs] Dump the logs of all invocations to files"
+ LINE_SEPARATOR
+ "\tb[ugreport] Dump a bugreport for the running Tradefed"
+ " instance"
+ LINE_SEPARATOR
+ "\tc[onfig] Dump the content of the specified config"
+ LINE_SEPARATOR
+ "\tcommandQueue Dump the contents of the commmand"
+ " execution queue"
+ LINE_SEPARATOR
+ "\tcommands Dump all the config XML for the commands"
+ " waiting to be executed"
+ LINE_SEPARATOR
+ "\tcommands [pattern] Dump all the config XML for the commands"
+ " matching the pattern and waiting to be executed"
+ LINE_SEPARATOR
+ "\te[nv] Dump the environment variables available"
+ " to test harness process"
+ LINE_SEPARATOR
+ "\tu[ptime] Dump how long the TradeFed process has"
+ " been running"
+ LINE_SEPARATOR,
DUMP_PATTERN));
commandHelp.put(
RUN_PATTERN,
String.format(
"%s help:"
+ LINE_SEPARATOR
+ "\tcommand [options] Run the specified command"
+ LINE_SEPARATOR
+ "\t [options] Shortcut for the above: run"
+ " specified command"
+ LINE_SEPARATOR
+ "\tcmdfile Run the specified"
+ " commandfile"
+ LINE_SEPARATOR
+ "\tcommandAndExit [options] Run the specified command,"
+ " and run 'exit -c' immediately afterward"
+ LINE_SEPARATOR
+ "\tcmdfileAndExit Run the specified"
+ " commandfile, and run 'exit -c' immediately afterward"
+ LINE_SEPARATOR,
RUN_PATTERN));
commandHelp.put(
SET_PATTERN,
String.format(
"%s help:"
+ LINE_SEPARATOR
+ "\tlog-level-display Sets the global display log level"
+ " to "
+ LINE_SEPARATOR,
SET_PATTERN));
commandHelp.put(
REMOVE_PATTERN,
String.format(
"%s help:"
+ LINE_SEPARATOR
+ "\tremove allCommands Remove all commands currently waiting to"
+ " be executed"
+ LINE_SEPARATOR,
REMOVE_PATTERN));
commandHelp.put(
DEBUG_PATTERN,
String.format(
"%s help:"
+ LINE_SEPARATOR
+ "\tgc Attempt to force a GC"
+ LINE_SEPARATOR,
DEBUG_PATTERN));
commandHelp.put(
INVOC_PATTERN,
String.format(
"%s help:"
+ LINE_SEPARATOR
+ "\ti[nvocation] [Command Id] Information of the"
+ " invocation thread"
+ LINE_SEPARATOR
+ "\ti[nvocation] [Command Id] stop Notify to stop the invocation"
+ LINE_SEPARATOR,
INVOC_PATTERN));
// Handle quit commands
trie.put(new QuitRunnable(), EXIT_PATTERN, null);
trie.put(new QuitRunnable(), EXIT_PATTERN);
trie.put(new ForceQuitRunnable(), "kill");
// List commands
trie.put(
new Runnable() {
@Override
public void run() {
mScheduler.displayInvocationsInfo(new PrintWriter(System.out, true));
}
},
LIST_PATTERN,
"i(?:nvocations)?");
trie.put(
new Runnable() {
@Override
public void run() {
IDeviceManager manager = GlobalConfiguration.getDeviceManagerInstance();
manager.displayDevicesInfo(new PrintWriter(System.out, true), false);
}
},
LIST_PATTERN,
"d(?:evices)?");
trie.put(
new Runnable() {
@Override
public void run() {
IDeviceManager manager = GlobalConfiguration.getDeviceManagerInstance();
manager.displayDevicesInfo(new PrintWriter(System.out, true), true);
}
},
LIST_PATTERN,
"d(?:evices)?",
"all");
trie.put(
new Runnable() {
@Override
public void run() {
mScheduler.displayCommandsInfo(new PrintWriter(System.out, true), null);
}
},
LIST_PATTERN,
LIST_COMMANDS_PATTERN);
ArgRunnable listCmdRun =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
// Skip 2 tokens to get past listPattern and "commands"
String pattern = args.get(2).get(0);
mScheduler.displayCommandsInfo(new PrintWriter(System.out, true), pattern);
}
};
trie.put(listCmdRun, LIST_PATTERN, LIST_COMMANDS_PATTERN, "(.*)");
trie.put(
new Runnable() {
@Override
public void run() {
printLine(
"Use 'run command --help' to get list of"
+ " options for a configuration");
printLine(
"Use 'dump config ' to display the"
+ " configuration's XML content.");
printLine("");
printLine("Available configurations include:");
getConfigurationFactory().printHelp(System.out);
}
},
LIST_PATTERN,
"configs");
// Invocation commands
trie.put(
new ArgRunnable() {
@Override
public void run(CaptureList args) {
int invocId = Integer.parseInt(args.get(1).get(0));
String info = mScheduler.getInvocationInfo(invocId);
if (info != null) {
printLine(String.format("invocation %s: %s", invocId, info));
} else {
printLine(
String.format(
"No information found for invocation %s.", invocId));
}
}
},
INVOC_PATTERN,
"([0-9]*)");
trie.put(
new ArgRunnable() {
@Override
public void run(CaptureList args) {
int invocId = Integer.parseInt(args.get(1).get(0));
if (mScheduler.stopInvocation(invocId)) {
printLine(
String.format(
"Invocation %s has been requested to stop."
+ " It may take some times.",
invocId));
} else {
printLine(
String.format(
"Could not stop invocation %s, try 'list invocation'"
+ " or 'invocation %s' for more information.",
invocId, invocId));
}
}
},
INVOC_PATTERN,
"([0-9]*)",
"stop");
// Dump commands
trie.put(
new Runnable() {
@Override
public void run() {
dumpStacks(System.out);
}
},
DUMP_PATTERN,
"s(?:tacks?)?");
trie.put(
new Runnable() {
@Override
public void run() {
dumpLogs();
}
},
DUMP_PATTERN,
"l(?:ogs?)?");
trie.put(
new Runnable() {
@Override
public void run() {
dumpTfBugreport();
}
},
DUMP_PATTERN,
"b(?:ugreport?)?");
trie.put(
new Runnable() {
@Override
public void run() {
printElapsedTime();
}
},
DUMP_PATTERN,
"u(?:ptime?)?");
ArgRunnable dumpConfigRun =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
// Skip 2 tokens to get past dumpPattern and "config"
String configArg = args.get(2).get(0);
getConfigurationFactory().dumpConfig(configArg, System.out);
}
};
trie.put(dumpConfigRun, DUMP_PATTERN, "c(?:onfig?)?", "(.*)");
trie.put(
new Runnable() {
@Override
public void run() {
mScheduler.displayCommandQueue(new PrintWriter(System.out, true));
}
},
DUMP_PATTERN,
"commandQueue");
trie.put(
new Runnable() {
@Override
public void run() {
mScheduler.dumpCommandsXml(new PrintWriter(System.out, true), null);
}
},
DUMP_PATTERN,
LIST_COMMANDS_PATTERN);
ArgRunnable dumpCmdRun =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
// Skip 2 tokens to get past listPattern and "commands"
String pattern = args.get(2).get(0);
mScheduler.dumpCommandsXml(new PrintWriter(System.out, true), pattern);
}
};
trie.put(dumpCmdRun, DUMP_PATTERN, LIST_COMMANDS_PATTERN, "(.*)");
trie.put(
new Runnable() {
@Override
public void run() {
dumpEnv();
}
},
DUMP_PATTERN,
"e(?:nv)?");
// Run commands
ArgRunnable runRunCommand =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
// The second argument "command" may also be missing, if the
// caller used the shortcut.
int startIdx = 1;
if (args.get(1).isEmpty()) {
// Empty array (that is, not even containing an empty string) means that
// we matched and skipped /(?:singleC|c)ommand/
startIdx = 2;
}
String[] flatArgs = new String[args.size() - startIdx];
for (int i = startIdx; i < args.size(); i++) {
flatArgs[i - startIdx] = args.get(i).get(0);
}
try {
mScheduler.addCommand(flatArgs);
} catch (ConfigurationException e) {
printLine(
String.format(
"Failed to run command: %s\n%s",
e.toString(), StreamUtil.getStackTrace(e)));
}
}
};
trie.put(runRunCommand, RUN_PATTERN, "c(?:ommand)?", null);
trie.put(runRunCommand, RUN_PATTERN, null);
trie.put(
new Runnable() {
@Override
public void run() {
String version = VersionParser.fetchVersion();
if (version != null) {
printLine(version);
} else {
printLine("Failed to fetch version information for Tradefed.");
}
}
},
VERSION_PATTERN);
ArgRunnable runAndExitCommand =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
// Skip 2 tokens to get past runPattern and "singleCommand"
String[] flatArgs = new String[args.size() - 2];
for (int i = 2; i < args.size(); i++) {
flatArgs[i - 2] = args.get(i).get(0);
}
try {
if (mScheduler.addCommand(flatArgs).first) {
mScheduler.shutdownOnEmpty();
}
} catch (ConfigurationException e) {
printLine("Failed to run command: " + e.toString());
}
// Intentionally kill the console before CommandScheduler finishes
mShouldExit.set(true);
}
};
trie.put(runAndExitCommand, RUN_PATTERN, "s(?:ingleCommand)?", null);
trie.put(runAndExitCommand, RUN_PATTERN, "commandAndExit", null);
// Missing required argument: show help
// FIXME: fix this functionality
// trie.put(runHelpRun, runPattern, "(?:singleC|c)ommand");
final ArgRunnable runRunCmdfile =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
// Skip 2 tokens to get past runPattern and "cmdfile". We're guaranteed to
// have at
// least 3 tokens if we got #run.
int startIdx = 2;
List flatArgs = getFlatArgs(startIdx, args);
String file = flatArgs.get(0);
List extraArgs = flatArgs.subList(1, flatArgs.size());
printLine(
String.format(
"Attempting to run cmdfile %s with args %s",
file, extraArgs.toString()));
runCmdfile(file, extraArgs);
}
};
trie.put(runRunCmdfile, RUN_PATTERN, "cmdfile", "(.*)");
trie.put(runRunCmdfile, RUN_PATTERN, "cmdfile", "(.*)", null);
ArgRunnable runRunCmdfileAndExit =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
runRunCmdfile.run(args);
mScheduler.shutdownOnEmpty();
}
};
trie.put(runRunCmdfileAndExit, RUN_PATTERN, "cmdfileAndExit", "(.*)");
trie.put(runRunCmdfileAndExit, RUN_PATTERN, "cmdfileAndExit", "(.*)", null);
ArgRunnable runRunAllCmdfilesAndExit =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
// skip 2 tokens to get past runPattern and "allCmdfilesAndExit"
if (args.size() <= 2) {
printLine("No cmdfiles specified!");
} else {
// Each group should have exactly one element, given how the null
// wildcard
// operates; so we flatten them.
for (String cmdfile : getFlatArgs(2 /* startIdx */, args)) {
runCmdfile(cmdfile, new ArrayList(0));
}
}
mScheduler.shutdownOnEmpty();
}
};
trie.put(runRunAllCmdfilesAndExit, RUN_PATTERN, "allCmdfilesAndExit");
trie.put(runRunAllCmdfilesAndExit, RUN_PATTERN, "allCmdfilesAndExit", null);
// Missing required argument: show help
// FIXME: fix this functionality
// trie.put(runHelpRun, runPattern, "cmdfile");
// Set commands
ArgRunnable runSetLog =
new ArgRunnable() {
@Override
public void run(CaptureList args) {
// Skip 2 tokens to get past "set" and "log-level-display"
String logLevelStr = args.get(2).get(0);
LogLevel newLogLevel = LogLevel.getByString(logLevelStr);
LogLevel currentLogLevel =
LogRegistry.getLogRegistry().getGlobalLogDisplayLevel();
if (newLogLevel != null) {
LogRegistry.getLogRegistry().setGlobalLogDisplayLevel(newLogLevel);
// Make sure that the level was set.
currentLogLevel =
LogRegistry.getLogRegistry().getGlobalLogDisplayLevel();
if (currentLogLevel != null) {
printLine(
String.format(
"Log level now set to '%s'.", currentLogLevel));
}
} else {
if (currentLogLevel == null) {
printLine(String.format("Invalid log level '%s'.", newLogLevel));
} else {
printLine(
String.format(
"Invalid log level '%s'; log level remains at"
+ " '%s'.",
newLogLevel, currentLogLevel));
}
}
}
};
trie.put(runSetLog, SET_PATTERN, "log-level-display", "(.*)");
// Debug commands
trie.put(
new Runnable() {
@Override
public void run() {
System.gc();
}
},
DEBUG_PATTERN,
"gc");
// Remove commands
trie.put(
new Runnable() {
@Override
public void run() {
mScheduler.removeAllCommands();
}
},
REMOVE_PATTERN,
"allCommands");
}
/** Print the uptime of the Tradefed process. */
private void printElapsedTime() {
long elapsedTime = System.currentTimeMillis() - mConsoleStartTime;
String elapsed =
String.format(
"TF has been running for %s", TimeUtil.formatElapsedTime(elapsedTime));
printLine(elapsed);
}
/**
* Get input from the console
*
* @return A {@link String} containing the input to parse and run. Will return {@code null} if
* console is not available or user entered EOF ({@code ^D}).
*/
@VisibleForTesting
String getConsoleInput() throws IOException {
if (mConsoleReader != null) {
try {
return mConsoleReader.readLine(getConsolePrompt());
} catch (EndOfFileException e) {
return null;
} catch (UserInterruptException e) {
printLine("\nInterrupted by User.Exiting.");
return null;
}
} else {
return null;
}
}
/** @return the text {@link String} to display for the console prompt */
protected String getConsolePrompt() {
return CONSOLE_PROMPT;
}
/**
* Display a line of text on console
*
* @param output
*/
protected void printLine(String output) {
System.out.print(output);
System.out.println();
}
/**
* Print the line to a Printwriter
*
* @param output
*/
protected void printLine(String output, PrintStream pw) {
pw.print(output);
pw.println();
}
/**
* Execute a command.
*
* Exposed for unit testing
*/
@SuppressWarnings("unchecked")
void executeCmdRunnable(Runnable command, CaptureList groups) {
try {
if (command instanceof ArgRunnable) {
// FIXME: verify that command implements ArgRunnable instead
// FIXME: of just ArgRunnable
((ArgRunnable) command).run(groups);
} else {
command.run();
}
} catch (RuntimeException e) {
e.printStackTrace();
}
}
/**
* Return whether we should expect the console to be usable.
*
* Exposed for unit testing.
*/
@SuppressWarnings("SystemConsoleNull") // https://errorprone.info/bugpattern/SystemConsoleNull
boolean isConsoleFunctional() {
java.io.Console systemConsole = System.console();
if (Runtime.version().feature() < 22) {
return systemConsole != null;
}
try {
return (Boolean) java.io.Console.class.getMethod("isTerminal").invoke(systemConsole);
} catch (ReflectiveOperationException e) {
throw new LinkageError(e.getMessage(), e);
}
}
/**
* The main method to launch the console. Will keep running until shutdown command is issued.
*/
@Override
public void run() {
List arrrgs = mMainArgs;
if (mScheduler == null) {
throw new IllegalStateException("command scheduler hasn't been set");
}
try {
// Check System.console() since jline doesn't seem to consistently know whether or not
// the console is functional.
if (!isConsoleFunctional()) {
if (arrrgs.isEmpty()) {
printLine("No commands for non-interactive mode; exiting.");
// FIXME: need to run the scheduler here so that the things blocking on it
// FIXME: will be released.
mScheduler.start();
mScheduler.await();
return;
} else {
printLine("Non-interactive mode: Running initial command then exiting.");
mShouldExit.set(true);
}
}
// Wait for the CommandScheduler to start. It will hold the JVM open (since the Console
// thread is a Daemon thread), and also we require it to have started so that we can
// start processing user input.
mScheduler.start();
mScheduler.await();
String input = "";
CaptureList groups = new CaptureList();
String[] tokens;
// Note: since Console is a daemon thread, the JVM may exit without us actually leaving
// this read loop. This is by design.
do {
if (arrrgs.isEmpty()) {
input = getConsoleInput();
if (input == null) {
// Usually the result of getting EOF on the console
printLine("");
printLine("Received EOF; quitting...");
mShouldExit.set(true);
break;
}
tokens = null;
try {
tokens = QuotationAwareTokenizer.tokenizeLine(input);
} catch (IllegalArgumentException e) {
printLine(String.format("Invalid input: %s.", input));
continue;
}
if (tokens == null || tokens.length == 0) {
continue;
}
} else {
printLine(
String.format(
"Using commandline arguments as starting command: %s", arrrgs));
if (mConsoleReader != null) {
// Add the starting command as the first item in the console history
// FIXME: this will not properly escape commands that were properly escaped
// FIXME: on the commandline. That said, it will still be more convenient
// FIXME: than copying by hand.
final String cmd = ArrayUtil.join(" ", arrrgs);
mConsoleReader.getHistory().add(cmd);
}
tokens = arrrgs.toArray(new String[0]);
if (arrrgs.get(0).matches(HELP_PATTERN)) {
// if started from command line for help, return to shell
mShouldExit.set(true);
}
arrrgs = Collections.emptyList();
}
Runnable command = mCommandTrie.retrieve(groups, tokens);
if (command != null) {
executeCmdRunnable(command, groups);
} else {
printLine(
String.format(
"Unable to handle command '%s'. Enter 'help' for help.",
tokens[0]));
}
RunUtil.getDefault().sleep(100);
} while (!mShouldExit.get());
} catch (Exception e) {
printLine("Console received an unexpected exception (shown below); shutting down TF.");
e.printStackTrace();
} finally {
mScheduler.shutdown();
GlobalConfiguration.getInstance().cleanup();
// Make sure that we don't quit with messages still in the buffers
System.err.flush();
System.out.flush();
}
}
/** set the flag to exit the console. */
@VisibleForTesting
void exitConsole() {
mShouldExit.set(true);
}
void awaitScheduler() throws InterruptedException {
mScheduler.await();
}
/**
* Method for getting a {@link IConfigurationFactory}.
*
* Exposed for unit testing.
*/
IConfigurationFactory getConfigurationFactory() {
return ConfigurationFactory.getInstance();
}
private void dumpStacks(PrintStream ps) {
Map threadMap = Thread.getAllStackTraces();
for (Map.Entry threadEntry : threadMap.entrySet()) {
dumpThreadStack(threadEntry.getKey(), threadEntry.getValue(), ps);
}
}
private void dumpThreadStack(Thread thread, StackTraceElement[] trace, PrintStream ps) {
printLine(String.format("%s", thread), ps);
for (int i = 0; i < trace.length; i++) {
printLine(String.format("\t%s", trace[i]), ps);
}
printLine("", ps);
}
private void dumpLogs() {
LogRegistry.getLogRegistry().dumpLogs();
}
/** Dumps the environment variables to console, sorted by variable names */
private void dumpEnv() {
// use TreeMap to sort variables by name
Map env = new TreeMap<>(System.getenv());
for (Map.Entry entry : env.entrySet()) {
printLine(String.format("\t%s=%s", entry.getKey(), entry.getValue()));
}
}
/** Dump a Tradefed Bugreport containing the stack traces and logs. */
private void dumpTfBugreport() {
File tmpBugreportDir = null;
PrintStream ps = null;
try {
// dump stacks
tmpBugreportDir = FileUtil.createNamedTempDir("bugreport_tf");
File tmpStackFile = FileUtil.createTempFile("dump_stacks_", ".log", tmpBugreportDir);
ps = new PrintStream(tmpStackFile);
dumpStacks(ps);
ps.flush();
// dump logs
((LogRegistry) LogRegistry.getLogRegistry()).dumpLogsToDir(tmpBugreportDir);
// add them to a zip and log.
File zippedBugreport = ZipUtil.createZip(tmpBugreportDir, "tradefed_bugreport_");
printLine(
String.format("Output bugreport zip in %s", zippedBugreport.getAbsolutePath()));
} catch (IOException io) {
printLine("Error when trying to dump bugreport");
} finally {
ps.close();
FileUtil.recursiveDelete(tmpBugreportDir);
}
}
/**
* Sets the console starting arguments.
*
* @param mainArgs the arguments
*/
public void setArgs(List mainArgs) {
mMainArgs = mainArgs;
}
private static class TerminateGRPCServers extends Thread {
private final TradefedFeatureServer mFeatureServer;
private final TestInvocationManagementServer mInvocationServer;
private final DeviceManagementGrpcServer mDeviceServer;
public TerminateGRPCServers(
TradefedFeatureServer featureServer,
TestInvocationManagementServer invocationServer,
DeviceManagementGrpcServer deviceServer) {
mFeatureServer = featureServer;
mInvocationServer = invocationServer;
mDeviceServer = deviceServer;
}
@Override
public void run() {
if (mFeatureServer != null) {
try {
mFeatureServer.shutdown();
} catch (InterruptedException e) {
CLog.e(e);
}
}
if (mInvocationServer != null) {
try {
mInvocationServer.shutdown();
} catch (InterruptedException e) {
CLog.e(e);
}
}
if (mDeviceServer != null) {
try {
mDeviceServer.shutdown();
} catch (InterruptedException e) {
CLog.e(e);
}
}
}
}
public static void main(final String[] mainArgs)
throws InterruptedException, ConfigurationException {
Console console = new Console();
try {
startConsole(console, mainArgs);
} catch (ConfigurationException e) {
e.printStackTrace();
System.exit(ExitCode.CONFIG_EXCEPTION.getCodeValue());
} catch (InterruptedException interrupt) {
interrupt.printStackTrace();
System.exit(ExitCode.THROWABLE_EXCEPTION.getCodeValue());
}
}
/**
* Starts the given Tradefed console with given args
*
* @param console the {@link Console} to start
* @param args the command line arguments
*/
public static void startConsole(Console console, String[] args)
throws InterruptedException, ConfigurationException {
ClearcutClient client =
new ClearcutClient(
TestSuiteInfo.getInstance().didLoadFromProperties()
? TestSuiteInfo.getInstance().getName()
: "");
Runtime.getRuntime().addShutdownHook(new TerminateClearcutClient(client));
client.notifyTradefedStartEvent();
TradefedFeatureServer server = null;
try {
server = new TradefedFeatureServer();
server.start();
} catch (RuntimeException e) {
System.out.println(String.format("Error starting feature server: %s", e));
// Abort the start if we fail to start the server, it is a critical component.
throw e;
}
TestInvocationManagementServer invocationManagementServer = null;
DeviceManagementGrpcServer deviceManagementServer = null;
try {
List nonGlobalArgs = GlobalConfiguration.createGlobalConfiguration(args);
GlobalConfiguration.getInstance().setup();
if (server != null) {
GlobalConfiguration.getInstance().setTradefedFeatureServer(server);
}
console.setArgs(nonGlobalArgs);
console.setCommandScheduler(GlobalConfiguration.getInstance().getCommandScheduler());
console.setKeyStoreFactory(GlobalConfiguration.getInstance().getKeyStoreFactory());
console.setDaemon(true);
GlobalConfiguration.getInstance().getCommandScheduler().setClearcutClient(client);
// Initialize the locks for the TF session
GlobalConfiguration.getInstance().getHostOptions().initConcurrentLocks();
console.start();
// Wait for the CommandScheduler to get started before we exit the main thread. See
// full
// explanation near the top of #run()
console.awaitScheduler();
console.registerShutdownSignals();
// Gate the server starting to a port being explicitly defined
Integer deviceManagementPort = DeviceManagementGrpcServer.getPort();
if (deviceManagementPort != null) {
try {
deviceManagementServer =
new DeviceManagementGrpcServer(
deviceManagementPort,
GlobalConfiguration.getDeviceManagerInstance(),
GlobalConfiguration.getInstance().getCommandScheduler());
GlobalConfiguration.getInstance()
.setDeviceManagementServer(deviceManagementServer);
deviceManagementServer.start();
} catch (RuntimeException e) {
System.out.println(
String.format("Error starting device management server: %s", e));
}
}
Integer port = TestInvocationManagementServer.getPort();
if (port != null) {
try {
invocationManagementServer =
new TestInvocationManagementServer(
port,
GlobalConfiguration.getInstance().getCommandScheduler(),
deviceManagementServer);
GlobalConfiguration.getInstance()
.setInvocationServer(invocationManagementServer);
// Start the server last to ensure that command scheduler is started
invocationManagementServer.start();
} catch (RuntimeException e) {
System.out.println(String.format("Error starting invocation server: %s", e));
}
}
} finally {
Runtime.getRuntime()
.addShutdownHook(
new TerminateGRPCServers(
server, invocationManagementServer, deviceManagementServer));
}
}
}