[stacked] Finalize bullet_stream output update

.github/workflows/ci.yml

@@ -97,12 +97,11 @@ jobs:
         # Runs only tests annotated with the `ignore` attribute (which in this repo, are the integration tests).
         run: cargo test --locked -- --ignored --test-threads 16
 
-  print-pack-getting-started-output:
-    runs-on: ${{ matrix.target == 'aarch64-unknown-linux-musl' && 'pub-hk-ubuntu-24.04-arm-medium' || 'ubuntu-24.04' }}
+  print-guide:
+    runs-on: 'pub-hk-ubuntu-24.04-arm-medium'
     strategy:
       matrix:
-        target: ["aarch64-unknown-linux-musl", "x86_64-unknown-linux-musl"]
-        guide: ["heroku/java-getting-started", "heroku/gradle-getting-started", "heroku/scala-getting-started"]
+        guide: ["java-getting-started", "gradle-getting-started", "scala-getting-started"]
       fail-fast: false
     steps:
       - name: Checkout
@@ -114,7 +113,7 @@ jobs:
       - name: Update Rust toolchain
         run: rustup update
       - name: Install Rust linux-musl target
-        run: rustup target add ${{ matrix.target }}
+        run: rustup target add aarch64-unknown-linux-musl
       - name: Rust Cache
         uses: Swatinem/[email protected]
       - name: Install Pack CLI
@@ -126,31 +125,31 @@ jobs:
       - name: Clone getting started guide
         uses: actions/checkout@v4
         with:
-          repository: ${{ matrix.guide }}
+          repository: "heroku/${{ matrix.guide }}"
           path: tmp/guide
       - name: Install libcnb-cargo for `cargo libcnb package` command
         run: cargo install libcnb-cargo
       - name: Compile buildpack
-        run: cargo libcnb package --target ${{ matrix.target }}
+        run: cargo libcnb package --target aarch64-unknown-linux-musl
       - name: "PRINT: Getting started guide output"
         run: |
           set -euo pipefail
 
           PACK_CMD="pack build my-image --force-color --builder heroku/builder:24 --trust-extra-buildpacks --path tmp/guide --pull-policy never "
           case "${{ matrix.guide }}" in
-            "heroku/java-getting-started")
-              PACK_CMD+=" --buildpack packaged/${{ matrix.target }}/debug/heroku_jvm "
-              PACK_CMD+=" --buildpack packaged/${{ matrix.target }}/debug/heroku_java "
-              PACK_CMD+=" --buildpack packaged/${{ matrix.target }}/debug/heroku_maven "
+            "java-getting-started")
+              PACK_CMD+=" --buildpack packaged/aarch64-unknown-linux-musl/debug/heroku_jvm "
+              PACK_CMD+=" --buildpack packaged/aarch64-unknown-linux-musl/debug/heroku_java "
+              PACK_CMD+=" --buildpack packaged/aarch64-unknown-linux-musl/debug/heroku_maven "
               ;;
-            "heroku/gradle-getting-started")
-              PACK_CMD+=" --buildpack packaged/${{ matrix.target }}/debug/heroku_jvm "
-              PACK_CMD+=" --buildpack packaged/${{ matrix.target }}/debug/heroku_gradle "
+            "gradle-getting-started")
+              PACK_CMD+=" --buildpack packaged/aarch64-unknown-linux-musl/debug/heroku_jvm "
+              PACK_CMD+=" --buildpack packaged/aarch64-unknown-linux-musl/debug/heroku_gradle "
               ;;
-            "heroku/scala-getting-started")
-              PACK_CMD+=" --buildpack packaged/${{ matrix.target }}/debug/heroku_jvm "
-              PACK_CMD+=" --buildpack packaged/${{ matrix.target }}/debug/heroku_sbt "
-              PACK_CMD+=" --buildpack packaged/${{ matrix.target }}/debug/heroku_scala "
+            "scala-getting-started")
+              PACK_CMD+=" --buildpack packaged/aarch64-unknown-linux-musl/debug/heroku_jvm "
+              PACK_CMD+=" --buildpack packaged/aarch64-unknown-linux-musl/debug/heroku_sbt "
+              PACK_CMD+=" --buildpack packaged/aarch64-unknown-linux-musl/debug/heroku_scala "
               ;;
             *)
               echo "Unknown guide: ${{ matrix.guide }}"

buildpacks/gradle/Cargo.toml

