Refactor release phase to use YAML pattern instead of bash wrapper

ramonskie · ramonskie · commit 779268bd9323 · 2025-12-01T13:40:59.000+01:00
**Problem:** The Java buildpack was using a custom bash wrapper script ($HOME/.java-buildpack/start.sh) that sourced profile.d scripts and executed the container command. This pattern: - Required maintaining custom bash logic for environment setup - Didn't follow Cloud Foundry buildpack conventions - Made it harder to integrate with CF lifecycle hooks **Solution:** Adopt the standard release YAML pattern used by all reference buildpacks (Ruby, Go, Node.js, Python): 1. **Finalize phase** writes `tmp/java-buildpack-release-step.yml` with direct container commands (e.g., `bin/application` for DistZip, `java -jar app.jar` for Spring Boot) 2. **Release phase** reads and outputs this YAML to stdout for Cloud Foundry to parse 3. **Cloud Foundry runtime** handles profile.d sourcing automatically before executing the command **Changes:** - src/java/finalize/cli/main.go: Added RunAfterCompile() and SetLaunchEnvironment() lifecycle hooks - src/java/finalize/finalize.go: Replaced generateStartupScript() with writeReleaseYaml() - src/java/release/release.go: Changed from hardcoded bash wrapper to YAML passthrough - src/java/release/release_test.go: Updated test to simulate finalize phase creating YAML file **Benefits:** - Aligns with Cloud Foundry buildpack conventions - Simplifies maintenance (no custom bash wrapper logic) - Better integration with CF lifecycle hooks - Profile.d scripts handled by platform (from Commit 1: 23bd35c) **Related:** - Depends on Commit 1 (23bd35c) which migrated environment setup to .profile.d/*.sh scripts - Part of 3-commit refactoring series to align with CF runtime standards
diff --git a/src/java/finalize/cli/main.go b/src/java/finalize/cli/main.go
@@ -62,6 +62,16 @@ func main() {
 		os.Exit(14)
 	}
 
