Enhance Gradle init script handling by querying Java's user home (#343)

Author: igalsi-t

artifactory/commands/gradle/gradle.go

@@ -38,6 +38,7 @@ const (
 
 	UserHomeEnv    = "GRADLE_USER_HOME"
 	InitScriptName = "jfrog.init.gradle"
+	javaUserHome   = "user.home"
 )
 
 type GradleCommand struct {
@@ -383,7 +384,14 @@ func GenerateInitScript(config InitScriptAuthConfig) (string, error) {
 func WriteInitScript(initScript string) error {
 	gradleHome := os.Getenv(UserHomeEnv)
 	if gradleHome == "" {
-		gradleHome = filepath.Join(clientutils.GetUserHomeDir(), ".gradle")
+		// Try Java's user.home first (fixes container issue where $HOME != user.home)
+		if javaHome, err := getJavaUserHome(); err == nil && javaHome != "" {
+			log.Debug("Using Java user.home for Gradle:", javaHome)
+			gradleHome = filepath.Join(javaHome, ".gradle")
+		} else {
+			// Fall back to $HOME if Java is not available
+			gradleHome = filepath.Join(clientutils.GetUserHomeDir(), ".gradle")
+		}
 	}
 	// Sanitize the path to prevent directory traversal attacks
 	gradleHome = filepath.Clean(gradleHome)
@@ -399,6 +407,32 @@ func WriteInitScript(initScript string) error {
 	return nil
 }
 
+// getJavaUserHome queries Java for its user.home system property.
+// Gradle uses this property (not $HOME) to determine where to look for init scripts.
+// This fixes issues in containers where $HOME and Java's user.home can differ.
+func getJavaUserHome() (string, error) {
+	cmd := exec.Command("java", "-XshowSettings:properties", "-version")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("failed to run java: %w", err)
+	}
+	return parseUserHomeFromJavaOutput(string(output))
+}
+
+// parseUserHomeFromJavaOutput extracts the user.home property from Java's -XshowSettings:properties output.
+// This is separated from getJavaUserHome for unit testing purposes.
+func parseUserHomeFromJavaOutput(output string) (string, error) {
+	for _, line := range strings.Split(output, "\n") {
+		if strings.Contains(line, javaUserHome) {
+			parts := strings.SplitN(line, "=", 2)
+			if len(parts) == 2 {
+				return strings.TrimSpace(parts[1]), nil
+			}
+		}
+	}
+	return "", fmt.Errorf("user.home not found in java output")
+}
+
 func runGradle(vConfig *viper.Viper, tasks []string, deployableArtifactsFile string, configuration *build.BuildConfiguration, threads int, disableDeploy bool) error {
 	buildInfoService := build.CreateBuildInfoService()
 	buildName, err := configuration.GetBuildName()

artifactory/commands/gradle/gradle_test.go

@@ -170,6 +170,151 @@ func TestExtractBuildFilePath(t *testing.T) {
 	}
 }
 
+// TestParseUserHomeFromJavaOutput tests the parsing of user.home from Java output
+func TestParseUserHomeFromJavaOutput(t *testing.T) {
+	tests := []struct {
+		name        string
+		input       string
+		expected    string
+		expectError bool
+	}{
+		{
+			name: "valid output with user.home",
+			input: `Property settings:
+    file.encoding = UTF-8
+    java.home = /opt/java
+    user.dir = /home/user/project
+    user.home = /home/user
+    user.name = testuser`,
+			expected:    "/home/user",
+			expectError: false,
+		},
+		{
+			name: "valid output with spaces around equals",
+			input: `Property settings:
+    user.home = /Users/developer
+    user.name = dev`,
+			expected:    "/Users/developer",
+			expectError: false,
+		},
+		{
+			name:        "valid output with Windows path",
+			input:       "Property settings:\n    user.home = C:\\Users\\Developer\n    user.name = dev",
+			expected:    "C:\\Users\\Developer",
+			expectError: false,
+		},
+		{
+			name: "valid output with root user (container scenario)",
+			input: `Property settings:
+    user.home = /root
+    user.name = root`,
+			expected:    "/root",
+			expectError: false,
+		},
+		{
+			name:        "empty output",
+			input:       "",
+			expected:    "",
+			expectError: true,
+		},
+		{
+			name: "output without user.home",
+			input: `Property settings:
+    java.home = /opt/java
+    user.name = testuser`,
+			expected:    "",
+			expectError: true,
+		},
+		{
+			name:        "malformed line without equals",
+			input:       "user.home /home/user",
+			expected:    "",
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := parseUserHomeFromJavaOutput(tt.input)
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
+			}
+		})
+	}
+}
+
+// TestWriteInitScriptUsesJavaUserHome specifically tests the new case where
+// Java's user.home is used instead of $HOME when GRADLE_USER_HOME is not set.
+// This is the fix for container environments where $HOME differs from Java's user.home.
+func TestWriteInitScriptUsesJavaUserHome(t *testing.T) {
+	// Get Java's user.home - skip if Java is not available
+	javaHome, err := getJavaUserHome()
+	if err != nil {
+		t.Skip("Java not available, skipping test")
+	}
+
+	// Ensure GRADLE_USER_HOME is NOT set so we exercise the Java user.home path
+	t.Setenv(UserHomeEnv, "")
+
+	// Set $HOME to a DIFFERENT temp directory to simulate container environment
+	// where $HOME differs from Java's user.home
+	fakeHome := t.TempDir()
+	t.Setenv("HOME", fakeHome)
+
+	initScript := "test init script for java user.home case"
+
+	err = WriteInitScript(initScript)
+	assert.NoError(t, err)
+
+	// Verify: init script should be in Java's user.home, NOT in fake $HOME
+	expectedPath := filepath.Join(javaHome, ".gradle", "init.d", InitScriptName)
+	wrongPath := filepath.Join(fakeHome, ".gradle", "init.d", InitScriptName)
+
+	// Should exist in Java user.home (the correct location)
+	content, err := os.ReadFile(expectedPath)
+	assert.NoError(t, err, "Init script should be written to Java user.home: %s", expectedPath)
+	assert.Equal(t, initScript, string(content))
+
+	// Should NOT exist in fake $HOME (this was the bug!)
+	_, err = os.Stat(wrongPath)
+	assert.True(t, os.IsNotExist(err), "Init script should NOT be written to $HOME: %s", wrongPath)
+
+	// Cleanup - use t.Cleanup for deferred cleanup
+	t.Cleanup(func() {
+		_ = os.Remove(expectedPath)
+	})
+}
+
+// TestWriteInitScriptFallsBackToHome tests that WriteInitScript falls back to $HOME
+// when both GRADLE_USER_HOME is not set AND Java is not available
+func TestWriteInitScriptFallsBackToHome(t *testing.T) {
+	// Ensure GRADLE_USER_HOME is NOT set
+	t.Setenv(UserHomeEnv, "")
+
+	// Set a known HOME for the fallback case
+	tempDir := t.TempDir()
+	t.Setenv("HOME", tempDir)
+
+	// Temporarily modify PATH to ensure Java is not found
+	// This simulates an environment where Java is not installed
+	// Note: t.Setenv automatically restores the original value after the test
+	t.Setenv("PATH", "/nonexistent")
+
+	initScript := "test init script for HOME fallback case"
+
+	err := WriteInitScript(initScript)
+	assert.NoError(t, err)
+
+	// Verify the init script was written to $HOME fallback location
+	fallbackPath := filepath.Join(tempDir, ".gradle", "init.d", InitScriptName)
+	content, err := os.ReadFile(fallbackPath)
+	assert.NoError(t, err, "Init script should be written to $HOME fallback: %s", fallbackPath)
+	assert.Equal(t, initScript, string(content))
+}
+
 // TestExtractBuildFilePathWindowsPaths tests Windows-style paths if on Windows
 func TestExtractBuildFilePathWindowsPaths(t *testing.T) {
 	if runtime.GOOS != "windows" {