Java CommandLine.parse方法代码示例

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
private static boolean testExecutable() {
    CommandLine commandLine = CommandLine.parse(RCLIProcessor.rExecutable + " " + VERSION_CALL);

    DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
    Executor executor = new DefaultExecutor();

    // put a watchdog with a timeout
    ExecuteWatchdog watchdog = new ExecuteWatchdog(new Long(TIMEOUT_SECONDS) * 1000);
    executor.setWatchdog(watchdog);

    try {
        executor.execute(commandLine, resultHandler);
        resultHandler.waitFor();
        int exitVal = resultHandler.getExitValue();
        if (exitVal != 0) {
            return false;
        }
            return true;
    }
    catch (Exception e) {
        return false;
    }
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
public static boolean testExecutable() {
	CommandLine commandLine = CommandLine.parse(PythonCLIProcessor.pythonExecutable + " --version");

	DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
	Executor executor = new DefaultExecutor();

	// put a watchdog with a timeout
	ExecuteWatchdog watchdog = new ExecuteWatchdog(new Long(timeout_seconds) * 1000);
	executor.setWatchdog(watchdog);

	try {
		executor.execute(commandLine, resultHandler);
		resultHandler.waitFor();
		int exitVal = resultHandler.getExitValue();
		if (exitVal != 0) {
			return false;
		}
		return true;
	}
	catch (Exception e) {
		return false;
	}
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
/**
 * Starts the jekyll build process (jekyll build --incremental)
 * @return true, if jekyll build was successful
 */
public boolean startJekyllCI() {
	int exitValue = -1;
	String line = JEKYLL_PATH;
	ByteArrayOutputStream jekyllBuildOutput = new ByteArrayOutputStream();
	CommandLine cmdLine = CommandLine.parse(line);
	cmdLine.addArgument(JEKYLL_OPTION_BUILD);
	cmdLine.addArgument(JEKYLL_OPTION_INCR);
	DefaultExecutor executor = new DefaultExecutor();
	executor.setWorkingDirectory(new File(LOCAL_REPO_PATH));
	PumpStreamHandler streamHandler = new PumpStreamHandler(jekyllBuildOutput);
	executor.setStreamHandler(streamHandler);
	try {
		LOGGER.info("Starting jekyll build");
		exitValue = executor.execute(cmdLine);
		LOGGER.info("Jekyll build command executed");
	} catch (IOException e) {
		LOGGER.error("Error while executing jekyll build. Error message: {}", e.getMessage());
		e.printStackTrace();
		return false;
	}
	printJekyllStatus(exitValue, jekyllBuildOutput.toString());
	return true;
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    String cmd = "/tmp/test.sh";
    CommandLine cmdLine = CommandLine.parse("/bin/bash " + cmd);

    ByteArrayOutputStream stdout = new ByteArrayOutputStream();
    ByteArrayOutputStream stderr = new ByteArrayOutputStream();
    PumpStreamHandler psh = new PumpStreamHandler(stdout, stderr);

    psh.setStopTimeout(TIMEOUT_FIVE_MINUTES);

    ExecuteWatchdog watchdog = new ExecuteWatchdog(TIMEOUT_TEN_MINUTES); // timeout in milliseconds

    Executor executor = new DefaultExecutor();
    executor.setExitValue(0);
    executor.setStreamHandler(psh);
    executor.setWatchdog(watchdog);

    int exitValue = executor.execute(cmdLine, Collections.emptyMap());
    System.out.println(exitValue);
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
@Test
public void testCommonsCodecsConflicts() throws IOException, VerificationException {
    SetupContent setupContent = new SetupContent().invoke();
    String shadedJar = setupContent.getShadedJar();
    String issue24POM = setupContent.getIssue24POM();
    String issue24TestFile = setupContent.getIssue24TestFile();
    File cwdFile = setupContent.getCwdFile();
    

    String line = String.format("java -jar %s -v -p %s %s %s", shadedJar, issue24POM, issue24TestFile,
            StringUtils.join(new String[] {cwdFile.getAbsolutePath(), "testCommonsCodecsConflicts.html"}, File.separator));
    CommandLine command = CommandLine.parse(line);
    DefaultExecutor executor = new DefaultExecutor();
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ByteArrayOutputStream err = new ByteArrayOutputStream();
    executor.setStreamHandler(new PumpStreamHandler(out, err));
    executor.execute(command);
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
@Test
public void shouldNotOverwriteInputFile() throws IOException, VerificationException {
    SetupContent setupContent = new SetupContent().invoke();
    String shadedJar = setupContent.getShadedJar();
    String issue24POM = setupContent.getIssue24POM();
    String issue24TestFile = setupContent.getIssue24TestFile();
    File specFile = new File(issue24TestFile);
    File specBackupFile = new File(issue24TestFile + ".orig");
    FileUtils.copyFile(specFile, specBackupFile);

    String line = String.format("java -jar %s -v -p %s %s", shadedJar, issue24POM, issue24TestFile);
    CommandLine command = CommandLine.parse(line);
    DefaultExecutor executor = new DefaultExecutor();
    executor.setWorkingDirectory(specFile.getParentFile());
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ByteArrayOutputStream err = new ByteArrayOutputStream();
    executor.setStreamHandler(new PumpStreamHandler(out, err));
    executor.execute(command);

    assertTrue("The specification should not be overriden by the output", FileUtils.contentEquals(specFile,specBackupFile));
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
@Test
void testRunEchoHelloWorld() throws IOException, InterruptedException {
    final CommandLine expected = SystemUtils.IS_OS_WINDOWS
            ? CommandLine.parse("cmd /C echo hello world")
            : CommandLine.parse("/bin/sh -c").addArgument("echo hello world", false);

    final DefaultExecutor cmdExecMock = Mockito.mock(DefaultExecutor.class);
    final CommandRunner cmdRunner = new CommandBuilder()
            .withShellWrapper(true)
            .withCommandExecutor(cmdExecMock)
            .build();

    cmdRunner.exec(CommandLine.parse("echo hello world"), null);

    verify(cmdExecMock).execute(runEchoCaptor.capture(), (File) isNull());
    assertEquals(expected.toString(), runEchoCaptor.getValue().toString());
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
public void createSecureConfiguration() throws InterpreterException {
  Properties properties = getProperties();
  CommandLine cmdLine = CommandLine.parse(shell);
  cmdLine.addArgument("-c", false);
  String kinitCommand = String.format("kinit -k -t %s %s",
      properties.getProperty("zeppelin.shell.keytab.location"),
      properties.getProperty("zeppelin.shell.principal"));
  cmdLine.addArgument(kinitCommand, false);
  DefaultExecutor executor = new DefaultExecutor();
  try {
    executor.execute(cmdLine);
  } catch (Exception e) {
    LOGGER.error("Unable to run kinit for zeppelin user " + kinitCommand, e);
    throw new InterpreterException(e);
  }
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
public static int run(final GeneratorConfig gc, final ExecutionConfig ec) throws IOException, InterruptedException {
	final File configFile = File.createTempFile("trainbenchmark-generator-", ".conf");
	final String configPath = configFile.getAbsolutePath();
	gc.saveToFile(configPath);

	final String projectName = String.format("trainbenchmark-generator-%s", gc.getProjectName());
	final String jarPath = String.format("../%s/build/libs/%s-1.0.0-SNAPSHOT-fat.jar", projectName, projectName);
	final String javaCommand = String.format("java -Xms%s -Xmx%s -server -jar %s %s", ec.getXms(), ec.getXmx(),
			jarPath, configPath);

	final CommandLine cmdLine = CommandLine.parse(javaCommand);
	final DefaultExecutor executor = new DefaultExecutor();
	try {
		final int exitValue = executor.execute(cmdLine);
		System.out.println();
		return exitValue;
	} catch (final ExecuteException e) {
		e.printStackTrace(System.out);
		return e.getExitValue();
	}
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
public static int executeCommand(String command,ExecuteWatchdog watchdog) {
	CommandLine cmdLine = CommandLine.parse(command);
	DefaultExecutor executor = new DefaultExecutor();
	executor.setStreamHandler(new PumpStreamHandler(System.out,System.err, null));
	executor.setExitValues(new int[]{0, 1});
	if(watchdog != null){
		executor.setWatchdog(watchdog);
	}
	int exitValue = 0;
	try {
		exitValue = executor.execute(cmdLine);
	} catch (IOException e) {
		exitValue = 1;
		log.error("error executing command", e);
	}
	return exitValue;
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
private Protos.CommandInfo buildCommand(final Protos.CommandInfo.URI uri, final String script, final ShardingContexts shardingContexts, final boolean isCommandExecutor) {
    Protos.CommandInfo.Builder result = Protos.CommandInfo.newBuilder().addUris(uri).setShell(true);
    if (isCommandExecutor) {
        CommandLine commandLine = CommandLine.parse(script);
        commandLine.addArgument(GsonFactory.getGson().toJson(shardingContexts), false);
        result.setValue(Joiner.on(" ").join(commandLine.getExecutable(), Joiner.on(" ").join(commandLine.getArguments())));
    } else {
        result.setValue(script);
    }
    return result.build();
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
private void executeScript(final ShardingContext shardingContext, final String scriptCommandLine) {
    CommandLine commandLine = CommandLine.parse(scriptCommandLine);
    commandLine.addArgument(GsonFactory.getGson().toJson(shardingContext), false);
    try {
        new DefaultExecutor().execute(commandLine);
    } catch (final IOException ex) {
        throw new JobConfigurationException("Execute script failure.", ex);
    }
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
public String execToString(String command) throws Exception {
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    CommandLine commandline = CommandLine.parse(command);
    DefaultExecutor exec = new DefaultExecutor();
    PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream);
    exec.setStreamHandler(streamHandler);
    exec.execute(commandline);
    return (outputStream.toString());
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
private void menuItem1ActionPerformed(ActionEvent e) {
    if(this.api == ModificationAPI.BUKKIT) {
        showBukkitIncompatibleFeature();
        return;
    }
    System.out.println("Starting client...");
    SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {
        @Override
        protected Void doInBackground() throws Exception {
            GradleConnector.newConnector().forProjectDirectory(workDirectory).connect().newBuild().forTasks("runClient").run();
            return null;
        }
    };
    if(this.api == ModificationAPI.MCP) {
        worker = new SwingWorker<Void, Void>() {
            @Override
            protected Void doInBackground() throws Exception {
                if(System.getProperty("os.name").startsWith("Windows")) {
                    Runtime.getRuntime().exec("cmd /c startclient.bat", null, workDirectory);
                    return null;
                }
                try {
                    CommandLine startClient = CommandLine.parse("python " + new File(new File(workDirectory, "runtime"), "startclient.py").getAbsolutePath() + " [email protected]");
                    CommandLine authClient = CommandLine.parse("chmod 755 " + new File(new File(workDirectory, "runtime"), "startclient.py").getAbsolutePath());
                    DefaultExecutor executor = new DefaultExecutor();
                    executor.setWorkingDirectory(workDirectory);
                    executor.execute(authClient);
                    executor.execute(startClient);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }
        };
    }
    worker.execute();
}
 

import org.apache.commons.exec.CommandLine; //导入方法依赖的package包/类
private void menuItem2ActionPerformed(ActionEvent e) {
    if(this.api == ModificationAPI.BUKKIT) {
        showBukkitIncompatibleFeature();
        return;
    }
    System.out.println("Starting server...");
    SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {
        @Override
        protected Void doInBackground() throws Exception {
            GradleConnector.newConnector().forProjectDirectory(workDirectory).connect().newBuild().forTasks("runServer").run();
            return null;
        }
    };
    if (this.api == ModificationAPI.MCP) {
        worker = new SwingWorker<Void, Void>() {
            @Override
            protected Void doInBackground() throws Exception {
                if (System.getProperty("os.name").startsWith("Windows")) {
                    Runtime.getRuntime().exec("cmd /c startserver.bat", null, workDirectory);
                    return null;
                }
                try {
                    CommandLine startServer = CommandLine.parse("python " + new File(new File(workDirectory, "runtime"), "startserver.py").getAbsolutePath() + " [email protected]");
                    CommandLine authServer = CommandLine.parse("chmod 755 " + new File(new File(workDirectory, "runtime"), "startserver.py").getAbsolutePath());
                    DefaultExecutor executor = new DefaultExecutor();
                    executor.setWorkingDirectory(workDirectory);
                    executor.execute(authServer);
                    executor.execute(startServer);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }
        };
    }
    worker.execute();
}