SCANPY-177 SONAR_SCANNER_JAVA_OPTS should be used for the spawned JRE

Author: ghislainpiot

src/pysonar_scanner/scannerengine.py

@@ -21,12 +21,14 @@
 import logging
 import pathlib
 from dataclasses import dataclass
+import shlex
 from subprocess import Popen, PIPE
 from threading import Thread
 from typing import IO, Any, Callable, Optional
 
 from pysonar_scanner.api import EngineInfo, SonarQubeApi
 from pysonar_scanner.cache import Cache, CacheFile
+from pysonar_scanner.configuration.properties import SONAR_SCANNER_JAVA_OPTS
 from pysonar_scanner.exceptions import ChecksumException
 from pysonar_scanner.jre import JREResolvedPath
 
@@ -144,19 +146,39 @@ def __init__(self, jre_path: JREResolvedPath, scanner_engine_path: pathlib.Path)
         self.scanner_engine_path = scanner_engine_path
 
     def run(self, config: dict[str, Any]):
-        cmd = self.__build_command(self.jre_path, self.scanner_engine_path)
+        # Extract Java options if present; they must influence the JVM invocation, not the scanner engine itself
+        java_opts = config.get(SONAR_SCANNER_JAVA_OPTS)
+
+        cmd = self.__build_command(self.jre_path, self.scanner_engine_path, java_opts)
         logging.debug(f"Command: {cmd}")
         properties_str = self.__config_to_json(config)
         logging.debug(f"Properties: {properties_str}")
         return CmdExecutor(cmd, properties_str).execute()
 
-    def __build_command(self, jre_path: JREResolvedPath, scanner_engine_path: pathlib.Path) -> list[str]:
+    def __build_command(
+        self,
+        jre_path: JREResolvedPath,
+        scanner_engine_path: pathlib.Path,
+        java_opts: Optional[str] = None,
+    ) -> list[str]:
         cmd: list[str] = []
         cmd.append(str(jre_path.path))
+
+        if java_opts:
+            cmd.extend(self.__decompose_java_opts(java_opts))
+
         cmd.append("-jar")
         cmd.append(str(scanner_engine_path))
         return cmd
 
     def __config_to_json(self, config: dict[str, Any]) -> str:
-        scanner_properties = [{"key": k, "value": v} for k, v in config.items()]
+        # Remove sonar.scanner.javaOpts from the properties passed to the engine, as per guidelines
+        scanner_properties = [
+            {"key": k, "value": v}
+            for k, v in config.items()
+            if k != SONAR_SCANNER_JAVA_OPTS
+        ]
         return json.dumps({"scannerProperties": scanner_properties})
+
+    def __decompose_java_opts(self, java_opts: str) -> list[str]:
+        return shlex.split(java_opts.strip())

tests/unit/test_scannerengine.py

@@ -29,6 +29,7 @@
 
 from pysonar_scanner import cache
 from pysonar_scanner import scannerengine
+from pysonar_scanner.configuration.properties import SONAR_SCANNER_JAVA_OPTS
 from pysonar_scanner.exceptions import ChecksumException
 from pysonar_scanner.scannerengine import (
     LogLine,
@@ -163,6 +164,133 @@ def test_command_building(self, execute_mock):
             [str(java_path), "-jar", str(pathlib.Path("/test/scanner-engine.jar"))], expected_std_in
         )
 
