private String getGoEnvFromTool(ProcessExecutor processExecutor, String env) { Path goTool = getGoToolPath(); Optional<Map<String, String>> goRootEnv = delegate .getPath("go", "root") .transform( new Function<Path, Map<String, String>>() { @Override public Map<String, String> apply(Path input) { return ImmutableMap.of("GOROOT", input.toString()); } }); try { ProcessExecutor.Result goToolResult = processExecutor.launchAndExecute( ProcessExecutorParams.builder() .addCommand(goTool.toString(), "env", env) .setEnvironment(goRootEnv) .build(), EnumSet.of(ProcessExecutor.Option.EXPECTING_STD_ERR), /* stdin */ Optional.<String>absent(), /* timeOutMs */ Optional.<Long>absent(), /* timeoutHandler */ Optional.<Function<Process, Void>>absent()); if (goToolResult.getExitCode() == 0) { return CharMatcher.WHITESPACE.trimFrom(goToolResult.getStdout().get()); } else { throw new HumanReadableException(goToolResult.getStderr().get()); } } catch (InterruptedException e) { throw Throwables.propagate(e); } catch (IOException e) { throw new HumanReadableException(e, "Could not run \"%s env %s\": %s", env, goTool); } }
public int createIntellijProject( File jsonTempFile, ProcessExecutor processExecutor, boolean generateMinimalProject, PrintStream stdOut, PrintStream stdErr) throws IOException { List<Module> modules = createModulesForProjectConfigs(); writeJsonConfig(jsonTempFile, modules); List<String> modifiedFiles = Lists.newArrayList(); // Process the JSON config to generate the .xml and .iml files for IntelliJ. ExitCodeAndOutput result = processJsonConfig(jsonTempFile, generateMinimalProject); if (result.exitCode != 0) { return result.exitCode; } else { // intellij.py writes the list of modified files to stdout, so parse stdout and add the // resulting file paths to the modifiedFiles list. Iterable<String> paths = Splitter.on('\n').trimResults().omitEmptyStrings().split(result.stdOut); Iterables.addAll(modifiedFiles, paths); } // Write out the project.properties files. List<String> modifiedPropertiesFiles = generateProjectDotPropertiesFiles(modules); modifiedFiles.addAll(modifiedPropertiesFiles); // Write out the .idea/compiler.xml file (the .idea/ directory is guaranteed to exist). CompilerXml compilerXml = new CompilerXml(modules); final String pathToCompilerXml = ".idea/compiler.xml"; File compilerXmlFile = projectFilesystem.getFileForRelativePath(pathToCompilerXml); if (compilerXml.write(compilerXmlFile)) { modifiedFiles.add(pathToCompilerXml); } // If the user specified a post-processing script, then run it. if (pathToPostProcessScript.isPresent()) { String pathToScript = pathToPostProcessScript.get(); Process process = Runtime.getRuntime().exec(new String[] {pathToScript}); ProcessExecutor.Result postProcessResult = processExecutor.execute(process); int postProcessExitCode = postProcessResult.getExitCode(); if (postProcessExitCode != 0) { return postProcessExitCode; } } // If any files have been modified by `buck project`, then list them for the user. if (!modifiedFiles.isEmpty()) { SortedSet<String> modifiedFilesInSortedForder = Sets.newTreeSet(modifiedFiles); stdOut.printf("MODIFIED FILES:\n%s\n", Joiner.on('\n').join(modifiedFilesInSortedForder)); } // Blit stderr from intellij.py to parent stderr. stdErr.print(result.stdErr); return 0; }
private ProcessExecutor.Result runRuleKeyDiffer(ProjectWorkspace workspace) throws IOException, InterruptedException { ProcessExecutor.Result result = workspace.runCommand( "python2.7", Paths.get("scripts", "diff_rulekeys.py").toString(), tmp.getRootPath().resolve("buck-0.log").toString(), tmp.getRootPath().resolve("buck-1.log").toString(), "//:java_lib_2"); assertThat(result.getStderr(), Matchers.equalTo(Optional.of(""))); assertThat(result.getExitCode(), Matchers.is(0)); return result; }
@Override public StepExecutionResult execute(ExecutionContext context) throws InterruptedException { // Build the process, redirecting output to the provided output file. In general, // it's undesirable that both stdout and stderr are being redirected to the same // input stream. However, due to the nature of OS pipe buffering, we can't really // maintain the natural interleaving of multiple output streams in a way that we // can correctly associate both stdout/stderr streams to the one correct test out // of the many that ran. So, our best bet is to just combine them all into stdout, // so they get properly interleaved with the test start and end messages that we // use when we parse the test output. ProcessBuilder builder = new ProcessBuilder(); builder.command(command); builder.redirectOutput(filesystem.resolve(output).toFile()); builder.redirectErrorStream(true); Process process; try { process = BgProcessKiller.startProcess(builder); } catch (IOException e) { context.logError(e, "Error starting command %s", command); return StepExecutionResult.ERROR; } // Run the test process, saving the exit code. ProcessExecutor executor = context.getProcessExecutor(); ImmutableSet<ProcessExecutor.Option> options = ImmutableSet.of(ProcessExecutor.Option.EXPECTING_STD_OUT); ProcessExecutor.Result result = executor.execute( process, options, /* stdin */ Optional.<String>absent(), /* timeOutMs */ testRuleTimeoutMs, /* timeOutHandler */ Optional.<Function<Process, Void>>absent()); if (result.isTimedOut()) { throw new HumanReadableException( "Timed out after %d ms running test command %s", testRuleTimeoutMs.or(-1L), command); } // Since test binaries return a non-zero exit code when unittests fail, save the exit code // to a file rather than signalling a step failure. try (FileOutputStream stream = new FileOutputStream(filesystem.resolve(exitCode).toFile())) { stream.write((Integer.toString(result.getExitCode())).getBytes()); } catch (IOException e) { context.logError(e, "Error saving exit code to %s", exitCode); return StepExecutionResult.ERROR; } return StepExecutionResult.SUCCESS; }
@VisibleForTesting static PythonVersion extractPythonVersion(Path pythonPath, ProcessExecutor.Result versionResult) { if (versionResult.getExitCode() == 0) { String versionString = CharMatcher.WHITESPACE.trimFrom( CharMatcher.WHITESPACE.trimFrom(versionResult.getStderr().get()) + CharMatcher.WHITESPACE .trimFrom(versionResult.getStdout().get()) .replaceAll("\u001B\\[[;\\d]*m", "")); Matcher matcher = PYTHON_VERSION_REGEX.matcher(versionString.split("\\r?\\n")[0]); if (!matcher.matches()) { throw new HumanReadableException( "`%s -V` returned an invalid version string %s", pythonPath, versionString); } return PythonVersion.of(matcher.group(1)); } else { throw new HumanReadableException(versionResult.getStderr().get()); } }
/** * Checks whether a binary or bundle already has a valid code signature. * * @param path Resolved path to the binary or bundle. * @return Whether the binary or bundle has a valid code signature. */ public static boolean hasValidSignature(ProcessExecutor processExecutor, Path path) throws InterruptedException, IOException { ProcessExecutorParams processExecutorParams = ProcessExecutorParams.builder() .setCommand(ImmutableList.of("codesign", "-vvvv", path.toString())) .build(); // Specify that stdout is expected, or else output may be wrapped in Ansi escape chars. Set<ProcessExecutor.Option> options = EnumSet.of(ProcessExecutor.Option.EXPECTING_STD_OUT, ProcessExecutor.Option.IS_SILENT); ProcessExecutor.Result result = processExecutor.launchAndExecute( processExecutorParams, options, /* stdin */ Optional.empty(), /* timeOutMs */ Optional.empty(), /* timeOutHandler */ Optional.empty()); return result.getExitCode() == 0 && result.getStderr().isPresent() && result.getStderr().get().contains(": satisfies its Designated Requirement"); }
@Test public void appleLibraryBuildsMultiarchFramework() throws Exception { assumeTrue(Platform.detect() == Platform.MACOS); assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.MACOSX)); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "apple_library_builds_something", tmp); workspace.setUp(); ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath()); BuildTarget target = BuildTargetFactory.newInstance( "//Libraries/TestLibrary:TestLibrary#framework,macosx-x86_64,macosx-i386,no-debug"); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand("build", target.getFullyQualifiedName()); result.assertSuccess(); Path frameworkPath = workspace.getPath( BuildTargets.getGenPath( filesystem, BuildTarget.builder(target) .addFlavors(AppleDescriptions.INCLUDE_FRAMEWORKS_FLAVOR) .build(), "%s") .resolve("TestLibrary.framework")); Path libraryPath = frameworkPath.resolve("TestLibrary"); assertThat(Files.exists(libraryPath), is(true)); ProcessExecutor.Result lipoVerifyResult = workspace.runCommand("lipo", libraryPath.toString(), "-verify_arch", "i386", "x86_64"); assertEquals(lipoVerifyResult.getStderr().orElse(""), 0, lipoVerifyResult.getExitCode()); assertThat( workspace.runCommand("file", libraryPath.toString()).getStdout().get(), containsString("dynamically linked shared library")); }