Draft: esd-spack-installation: added abstract methods for spack manager and added...

esd-spack-installation: added abstract methods for spack manager and added ci/cd testing for spack installation

esd/build_cache/BuildCacheManager.py

@@ -2,18 +2,19 @@ import os
 import oras.client
 from pathlib import Path
 
-from esd.logger.logger_config import LoggerConfig
+from esd.build_cache.BuildCacheManagerInterface import BuildCacheManagerInterface
+from esd.logger.logger_builder import get_logger
 from esd.utils.utils import clean_up
 
 
-class BuildCacheManager:
+class BuildCacheManager(BuildCacheManagerInterface):
     """
         This class aims to manage the push/pull/delete of build cache files
     """
 
-    def __init__(self, auth_backend='basic', log_path='./', insecure=False):
+    def __init__(self, auth_backend='basic', insecure=False):
+        self.logger = get_logger(__name__, BuildCacheManager.__name__)
         self.home_path = Path(os.environ.get("HOME_PATH", os.getcwd()))
-        self.log_file = Path(log_path) / "log_oras.txt"
         self.registry_project = os.environ.get("REGISTRY_PROJECT")
 
         self._registry_username = str(os.environ.get("REGISTRY_USERNAME"))
@@ -27,24 +28,22 @@ class BuildCacheManager:
         self.client = oras.client.OrasClient(hostname=self.registry_host, auth_backend=auth_backend, insecure=insecure)
         self.client.login(username=self._registry_username, password=self._registry_password)
         self.oci_registry_path = f'{self.registry_host}/{self.registry_project}/cache'
-        self.LOGGER = LoggerConfig(self.log_file).get_logger()
 
-    def oci_registry_upload_build_cache(self, cache_dir: Path):
+    def upload(self, out_dir: Path):
         """
             This method pushed all the files from the build cache folder into the OCI Registry
         """
-        build_cache_path = self.home_path / cache_dir
+        build_cache_path = self.home_path / out_dir
         # build cache folder must exist before pushing all the artifacts
         if not build_cache_path.exists():
-            raise FileNotFoundError(
-                f"BuildCacheManager::oci_registry_upload_build_cache::Path {build_cache_path} not found.")
+            self.logger.error(f"Path {build_cache_path} not found.")
 
         for sub_path in build_cache_path.rglob("*"):
             if sub_path.is_file():
-                rel_path = str(sub_path.relative_to(build_cache_path)).replace(str(sub_path.name), "")
-                target = f"{self.registry_host}/{self.registry_project}/cache:{str(sub_path.name)}"
+                rel_path = str(sub_path.relative_to(build_cache_path)).replace(str(sub_path.env_name), "")
+                target = f"{self.registry_host}/{self.registry_project}/cache:{str(sub_path.env_name)}"
                 try:
-                    self.LOGGER.info(f"Pushing folder '{sub_path}' to ORAS target '{target}' ...")
+                    self.logger.info(f"Pushing folder '{sub_path}' to ORAS target '{target}' ...")
                     self.client.push(
                         files=[str(sub_path)],
                         target=target,
@@ -52,31 +51,31 @@ class BuildCacheManager:
                         manifest_annotations={"path": rel_path},
                         disable_path_validation=True,
                     )
-                    self.LOGGER.info(f"Successfully pushed {sub_path.name}")
+                    self.logger.info(f"Successfully pushed {sub_path.env_name}")
                 except Exception as e:
-                    self.LOGGER.error(
-                        f"BuildCacheManager::registry_upload_build_cache::An error occurred while pushing: {e}")
-        # delete the build cache after being pushed to the OCI Registry
-        clean_up([str(build_cache_path)], self.LOGGER)
+                    self.logger.error(
+                        f"An error occurred while pushing: {e}")
+        # todo to be discussed hot to delete the build cache after being pushed to the OCI Registry
+        # clean_up([str(build_cache_path)], self.logger)
 
-    def oci_registry_get_tags(self):
+    def list_tags(self):
         """
             This method retrieves all tags from an OCI Registry
         """
         try:
             return self.client.get_tags(self.oci_registry_path)
         except Exception as e:
-            self.LOGGER.error(f"BuildCacheManager::oci_registry_get_tags::Failed to list tags: {e}")
+            self.logger.error(f"Failed to list tags: {e}")
         return None
 
-    def oci_registry_download_build_cache(self, cache_dir: Path):
+    def download(self, in_dir: Path):
         """
             This method pulls all the files from the OCI Registry into the build cache folder
         """
-        build_cache_path = self.home_path / cache_dir
+        build_cache_path = self.home_path / in_dir
         # create the buildcache dir if it does not exist
         os.makedirs(build_cache_path, exist_ok=True)
-        tags = self.oci_registry_get_tags()
+        tags = self.list_tags()
         if tags is not None:
             for tag in tags:
                 ref = f"{self.registry_host}/{self.registry_project}/cache:{tag}"
@@ -88,27 +87,27 @@ class BuildCacheManager:
                 try:
                     self.client.pull(
                         ref,
-                        # missing dirs to outdir are created automatically by OrasClient pull method
+                        # missing dirs to output dir are created automatically by OrasClient pull method
                         outdir=str(build_cache_path / cache_path),
                         overwrite=True
                     )
-                    self.LOGGER.info(f"Successfully pulled artifact {tag}.")
+                    self.logger.info(f"Successfully pulled artifact {tag}.")
                 except Exception as e:
-                    self.LOGGER.error(
-                        f"BuildCacheManager::registry_download_build_cache::Failed to pull artifact {tag} : {e}")
+                    self.logger.error(
+                        f"Failed to pull artifact {tag} : {e}")
 
-    def oci_registry_delete_build_cache(self):
+    def delete(self):
         """
             Deletes all artifacts from an OCI Registry based on their tags.
             This method removes artifacts identified by their tags in the specified OCI Registry.
             It requires appropriate permissions to delete artifacts from the registry.
             If the registry or user does not have the necessary delete permissions, the operation might fail.
         """
-        tags = self.oci_registry_get_tags()
+        tags = self.list_tags()
         if tags is not None:
             try:
                 self.client.delete_tags(self.oci_registry_path, tags)
-                self.LOGGER.info(f"Successfully deleted all artifacts form OCI registry.")
+                self.logger.info(f"Successfully deleted all artifacts form OCI registry.")
             except RuntimeError as e:
-                self.LOGGER.error(
-                    f"BuildCacheManager::registry_delete_build_cache::Failed to delete artifacts: {e}")
+                self.logger.error(
+                    f"Failed to delete artifacts: {e}")