@@ -10,7 +10,7 @@ workspace = true
 buildpacks-jvm-shared.workspace = true
 indoc = "2"
 libcnb = "=0.26.0"
-libherokubuildpack = { version = "=0.26.0", default-features = false, features = ["command", "error", "log"] }
+libherokubuildpack = { version = "=0.26.0", default-features = false, features = ["error"] }
 nom = "7"
 serde = { version = "1", features = ["derive"] }
 

buildpacks/gradle/src/errors.rs

@@ -1,15 +1,18 @@
 use crate::GradleBuildpackError;
-use buildpacks_jvm_shared::log::{
-    log_build_tool_io_error, log_build_tool_unexpected_exit_code_error, log_please_try_again_error,
+use buildpacks_jvm_shared::{
+    log::{
+        log_build_tool_io_error, log_build_tool_unexpected_exit_code_error,
+        log_please_try_again_error,
+    },
+    output::print_error,
 };
 use indoc::indoc;
-use libherokubuildpack::log::log_error;
 
 #[allow(clippy::too_many_lines, clippy::needless_pass_by_value)]
 pub(crate) fn on_error_gradle_buildpack(error: GradleBuildpackError) {
     match error {
         GradleBuildpackError::GradleWrapperNotFound => {
-            log_error(
+            print_error(
                 "Missing Gradle Wrapper",
                 indoc! {"
                     This buildpack leverages Gradle Wrapper to install the correct Gradle version to build your application.
@@ -59,7 +62,7 @@ pub(crate) fn on_error_gradle_buildpack(error: GradleBuildpackError) {
             "The Gradle daemon for this build could not be started.",
             error,
         ),
-        GradleBuildpackError::BuildTaskUnknown => log_error(
+        GradleBuildpackError::BuildTaskUnknown => print_error(
             "Failed to determine build task",
             indoc! {"
                 It looks like your project does not contain a 'stage' task, which Heroku needs in order

buildpacks/gradle/src/gradle_command/daemon.rs

@@ -1,47 +1,47 @@
 use crate::gradle_command::GradleCommandError;
 use crate::GRADLE_TASK_NAME_HEROKU_START_DAEMON;
+use buildpacks_jvm_shared::output;
 use libcnb::Env;
-use libherokubuildpack::command::CommandExt;
-use std::io::{stderr, stdout};
 use std::path::Path;
 use std::process::Command;
 
 pub(crate) fn start(
     gradle_wrapper_executable_path: &Path,
     gradle_env: &Env,
 ) -> Result<(), GradleCommandError<()>> {
-    let output = Command::new(gradle_wrapper_executable_path)
+    let mut command = Command::new(gradle_wrapper_executable_path);
+    command
         .args([
             // Fixes an issue when running under Apple Rosetta emulation
             "-Djdk.lang.Process.launchMechanism=vfork",
             "--daemon",
             GRADLE_TASK_NAME_HEROKU_START_DAEMON,
         ])
-        .envs(gradle_env)
-        .output_and_write_streams(stdout(), stderr())
-        .map_err(GradleCommandError::Io)?;
+        .envs(gradle_env);
 
-    if output.status.success() {
-        Ok(())
-    } else {
-        Err(GradleCommandError::UnexpectedExitStatus {
+    output::run_command(command, false, GradleCommandError::Io, |output| {
+        GradleCommandError::UnexpectedExitStatus {
             status: output.status,
             stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
             stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
-        })
-    }
+        }
+    })
+    .map(|_| ())
 }
 
 pub(crate) fn stop(
     gradle_wrapper_executable_path: &Path,
     gradle_env: &Env,
 ) -> Result<(), GradleCommandError<()>> {
-    Command::new(gradle_wrapper_executable_path)
-        .args(["-q", "--stop"])
-        .envs(gradle_env)
-        .spawn()
-        .and_then(|mut child| child.wait())
-        .map_err(GradleCommandError::Io)?;
+    let mut command = Command::new(gradle_wrapper_executable_path);
+    command.args(["-q", "--stop"]).envs(gradle_env);
 
-    Ok(())
+    output::run_command(command, true, GradleCommandError::Io, |output| {
+        GradleCommandError::UnexpectedExitStatus {
+            status: output.status,
+            stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
+            stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
+        }
+    })
+    .map(|_| ())
 }

buildpacks/gradle/src/gradle_command/dependency_report.rs

@@ -1,4 +1,5 @@
 use crate::gradle_command::GradleCommandError;
+use buildpacks_jvm_shared::output::run_command;
 use libcnb::Env;
 use std::collections::BTreeMap;
 use std::path::Path;
@@ -8,27 +9,23 @@ pub(crate) fn dependency_report(
     app_dir: &Path,
     env: &Env,
 ) -> Result<GradleDependencyReport, GradleCommandError<()>> {
-    let output = Command::new(app_dir.join("gradlew"))
+    let mut command = Command::new(app_dir.join("gradlew"));
+    command
         .current_dir(app_dir)
         .envs(env)
-        .args(["--quiet", "dependencies"])
-        .output()
-        .map_err(GradleCommandError::Io)?;
+        .args(["--quiet", "dependencies"]);
 
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-
-    if output.status.success() {
-        parser::dependency_report(&stdout)
-            .map_err(|_| GradleCommandError::Parse(()))
-            .map(|(_, dependency_report)| dependency_report)
-    } else {
-        Err(GradleCommandError::UnexpectedExitStatus {
+    let output = run_command(command, true, GradleCommandError::Io, |output| {
+        GradleCommandError::UnexpectedExitStatus {
             status: output.status,
-            stdout: stdout.into_owned(),
-            stderr: stderr.into_owned(),
-        })
-    }
+            stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
+            stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
+        }
+    })?;
+
+    parser::dependency_report(&String::from_utf8_lossy(&output.stdout))
+        .map_err(|_| GradleCommandError::Parse(()))
+        .map(|(_, dependency_report)| dependency_report)
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]

buildpacks/gradle/src/gradle_command/mod.rs

@@ -7,8 +7,6 @@ pub(crate) use daemon::stop as stop_daemon;
 pub(crate) use dependency_report::{dependency_report, GradleDependencyReport};
 pub(crate) use tasks::tasks;
 
-use std::process::Command;
-
 #[derive(Debug)]
 pub(crate) enum GradleCommandError<P> {
     Io(std::io::Error),
@@ -40,23 +38,3 @@ impl<P> GradleCommandError<P> {
         }
     }
 }
-
-fn run_gradle_command<T, F, P>(command: &mut Command, parser: F) -> Result<T, GradleCommandError<P>>
-where
-    F: FnOnce(&str, &str) -> Result<T, P>,
-{
-    let output = command.output().map_err(GradleCommandError::Io)?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
-    let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
-
-    if output.status.success() {
-        parser(&stdout, &stderr).map_err(GradleCommandError::Parse)
-    } else {
-        Err(GradleCommandError::UnexpectedExitStatus {
-            status: output.status,
-            stdout,
-            stderr,
-        })
-    }
-}

buildpacks/gradle/src/gradle_command/tasks.rs

@@ -1,4 +1,5 @@
-use crate::gradle_command::{run_gradle_command, GradleCommandError};
+use crate::gradle_command::GradleCommandError;
+use buildpacks_jvm_shared::output::run_command;
 use libcnb::Env;
 use std::path::Path;
 use std::process::Command;
@@ -7,20 +8,27 @@ pub(crate) fn tasks(
     current_dir: &Path,
     env: &Env,
 ) -> Result<Tasks, GradleCommandError<nom::error::Error<String>>> {
-    run_gradle_command(
-        Command::new(current_dir.join("gradlew"))
-            .current_dir(current_dir)
-            .envs(env)
-            .args(["--quiet", "tasks"]),
-        |stdout, _stderr| {
-            parser::parse(stdout)
-                .map(|groups| Tasks { groups })
-                .map_err(|error| nom::error::Error {
-                    input: error.input.to_string(),
-                    code: error.code,
-                })
-        },
-    )
+    let mut command = Command::new(current_dir.join("gradlew"));
+    command
+        .current_dir(current_dir)
+        .envs(env)
+        .args(["--quiet", "tasks"]);
+
+    let output = run_command(command, true, GradleCommandError::Io, |output| {
+        GradleCommandError::UnexpectedExitStatus {
+            status: output.status,
+            stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
+            stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
+        }
+    })?;
+
+    parser::parse(&String::from_utf8_lossy(&output.stdout))
+        .map(|groups| Tasks { groups })
+        .map_err(|error| nom::error::Error {
+            input: error.input.to_string(),
+            code: error.code,
+        })
+        .map_err(GradleCommandError::Parse)
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]