package frameworks

import (

"fmt"

"github.com/cloudfoundry/java-buildpack/src/java/common"

"os"

"strings"

"unicode"

)

// JavaOptsFramework implements custom JAVA_OPTS configuration

type JavaOptsFramework struct {

context *common.Context

}

// JavaOptsConfig represents the java_opts.yml configuration

type JavaOptsConfig struct {

FromEnvironment bool `yaml:"from_environment"`

JavaOpts []string `yaml:"java_opts"`

}

// NewJavaOptsFramework creates a new Java Opts framework instance

func NewJavaOptsFramework(ctx *common.Context) *JavaOptsFramework {

return &JavaOptsFramework{context: ctx}

}

// Detect returns a positive result if loadConfig() finds settings (universal framework for JAVA_OPTS configuration)

func (j *JavaOptsFramework) Detect() (string, error) {

// Check if there's any configuration to apply

config, err := j.loadConfig()

if err != nil {

// if detect "fails" Finalize() is not called so log parse failures as warning

j.context.Log.Warning("Failed to load java_opts config: %s", err.Error())

return "", nil

}

// Detect if there are any custom java_opts or if from_environment is enabled

if len(config.JavaOpts) > 0 || config.FromEnvironment {

return "Java Opts", nil

}

return "", nil

}

// Supply does nothing (no dependencies to install)

func (j *JavaOptsFramework) Supply() error {

// Java Opts framework only configures environment in finalize phase

return nil

}

// Finalize applies the JAVA_OPTS configuration

func (j *JavaOptsFramework) Finalize() error {

j.context.Log.BeginStep("Configuring Java Opts")

// Load configuration

config, err := j.loadConfig()

if err != nil {

j.context.Log.Warning("Failed to load java_opts config: %s", err.Error())

return nil // Don't fail the build

}

var configuredOpts []string

// Add configured java_opts from config file

if len(config.JavaOpts) > 0 {

j.context.Log.Info("Adding configured JAVA_OPTS: %v", config.JavaOpts)

configuredOpts = append(configuredOpts, config.JavaOpts...)

}

// Build the configured JAVA_OPTS value

// Escape each opt using Ruby buildpack's strategy: backslash-escape special characters

// This allows values with spaces to be preserved when passed through shell evaluation

var escapedOpts []string

for _, opt := range configuredOpts {

escapedOpts = append(escapedOpts, rubyStyleEscape(opt))

}

optsString := strings.Join(escapedOpts, " ")

// Write user-defined JAVA_OPTS to .opts file with priority 99 (Ruby buildpack line 82)

// This ensures user opts run LAST, allowing them to override framework defaults

//

// Handle from_environment setting (matching Ruby buildpack order):

// - If true: configured opts FIRST, then append $JAVA_OPTS (allows environment to override config)

// - If false: only use configured opts (ignore environment JAVA_OPTS)

//

// Ruby buildpack order (lines 39-44):

// configured.shellsplit.map {...}.each { |java_opt| @droplet.java_opts << java_opt }

// @droplet.java_opts << '$JAVA_OPTS' if from_environment?

var finalOpts string

if config.FromEnvironment {

// Add configured opts first, then environment JAVA_OPTS (Ruby order)

if optsString != "" {

finalOpts = fmt.Sprintf("%s $JAVA_OPTS", optsString)

} else {

// No configured opts, use only environment JAVA_OPTS

finalOpts = "$JAVA_OPTS"

}

} else {

// Ignore environment JAVA_OPTS, use only configured opts

finalOpts = optsString

}

// Write to .opts file (priority 99 = always last)

if finalOpts != "" {

if err := writeJavaOptsFile(j.context, 99, "user_java_opts", finalOpts); err != nil {

return fmt.Errorf("failed to write java_opts file: %w", err)

}

}

j.context.Log.Info("Configured user JAVA_OPTS for runtime (priority 99)")

return nil

}

// shellSplit splits a string like a shell would, respecting quotes

// Similar to Ruby's Shellwords.shellsplit

func shellSplit(input string) ([]string, error) {

var tokens []string

var current strings.Builder

var inSingleQuote, inDoubleQuote bool

var escaped bool

for _, r := range input {

// Handle escape sequences

if escaped {

current.WriteRune(r)

escaped = false

continue

}

if r == '\\' {

escaped = true

continue

}

// Handle quotes

if r == '\'' && !inDoubleQuote {

inSingleQuote = !inSingleQuote

continue

}

if r == '"' && !inSingleQuote {

inDoubleQuote = !inDoubleQuote

continue

}

// Handle spaces (word separators when not quoted)

if unicode.IsSpace(r) && !inSingleQuote && !inDoubleQuote {

if current.Len() > 0 {

tokens = append(tokens, current.String())

current.Reset()

}

continue

}

// Regular character

current.WriteRune(r)

}

// Add last token if exists

if current.Len() > 0 {

tokens = append(tokens, current.String())

}

// Check for unclosed quotes

if inSingleQuote || inDoubleQuote {

return nil, fmt.Errorf("unclosed quote in string: %s", input)

}

return tokens, nil

}

// rubyStyleEscape escapes a Java option exactly like the Ruby buildpack

//

// Ruby source: lib/java_buildpack/framework/java_opts.rb:40-41

//

