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); } }
@Test public void fatJarWithOutput() throws IOException, InterruptedException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "fat_jar", tmp); workspace.setUp(); Path jar = workspace.buildAndReturnOutput("//:bin-output"); ProcessExecutor.Result result = workspace.runJar(jar); assertEquals("output", result.getStdout().get().trim()); assertEquals("error", result.getStderr().get().trim()); }
@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()); } }
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; }
/** * 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")); }