Run gradle daemon quietly in background

Author: schneems

Cargo.lock

@@ -13,6 +13,7 @@ libcnb = "=0.26.0"
 libherokubuildpack = { version = "=0.26.0", default-features = false, features = ["command", "error", "log"] }
 nom = "7"
 serde = { version = "1", features = ["derive"] }
+tempfile = "3.15.0"
 
 [dev-dependencies]
 buildpacks-jvm-shared-test.workspace = true

buildpacks/gradle/Cargo.toml

@@ -1,35 +1,51 @@
 use crate::gradle_command::GradleCommandError;
 use crate::GRADLE_TASK_NAME_HEROKU_START_DAEMON;
+use buildpacks_jvm_shared::output::{self, CmdError};
 use libcnb::Env;
-use libherokubuildpack::command::CommandExt;
-use std::io::{stderr, stdout};
 use std::path::Path;
-use std::process::Command;
+use std::process::{Command, Stdio};
+use tempfile::NamedTempFile;
+
+pub(crate) struct GradleDaemonLog {
+    file: NamedTempFile,
+}
 
 pub(crate) fn start(
     gradle_wrapper_executable_path: &Path,
     gradle_env: &Env,
-) -> Result<(), GradleCommandError<()>> {
-    let output = Command::new(gradle_wrapper_executable_path)
+) -> Result<GradleDaemonLog, GradleCommandError<()>> {
+    let log = GradleDaemonLog {
+        file: tempfile::NamedTempFile::new().map_err(GradleCommandError::Io)?,
+    };
+    std::fs::write(&log.file, "").map_err(GradleCommandError::Io)?;
+    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);
+    let file = log.file.reopen().map_err(GradleCommandError::Io)?;
+
+    command.stdout(Stdio::from(
+        file.try_clone().map_err(GradleCommandError::Io)?,
+    ));
+    command.stderr(Stdio::from(file));
 
-    if output.status.success() {
-        Ok(())
-    } else {
-        Err(GradleCommandError::UnexpectedExitStatus {
-            status: output.status,
-            stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
-            stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
-        })
-    }
+    let _ = output::run_command(command, true).map_err(|error| match error {
+        CmdError::SystemError(_, error) => GradleCommandError::Io(error),
+        CmdError::NonZeroExitNotStreamed(named_output)
+        | CmdError::NonZeroExitAlreadyStreamed(named_output) => {
+            GradleCommandError::UnexpectedExitStatus {
+                status: *named_output.status(),
+                stdout: named_output.stdout_lossy(),
+                stderr: named_output.stderr_lossy(),
+            }
+        }
+    })?;
+    Ok(log)
 }
 
 pub(crate) fn stop(

buildpacks/gradle/src/gradle_command/daemon.rs

@@ -92,10 +92,9 @@ impl Buildpack for GradleBuildpack {
 
         print_section("Running Gradle build");
 
-        track_timing_subsection("Starting Gradle daemon", || {
-            gradle_command::start_daemon(&gradle_wrapper_executable_path, &gradle_env)
-                .map_err(GradleBuildpackError::StartGradleDaemonError)
-        })?;
+        print_subsection("Starting Gradle daemon");
+        let daemon_log = gradle_command::start_daemon(&gradle_wrapper_executable_path, &gradle_env)
+            .map_err(GradleBuildpackError::StartGradleDaemonError)?;
 
         let project_tasks = track_timing_subsection("Querying tasks", || {
             gradle_command::tasks(&context.app_dir, &gradle_env)
@@ -142,6 +141,7 @@ impl Buildpack for GradleBuildpack {
         let process = default_app_process(&dependency_report, &context.app_dir)
             .map_err(GradleBuildpackError::CannotDetermineDefaultAppProcess)?;
 
+        drop(daemon_log);
         output::print_all_done(build_timer);
         process
             .map_or(BuildResultBuilder::new(), |process| {