feat: Allow filtering by platform on workflow call

.github/workflows/build_images.yaml

@@ -18,6 +18,10 @@ on:
         type: string
         description: Flavor name/s | one (alone), several (separated by commas)
         default: "*"
+      platforms:
+        type: string
+        description: Platforms to build for, formatted as os/arch (e.g. linux/amd64). Can be a single platform, a comma-separated list, or * for all
+        default: "*"
       secrets:
         type: string
         description: Secrets to pass to the image
@@ -115,6 +119,7 @@ jobs:
           vars: |
             repo_name="${{ github.repository }}"
             flavors="${{ inputs.flavors }}"
+            platforms="${{ inputs.platforms }}"
             auth_strategy="${{ inputs.auth_strategy }}"
             snapshots_registry="${{ vars.DOCKER_REGISTRY_SNAPSHOTS }}"
             releases_registry="${{ vars.DOCKER_REGISTRY_RELEASES }}"

firestarter/tests/test_build_images_functionality.py

@@ -25,6 +25,7 @@
     "releases_registry": "xxxx.azurecr.io",
     "snapshots_registry_creds": "test_snapshots_creds",
     "releases_registry_creds": "test_releases_creds",
+    "platforms": "linux/amd64,linux/arm64",
 }
 secrets = {}
 config_file_path = f"{os.path.dirname(os.path.realpath(__file__))}/fixtures/build_images.yaml"
@@ -426,6 +427,35 @@ async def test_compile_images_for_all_flavors(mocker) -> None:
     assert result[7]["repository"] == "repo3"
     assert result[7]["image_tag"] == "flavor3-custom-tag"
 
+@pytest.mark.asyncio
+async def test_compile_images_filtering_by_platform(mocker) -> None:
+    mocker.patch("dagger.Config")
+    mocker.patch("dagger.Connection")
+    mocker.patch.object(builder, "compile_image_and_publish")
+
+    dagger_config_mock = dagger.Config
+    dagger_connection_mock = dagger.Connection
+
+    builder._flavors = "flavor1, flavor3"
+    builder._platforms = "linux/amd64"
+    builder.filter_flavors()
+
+    result = await builder.compile_images_for_all_flavors()
+    built_flavors = set([image["flavor"] for image in result])
+    assert built_flavors == {"flavor1", "flavor3"}
+
+    builder._platforms = "arm64"
+
+    result = await builder.compile_images_for_all_flavors()
+    built_flavors = set([image["flavor"] for image in result])
+    assert built_flavors == {"flavor3"}
+
+    builder._platforms = "*"
+
+    result = await builder.compile_images_for_all_flavors()
+    built_flavors = set([image["flavor"] for image in result])
+    assert built_flavors == {"flavor1", "flavor3"}
+
 # The object correctly returns the flavor data of a chosen flavor,
 # as written in fixtures/build_images.yaml
 def test_get_flavor_data() -> None:

firestarter/workflows/build_images/build_images.py

@@ -52,6 +52,9 @@ def __init__(self, **kwargs) -> None:
         self._workflow_run_url = self.vars.get('workflow_run_url', None)
         self._service_path = self.vars.get('service_path', '')
         self._flavors = self.vars.get('flavors', 'default')
+        self._platforms = self.validate_platforms(
+            self.vars.get('platforms', '*')
+        )
         self._container_structure_filename = self.vars.get(
             'container_structure_filename', None
         )
@@ -123,6 +126,10 @@ def workflow_run_url(self):
     def flavors(self):
         return self._flavors
 
+    @property
+    def platforms(self):
+        return self._platforms
+
     @property
     def service_path(self):
         return self._service_path
@@ -251,7 +258,6 @@ def filter_flavors(self):
 
         self._flavors = final_flavors_list
 
-
     def filter_auto_build(self):
         logger.info(
             'Publishing all flavors with auto build enabled:',
@@ -359,6 +365,32 @@ async def compile_images_for_all_flavors(self):
                         dockerfile, extra_registries,\
                         extra_tags, platforms = self.get_flavor_data(flavor)
 
+                platforms_to_build = []
+                if self.check_if_build_all_platforms():
+                    platforms_to_build = platforms
+                else:
+                    allowed_platforms = self.platforms.replace(' ', '').split(',')
+                    normalized_allowed_platforms = {
+                        p.replace('linux/', '') for p in allowed_platforms
+                    }
+
+                    # Get the platforms to build for this flavor by checking the intersection
+                    platforms_to_build = [
+                        platform for platform in platforms
+                        if platform.replace('linux/', '') in normalized_allowed_platforms
+                    ]
+
+                logger.info(
+                    f"Building flavor {flavor} for platforms: {platforms_to_build}"
+                )
+
+                if len(platforms_to_build) == 0:
+                    logger.warning(
+                        f"No matching platforms to build for flavor {flavor}. "
+                        f"Skipping..."
+                    )
+                    continue
+
                 # Set the build arguments for the current flavor
                 build_args_list = [
                     dagger.BuildArg(name=key, value=value)
@@ -424,7 +456,7 @@ async def compile_images_for_all_flavors(self):
                         secrets,
                         dockerfile,
                         image,
-                        platforms
+                        platforms_to_build
                     )
 
                     image_tag = image.split(":")[1]
@@ -444,12 +476,39 @@ async def compile_images_for_all_flavors(self):
                         "workflow_run_url": self.workflow_run_url
                     })
 
+        if len(results_list) == 0:
+            error_message = (
+                f"No images were built. "
+                f"Please check the workflow filters are correct."
+            )
+            raise Exception(error_message)
+
         yaml.default_flow_style = False
         with open(os.path.join("/tmp", self.output_results), "w") as f:
             yaml.dump(results_list, f)
 
         return results_list
 
+    def check_if_build_all_platforms(self):
+        return self.platforms.replace(' ', '') == '*'
+
+    def validate_platforms(self, platforms):
+        trimmed_platforms = platforms.replace(' ', '')
+        if trimmed_platforms == '*':
+            return platforms
+
+        platform_list = trimmed_platforms.split(',')
+
+        for platform in platform_list:
+            if not re.match(r'^(linux/)?(amd64|arm64)$', platform):
+                raise ValueError(
+                    f"Invalid platform: {platform}. "
+                    "Valid platforms are: linux/amd64, linux/arm64, amd64, arm64, "
+                    "or '*'. Whitespace around comma-separated entries is ignored."
+                )
+
+        return trimmed_platforms
+
     def get_flavor_data(self, flavor):
         flavor_data = self.config.images[flavor]