Warn for missing BuildArchitecture during Layer build (#6355)

* wip

* Add check for BuildArchitecture in LayerVersion constructor

* Add check in Compatible architectures

* Add test for BuildArch not in CompatibleArch

* formatting fixes

* Fix string too long

* Remove unnecessary changes

* Format fix

---------

Co-authored-by: Jared Bentvelsen <bentvels@amazon.com>

Author: bentvelj

samcli/lib/providers/provider.py

@@ -242,11 +242,24 @@ def __init__(
         self._metadata = metadata
         self._build_method = cast(Optional[str], metadata.get("BuildMethod", None))
         self._compatible_runtimes = compatible_runtimes
+        self._custom_layer_id = metadata.get(SAM_RESOURCE_ID_KEY)
+
+        if "BuildArchitecture" not in metadata:
+            LOG.warning(
+                f"WARNING: No BuildArchitecture specifed in Layer `{self._custom_layer_id}`"
+                + " Metadata. Defaulting to x86_64."
+            )
 
         self._build_architecture = cast(str, metadata.get("BuildArchitecture", X86_64))
         self._compatible_architectures = compatible_architectures
+
+        if self._compatible_architectures and self._build_architecture not in self._compatible_architectures:
+            LOG.warning(
+                f"WARNING: Layer `{self._custom_layer_id}` has BuildArchitecture `{self._build_architecture}`,"
+                + " which is not listed in CompatibleArchitectures."
+            )
+
         self._skip_build = bool(metadata.get(SAM_METADATA_SKIP_BUILD_KEY, False))
-        self._custom_layer_id = metadata.get(SAM_RESOURCE_ID_KEY)
 
     @staticmethod
     def _compute_layer_version(is_defined_within_template: bool, arn: str) -> Optional[int]:

tests/integration/buildcmd/test_build_cmd.py

@@ -1494,6 +1494,33 @@ def test_build_layer_with_makefile_no_compatible_runtimes(self):
             "random",
         )
 
+    @parameterized.expand(
+        [("makefile", False), ("makefile", "use_container"), ("python3.9", False), ("python3.9", "use_container")]
+    )
+    def test_build_layer_with_architecture_not_compatible(self, build_method, use_container):
+        # The BuildArchitecture is not one of the listed CompatibleArchitectures
+
+        layer_identifier = "LayerWithNoCompatibleArchitectures"
+
+        overrides = {
+            "LayerBuildMethod": build_method,
+            "LayerMakeContentUri": "PyLayerMake",
+            "LayerBuildArchitecture": "x86_64",
+            "LayerCompatibleArchitecture": "arm64",
+        }
+        cmdlist = self.get_command_list(
+            use_container=use_container, parameter_overrides=overrides, function_identifier=layer_identifier
+        )
+
+        command_result = run_command(cmdlist, cwd=self.working_dir)
+        # Capture warning
+        self.assertIn(
+            f"Layer `{layer_identifier}` has BuildArchitecture `x86_64`, which is not listed in CompatibleArchitectures.",
+            str(command_result.stderr),
+        )
+        # Build should still succeed
+        self.assertEqual(command_result.process.returncode, 0)
+
     @parameterized.expand([("python3.7", False, "LayerTwo"), ("python3.7", "use_container", "LayerTwo")])
     def test_build_fails_with_missing_metadata(self, runtime, use_container, layer_identifier):
         if use_container and (SKIP_DOCKER_TESTS or SKIP_DOCKER_BUILD):
@@ -1508,6 +1535,19 @@ def test_build_fails_with_missing_metadata(self, runtime, use_container, layer_i
         self.assertEqual(command_result.process.returncode, 1)
         self.assertFalse(self.default_build_dir.joinpath(layer_identifier).exists())
 
+    @parameterized.expand([("python3.7", False, "LayerOne"), ("python3.7", "use_container", "LayerOne")])
+    def test_build_with_missing_buildarchitecture(self, runtime, use_container, layer_identifier):
+        if use_container and (SKIP_DOCKER_TESTS or SKIP_DOCKER_BUILD):
+            self.skipTest(SKIP_DOCKER_MESSAGE)
+
+        overrides = {"LayerBuildMethod": runtime, "LayerContentUri": "PyLayer"}
+        cmdlist = self.get_command_list(
+            use_container=use_container, parameter_overrides=overrides, function_identifier=layer_identifier
+        )
+        command_result = run_command(cmdlist, cwd=self.working_dir)
+        self.assertEqual(command_result.process.returncode, 0)
+        self.assertIn("No BuildArchitecture specifed", str(command_result.stderr))
+
     @parameterized.expand([("python3.7", False), ("python3.7", "use_container")])
     def test_build_function_and_layer(self, runtime, use_container):
         if use_container and (SKIP_DOCKER_TESTS or SKIP_DOCKER_BUILD):

tests/integration/testdata/buildcmd/PyLayerMake/Makefile

@@ -7,4 +7,7 @@ build-LayerWithMakefileNoCompatibleRuntimes:
 	mkdir -p "$(ARTIFACTS_DIR)/random"
 	cp *.py "$(ARTIFACTS_DIR)/random"
 	cp *.txt "$(ARTIFACTS_DIR)/random"
-
+build-LayerWithNoCompatibleArchitectures: 
+	mkdir -p "$(ARTIFACTS_DIR)/random"
+	cp *.py "$(ARTIFACTS_DIR)/random"
+	cp *.txt "$(ARTIFACTS_DIR)/random"

tests/integration/testdata/buildcmd/layers-functions-template.yaml

@@ -14,6 +14,11 @@ Parameters:
     Type: String
   LayerBuildMethod:
     Type: String
+  LayerBuildArchitecture:
+    Default: x86_64
+    Type: String
+  LayerCompatibleArchitecture:
+    Type: String
 
 Resources:
 
@@ -72,3 +77,14 @@ Resources:
       ContentUri: !Ref LayerMakeContentUri
     Metadata:
       BuildMethod: !Ref LayerBuildMethod
+
+  LayerWithNoCompatibleArchitectures:
+    Type: AWS::Serverless::LayerVersion
+    Properties:
+      Description: Layer four
+      ContentUri: !Ref LayerMakeContentUri
+      CompatibleArchitectures:
+        - !Ref LayerCompatibleArchitecture
+    Metadata:
+      BuildMethod: !Ref LayerBuildMethod
+      BuildArchitecture: !Ref LayerBuildArchitecture