SCANPY-145 tmp

Author: guillaume-dequenne

src/pysonar_scanner/api.py

@@ -32,7 +32,7 @@
     Key,
 )
 from pysonar_scanner.exceptions import MissingKeyException, SonarQubeApiException
-from pysonar_scanner.utils import Arch, Os, remove_trailing_slash
+from pysonar_scanner.utils import remove_trailing_slash, OsStr, ArchStr
 
 
 @dataclass(frozen=True)
@@ -211,12 +211,9 @@ def download_analysis_engine(self, handle: typing.BinaryIO) -> None:
         except requests.RequestException as e:
             raise SonarQubeApiException("Error while fetching the analysis engine") from e
 
-    def get_analysis_jres(self, os: Optional[Os] = None, arch: Optional[Arch] = None) -> list[JRE]:
+    def get_analysis_jres(self, os: OsStr, arch: ArchStr) -> list[JRE]:
         try:
-            params = {
-                "os": os.value if os else None,
-                "arch": arch.value if arch else None,
-            }
+            params = {"os": os, "arch": arch}
             res = requests.get(
                 f"{self.base_urls.api_base_url}/analysis/jres",
                 auth=self.auth,

src/pysonar_scanner/configuration/configuration_loader.py

@@ -23,7 +23,7 @@
 from pysonar_scanner.configuration.pyproject_toml import TomlConfigurationLoader
 from pysonar_scanner.configuration.properties import SONAR_TOKEN, SONAR_PROJECT_BASE_DIR, Key
 from pysonar_scanner.configuration.properties import PROPERTIES
-from pysonar_scanner.configuration import sonar_project_properties, environment_variables
+from pysonar_scanner.configuration import sonar_project_properties, environment_variables, dynamic_defaults_loader
 
 from pysonar_scanner.exceptions import MissingKeyException
 
@@ -38,6 +38,7 @@ def load() -> dict[Key, any]:
         # each property loader is required to return NO default values.
         # E.g. if no property has been set, an empty dict must be returned.
         # Default values should be set through the get_static_default_properties() method
+
         cli_properties = CliConfigurationLoader.load()
         # CLI properties have a higher priority than properties file,
         # but we need to resolve them first to load the properties file
@@ -48,6 +49,7 @@ def load() -> dict[Key, any]:
         toml_properties = TomlConfigurationLoader.load(toml_dir)
 
         resolved_properties = get_static_default_properties()
+        resolved_properties.update(dynamic_defaults_loader.load())
         resolved_properties.update(toml_properties.project_properties)
         resolved_properties.update(sonar_project_properties.load(base_dir))
         resolved_properties.update(toml_properties.sonar_properties)

src/pysonar_scanner/configuration/dynamic_defaults_loader.py

@@ -0,0 +1,36 @@
+#
+# Sonar Scanner Python
+# Copyright (C) 2011-2024 SonarSource SA.
+# mailto:info AT sonarsource DOT com
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+# This program is distributed in the hope that it will be useful,
+#
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+import os
+from typing import Dict
+
+from pysonar_scanner.configuration.properties import Key, SONAR_SCANNER_OS, SONAR_SCANNER_ARCH, SONAR_PROJECT_BASE_DIR
+from pysonar_scanner import utils
+
+
+def load() -> Dict[Key, any]:
+    """
+    Load dynamically computed default properties
+    """
+    properties = {
+        SONAR_SCANNER_OS: utils.get_os(),
+        SONAR_SCANNER_ARCH: utils.get_arch(),
+        SONAR_PROJECT_BASE_DIR: os.getcwd(),
+    }
+    return properties

src/pysonar_scanner/configuration/properties.py

@@ -178,7 +178,7 @@ def env_variable_name(self) -> str:
     ),
     Property(
         name=SONAR_USER_HOME, 
-        default_value="~/.sonar", 
+        default_value=None,
         cli_getter=lambda args: args.sonar_user_home
     ),  
     Property(

src/pysonar_scanner/jre.py

@@ -53,9 +53,11 @@ def from_string(path: str) -> "JREResolvedPath":
 
 
 class JREProvisioner:
-    def __init__(self, api: SonarQubeApi, cache: Cache):
+    def __init__(self, api: SonarQubeApi, cache: Cache, sonar_scanner_os: str, sonar_scanner_arch: str):
         self.api = api
         self.cache = cache
+        self.sonar_scanner_os = sonar_scanner_os
+        self.sonar_scanner_arch = sonar_scanner_arch
 
     def provision(self) -> JREResolvedPath:
         jre, resolved_path = self.__attempt_provisioning_jre_with_retry()
@@ -67,7 +69,7 @@ def __attempt_provisioning_jre_with_retry(self) -> tuple[JRE, pathlib.Path]:
             jre_and_resolved_path = self.__attempt_provisioning_jre()
         if jre_and_resolved_path is None:
             raise ChecksumException(
-                f"Failed to download and verify JRE for {utils.get_os().value} and {utils.get_arch().value}"
+                f"Failed to download and verify JRE for {self.sonar_scanner_os} and {self.sonar_scanner_arch}"
             )
 
         return jre_and_resolved_path
@@ -83,10 +85,10 @@ def __attempt_provisioning_jre(self) -> Optional[tuple[JRE, pathlib.Path]]:
         return (jre, jre_path) if jre_path is not None else None
 
     def __get_available_jre(self) -> JRE:
-        jres = self.api.get_analysis_jres(os=utils.get_os(), arch=utils.get_arch())
+        jres = self.api.get_analysis_jres(os=self.sonar_scanner_os, arch=self.sonar_scanner_arch)
         if len(jres) == 0:
             raise NoJreAvailableException(
-                f"No JREs are available for {utils.get_os().value} and {utils.get_arch().value}"
+                f"No JREs are available for {self.sonar_scanner_os} and {self.sonar_scanner_arch}"
             )
         return jres[0]
 

src/pysonar_scanner/scannerengine.py

@@ -31,6 +31,7 @@
 
 from pysonar_scanner.api import SonarQubeApi
 from pysonar_scanner.cache import Cache, CacheFile
+from pysonar_scanner.configuration.properties import SONAR_SCANNER_OS, SONAR_SCANNER_ARCH
 from pysonar_scanner.exceptions import ChecksumException, SQTooOldException
 from pysonar_scanner.jre import JREProvisioner, JREResolvedPath, JREResolver, JREResolverConfiguration
 from subprocess import Popen, PIPE
@@ -175,6 +176,6 @@ def __version_check(self):
             )
 
     def __resolve_jre(self, config: dict[str, any]) -> JREResolvedPath:
