Consume build_scenario via build_info for registry repo and other info

Author: viveksinghggits

.evergreen-functions.yml

@@ -227,7 +227,8 @@ functions:
       working_dir: src/github.com/mongodb/mongodb-kubernetes
       add_to_path:
         - ${workdir}/bin
-      binary: scripts/dev/helm_registry_login.sh
+        - ${PROJECT_DIR}/bin
+      binary: scripts/dev/run_python.sh scripts/release/helm_registry_login.py
 
   # Logs into all used registries
   configure_docker_auth: &configure_docker_auth

.evergreen.yml

@@ -438,11 +438,11 @@ tasks:
   - name: publish_helm_chart
     commands:
       - func: clone
+      - func: python_venv
       - func: setup_kubectl
       - func: setup_aws
       - func: prepare_aws
       - func: helm_registry_login
-      - func: python_venv
       - func: publish_helm_chart
 
   - name: prepare_aws

build_info.json

@@ -345,15 +345,20 @@
   "helm-charts": {
     "mongodb-kubernetes": {
       "patch": {
-        "repositories": ["268558157000.dkr.ecr.us-east-1.amazonaws.com/dev/helm-charts"]
+        "registry": "268558157000.dkr.ecr.us-east-1.amazonaws.com",
+        "region": "us-east-1",
+        "repository": "dev/mongodb/helm-charts"
       },
       "staging": {
         "sign": true,
-        "repositories": ["268558157000.dkr.ecr.us-east-1.amazonaws.com/staging/helm-charts"]
+        "registry": "268558157000.dkr.ecr.us-east-1.amazonaws.com",
+        "region": "us-east-1",
+        "repository": "staging/mongodb/helm-charts"
       },
       "release": {
         "sign": true,
-        "repositories": ["quay.io/mongodb/helm-charts"]
+        "registry": "quay.io",
+        "repository": "mongodb/helm-charts"
       }
     }
   }

scripts/dev/helm_registry_login.sh

@@ -1,31 +1,39 @@
-import subprocess
 import os
+import subprocess
+import sys
+
 import yaml
 
 from lib.base_logger import logger
+from scripts.release.build.build_info import *
 
 CHART_DIR = "helm_chart"
 
-OCI_REGISTRY = "oci://268558157000.dkr.ecr.us-east-1.amazonaws.com/dev/helm-charts"
 
-def run_command(command: list[str], description: str):
+def run_command(command: list[str]):
     try:
-        subprocess.run(command, check=True, text=True, capture_output=False)
-        logger.info(f"Command {' '.join(command)} executed successfully.")
+        # Using capture_output=True to grab stdout/stderr for better error logging.
+        process = subprocess.run(command, check=True, text=True, capture_output=True)
+        logger.info(f"Successfully executed: {' '.join(command)}")
+        if process.stdout:
+            logger.info(process.stdout)
     except subprocess.CalledProcessError as e:
-        logger.error(f"Error executing command: {' '.join(command)}")
-        raise RuntimeError(f"{description} failed.") from e
+        raise RuntimeError(f"Command {' '.join(command)} failed. Stderr: {e.stderr.strip()}") from e
     except FileNotFoundError:
-        raise FileNotFoundError("Error: 'helm' command not found. Ensure Helm CLI is installed and in your PATH.")
+        raise FileNotFoundError(f"Error: {command[0]} command not found. Ensure {command[0]} is installed and in your PATH.")
 
+
+# update_chart_and_get_metadata updates the helm chart's Chart.yaml and sets the version
+# to either evg patch id or commit which is set in OPERATOR_VERSION.
 def update_chart_and_get_metadata(chart_dir: str) -> tuple[str, str]:
     chart_path = os.path.join(chart_dir, "Chart.yaml")
-    version_id = os.environ.get('version_id')
+    version_id = os.environ.get("OPERATOR_VERSION")
     if not version_id:
