oshi.util.ExecutingCommand Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2016-2022 The OSHI Project Contributors
* SPDX-License-Identifier: MIT
*/
package oshi.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sun.jna.Platform;
import oshi.annotation.concurrent.ThreadSafe;
/**
* A class for executing on the command line and returning the result of execution.
*/
@ThreadSafe
public final class ExecutingCommand {
private static final Logger LOG = LoggerFactory.getLogger(ExecutingCommand.class);
private static final String[] DEFAULT_ENV = getDefaultEnv();
private ExecutingCommand() {
}
private static String[] getDefaultEnv() {
if (Platform.isWindows()) {
return new String[] { "LANGUAGE=C" };
} else {
return new String[] { "LC_ALL=C" };
}
}
/**
* Executes a command on the native command line and returns the result. This is a convenience method to call
* {@link java.lang.Runtime#exec(String)} and capture the resulting output in a list of Strings. On Windows,
* built-in commands not associated with an executable program may require {@code cmd.exe /c} to be prepended to the
* command.
*
* @param cmdToRun Command to run
* @return A list of Strings representing the result of the command, or empty string if the command failed
*/
public static List runNative(String cmdToRun) {
String[] cmd = cmdToRun.split(" ");
return runNative(cmd);
}
/**
* Executes a command on the native command line and returns the result line by line. This is a convenience method
* to call {@link java.lang.Runtime#exec(String[])} and capture the resulting output in a list of Strings. On
* Windows, built-in commands not associated with an executable program may require the strings {@code cmd.exe} and
* {@code /c} to be prepended to the array.
*
* @param cmdToRunWithArgs Command to run and args, in an array
* @return A list of Strings representing the result of the command, or empty string if the command failed
*/
public static List runNative(String[] cmdToRunWithArgs) {
return runNative(cmdToRunWithArgs, DEFAULT_ENV);
}
/**
* Executes a command on the native command line and returns the result line by line. This is a convenience method
* to call {@link java.lang.Runtime#exec(String[])} and capture the resulting output in a list of Strings. On
* Windows, built-in commands not associated with an executable program may require the strings {@code cmd.exe} and
* {@code /c} to be prepended to the array.
*
* @param cmdToRunWithArgs Command to run and args, in an array
* @param envp array of strings, each element of which has environment variable settings in the format
* name=value, or null if the subprocess should inherit the environment of the current
* process.
* @return A list of Strings representing the result of the command, or empty string if the command failed
*/
public static List runNative(String[] cmdToRunWithArgs, String[] envp) {
Process p = null;
try {
p = Runtime.getRuntime().exec(cmdToRunWithArgs, envp);
return getProcessOutput(p, cmdToRunWithArgs);
} catch (SecurityException | IOException e) {
LOG.trace("Couldn't run command {}: {}", Arrays.toString(cmdToRunWithArgs), e.getMessage());
} finally {
// Ensure all resources are released
if (p != null) {
// Windows and Solaris don't close descriptors on destroy,
// so we must handle separately
if (Platform.isWindows() || Platform.isSolaris()) {
try {
p.getOutputStream().close();
} catch (IOException e) {
// do nothing on failure
}
try {
p.getInputStream().close();
} catch (IOException e) {
// do nothing on failure
}
try {
p.getErrorStream().close();
} catch (IOException e) {
// do nothing on failure
}
}
p.destroy();
}
}
return Collections.emptyList();
}
private static List getProcessOutput(Process p, String[] cmd) {
ArrayList sa = new ArrayList<>();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(p.getInputStream(), Charset.defaultCharset()))) {
String line;
while ((line = reader.readLine()) != null) {
sa.add(line);
}
p.waitFor();
} catch (IOException e) {
LOG.trace("Problem reading output from {}: {}", Arrays.toString(cmd), e.getMessage());
} catch (InterruptedException ie) {
LOG.trace("Interrupted while reading output from {}: {}", Arrays.toString(cmd), ie.getMessage());
Thread.currentThread().interrupt();
}
return sa;
}
/**
* Return first line of response for selected command.
*
* @param cmd2launch String command to be launched
* @return String or empty string if command failed
*/
public static String getFirstAnswer(String cmd2launch) {
return getAnswerAt(cmd2launch, 0);
}
/**
* Return response on selected line index (0-based) after running selected command.
*
* @param cmd2launch String command to be launched
* @param answerIdx int index of line in response of the command
* @return String whole line in response or empty string if invalid index or running of command fails
*/
public static String getAnswerAt(String cmd2launch, int answerIdx) {
List sa = ExecutingCommand.runNative(cmd2launch);
if (answerIdx >= 0 && answerIdx < sa.size()) {
return sa.get(answerIdx);
}
return "";
}
}