mirror of
https://github.com/fankes/termux-app.git
synced 2025-09-06 10:45:23 +08:00
Improve TermuxSession and TermuxTask
TermuxSession, TermuxTask and TermuxSessionClientBase have been moved to termux-shared. They are now not dependent on TermuxService anymore and have become abstract so that they can be called from anywhere. TermuxSession.TermuxSessionClient and TermuxTask.TermuxTaskClient interfaces have been created for callbacks, which the TermuxService now implements. The TermuxTask now also supports synchronous command execution as well to run shell commands from anywhere for internal use by termux app and its plugins. TermuxTask now also supports killing the process being run by sending it a SIGKILL. This is used by TermuxService to kill all the TermuxTasks (in addition to TermuxSessions) it manages when it is destroyed, either by user exiting it or by android killing it. Only the tasks that were started by a plugin which **expects** the result back via a pending intent will be killed, but the remaining background tasks will keep on running until the termux app process is killed by android, like by OOM. Check TermuxService.killAllTermuxExecutionCommands() for more details on how TermuxService kills TermuxTasks and TermuxSessions. Fixed null pointer exception when getting terminal transcript if TerminalEmulator not initialized.
This commit is contained in:
agnostic-apollo
@@ -16,6 +16,8 @@ android {
|
||||
// will be runtime exceptions on android < 8
|
||||
// due to missing classes like java.nio.file.Path.
|
||||
implementation "commons-io:commons-io:2.5"
|
||||
|
||||
implementation project(":terminal-view")
|
||||
}
|
||||
|
||||
defaultConfig {
|
||||
|
||||
@@ -0,0 +1,563 @@
|
||||
package com.termux.shared.models;
|
||||
|
||||
import android.app.Activity;
|
||||
import android.app.PendingIntent;
|
||||
import android.net.Uri;
|
||||
|
||||
import androidx.annotation.NonNull;
|
||||
|
||||
import com.termux.shared.termux.TermuxConstants.TERMUX_APP.TERMUX_SERVICE;
|
||||
import com.termux.shared.logger.Logger;
|
||||
import com.termux.shared.markdown.MarkdownUtils;
|
||||
import com.termux.shared.data.DataUtils;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class ExecutionCommand {
|
||||
|
||||
/*
|
||||
The {@link ExecutionState#SUCCESS} and {@link ExecutionState#FAILED} is defined based on
|
||||
successful execution of command without any internal errors or exceptions being raised.
|
||||
The shell command {@link #exitCode} being non-zero **does not** mean that execution command failed.
|
||||
Only the {@link #errCode} being non-zero means that execution command failed from the Termux app
|
||||
perspective.
|
||||
*/
|
||||
|
||||
/** The {@link Enum} that defines {@link ExecutionCommand} state. */
|
||||
public enum ExecutionState {
|
||||
|
||||
PRE_EXECUTION("Pre-Execution", 0),
|
||||
EXECUTING("Executing", 1),
|
||||
EXECUTED("Executed", 2),
|
||||
SUCCESS("Success", 3),
|
||||
FAILED("Failed", 4);
|
||||
|
||||
private final String name;
|
||||
private final int value;
|
||||
|
||||
ExecutionState(final String name, final int value) {
|
||||
this.name = name;
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public int getValue() {
|
||||
return value;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Define errCode values
|
||||
// TODO: Define custom values for different cases
|
||||
public final static int RESULT_CODE_OK = Activity.RESULT_OK;
|
||||
public final static int RESULT_CODE_OK_MINOR_FAILURES = Activity.RESULT_FIRST_USER;
|
||||
public final static int RESULT_CODE_FAILED = Activity.RESULT_FIRST_USER + 1;
|
||||
public final static int RESULT_CODE_CANCELED = Activity.RESULT_FIRST_USER + 2;
|
||||
|
||||
/** The optional unique id for the {@link ExecutionCommand}. */
|
||||
public Integer id;
|
||||
|
||||
|
||||
/** The current state of the {@link ExecutionCommand}. */
|
||||
private ExecutionState currentState = ExecutionState.PRE_EXECUTION;
|
||||
/** The previous state of the {@link ExecutionCommand}. */
|
||||
private ExecutionState previousState = ExecutionState.PRE_EXECUTION;
|
||||
|
||||
|
||||
/** The executable for the {@link ExecutionCommand}. */
|
||||
public String executable;
|
||||
/** The executable Uri for the {@link ExecutionCommand}. */
|
||||
public Uri executableUri;
|
||||
/** The executable arguments array for the {@link ExecutionCommand}. */
|
||||
public String[] arguments;
|
||||
/** The current working directory for the {@link ExecutionCommand}. */
|
||||
public String workingDirectory;
|
||||
|
||||
|
||||
/** If the {@link ExecutionCommand} is a background or a foreground terminal session command. */
|
||||
public boolean inBackground;
|
||||
/** If the {@link ExecutionCommand} is meant to start a failsafe terminal session. */
|
||||
public boolean isFailsafe;
|
||||
|
||||
|
||||
/** The session action of foreground commands. */
|
||||
public String sessionAction;
|
||||
|
||||
|
||||
/** The command label for the {@link ExecutionCommand}. */
|
||||
public String commandLabel;
|
||||
/** The markdown text for the command description for the {@link ExecutionCommand}. */
|
||||
public String commandDescription;
|
||||
/** The markdown text for the help of command for the {@link ExecutionCommand}. This can be used
|
||||
* to provide useful info to the user if an internal error is raised. */
|
||||
public String commandHelp;
|
||||
|
||||
|
||||
/** Defines the markdown text for the help of the Termux plugin API that was used to start the
|
||||
* {@link ExecutionCommand}. This can be used to provide useful info to the user if an internal
|
||||
* error is raised. */
|
||||
public String pluginAPIHelp;
|
||||
|
||||
|
||||
/** Defines if {@link ExecutionCommand} was started because of an external plugin request
|
||||
* like {@link TERMUX_SERVICE#ACTION_SERVICE_EXECUTE} intent or from within Termux app itself.
|
||||
*/
|
||||
public boolean isPluginExecutionCommand;
|
||||
/** Defines {@link PendingIntent} that should be sent if an external plugin requested the execution. */
|
||||
public PendingIntent pluginPendingIntent;
|
||||
|
||||
|
||||
/** The stdout of shell command. */
|
||||
public String stdout;
|
||||
/** The stderr of shell command. */
|
||||
public String stderr;
|
||||
/** The exit code of shell command. */
|
||||
public Integer exitCode;
|
||||
|
||||
|
||||
/** The internal error code of {@link ExecutionCommand}. */
|
||||
public Integer errCode = RESULT_CODE_OK;
|
||||
/** The internal error message of {@link ExecutionCommand}. */
|
||||
public String errmsg;
|
||||
/** The internal exceptions of {@link ExecutionCommand}. */
|
||||
public List<Throwable> throwableList = new ArrayList<>();
|
||||
|
||||
/** Defines if processing results already called for this {@link ExecutionCommand}. */
|
||||
public boolean processingResultsAlreadyCalled;
|
||||
|
||||
|
||||
|
||||
public ExecutionCommand(){
|
||||
}
|
||||
|
||||
public ExecutionCommand(Integer id){
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public ExecutionCommand(Integer id, String executable, String[] arguments, String workingDirectory, boolean inBackground, boolean isFailsafe) {
|
||||
this.id = id;
|
||||
this.executable = executable;
|
||||
this.arguments = arguments;
|
||||
this.workingDirectory = workingDirectory;
|
||||
this.inBackground = inBackground;
|
||||
this.isFailsafe = isFailsafe;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
@Override
|
||||
public String toString() {
|
||||
if (!hasExecuted())
|
||||
return getExecutionInputLogString(this, true);
|
||||
else {
|
||||
return getExecutionOutputLogString(this, true);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a log friendly {@link String} for {@link ExecutionCommand} execution input parameters.
|
||||
*
|
||||
* @param executionCommand The {@link ExecutionCommand} to convert.
|
||||
* @param ignoreNull Set to {@code true} if non-critical {@code null} values are to be ignored.
|
||||
* @return Returns the log friendly {@link String}.
|
||||
*/
|
||||
public static String getExecutionInputLogString(final ExecutionCommand executionCommand, boolean ignoreNull) {
|
||||
if (executionCommand == null) return "null";
|
||||
|
||||
StringBuilder logString = new StringBuilder();
|
||||
|
||||
logString.append(executionCommand.getCommandIdAndLabelLogString()).append(":");
|
||||
|
||||
if (executionCommand.previousState != ExecutionState.PRE_EXECUTION)
|
||||
logString.append("\n").append(executionCommand.getPreviousStateLogString());
|
||||
logString.append("\n").append(executionCommand.getCurrentStateLogString());
|
||||
|
||||
logString.append("\n").append(executionCommand.getExecutableLogString());
|
||||
logString.append("\n").append(executionCommand.getArgumentsLogString());
|
||||
logString.append("\n").append(executionCommand.getWorkingDirectoryLogString());
|
||||
logString.append("\n").append(executionCommand.getInBackgroundLogString());
|
||||
logString.append("\n").append(executionCommand.getIsFailsafeLogString());
|
||||
|
||||
|
||||
if (!ignoreNull || executionCommand.sessionAction != null)
|
||||
logString.append("\n").append(executionCommand.getSessionActionLogString());
|
||||
|
||||
logString.append("\n").append(executionCommand.getIsPluginExecutionCommandLogString());
|
||||
if (!ignoreNull || executionCommand.isPluginExecutionCommand) {
|
||||
if (!ignoreNull || executionCommand.pluginPendingIntent != null)
|
||||
logString.append("\n").append(executionCommand.getPendingIntentCreatorLogString());
|
||||
}
|
||||
|
||||
return logString.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a log friendly {@link String} for {@link ExecutionCommand} execution output parameters.
|
||||
*
|
||||
* @param executionCommand The {@link ExecutionCommand} to convert.
|
||||
* @param ignoreNull Set to {@code true} if non-critical {@code null} values are to be ignored.
|
||||
* @return Returns the log friendly {@link String}.
|
||||
*/
|
||||
public static String getExecutionOutputLogString(final ExecutionCommand executionCommand, boolean ignoreNull) {
|
||||
if (executionCommand == null) return "null";
|
||||
|
||||
StringBuilder logString = new StringBuilder();
|
||||
|
||||
logString.append(executionCommand.getCommandIdAndLabelLogString()).append(":");
|
||||
|
||||
logString.append("\n").append(executionCommand.getPreviousStateLogString());
|
||||
logString.append("\n").append(executionCommand.getCurrentStateLogString());
|
||||
|
||||
logString.append("\n").append(executionCommand.getStdoutLogString());
|
||||
logString.append("\n").append(executionCommand.getStderrLogString());
|
||||
logString.append("\n").append(executionCommand.getExitCodeLogString());
|
||||
|
||||
logString.append(getExecutionErrLogString(executionCommand, ignoreNull));
|
||||
|
||||
return logString.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a log friendly {@link String} for {@link ExecutionCommand} execution error parameters.
|
||||
*
|
||||
* @param executionCommand The {@link ExecutionCommand} to convert.
|
||||
* @param ignoreNull Set to {@code true} if non-critical {@code null} values are to be ignored.
|
||||
* @return Returns the log friendly {@link String}.
|
||||
*/
|
||||
public static String getExecutionErrLogString(final ExecutionCommand executionCommand, boolean ignoreNull) {
|
||||
StringBuilder logString = new StringBuilder();
|
||||
|
||||
if (!ignoreNull || (executionCommand.isStateFailed())) {
|
||||
logString.append("\n").append(executionCommand.getErrCodeLogString());
|
||||
logString.append("\n").append(executionCommand.getErrmsgLogString());
|
||||
logString.append("\n").append(executionCommand.geStackTracesLogString());
|
||||
} else {
|
||||
logString.append("");
|
||||
}
|
||||
|
||||
return logString.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a log friendly {@link String} for {@link ExecutionCommand} with more details.
|
||||
*
|
||||
* @param executionCommand The {@link ExecutionCommand} to convert.
|
||||
* @return Returns the log friendly {@link String}.
|
||||
*/
|
||||
public static String getDetailedLogString(final ExecutionCommand executionCommand) {
|
||||
if (executionCommand == null) return "null";
|
||||
|
||||
StringBuilder logString = new StringBuilder();
|
||||
|
||||
logString.append(getExecutionInputLogString(executionCommand, false));
|
||||
logString.append(getExecutionOutputLogString(executionCommand, false));
|
||||
|
||||
logString.append("\n").append(executionCommand.getCommandDescriptionLogString());
|
||||
logString.append("\n").append(executionCommand.getCommandHelpLogString());
|
||||
logString.append("\n").append(executionCommand.getPluginAPIHelpLogString());
|
||||
|
||||
return logString.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a markdown {@link String} for {@link ExecutionCommand}.
|
||||
*
|
||||
* @param executionCommand The {@link ExecutionCommand} to convert.
|
||||
* @return Returns the markdown {@link String}.
|
||||
*/
|
||||
public static String getExecutionCommandMarkdownString(final ExecutionCommand executionCommand) {
|
||||
if (executionCommand == null) return "null";
|
||||
|
||||
if (executionCommand.commandLabel == null) executionCommand.commandLabel = "Execution Command";
|
||||
|
||||
StringBuilder markdownString = new StringBuilder();
|
||||
|
||||
markdownString.append("## ").append(executionCommand.commandLabel).append("\n");
|
||||
|
||||
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Previous State", executionCommand.previousState.getName(), "-"));
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Current State", executionCommand.currentState.getName(), "-"));
|
||||
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Executable", executionCommand.executable, "-"));
|
||||
markdownString.append("\n").append(getArgumentsMarkdownString(executionCommand.arguments));
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Working Directory", executionCommand.workingDirectory, "-"));
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("inBackground", executionCommand.inBackground, "-"));
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("isFailsafe", executionCommand.isFailsafe, "-"));
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Session Action", executionCommand.sessionAction, "-"));
|
||||
|
||||
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("isPluginExecutionCommand", executionCommand.isPluginExecutionCommand, "-"));
|
||||
if (executionCommand.pluginPendingIntent != null)
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Pending Intent Creator", executionCommand.pluginPendingIntent.getCreatorPackage(), "-"));
|
||||
else
|
||||
markdownString.append("\n").append("**Pending Intent Creator:** - ");
|
||||
|
||||
markdownString.append("\n\n").append(MarkdownUtils.getMultiLineMarkdownStringEntry("Stdout", executionCommand.stdout, "-"));
|
||||
markdownString.append("\n").append(MarkdownUtils.getMultiLineMarkdownStringEntry("Stderr", executionCommand.stderr, "-"));
|
||||
markdownString.append("\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Exit Code", executionCommand.exitCode, "-"));
|
||||
|
||||
markdownString.append("\n\n").append(MarkdownUtils.getSingleLineMarkdownStringEntry("Err Code", executionCommand.errCode, "-"));
|
||||
markdownString.append("\n").append("**Errmsg:**\n").append(DataUtils.getDefaultIfNull(executionCommand.errmsg, "-"));
|
||||
markdownString.append("\n\n").append(executionCommand.geStackTracesMarkdownString());
|
||||
|
||||
if (executionCommand.commandDescription != null || executionCommand.commandHelp != null) {
|
||||
if (executionCommand.commandDescription != null)
|
||||
markdownString.append("\n\n### Command Description\n\n").append(executionCommand.commandDescription).append("\n");
|
||||
if (executionCommand.commandHelp != null)
|
||||
markdownString.append("\n\n### Command Help\n\n").append(executionCommand.commandHelp).append("\n");
|
||||
markdownString.append("\n##\n");
|
||||
}
|
||||
|
||||
if (executionCommand.pluginAPIHelp != null) {
|
||||
markdownString.append("\n\n### Plugin API Help\n\n").append(executionCommand.pluginAPIHelp);
|
||||
markdownString.append("\n##\n");
|
||||
}
|
||||
|
||||
return markdownString.toString();
|
||||
}
|
||||
|
||||
|
||||
|
||||
public String getIdLogString() {
|
||||
if (id != null)
|
||||
return "(" + id + ") ";
|
||||
else
|
||||
return "";
|
||||
}
|
||||
|
||||
public String getCurrentStateLogString() {
|
||||
return "Current State: `" + currentState.getName() + "`";
|
||||
}
|
||||
|
||||
public String getPreviousStateLogString() {
|
||||
return "Previous State: `" + previousState.getName() + "`";
|
||||
}
|
||||
|
||||
public String getCommandLabelLogString() {
|
||||
if (commandLabel != null && !commandLabel.isEmpty())
|
||||
return commandLabel;
|
||||
else
|
||||
return "Execution Command";
|
||||
}
|
||||
|
||||
public String getCommandIdAndLabelLogString() {
|
||||
return getIdLogString() + getCommandLabelLogString();
|
||||
}
|
||||
|
||||
public String getExecutableLogString() {
|
||||
return "Executable: `" + executable + "`";
|
||||
}
|
||||
|
||||
public String getArgumentsLogString() {
|
||||
return getArgumentsLogString(arguments);
|
||||
}
|
||||
|
||||
public String getWorkingDirectoryLogString() {
|
||||
return "Working Directory: `" + workingDirectory + "`";
|
||||
}
|
||||
|
||||
public String getInBackgroundLogString() {
|
||||
return "inBackground: `" + inBackground + "`";
|
||||
}
|
||||
|
||||
public String getIsFailsafeLogString() {
|
||||
return "isFailsafe: `" + isFailsafe + "`";
|
||||
}
|
||||
|
||||
public String getIsPluginExecutionCommandLogString() {
|
||||
return "isPluginExecutionCommand: `" + isPluginExecutionCommand + "`";
|
||||
}
|
||||
|
||||
public String getSessionActionLogString() {
|
||||
return Logger.getSingleLineLogStringEntry("Session Action", sessionAction, "-");
|
||||
}
|
||||
|
||||
public String getPendingIntentCreatorLogString() {
|
||||
if (pluginPendingIntent != null)
|
||||
return "Pending Intent Creator: `" + pluginPendingIntent.getCreatorPackage() + "`";
|
||||
else
|
||||
return "Pending Intent Creator: -";
|
||||
}
|
||||
|
||||
public String getCommandDescriptionLogString() {
|
||||
return Logger.getSingleLineLogStringEntry("Command Description", commandDescription, "-");
|
||||
}
|
||||
|
||||
public String getCommandHelpLogString() {
|
||||
return Logger.getSingleLineLogStringEntry("Command Help", commandHelp, "-");
|
||||
}
|
||||
|
||||
public String getPluginAPIHelpLogString() {
|
||||
return Logger.getSingleLineLogStringEntry("Plugin API Help", pluginAPIHelp, "-");
|
||||
}
|
||||
|
||||
public String getStdoutLogString() {
|
||||
return Logger.getMultiLineLogStringEntry("Stdout", DataUtils.getTruncatedCommandOutput(stdout, Logger.LOGGER_ENTRY_SIZE_LIMIT_IN_BYTES / 5, false, false, true), "-");
|
||||
}
|
||||
|
||||
public String getStderrLogString() {
|
||||
return Logger.getMultiLineLogStringEntry("Stderr", DataUtils.getTruncatedCommandOutput(stderr, Logger.LOGGER_ENTRY_SIZE_LIMIT_IN_BYTES / 5, false, false, true), "-");
|
||||
}
|
||||
|
||||
public String getExitCodeLogString() {
|
||||
return Logger.getSingleLineLogStringEntry("Exit Code", exitCode, "-");
|
||||
}
|
||||
|
||||
public String getErrCodeLogString() {
|
||||
return Logger.getSingleLineLogStringEntry("Err Code", errCode, "-");
|
||||
}
|
||||
|
||||
public String getErrmsgLogString() {
|
||||
return Logger.getMultiLineLogStringEntry("Errmsg", errmsg, "-");
|
||||
}
|
||||
|
||||
public String geStackTracesLogString() {
|
||||
return Logger.getStackTracesString("StackTraces:", Logger.getStackTraceStringArray(throwableList));
|
||||
}
|
||||
|
||||
public String geStackTracesMarkdownString() {
|
||||
return Logger.getStackTracesMarkdownString("StackTraces", Logger.getStackTraceStringArray(throwableList));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Get a markdown {@link String} for {@link String[]} argumentsArray.
|
||||
* If argumentsArray are null or of size 0, then `**Arguments:** -` is returned. Otherwise
|
||||
* following format is returned:
|
||||
*
|
||||
* **Arguments:**
|
||||
*
|
||||
* **Arg 1:**
|
||||
* ```
|
||||
* value
|
||||
* ```
|
||||
* **Arg 2:**
|
||||
* ```
|
||||
* value
|
||||
*```
|
||||
*
|
||||
* @param argumentsArray The {@link String[]} argumentsArray to convert.
|
||||
* @return Returns the markdown {@link String}.
|
||||
*/
|
||||
public static String getArgumentsMarkdownString(final String[] argumentsArray) {
|
||||
StringBuilder argumentsString = new StringBuilder("**Arguments:**");
|
||||
|
||||
if (argumentsArray != null && argumentsArray.length != 0) {
|
||||
argumentsString.append("\n");
|
||||
for (int i = 0; i != argumentsArray.length; i++) {
|
||||
argumentsString.append(MarkdownUtils.getMultiLineMarkdownStringEntry("Arg " + (i + 1), argumentsArray[i], "-")).append("\n");
|
||||
}
|
||||
} else{
|
||||
argumentsString.append(" - ");
|
||||
}
|
||||
|
||||
return argumentsString.toString();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get a log friendly {@link String} for {@link List<String>} argumentsArray.
|
||||
* If argumentsArray are null or of size 0, then `Arguments: -` is returned. Otherwise
|
||||
* following format is returned:
|
||||
*
|
||||
* Arguments:
|
||||
* ```
|
||||
* Arg 1: `value`
|
||||
* Arg 2: 'value`
|
||||
* ```
|
||||
*
|
||||
* @param argumentsArray The {@link String[]} argumentsArray to convert.
|
||||
* @return Returns the log friendly {@link String}.
|
||||
*/
|
||||
public static String getArgumentsLogString(final String[] argumentsArray) {
|
||||
StringBuilder argumentsString = new StringBuilder("Arguments:");
|
||||
|
||||
if (argumentsArray != null && argumentsArray.length != 0) {
|
||||
argumentsString.append("\n```\n");
|
||||
for (int i = 0; i != argumentsArray.length; i++) {
|
||||
argumentsString.append(Logger.getSingleLineLogStringEntry("Arg " + (i + 1),
|
||||
DataUtils.getTruncatedCommandOutput(argumentsArray[i], Logger.LOGGER_ENTRY_SIZE_LIMIT_IN_BYTES / 5, true, false, true),
|
||||
"-")).append("`\n");
|
||||
}
|
||||
argumentsString.append("```");
|
||||
} else{
|
||||
argumentsString.append(" -");
|
||||
}
|
||||
|
||||
return argumentsString.toString();
|
||||
}
|
||||
|
||||
|
||||
public synchronized boolean setState(ExecutionState newState) {
|
||||
// The state transition cannot go back or change if already at {@link ExecutionState#SUCCESS}
|
||||
if (newState.getValue() < currentState.getValue() || currentState == ExecutionState.SUCCESS) {
|
||||
Logger.logError("Invalid "+ getCommandIdAndLabelLogString() + " state transition from \"" + currentState.getName() + "\" to " + "\"" + newState.getName() + "\"");
|
||||
return false;
|
||||
}
|
||||
|
||||
// The {@link ExecutionState#FAILED} can be set again, like to add more errors, but we don't update
|
||||
// {@link #previousState} with the {@link #currentState} value if its at {@link ExecutionState#FAILED} to
|
||||
// preserve the last valid state
|
||||
if (currentState != ExecutionState.FAILED)
|
||||
previousState = currentState;
|
||||
|
||||
currentState = newState;
|
||||
return true;
|
||||
}
|
||||
|
||||
public synchronized boolean setStateFailed(int errCode, String errmsg, Throwable throwable) {
|
||||
if (errCode > RESULT_CODE_OK) {
|
||||
this.errCode = errCode;
|
||||
} else {
|
||||
Logger.logWarn("Ignoring invalid " + getCommandIdAndLabelLogString() + " errCode value \"" + errCode + "\". Force setting it to RESULT_CODE_FAILED \"" + RESULT_CODE_FAILED + "\"");
|
||||
this.errCode = RESULT_CODE_FAILED;
|
||||
}
|
||||
|
||||
this.errmsg = errmsg;
|
||||
|
||||
if (!setState(ExecutionState.FAILED))
|
||||
return false;
|
||||
|
||||
if (this.throwableList == null)
|
||||
this.throwableList = new ArrayList<>();
|
||||
|
||||
if (throwable != null)
|
||||
this.throwableList.add(throwable);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public synchronized boolean shouldNotProcessResults() {
|
||||
if (processingResultsAlreadyCalled) {
|
||||
return true;
|
||||
} else {
|
||||
processingResultsAlreadyCalled = true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized boolean isStateFailed() {
|
||||
if (currentState != ExecutionState.FAILED)
|
||||
return false;
|
||||
|
||||
if (errCode <= RESULT_CODE_OK) {
|
||||
Logger.logWarn("The " + getCommandIdAndLabelLogString() + " has an invalid errCode value \"" + errCode + "\" while having ExecutionState.FAILED state.");
|
||||
return false;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized boolean hasExecuted() {
|
||||
return currentState.getValue() >= ExecutionState.EXECUTED.getValue();
|
||||
}
|
||||
|
||||
public synchronized boolean isExecuting() {
|
||||
return currentState == ExecutionState.EXECUTING;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -2,11 +2,16 @@ package com.termux.shared.shell;
|
||||
|
||||
import android.content.Context;
|
||||
|
||||
import androidx.annotation.NonNull;
|
||||
|
||||
import com.termux.shared.termux.TermuxConstants;
|
||||
import com.termux.shared.file.FileUtils;
|
||||
import com.termux.shared.logger.Logger;
|
||||
import com.termux.shared.packages.PackageUtils;
|
||||
import com.termux.shared.termux.TermuxUtils;
|
||||
import com.termux.terminal.TerminalBuffer;
|
||||
import com.termux.terminal.TerminalEmulator;
|
||||
import com.termux.terminal.TerminalSession;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
@@ -85,7 +90,7 @@ public class ShellUtils {
|
||||
}
|
||||
}
|
||||
|
||||
public static String[] setupProcessArgs(String fileToExecute, String[] arguments) {
|
||||
public static String[] setupProcessArgs(@NonNull String fileToExecute, String[] arguments) {
|
||||
// The file to execute may either be:
|
||||
// - An elf file, in which we execute it directly.
|
||||
// - A script file without shebang, which we execute with our standard shell $PREFIX/bin/sh instead of the
|
||||
@@ -153,4 +158,28 @@ public class ShellUtils {
|
||||
}
|
||||
}
|
||||
|
||||
public static String getTerminalSessionTranscriptText(TerminalSession terminalSession, boolean linesJoined, boolean trim) {
|
||||
if (terminalSession == null) return null;
|
||||
|
||||
TerminalEmulator terminalEmulator = terminalSession.getEmulator();
|
||||
if (terminalEmulator == null) return null;
|
||||
|
||||
TerminalBuffer terminalBuffer = terminalEmulator.getScreen();
|
||||
if (terminalBuffer == null) return null;
|
||||
|
||||
String transcriptText;
|
||||
|
||||
if(linesJoined)
|
||||
transcriptText = terminalBuffer.getTranscriptTextWithFullLinesJoined();
|
||||
else
|
||||
transcriptText = terminalBuffer.getTranscriptTextWithoutJoinedLines();
|
||||
|
||||
if (transcriptText == null) return null;
|
||||
|
||||
if(trim)
|
||||
transcriptText = transcriptText.trim();
|
||||
|
||||
return transcriptText;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -32,6 +32,9 @@ import com.termux.shared.logger.Logger;
|
||||
|
||||
/**
|
||||
* Thread utility class continuously reading from an InputStream
|
||||
*
|
||||
* https://github.com/Chainfire/libsuperuser/blob/1.1.0.201907261845/libsuperuser/src/eu/chainfire/libsuperuser/Shell.java#L141
|
||||
* https://github.com/Chainfire/libsuperuser/blob/1.1.0.201907261845/libsuperuser/src/eu/chainfire/libsuperuser/StreamGobbler.java
|
||||
*/
|
||||
@SuppressWarnings({"WeakerAccess"})
|
||||
public class StreamGobbler extends Thread {
|
||||
@@ -170,6 +173,7 @@ public class StreamGobbler extends Thread {
|
||||
// optionally pausing when a command is executed that consumes the InputStream itself
|
||||
int currentLogLevel = Logger.getLogLevel();
|
||||
int logLevelVerbose = Logger.LOG_LEVEL_VERBOSE;
|
||||
|
||||
try {
|
||||
String line;
|
||||
while ((line = reader.readLine()) != null) {
|
||||
|
||||
@@ -0,0 +1,258 @@
|
||||
package com.termux.shared.shell;
|
||||
|
||||
import android.content.Context;
|
||||
import android.system.OsConstants;
|
||||
|
||||
import androidx.annotation.NonNull;
|
||||
|
||||
import com.termux.shared.R;
|
||||
import com.termux.shared.models.ExecutionCommand;
|
||||
import com.termux.shared.termux.TermuxConstants;
|
||||
import com.termux.shared.logger.Logger;
|
||||
import com.termux.terminal.TerminalSession;
|
||||
import com.termux.terminal.TerminalSessionClient;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
/**
|
||||
* A class that maintains info for foreground Termux sessions.
|
||||
* It also provides a way to link each {@link TerminalSession} with the {@link ExecutionCommand}
|
||||
* that started it.
|
||||
*/
|
||||
public class TermuxSession {
|
||||
|
||||
private final TerminalSession mTerminalSession;
|
||||
private final ExecutionCommand mExecutionCommand;
|
||||
private final TermuxSessionClient mTermuxSessionClient;
|
||||
private final boolean mSetStdoutOnExit;
|
||||
|
||||
private static final String LOG_TAG = "TermuxSession";
|
||||
|
||||
private TermuxSession(@NonNull final TerminalSession terminalSession, @NonNull final ExecutionCommand executionCommand,
|
||||
final TermuxSessionClient termuxSessionClient, final boolean setStdoutOnExit) {
|
||||
this.mTerminalSession = terminalSession;
|
||||
this.mExecutionCommand = executionCommand;
|
||||
this.mTermuxSessionClient = termuxSessionClient;
|
||||
this.mSetStdoutOnExit = setStdoutOnExit;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start execution of an {@link ExecutionCommand} with {@link Runtime#exec(String[], String[], File)}.
|
||||
*
|
||||
* The {@link ExecutionCommand#executable}, must be set, {@link ExecutionCommand#commandLabel},
|
||||
* {@link ExecutionCommand#arguments} and {@link ExecutionCommand#workingDirectory} may optionally
|
||||
* be set.
|
||||
*
|
||||
* If {@link ExecutionCommand#executable} is {@code null}, then a default shell is automatically
|
||||
* chosen.
|
||||
*
|
||||
* @param context The {@link Context} for operations.
|
||||
* @param executionCommand The {@link ExecutionCommand} containing the information for execution command.
|
||||
* @param terminalSessionClient The {@link TerminalSessionClient} interface implementation.
|
||||
* @param termuxSessionClient The {@link TermuxSessionClient} interface implementation.
|
||||
* @param sessionName The optional {@link TerminalSession} name.
|
||||
* @param setStdoutOnExit If set to {@code true}, then the {@link ExecutionCommand#stdout}
|
||||
* available in the {@link TermuxSessionClient#onTermuxSessionExited(TermuxSession)}
|
||||
* callback will be set to the {@link TerminalSession} transcript. The session
|
||||
* transcript will contain both stdout and stderr combined, basically
|
||||
* anything sent to the the pseudo terminal /dev/pts, including PS1 prefixes.
|
||||
* Set this to {@code true} only if the session transcript is required,
|
||||
* since this requires extra processing to get it.
|
||||
* @return Returns the {@link TermuxSession}. This will be {@code null} if failed to start the execution command.
|
||||
*/
|
||||
public static TermuxSession execute(@NonNull final Context context, @NonNull ExecutionCommand executionCommand,
|
||||
@NonNull final TerminalSessionClient terminalSessionClient, final TermuxSessionClient termuxSessionClient,
|
||||
final String sessionName, final boolean setStdoutOnExit) {
|
||||
if (executionCommand.workingDirectory == null || executionCommand.workingDirectory.isEmpty()) executionCommand.workingDirectory = TermuxConstants.TERMUX_HOME_DIR_PATH;
|
||||
|
||||
String[] environment = ShellUtils.buildEnvironment(context, executionCommand.isFailsafe, executionCommand.workingDirectory);
|
||||
|
||||
boolean isLoginShell = false;
|
||||
if (executionCommand.executable == null) {
|
||||
if (!executionCommand.isFailsafe) {
|
||||
for (String shellBinary : new String[]{"login", "bash", "zsh"}) {
|
||||
File shellFile = new File(TermuxConstants.TERMUX_BIN_PREFIX_DIR_PATH, shellBinary);
|
||||
if (shellFile.canExecute()) {
|
||||
executionCommand.executable = shellFile.getAbsolutePath();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (executionCommand.executable == null) {
|
||||
// Fall back to system shell as last resort:
|
||||
executionCommand.executable = "/system/bin/sh";
|
||||
}
|
||||
isLoginShell = true;
|
||||
}
|
||||
|
||||
String[] processArgs = ShellUtils.setupProcessArgs(executionCommand.executable, executionCommand.arguments);
|
||||
|
||||
executionCommand.executable = processArgs[0];
|
||||
String processName = (isLoginShell ? "-" : "") + ShellUtils.getExecutableBasename(executionCommand.executable);
|
||||
|
||||
String[] arguments = new String[processArgs.length];
|
||||
arguments[0] = processName;
|
||||
if (processArgs.length > 1) System.arraycopy(processArgs, 1, arguments, 1, processArgs.length - 1);
|
||||
|
||||
executionCommand.arguments = arguments;
|
||||
|
||||
if (executionCommand.commandLabel == null)
|
||||
executionCommand.commandLabel = processName;
|
||||
|
||||
if (!executionCommand.setState(ExecutionCommand.ExecutionState.EXECUTING)) {
|
||||
executionCommand.setStateFailed(ExecutionCommand.RESULT_CODE_FAILED, context.getString(R.string.error_failed_to_execute_termux_session_command, executionCommand.getCommandIdAndLabelLogString()), null);
|
||||
TermuxSession.processTermuxSessionResult(null, executionCommand);
|
||||
return null;
|
||||
}
|
||||
|
||||
Logger.logDebug(LOG_TAG, executionCommand.toString());
|
||||
|
||||
Logger.logDebug(LOG_TAG, "Running \"" + executionCommand.getCommandIdAndLabelLogString() + "\" TermuxSession");
|
||||
TerminalSession terminalSession = new TerminalSession(executionCommand.executable, executionCommand.workingDirectory, executionCommand.arguments, environment, terminalSessionClient);
|
||||
|
||||
if (sessionName != null) {
|
||||
terminalSession.mSessionName = sessionName;
|
||||
}
|
||||
|
||||
return new TermuxSession(terminalSession, executionCommand, termuxSessionClient, setStdoutOnExit);
|
||||
}
|
||||
|
||||
/**
|
||||
* Signal that this {@link TermuxSession} has finished. This should be called when
|
||||
* {@link TerminalSessionClient#onSessionFinished(TerminalSession)} callback is received by the caller.
|
||||
*
|
||||
* If the processes has finished, then sets {@link ExecutionCommand#stdout}, {@link ExecutionCommand#stderr}
|
||||
* and {@link ExecutionCommand#exitCode} for the {@link #mExecutionCommand} of the {@code termuxTask}
|
||||
* and then calls {@link #processTermuxSessionResult(TermuxSession, ExecutionCommand)} to process the result}.
|
||||
*
|
||||
*/
|
||||
public void finish() {
|
||||
// If process is still running, then ignore the call
|
||||
if (mTerminalSession.isRunning()) return;
|
||||
|
||||
int exitCode = mTerminalSession.getExitStatus();
|
||||
|
||||
if (exitCode == 0)
|
||||
Logger.logDebug(LOG_TAG, "The \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxSession with exited normally");
|
||||
else
|
||||
Logger.logDebug(LOG_TAG, "The \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxSession with exited with code: " + exitCode);
|
||||
|
||||
// If the execution command has already failed, like SIGKILL was sent, then don't continue
|
||||
if (mExecutionCommand.isStateFailed()) {
|
||||
Logger.logDebug(LOG_TAG, "Ignoring setting \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxSession state to ExecutionState.EXECUTED and processing results since it has already failed");
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.mSetStdoutOnExit)
|
||||
mExecutionCommand.stdout = ShellUtils.getTerminalSessionTranscriptText(mTerminalSession, true, false);
|
||||
else
|
||||
mExecutionCommand.stdout = null;
|
||||
|
||||
mExecutionCommand.stderr = null;
|
||||
mExecutionCommand.exitCode = exitCode;
|
||||
|
||||
if (!mExecutionCommand.setState(ExecutionCommand.ExecutionState.EXECUTED))
|
||||
return;
|
||||
|
||||
TermuxSession.processTermuxSessionResult(this, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Kill this {@link TermuxSession} by sending a {@link OsConstants#SIGILL} to its {@link #mTerminalSession}
|
||||
* if its still executing.
|
||||
*
|
||||
* We process the results even if
|
||||
*
|
||||
* @param context The {@link Context} for operations.
|
||||
* @param processResult If set to {@code true}, then the {@link #processTermuxSessionResult(TermuxSession, ExecutionCommand)}
|
||||
* will be called to process the failure.
|
||||
*/
|
||||
public void killIfExecuting(@NonNull final Context context, boolean processResult) {
|
||||
// If execution command has already finished executing, then no need to process results or send SIGKILL
|
||||
if(mExecutionCommand.hasExecuted()) {
|
||||
Logger.logDebug(LOG_TAG, "Ignoring sending SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxSession since it has already finished executing");
|
||||
return;
|
||||
}
|
||||
|
||||
Logger.logDebug(LOG_TAG, "Send SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxSession");
|
||||
if (mExecutionCommand.setStateFailed(ExecutionCommand.RESULT_CODE_FAILED, context.getString(R.string.error_sending_sigkill_to_process), null)) {
|
||||
if (processResult) {
|
||||
// Get whatever output has been set till now in case its needed
|
||||
if (this.mSetStdoutOnExit)
|
||||
mExecutionCommand.stdout = ShellUtils.getTerminalSessionTranscriptText(mTerminalSession, true, false);
|
||||
else
|
||||
mExecutionCommand.stdout = null;
|
||||
|
||||
mExecutionCommand.stderr = null;
|
||||
mExecutionCommand.exitCode = 137; // SIGKILL
|
||||
|
||||
TermuxSession.processTermuxSessionResult(this, null);
|
||||
}
|
||||
}
|
||||
|
||||
// Send SIGKILL to process
|
||||
mTerminalSession.finishIfRunning();
|
||||
}
|
||||
|
||||
/**
|
||||
* Process the results of {@link TermuxSession} or {@link ExecutionCommand}.
|
||||
*
|
||||
* Only one of {@code termuxSession} and {@code executionCommand} must be set.
|
||||
*
|
||||
* If the {@code termuxSession} and its {@link #mTermuxSessionClient} are not {@code null},
|
||||
* then the {@link TermuxSession.TermuxSessionClient#onTermuxSessionExited(TermuxSession)}
|
||||
* callback will be called.
|
||||
*
|
||||
* @param termuxSession The {@link TermuxSession}, which should be set if
|
||||
* {@link #execute(Context, ExecutionCommand, TerminalSessionClient, TermuxSessionClient, String, boolean)}
|
||||
* successfully started the process.
|
||||
* @param executionCommand The {@link ExecutionCommand}, which should be set if
|
||||
* {@link #execute(Context, ExecutionCommand, TerminalSessionClient, TermuxSessionClient, String, boolean)}
|
||||
* failed to start the process.
|
||||
*/
|
||||
private static void processTermuxSessionResult(final TermuxSession termuxSession, ExecutionCommand executionCommand) {
|
||||
if (termuxSession != null)
|
||||
executionCommand = termuxSession.mExecutionCommand;
|
||||
|
||||
if (executionCommand == null) return;
|
||||
|
||||
if (executionCommand.shouldNotProcessResults()) {
|
||||
Logger.logDebug(LOG_TAG, "Ignoring duplicate call to process \"" + executionCommand.getCommandIdAndLabelLogString() + "\" TermuxSession result");
|
||||
return;
|
||||
}
|
||||
|
||||
Logger.logDebug(LOG_TAG, "Processing \"" + executionCommand.getCommandIdAndLabelLogString() + "\" TermuxSession result");
|
||||
|
||||
if (termuxSession != null && termuxSession.mTermuxSessionClient != null) {
|
||||
termuxSession.mTermuxSessionClient.onTermuxSessionExited(termuxSession);
|
||||
} else {
|
||||
// If a callback is not set and execution command didn't fail, then we set success state now
|
||||
// Otherwise, the callback host can set it himself when its done with the termuxSession
|
||||
if (!executionCommand.isStateFailed())
|
||||
executionCommand.setState(ExecutionCommand.ExecutionState.SUCCESS);
|
||||
}
|
||||
}
|
||||
|
||||
public TerminalSession getTerminalSession() {
|
||||
return mTerminalSession;
|
||||
}
|
||||
|
||||
public ExecutionCommand getExecutionCommand() {
|
||||
return mExecutionCommand;
|
||||
}
|
||||
|
||||
|
||||
|
||||
public interface TermuxSessionClient {
|
||||
|
||||
/**
|
||||
* Callback function for when {@link TermuxSession} exits.
|
||||
*
|
||||
* @param termuxSession The {@link TermuxSession} that exited.
|
||||
*/
|
||||
void onTermuxSessionExited(TermuxSession termuxSession);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
package com.termux.shared.shell;
|
||||
|
||||
import com.termux.shared.logger.Logger;
|
||||
import com.termux.terminal.TerminalSession;
|
||||
import com.termux.terminal.TerminalSessionClient;
|
||||
|
||||
public class TermuxSessionClientBase implements TerminalSessionClient {
|
||||
|
||||
public TermuxSessionClientBase() {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onTextChanged(TerminalSession changedSession) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onTitleChanged(TerminalSession updatedSession) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onSessionFinished(final TerminalSession finishedSession) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onClipboardText(TerminalSession session, String text) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onBell(TerminalSession session) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onColorsChanged(TerminalSession changedSession) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void logError(String tag, String message) {
|
||||
Logger.logError(tag, message);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void logWarn(String tag, String message) {
|
||||
Logger.logWarn(tag, message);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void logInfo(String tag, String message) {
|
||||
Logger.logInfo(tag, message);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void logDebug(String tag, String message) {
|
||||
Logger.logDebug(tag, message);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void logVerbose(String tag, String message) {
|
||||
Logger.logVerbose(tag, message);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void logStackTraceWithMessage(String tag, String message, Exception e) {
|
||||
Logger.logStackTraceWithMessage(tag, message, e);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void logStackTrace(String tag, Exception e) {
|
||||
Logger.logStackTrace(tag, e);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,273 @@
|
||||
package com.termux.shared.shell;
|
||||
|
||||
import android.content.Context;
|
||||
import android.system.ErrnoException;
|
||||
import android.system.Os;
|
||||
import android.system.OsConstants;
|
||||
|
||||
import androidx.annotation.NonNull;
|
||||
|
||||
import com.termux.shared.R;
|
||||
import com.termux.shared.models.ExecutionCommand;
|
||||
import com.termux.shared.termux.TermuxConstants;
|
||||
import com.termux.shared.logger.Logger;
|
||||
import com.termux.shared.models.ExecutionCommand.ExecutionState;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* A class that maintains info for background Termux tasks run with {@link Runtime#exec(String[], String[], File)}.
|
||||
* It also provides a way to link each {@link Process} with the {@link ExecutionCommand}
|
||||
* that started it.
|
||||
*/
|
||||
public final class TermuxTask {
|
||||
|
||||
private final Process mProcess;
|
||||
private final ExecutionCommand mExecutionCommand;
|
||||
private final TermuxTaskClient mTermuxTaskClient;
|
||||
|
||||
private final StringBuilder mStdout = new StringBuilder();
|
||||
private final StringBuilder mStderr = new StringBuilder();
|
||||
|
||||
private static final String LOG_TAG = "TermuxTask";
|
||||
|
||||
private TermuxTask(@NonNull final Process process, @NonNull final ExecutionCommand executionCommand,
|
||||
final TermuxTaskClient termuxTaskClient) {
|
||||
this.mProcess = process;
|
||||
this.mExecutionCommand = executionCommand;
|
||||
this.mTermuxTaskClient = termuxTaskClient;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start execution of an {@link ExecutionCommand} with {@link Runtime#exec(String[], String[], File)}.
|
||||
*
|
||||
* The {@link ExecutionCommand#executable}, must be set.
|
||||
* The {@link ExecutionCommand#commandLabel}, {@link ExecutionCommand#arguments} and
|
||||
* {@link ExecutionCommand#workingDirectory} may optionally be set.
|
||||
*
|
||||
* @param context The {@link Context} for operations.
|
||||
* @param executionCommand The {@link ExecutionCommand} containing the information for execution command.
|
||||
* @param termuxTaskClient The {@link TermuxTaskClient} interface implementation.
|
||||
* The {@link TermuxTaskClient#onTermuxTaskExited(TermuxTask)} will
|
||||
* be called regardless of {@code isSynchronous} value but not if
|
||||
* {@code null} is returned by this method. This can
|
||||
* optionally be {@code null}.
|
||||
* @param isSynchronous If set to {@code true}, then the command will be executed in the
|
||||
* caller thread and results returned synchronously in the {@link ExecutionCommand}
|
||||
* sub object of the {@link TermuxTask} returned.
|
||||
* If set to {@code false}, then a new thread is started run the commands
|
||||
* asynchronously in the background and control is returned to the caller thread.
|
||||
* @return Returns the {@link TermuxTask}. This will be {@code null} if failed to start the execution command.
|
||||
*/
|
||||
public static TermuxTask execute(@NonNull final Context context, @NonNull ExecutionCommand executionCommand,
|
||||
final TermuxTaskClient termuxTaskClient, final boolean isSynchronous) {
|
||||
if (executionCommand.workingDirectory == null || executionCommand.workingDirectory.isEmpty()) executionCommand.workingDirectory = TermuxConstants.TERMUX_HOME_DIR_PATH;
|
||||
|
||||
String[] env = ShellUtils.buildEnvironment(context, false, executionCommand.workingDirectory);
|
||||
|
||||
final String[] commandArray = ShellUtils.setupProcessArgs(executionCommand.executable, executionCommand.arguments);
|
||||
|
||||
if (!executionCommand.setState(ExecutionState.EXECUTING))
|
||||
return null;
|
||||
|
||||
Logger.logDebug(LOG_TAG, executionCommand.toString());
|
||||
|
||||
String taskName = ShellUtils.getExecutableBasename(executionCommand.executable);
|
||||
|
||||
if (executionCommand.commandLabel == null)
|
||||
executionCommand.commandLabel = taskName;
|
||||
|
||||
// Exec the process
|
||||
final Process process;
|
||||
try {
|
||||
process = Runtime.getRuntime().exec(commandArray, env, new File(executionCommand.workingDirectory));
|
||||
} catch (IOException e) {
|
||||
executionCommand.setStateFailed(ExecutionCommand.RESULT_CODE_FAILED, context.getString(R.string.error_failed_to_execute_termux_task_command, executionCommand.getCommandIdAndLabelLogString()), e);
|
||||
TermuxTask.processTermuxTaskResult(null, executionCommand);
|
||||
return null;
|
||||
}
|
||||
|
||||
final TermuxTask termuxTask = new TermuxTask(process, executionCommand, termuxTaskClient);
|
||||
|
||||
if (isSynchronous) {
|
||||
try {
|
||||
termuxTask.executeInner();
|
||||
} catch (IllegalThreadStateException | InterruptedException e) {
|
||||
// TODO: Should either of these be handled or returned?
|
||||
}
|
||||
} else {
|
||||
new Thread() {
|
||||
@Override
|
||||
public void run() {
|
||||
try {
|
||||
termuxTask.executeInner();
|
||||
} catch (IllegalThreadStateException | InterruptedException e) {
|
||||
// TODO: Should either of these be handled or returned?
|
||||
}
|
||||
}
|
||||
}.start();
|
||||
}
|
||||
|
||||
return termuxTask;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets up stdout and stderr readers for the {@link #mProcess} and waits for the process to end.
|
||||
*
|
||||
* If the processes finishes, then sets {@link ExecutionCommand#stdout}, {@link ExecutionCommand#stderr}
|
||||
* and {@link ExecutionCommand#exitCode} for the {@link #mExecutionCommand} of the {@code termuxTask}
|
||||
* and then calls {@link #processTermuxTaskResult(TermuxTask, ExecutionCommand) to process the result}.
|
||||
*/
|
||||
private void executeInner() throws IllegalThreadStateException, InterruptedException {
|
||||
final int pid = ShellUtils.getPid(mProcess);
|
||||
|
||||
Logger.logDebug(LOG_TAG, "Running \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask with pid " + pid);
|
||||
|
||||
mExecutionCommand.stdout = null;
|
||||
mExecutionCommand.stderr = null;
|
||||
mExecutionCommand.exitCode = null;
|
||||
|
||||
|
||||
|
||||
// setup stdout and stderr gobblers
|
||||
StreamGobbler STDOUT = new StreamGobbler(pid + "-stdout", mProcess.getInputStream(), mStdout);
|
||||
StreamGobbler STDERR = new StreamGobbler(pid + "-stderr", mProcess.getErrorStream(), mStderr);
|
||||
|
||||
// start gobbling
|
||||
STDOUT.start();
|
||||
STDERR.start();
|
||||
|
||||
// wait for our process to finish, while we gobble away in the background
|
||||
int exitCode = mProcess.waitFor();
|
||||
|
||||
// make sure our threads are done gobbling
|
||||
// and the process is destroyed - while the latter shouldn't be
|
||||
// needed in theory, and may even produce warnings, in "normal" Java
|
||||
// they are required for guaranteed cleanup of resources, so lets be
|
||||
// safe and do this on Android as well
|
||||
STDOUT.join();
|
||||
STDERR.join();
|
||||
mProcess.destroy();
|
||||
|
||||
// Process result
|
||||
if (exitCode == 0)
|
||||
Logger.logDebug(LOG_TAG, "The \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask with pid " + pid + " exited normally");
|
||||
else
|
||||
Logger.logDebug(LOG_TAG, "The \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask with pid " + pid + " exited with code: " + exitCode);
|
||||
|
||||
// If the execution command has already failed, like SIGKILL was sent, then don't continue
|
||||
if (mExecutionCommand.isStateFailed()) {
|
||||
Logger.logDebug(LOG_TAG, "Ignoring setting \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask state to ExecutionState.EXECUTED and processing results since it has already failed");
|
||||
return;
|
||||
}
|
||||
|
||||
mExecutionCommand.stdout = mStdout.toString();
|
||||
mExecutionCommand.stderr = mStderr.toString();
|
||||
mExecutionCommand.exitCode = exitCode;
|
||||
|
||||
if (!mExecutionCommand.setState(ExecutionState.EXECUTED))
|
||||
return;
|
||||
|
||||
TermuxTask.processTermuxTaskResult(this, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Kill this {@link TermuxTask} by sending a {@link OsConstants#SIGILL} to its {@link #mProcess}
|
||||
* if its still executing.
|
||||
*
|
||||
* @param context The {@link Context} for operations.
|
||||
* @param processResult If set to {@code true}, then the {@link #processTermuxTaskResult(TermuxTask, ExecutionCommand)}
|
||||
* will be called to process the failure.
|
||||
*/
|
||||
public void killIfExecuting(@NonNull final Context context, boolean processResult) {
|
||||
// If execution command has already finished executing, then no need to process results or send SIGKILL
|
||||
if(mExecutionCommand.hasExecuted()) {
|
||||
Logger.logDebug(LOG_TAG, "Ignoring sending SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask since it has already finished executing");
|
||||
return;
|
||||
}
|
||||
|
||||
Logger.logDebug(LOG_TAG, "Send SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask");
|
||||
|
||||
if (mExecutionCommand.setStateFailed(ExecutionCommand.RESULT_CODE_FAILED, context.getString(R.string.error_sending_sigkill_to_process), null)) {
|
||||
if (processResult) {
|
||||
// Get whatever output has been set till now in case its needed
|
||||
mExecutionCommand.stdout = mStdout.toString();
|
||||
mExecutionCommand.stderr = mStderr.toString();
|
||||
mExecutionCommand.exitCode = 137; // SIGKILL
|
||||
|
||||
TermuxTask.processTermuxTaskResult(this, null);
|
||||
}
|
||||
}
|
||||
|
||||
if (mExecutionCommand.isExecuting()) {
|
||||
int pid = ShellUtils.getPid(mProcess);
|
||||
try {
|
||||
// Send SIGKILL to process
|
||||
Os.kill(pid, OsConstants.SIGKILL);
|
||||
} catch (ErrnoException e) {
|
||||
Logger.logWarn(LOG_TAG, "Failed to send SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask with pid " + pid + ": " + e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Process the results of {@link TermuxTask} or {@link ExecutionCommand}.
|
||||
*
|
||||
* Only one of {@code termuxTask} and {@code executionCommand} must be set.
|
||||
*
|
||||
* If the {@code termuxTask} and its {@link #mTermuxTaskClient} are not {@code null},
|
||||
* then the {@link TermuxTaskClient#onTermuxTaskExited(TermuxTask)} callback will be called.
|
||||
*
|
||||
* @param termuxTask The {@link TermuxTask}, which should be set if
|
||||
* {@link #execute(Context, ExecutionCommand, TermuxTaskClient, boolean)}
|
||||
* successfully started the process.
|
||||
* @param executionCommand The {@link ExecutionCommand}, which should be set if
|
||||
* {@link #execute(Context, ExecutionCommand, TermuxTaskClient, boolean)}
|
||||
* failed to start the process.
|
||||
*/
|
||||
private static void processTermuxTaskResult(final TermuxTask termuxTask, ExecutionCommand executionCommand) {
|
||||
if (termuxTask != null)
|
||||
executionCommand = termuxTask.mExecutionCommand;
|
||||
|
||||
if (executionCommand == null) return;
|
||||
|
||||
if (executionCommand.shouldNotProcessResults()) {
|
||||
Logger.logDebug(LOG_TAG, "Ignoring duplicate call to process \"" + executionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask result");
|
||||
return;
|
||||
}
|
||||
|
||||
Logger.logDebug(LOG_TAG, "Processing \"" + executionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask result");
|
||||
|
||||
if (termuxTask != null && termuxTask.mTermuxTaskClient != null) {
|
||||
termuxTask.mTermuxTaskClient.onTermuxTaskExited(termuxTask);
|
||||
} else {
|
||||
// If a callback is not set and execution command didn't fail, then we set success state now
|
||||
// Otherwise, the callback host can set it himself when its done with the termuxTask
|
||||
if (!executionCommand.isStateFailed())
|
||||
executionCommand.setState(ExecutionCommand.ExecutionState.SUCCESS);
|
||||
}
|
||||
}
|
||||
|
||||
public Process getProcess() {
|
||||
return mProcess;
|
||||
}
|
||||
|
||||
public ExecutionCommand getExecutionCommand() {
|
||||
return mExecutionCommand;
|
||||
}
|
||||
|
||||
|
||||
|
||||
public interface TermuxTaskClient {
|
||||
|
||||
/**
|
||||
* Callback function for when {@link TermuxTask} exits.
|
||||
*
|
||||
* @param termuxTask The {@link TermuxTask} that exited.
|
||||
*/
|
||||
void onTermuxTaskExited(TermuxTask termuxTask);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -76,6 +76,15 @@
|
||||
<string name="msg_report_issue">If you want to report this issue, then copy its text from the options menu (3-dots on top right) and post an issue on one of the following links. If you are posting on Github, then post it in the repository at which the report belongs at. You may optionally remove any device specific info that you consider private or don\'t want to share or that is not relevant to the issue.</string>
|
||||
|
||||
|
||||
|
||||
<!-- ShellUtils -->
|
||||
<string name="error_sending_sigkill_to_process">Sending SIGKILL to process on user request or because android is killing the execution service</string>
|
||||
<string name="error_execution_cancelled">Execution has been cancelled since execution service is being killed</string>
|
||||
<string name="error_failed_to_execute_termux_session_command">"Failed to execute \"%1$s\" termux session command"</string>
|
||||
<string name="error_failed_to_execute_termux_task_command">"Failed to execute \"%1$s\" termux task command"</string>
|
||||
|
||||
|
||||
|
||||
<!-- Log Level -->
|
||||
<string name="log_level_title">Log Level</string>
|
||||
<string name="log_level_off">"Off"</string>
|
||||
|
||||
Reference in New Issue
Block a user