// .map { |java_opt| /(?<key>.+?)=(?<value>.+)/ =~ java_opt ? "#{key}=#{escape_value(value)}" : java_opt }

//

// Strategy: Split on first '=' and escape only the VALUE part

//

// Examples:

//

// "-Xmx512M" → "-Xmx512M"

// "-Dkey=value with spaces" → "-Dkey=value\\ with\\ spaces"

// "-XX:OnOutOfMemoryError=kill -9 %p" → "-XX:OnOutOfMemoryError=kill\\ -9\\ \\%p"

func rubyStyleEscape(javaOpt string) string {

idx := strings.IndexByte(javaOpt, '=')

if idx == -1 || idx == len(javaOpt)-1 {

return javaOpt // No '=' or ends with '='

}

key := javaOpt[:idx]

value := javaOpt[idx+1:]

return key + "=" + escapeValue(value)

}

// escapeValue escapes a string for shell safety using Ruby's escape_value method

//

// Ruby source: lib/java_buildpack/framework/java_opts.rb:61-67

//

// str.gsub(%r{([^A-Za-z0-9_\-.,:/@\n$\\])}, '\\\\\\1').gsub(/\n/, "'\n'")

//

// Safe chars (not escaped): A-Za-z0-9_-.,:/@$\

// All other chars are backslash-escaped, including: = ( ) [ ] { } ; & | space % etc.

func escapeValue(value string) string {

if value == "" {

return "''"

}

var result strings.Builder

for _, ch := range value {

if ch == '\n' {

result.WriteString("'\n'") // Special newline handling

continue

}

if !isRubySafeChar(ch) {

result.WriteRune('\\')

}

result.WriteRune(ch)

}

return result.String()

}

// isRubySafeChar checks if a character is in Ruby's safe set: A-Za-z0-9_-.,:/@\n$\

// Note: '=' is NOT safe and will be escaped

func isRubySafeChar(ch rune) bool {

return (ch >= 'A' && ch <= 'Z') ||

(ch >= 'a' && ch <= 'z') ||

(ch >= '0' && ch <= '9') ||

ch == '_' ||

ch == '-' ||

ch == '.' ||

ch == ',' ||

ch == ':' ||

ch == '/' ||

ch == '@' ||

ch == '\n' ||

ch == '$' ||

ch == '\\'

}

// loadConfig loads the java_opts.yml configuration

func (j *JavaOptsFramework) loadConfig() (*JavaOptsConfig, error) {

config := &JavaOptsConfig{

FromEnvironment: true, // Default to true (matches config file)

JavaOpts: []string{},

}

yamlHandler := common.YamlHandler{}

// Check for JBP_CONFIG_JAVA_OPTS override

configOverride := os.Getenv("JBP_CONFIG_JAVA_OPTS")

if configOverride != "" {

// First, parse the outer YAML string (handles single-quoted format like '{...}')

var yamlContent interface{}

if err := yamlHandler.Unmarshal([]byte(configOverride), &yamlContent); err != nil {

return nil, fmt.Errorf("failed to parse JBP_CONFIG_JAVA_OPTS: %w", err)

}

// Handle different YAML formats for backward compatibility

var configData []byte

switch v := yamlContent.(type) {

case string:

// It's a YAML string literal - parse the content

configData = []byte(v)

case map[string]interface{}:

// It's already a parsed YAML structure - marshal it back to bytes

var err error

configData, err = yamlHandler.Marshal(v)

if err != nil {

return nil, fmt.Errorf("failed to marshal config map: %w", err)

}

case []interface{}:

// Handle legacy format: [from_environment: false, java_opts: ...]

// This parses as an array of maps, so we need to merge them

mergedMap := make(map[string]interface{})

for _, item := range v {

if m, ok := item.(map[string]interface{}); ok {

for k, val := range m {

mergedMap[k] = val

}

}

}

var err error

configData, err = yamlHandler.Marshal(mergedMap)

if err != nil {

return nil, fmt.Errorf("failed to marshal merged config map: %w", err)

}

default:

return nil, fmt.Errorf("unexpected YAML type: %T", v)

}

// Parse into a generic map first to handle both string and array formats for java_opts

var rawConfig map[string]interface{}

if err := yamlHandler.Unmarshal(configData, &rawConfig); err != nil {

return nil, fmt.Errorf("failed to parse JBP_CONFIG_JAVA_OPTS structure: %w", err)

}

// Handle from_environment field

if fromEnv, ok := rawConfig["from_environment"].(bool); ok {

config.FromEnvironment = fromEnv

}

// Handle java_opts field - support both string and array formats

if javaOptsRaw, ok := rawConfig["java_opts"]; ok {

switch opts := javaOptsRaw.(type) {

case []interface{}:

// Already an array

for _, opt := range opts {

if optStr, ok := opt.(string); ok {

config.JavaOpts = append(config.JavaOpts, optStr)

}

}

case string:

// Legacy format: space-separated string

// Split on spaces but preserve quoted strings (like Ruby's shellsplit)

if opts != "" {

tokens, err := shellSplit(opts)

if err != nil {

return nil, fmt.Errorf("failed to parse java_opts string: %w", err)

}

config.JavaOpts = tokens

}

}

}

return config, nil

}

// No config file - use built-in defaults

// (The Ruby buildpack's config/java_opts.yml only contained these same defaults)

return config, nil

}