-        jre_provisionner = JREProvisioner(self.api, self.cache)
+        jre_provisionner = JREProvisioner(self.api, self.cache, config[SONAR_SCANNER_OS], config[SONAR_SCANNER_ARCH])
         jre_resolver = JREResolver(JREResolverConfiguration.from_dict(config), jre_provisionner)
         return jre_resolver.resolve_jre()

src/pysonar_scanner/utils.py

@@ -21,7 +21,9 @@
 import pathlib
 import platform
 import typing
-from enum import Enum
+
+OsStr = typing.Literal["windows", "linux", "mac", "alpine", "other"]
+ArchStr = typing.Literal["x86_64", "aarch64", "x86"]
 
 
 def remove_trailing_slash(url: str) -> str:
@@ -35,15 +37,7 @@ def calculate_checksum(filehandle: typing.BinaryIO) -> str:
     return sha256_hash.hexdigest()
 
 
-class Os(Enum):
-    WINDOWS = "windows"
-    LINUX = "linux"
-    MACOS = "mac"
-    ALPINE = "alpine"
-    OTHER = "other"
-
-
-def get_os() -> Os:
+def get_os() -> OsStr:
     def is_alpine() -> bool:
         try:
             os_release = pathlib.Path("/etc/os-release")
@@ -58,30 +52,24 @@ def is_alpine() -> bool:
 
     os_name = platform.system()
     if os_name == "Windows":
-        return Os.WINDOWS
+        return "windows"
     elif os_name == "Darwin":
-        return Os.MACOS
+        return "mac"
     elif os_name == "Linux":
         if is_alpine():
-            return Os.ALPINE
+            return "alpine"
         else:
-            return Os.LINUX
-    return Os.OTHER
-
-
-class Arch(Enum):
-    X64 = "x64"
-    AARCH64 = "aarch64"
-    OTHER = "other"
+            return "linux"
+    return "other"
 
 
-def get_arch() -> Arch:
+def get_arch() -> ArchStr:
     machine = platform.machine().lower()
     if machine in ["amd64", "x86_64"]:
-        return Arch.X64
+        return "x64"
     elif machine == "arm64":
-        return Arch.AARCH64
-    return Arch.OTHER
+        return "aarch64"
+    return "other"
 
 
 def filter_none_values(dictionary: dict) -> dict:

tests/sq_api_utils.py

@@ -79,8 +79,6 @@ def mock_analysis_engine_download(self, body: bytes = b"", status: int = 200) ->
     def mock_analysis_jres(
         self,
         body: Optional[list[dict]] = None,
-        os_matcher: Optional[str] = None,
-        arch_matcher: Optional[str] = None,
         status: int = 200,
     ) -> responses.BaseResponse:
         return self.rsps.get(
@@ -89,7 +87,6 @@ def mock_analysis_jres(
             status=status,
             match=[
                 matchers.header_matcher({"Accept": "application/json"}),
-                matchers.query_param_matcher(utils.filter_none_values({"os": os_matcher, "arch": arch_matcher})),
             ],
         )
 

tests/test_api.py

@@ -320,7 +320,7 @@ def test_get_analysis_jres(self):
         with self.subTest("get_analysis_jres works"), sq_api_mocker() as mocker:
             mocker.mock_analysis_jres([sq_api_utils.jre_to_dict(jre) for jre in expected_jres])
 
-            actual_jres = self.sq.get_analysis_jres()
+            actual_jres = self.sq.get_analysis_jres(os="linux", arch="x86_64")
             self.assertEqual(actual_jres, expected_jres)
 
         with (
@@ -329,15 +329,15 @@ def test_get_analysis_jres(self):
             self.assertRaises(SonarQubeApiException),
         ):
             mocker.mock_analysis_jres(status=404)
-            self.sq.get_analysis_jres()
+            self.sq.get_analysis_jres(os="linux", arch="x86_64")
 
         with (
             self.subTest("get_analysis_jres returns error when keys are missing"),
             sq_api_mocker() as mocker,
             self.assertRaises(SonarQubeApiException),
         ):
             mocker.mock_analysis_jres([{"id": "jre1"}])
-            self.sq.get_analysis_jres()
+            self.sq.get_analysis_jres(os="linux", arch="x86_64")
 
     def test_download_analysis_jre(self):
         jre_id = "jre1"