+    @patch("pysonar_scanner.scannerengine.CmdExecutor")
+    def test_command_building_with_java_opts_basic(self, execute_mock):
+        """Test that java_opts are added to the command"""
+        config = {
+            "sonar.token": "myToken",
+            "sonar.projectKey": "myProjectKey",
+            SONAR_SCANNER_JAVA_OPTS: "-Xmx1024m",
+        }
+
+        java_path = pathlib.Path("jre/bin/java")
+        jre_resolve_path_mock = Mock()
+        jre_resolve_path_mock.path = java_path
+        scanner_engine_mock = pathlib.Path("/test/scanner-engine.jar")
+
+        scannerengine.ScannerEngine(jre_resolve_path_mock, scanner_engine_mock).run(
+            config
+        )
+
+        called_args = execute_mock.call_args[0]
+        actual_command = called_args[0]
+
+        expected_command = [
+            str(java_path),
+            "-Xmx1024m",
+            "-jar",
+            str(scanner_engine_mock),
+        ]
+        self.assertEqual(actual_command, expected_command)
+
+    @patch("pysonar_scanner.scannerengine.CmdExecutor")
+    def test_command_building_with_java_opts_multiple(self, execute_mock):
+        """Test java_opts with multiple space-separated arguments"""
+        config = {
+            "sonar.token": "myToken",
+            "sonar.projectKey": "myProjectKey",
+            SONAR_SCANNER_JAVA_OPTS: "-Xmx1024m -XX:MaxPermSize=256m",
+        }
+
+        java_path = pathlib.Path("jre/bin/java")
+        jre_resolve_path_mock = Mock()
+        jre_resolve_path_mock.path = java_path
+        scanner_engine_mock = pathlib.Path("/test/scanner-engine.jar")
+
+        scannerengine.ScannerEngine(jre_resolve_path_mock, scanner_engine_mock).run(
+            config
+        )
+
+        called_args = execute_mock.call_args[0]
+        actual_command = called_args[0]
+
+        expected_command = [
+            str(java_path),
+            "-Xmx1024m",
+            "-XX:MaxPermSize=256m",
+            "-jar",
+            str(scanner_engine_mock),
+        ]
+        self.assertEqual(actual_command, expected_command)
+
+    @patch("pysonar_scanner.scannerengine.CmdExecutor")
+    def test_java_opts_filtered_from_properties(self, execute_mock):
+        """Test that SONAR_SCANNER_JAVA_OPTS is excluded from scanner properties JSON"""
+        config = {
+            "sonar.token": "myToken",
+            "sonar.projectKey": "myProjectKey",
+            SONAR_SCANNER_JAVA_OPTS: "-Xmx1024m",
+            "sonar.host.url": "https://sonar.example.com",
+        }
+
+        java_path = pathlib.Path("jre/bin/java")
+        jre_resolve_path_mock = Mock()
+        jre_resolve_path_mock.path = java_path
+        scanner_engine_mock = pathlib.Path("/test/scanner-engine.jar")
+
+        scannerengine.ScannerEngine(jre_resolve_path_mock, scanner_engine_mock).run(
+            config
+        )
+
+        called_args = execute_mock.call_args[0]
+        actual_properties_str = called_args[1]
+        actual_properties = json.loads(actual_properties_str)
+
+        property_keys = [prop["key"] for prop in actual_properties["scannerProperties"]]
+        self.assertNotIn(SONAR_SCANNER_JAVA_OPTS, property_keys)
+
+    @patch("pysonar_scanner.scannerengine.CmdExecutor")
+    def test_java_opts_edge_cases(self, execute_mock):
+        """Test edge cases for java_opts handling"""
+        java_path = pathlib.Path("jre/bin/java")
+        jre_resolve_path_mock = Mock()
+        jre_resolve_path_mock.path = java_path
+        scanner_engine_mock = pathlib.Path("/test/scanner-engine.jar")
+
+        test_cases = [
+            # (java_opts_value, expected_command_length, description)
+            (None, 3, "None java_opts"),
+            ("", 3, "Empty string java_opts"),
+            ("   ", 3, "Whitespace-only java_opts"),
+        ]
+
+        for java_opts_value, expected_length, description in test_cases:
+            with self.subTest(description=description):
+                execute_mock.reset_mock()
+
+                config = {
+                    "sonar.token": "myToken",
+                    "sonar.projectKey": "myProjectKey",
+                }
+                if java_opts_value is not None:
+                    config[SONAR_SCANNER_JAVA_OPTS] = java_opts_value
+
+                scannerengine.ScannerEngine(
+                    jre_resolve_path_mock, scanner_engine_mock
+                ).run(config)
+
+                called_args = execute_mock.call_args[0]
+                actual_command = called_args[0]
+
+                self.assertEqual(
+                    len(actual_command),
+                    expected_length,
+                    f"Expected command length {expected_length} for {description}",
+                )
+
+                self.assertEqual(actual_command[0], str(java_path))
+                self.assertEqual(actual_command[-2], "-jar")
+                self.assertEqual(actual_command[-1], str(scanner_engine_mock))
 
 class TestScannerEngineProvisioner(pyfakefs.TestCase):
     def setUp(self):