+	if err := libbuildpack.RunAfterCompile(stager); err != nil {
+		logger.Error("After Compile: %s", err.Error())
+		os.Exit(13)
+	}
+
+	if err := stager.SetLaunchEnvironment(); err != nil {
+		logger.Error("Unable to setup launch environment: %s", err.Error())
+		os.Exit(16)
+	}
+
 	if err := stager.WriteConfigYml(nil); err != nil {
 		logger.Error("Error writing config.yml: %s", err.Error())
 		os.Exit(15)
diff --git a/src/java/finalize/finalize.go b/src/java/finalize/finalize.go
@@ -74,9 +74,9 @@ func Run(f *Finalizer) error {
 		return err
 	}
 
-	// Generate startup script
-	if err := f.generateStartupScript(container); err != nil {
-		f.Log.Error("Failed to generate startup script: %s", err.Error())
+	// Write release YAML configuration
+	if err := f.writeReleaseYaml(container); err != nil {
+		f.Log.Error("Failed to write release YAML: %s", err.Error())
 		return err
 	}
 
@@ -224,56 +224,35 @@ func (f *Finalizer) finalizeFrameworks() error {
 	return nil
 }
 
-// generateStartupScript creates the main startup script that Cloud Foundry will execute
-func (f *Finalizer) generateStartupScript(container containers.Container) error {
-	f.Log.BeginStep("Generating startup script")
-
-	// Create .java-buildpack directory in HOME
-	// In Cloud Foundry, $HOME is the app directory at runtime
-	javaBuildpackDir := filepath.Join(f.Stager.BuildDir(), ".java-buildpack")
-	if err := os.MkdirAll(javaBuildpackDir, 0755); err != nil {
-		return fmt.Errorf("failed to create .java-buildpack directory: %w", err)
-	}
-
-	startScript := filepath.Join(javaBuildpackDir, "start.sh")
+// writeReleaseYaml writes the release configuration to a YAML file
+// This follows the pattern used by Ruby, Go, and Node.js buildpacks
+func (f *Finalizer) writeReleaseYaml(container containers.Container) error {
+	f.Log.BeginStep("Writing release configuration")
 
 	// Get the container's startup command
 	containerCommand, err := container.Release()
 	if err != nil {
 		return fmt.Errorf("failed to get container command: %w", err)
 	}
 
-	// Build startup script content
-	scriptContent := fmt.Sprintf(`#!/bin/bash
-set -e
-
-# Source profile.d scripts (sets JAVA_HOME, etc.)
-for script in $HOME/.profile.d/*.sh; do
-  [ -r "$script" ] && source "$script"
-done
-
-# Source memory calculator script
-if [ -r $DEPS_DIR/0/bin/memory_calculator.sh ]; then
-  source $DEPS_DIR/0/bin/memory_calculator.sh
-fi
-
-# Source environment variables
-if [ -d $DEPS_DIR/0/env ]; then
-  for envfile in $DEPS_DIR/0/env/*; do
-    [ -r "$envfile" ] && export $(basename "$envfile")="$(cat "$envfile")"
-  done
-fi
-
-# Execute application
-cd $HOME
-exec %s
+	// Create tmp directory in build dir
+	tmpDir := filepath.Join(f.Stager.BuildDir(), "tmp")
+	if err := os.MkdirAll(tmpDir, 0755); err != nil {
+		return fmt.Errorf("failed to create tmp directory: %w", err)
+	}
+
+	// Write YAML file with release information
+	releaseYamlPath := filepath.Join(tmpDir, "java-buildpack-release-step.yml")
+	yamlContent := fmt.Sprintf(`---
+default_process_types:
+  web: %s
 `, containerCommand)
 
-	// Write startup script
-	if err := os.WriteFile(startScript, []byte(scriptContent), 0755); err != nil {
-		return fmt.Errorf("failed to write startup script: %w", err)
+	if err := os.WriteFile(releaseYamlPath, []byte(yamlContent), 0644); err != nil {
+		return fmt.Errorf("failed to write release YAML: %w", err)
 	}
 
-	f.Log.Info("Startup script generated: %s", startScript)
+	f.Log.Info("Release YAML written: %s", releaseYamlPath)
+	f.Log.Info("Web process command: %s", containerCommand)
 	return nil
 }
diff --git a/src/java/release/release.go b/src/java/release/release.go
@@ -2,6 +2,8 @@ package release
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
 
 	"github.com/cloudfoundry/libbuildpack"
 )
@@ -13,13 +15,23 @@ type Releaser struct {
 }
 
 // Run generates the release information
-// The release phase is simple - it just outputs the default process type (web command)
-// The actual startup command will be determined at runtime by the finalized container
+// This follows the reference buildpack pattern (Ruby, Go, Node.js, Python):
+// 1. Read the YAML file written by the finalize phase
+// 2. Output it to stdout for Cloud Foundry to parse
+// The YAML file contains the direct container command (e.g., bin/application for DistZip)
 func Run(r *Releaser) error {
-	// Output default process types in YAML format
-	// This must be valid YAML parseable by Cloud Foundry
-	fmt.Println("---")
-	fmt.Println("default_process_types:")
-	fmt.Println("  web: $HOME/.java-buildpack/start.sh")
+	releaseYamlPath := filepath.Join(r.BuildDir, "tmp", "java-buildpack-release-step.yml")
+
+	// Read the YAML file written by finalize phase
+	yamlContent, err := os.ReadFile(releaseYamlPath)
+	if err != nil {
+		r.Log.Error("Failed to read release YAML file: %s", err.Error())
+		return fmt.Errorf("reading release YAML: %w", err)
+	}
+
+	// Output the YAML content to stdout
+	// Cloud Foundry will parse this to determine the web command
+	fmt.Print(string(yamlContent))
+
 	return nil
 }
diff --git a/src/java/release/release_test.go b/src/java/release/release_test.go
@@ -32,6 +32,20 @@ var _ = Describe("Release", func() {
 		buildDir, err = os.MkdirTemp("", "release-build")
 		Expect(err).NotTo(HaveOccurred())
 
+		// Create tmp directory for release YAML (simulating finalize phase)
+		tmpDir := buildDir + "/tmp"
+		err = os.MkdirAll(tmpDir, 0755)
+		Expect(err).NotTo(HaveOccurred())
+
+		// Create release YAML file (simulating finalize phase output)
+		releaseYamlPath := tmpDir + "/java-buildpack-release-step.yml"
+		releaseYaml := `---
+default_process_types:
+  web: $HOME/.java-buildpack/start.sh
+`
+		err = os.WriteFile(releaseYamlPath, []byte(releaseYaml), 0644)
+		Expect(err).NotTo(HaveOccurred())
+
 		// Create logger with buffer to capture output
 		stdout = new(bytes.Buffer)
 		logger = libbuildpack.NewLogger(stdout)
