ExternalProcess.java

package server.restful.common.processor;

import client.teavm.common.parameter.StringBuilderConsole;
import com.beust.jcommander.JCommander;
import com.beust.jcommander.internal.Console;
import libsidutils.IOUtils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.List;

import static java.lang.Integer.MAX_VALUE;
import static java.lang.String.format;
import static java.nio.charset.StandardCharsets.UTF_8;

public class ExternalProcess {

    private static class NoConsole implements Console {

        @Override
        public void print(CharSequence msg) {
        }

        @Override
        public void println(CharSequence msg) {
        }

        @Override
        public char[] readPassword(boolean echoInput) {
            throw new RuntimeException("readPassword not supported!");
        }

    }

    private List<String> arguments;

    public Process execute(Object parameterObject) throws IOException {
        JCommander jCommander = JCommander.newBuilder().addObject(new Object()).addCommand(parameterObject)
                .programName(parameterObject.getClass().getName()).console(new NoConsole()).build();

        if (jCommander.getCommands().isEmpty()) {
            throw new IOException(format("%s is missing a command!", parameterObject.getClass()));
        }
        StringBuilder usageMessage = new StringBuilder();
        Iterator<String> it = jCommander.getCommands().keySet().iterator();
        while (it.hasNext()) {
            String command = it.next();
            JCommander jCommand = jCommander.getCommands().get(command);

            ProcessCommandUsageFormatter usageFormatter = new ProcessCommandUsageFormatter(jCommand);
            jCommand.setUsageFormatter(usageFormatter);
            jCommand.usage();

            try {
                arguments = usageFormatter.getArguments();
                usageMessage.append("\n").append(String.join(" ", arguments));

                Process process = new ProcessBuilder(arguments).start();
                process.waitFor();
                if (process.exitValue() != 0 && !it.hasNext()) {
                    usageMessage.append(getStdout(process));
                    usageMessage.append(getStdErr(process));
                    throw new IOException(format("%s failed with exitValue: %d\n%s", command, process.exitValue(),
                            usageMessage));
                }
                return process;

            } catch (IOException | InterruptedException e) {
                // try the next alias command
            }
        }
        JCommander.newBuilder().programName("").addObject(new Object()).addCommand(parameterObject)
                .console(new StringBuilderConsole(usageMessage.append("\n"))).columnSize(MAX_VALUE).build().usage();

        throw new IOException(usageMessage.toString());
    }

    private String getStdErr(Process process) throws IOException {
        try (InputStream is = process.getErrorStream()) {
            return IOUtils.convertStreamToString(is, UTF_8);
        }
    }

    private String getStdout(Process process) throws IOException {
        try (InputStream is = process.getInputStream()) {
            return IOUtils.convertStreamToString(is, UTF_8);
        }
    }

    public List<String> getArguments() {
        return arguments;
    }
}