-        raise ValueError("Error: Environment variable 'version_id' must be set to determine the chart version to publish.")
-        
-    new_version = f"0.0.0+{version_id}"
+        raise ValueError(
+            "Error: Environment variable 'OPERATOR_VERSION' must be set to determine the chart version to publish."
+        )
 
+    new_version = f"0.0.0+{version_id}"
     logger.info(f"New helm chart version will be: {new_version}")
 
     if not os.path.exists(chart_path):
@@ -35,44 +43,76 @@ def update_chart_and_get_metadata(chart_dir: str) -> tuple[str, str]:
         )
 
     try:
-        with open(chart_path, 'r') as f:
+        with open(chart_path, "r") as f:
             data = yaml.safe_load(f)
 
-        chart_name = data.get('name')
+        chart_name = data.get("name")
         if not chart_name:
-             raise ValueError("Chart.yaml is missing required 'name' field.")
+            raise ValueError("Chart.yaml is missing required 'name' field.")
 
-        data['version'] = new_version
-        
-        with open(chart_path, 'w') as f:
-            yaml.safe_dump(data, f, sort_keys=False) 
+        data["version"] = new_version
 
-        logger.info(f"Successfully updated version for chart '{chart_name}' to '{new_version}' before publishing it.")
-        return chart_name, new_version
+        with open(chart_path, "w") as f:
+            yaml.safe_dump(data, f, sort_keys=False)
 
+        logger.info(f"Successfully updated version for chart '{chart_name}' to '{new_version}'.")
+        return chart_name, new_version
     except Exception as e:
         raise RuntimeError(f"Failed to read or update Chart.yaml: {e}")
 
-def publish_helm_chart():
+
+def get_oci_registry(chart_info: HelmChartInfo) -> str:
+    registry = chart_info.registry
+    repo = chart_info.repository
+
+    if not registry:
+        raise ValueError("Error: registry doesn't seem to be set in HelmChartInfo.")
+
+    if not repo:
+        raise ValueError("Error: reposiotry doesn't seem to be set in HelmChartInfo.")
+
+    
+    oci_registry = f"oci://{registry}/{repo}"
+    logger.info(f"Determined OCI Registry: {oci_registry}")
+    return oci_registry
+
+
+def publish_helm_chart(chart_info: HelmChartInfo):
     try:
+        oci_registry = get_oci_registry(chart_info)
         chart_name, chart_version = update_chart_and_get_metadata(CHART_DIR)
-        
         tgz_filename = f"{chart_name}-{chart_version}.tgz"
-        logger.info(f"Packaging chart: {chart_name} with Version: {chart_version}")
 
-        package_command = ["helm", "package", CHART_DIR]
-        run_command(package_command, f"Packaging chart '{CHART_DIR}'")
+        try:
+            logger.info(f"Packaging chart: {chart_name} with Version: {chart_version}")
+            package_command = ["helm", "package", CHART_DIR]
+            run_command(package_command)
+
+            logger.info(f"Pushing chart to registry: {oci_registry}")
+            push_command = ["helm", "push", tgz_filename, oci_registry]
+            run_command(push_command)
 
-        push_command = ["helm", "push", tgz_filename, OCI_REGISTRY]
-        run_command(push_command, f"Pushing '{tgz_filename}' to '{OCI_REGISTRY}'")
+            logger.info(f"Helm Chart {chart_name}:{chart_version} was published successfully!")
+        finally:
+            # Cleanup the local .tgz file regardless of push success/failure
+            if os.path.exists(tgz_filename):
+                logger.info(f"Cleaning up local file: {tgz_filename}")
+                os.remove(tgz_filename)
 
-        if os.path.exists(tgz_filename):
-            logger.info(f"\nCleaning up local file: {tgz_filename}")
-            os.remove(tgz_filename)
-        
-        logger(f"Helm Chart {chart_name}:{chart_version} was published successfully!")
     except (FileNotFoundError, RuntimeError, ValueError) as e:
-        logger.error(f"\Failed publishing the helm chart: {e}")
+        raise Exception(f"Failed publishing the helm chart {e}")
+
+
+def main():
+    build_scenario = os.environ.get("BUILD_SCENARIO")
+    build_info = load_build_info(build_scenario)
+
+    return publish_helm_chart(build_info.helm_charts["mongodb-kubernetes"])
+
 
 if __name__ == "__main__":
-    publish_helm_chart()
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Failure in the helm publishing process {e}")
+        sys.exit(1)

scripts/publish_helm_chart.py

@@ -37,7 +37,9 @@ class BinaryInfo:
 
 @dataclass
 class HelmChartInfo:
-    repositories: List[str]
+    repository: str
+    registry: str
+    region: str
     sign: bool = False
 
 
@@ -101,8 +103,10 @@ def load_build_info(scenario: BuildScenario) -> BuildInfo:
             continue
 
         helm_charts[name] = HelmChartInfo(
-            repositories=scenario_data["repositories"],
+            repository=scenario_data.get("repository"),
             sign=scenario_data.get("sign", False),
+            registry=scenario_data.get("registry"),
+            region=scenario_data.get("region")
         )
 
     return BuildInfo(images=images, binaries=binaries, helm_charts=helm_charts)

scripts/release/build/build_info.py

@@ -0,0 +1,89 @@
+import os
+import sys
+import subprocess
+from lib.base_logger import logger
+from scripts.release.build.build_info import load_build_info
+
+def helm_registry_login(helm_registry: str, region: str):
+    logger.info(f"Attempting to log into ECR registry: {helm_registry}, using helm registry login.")
+    
+    aws_command = [
+        "aws", 
+        "ecr", 
+        "get-login-password", 
+        "--region", 
+        region
+    ]
+    
+    # as we can see the password is being provided by stdin, that would mean we will have to
+    # pipe the aws_command (it figures out the password) into helm_command.
+    helm_command = [
+        "helm", 
+        "registry", 
+        "login", 
+        "--username", 
+        "AWS", 
+        "--password-stdin", 
+        helm_registry
+    ]
+
+    try:
+        logger.info("Starting AWS ECR credential retrieval.")
+        aws_proc = subprocess.Popen(
+            aws_command, 
+            stdout=subprocess.PIPE, 
+            stderr=subprocess.PIPE,
+            text=True  # Treat input/output as text strings
+        )
+        
+        logger.info("Starting Helm registry login.")
+        helm_proc = subprocess.Popen(
+            helm_command, 
+            stdin=aws_proc.stdout, 
+            stdout=subprocess.PIPE, 
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        # Close the stdout stream of aws_proc in the parent process 
+        # to prevent resource leakage (only needed if you plan to do more processing)
+        aws_proc.stdout.close() 
+
+        # Wait for the Helm command (helm_proc) to finish and capture its output
+        helm_stdout, helm_stderr = helm_proc.communicate()
+        
+        # Wait for the AWS process to finish as well
+        aws_proc.wait() 
+
+        if aws_proc.returncode != 0:
+            _, aws_stderr = aws_proc.communicate() 
+            raise Exception(f"aws command to get password failed. Error: {aws_stderr}")
+            
+        if helm_proc.returncode == 0:
+            logger.info("Login to helm registry was successful.")
+            logger.info(helm_stdout.strip())
+        else:
+            raise Exception(f"Login to helm registry failed, Exit code: {helm_proc.returncode}, Error: {helm_stderr.strip()}")
+
+    except FileNotFoundError as e:
+        # This catches errors if 'aws' or 'helm' are not in the PATH
+        raise Exception(f"Command not found. Please ensure '{e.filename}' is installed and in your system's PATH.")
+    except Exception as e:
+        raise Exception(f"An unexpected error occurred: {e}.")
+    
+
+def main():
+    build_scenario = os.environ.get("BUILD_SCENARIO")
+    build_info = load_build_info(build_scenario)
+
+
+    registry = build_info.helm_charts["mongodb-kubernetes"].registry
+    region = build_info.helm_charts["mongodb-kubernetes"].region
+    return helm_registry_login(registry, region)
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Failed while logging in to the helm registry. Error: {e}")
+        sys.exit(1)