feat: Error on --use-container for dotnet builds

samcli/commands/build/command.py

@@ -31,9 +31,10 @@
 Supported Runtimes
 ------------------
 1. Python 2.7, 3.6, 3.7 using PIP\n
-4. Nodejs 8.10, 6.10 using NPM
-4. Ruby 2.5 using Bundler
-5. Java 8 using Gradle
+2. Nodejs 8.10, 6.10 using NPM\n
+3. Ruby 2.5 using Bundler\n
+4. Java 8 using Gradle\n
+5. Dotnetcore2.0 and 2.1 using Dotnet CLI\n
 \b
 Examples
 --------

samcli/lib/build/app_builder.py

@@ -19,7 +19,7 @@
 from aws_lambda_builders.builder import LambdaBuilder
 from aws_lambda_builders.exceptions import LambdaBuilderError
 from aws_lambda_builders import RPC_PROTOCOL_VERSION as lambda_builders_protocol_version
-from .workflow_config import get_workflow_config
+from .workflow_config import get_workflow_config, supports_build_in_container
 
 
 LOG = logging.getLogger(__name__)
@@ -180,7 +180,13 @@ def _build_function(self, function_name, codeuri, runtime):
             # By default prefer to build in-process for speed
             build_method = self._build_function_in_process
             if self._container_manager:
-                build_method = self._build_function_on_container
+
+                container_build_supported, reason = supports_build_in_container(config)
+                if container_build_supported:
+                    build_method = self._build_function_on_container
+                else:
+                    LOG.warning(reason)
+                    LOG.warning("Continuing build without a container")
 
             return build_method(config,
                                 code_dir,

samcli/lib/build/workflow_config.py

@@ -117,6 +117,32 @@ def get_workflow_config(runtime, code_dir, project_dir):
                                           .format(runtime, str(ex)))
 
 
+def supports_build_in_container(config):
+    """
+    Given a workflow config, this method provides a boolean on whether the workflow can run within a container or not.
+
+    Parameters
+    ----------
+    config namedtuple(Capability)
+        Config specifying the particular build workflow
+
+    Returns
+    -------
+    tuple(bool, str)
+        True, if this workflow can be built inside a container. False, along with a reason message if it cannot be.
+    """
+
+    unsupported = {
+        DOTNET_CLIPACKAGE_CONFIG: "We do not support building dotnet Lambda functions within a container. Most "
+                                  "dotnet functions can be successfully built without a container.",
+    }
+
+    if config in unsupported:
+        return False, unsupported[config]
+
+    return True, None
+
+
 class BasicWorkflowSelector(object):
     """
     Basic workflow selector that returns the first available configuration in the given list of configurations

tests/unit/lib/build_module/test_app_builder.py

@@ -176,6 +176,47 @@ def test_must_build_in_container(self, osutils_mock, get_workflow_config_mock):
                                                                      manifest_path,
                                                                      runtime)
 
+    @patch("samcli.lib.build.app_builder.supports_build_in_container")
+    @patch("samcli.lib.build.app_builder.get_workflow_config")
+    @patch("samcli.lib.build.app_builder.osutils")
+    def test_must_fallback_to_build_in_process_for_unsupported_containers(self,
+                                                                          osutils_mock,
+                                                                          get_workflow_config_mock,
+                                                                          supports_build_in_container_mock):
+        function_name = "function_name"
+        codeuri = "path/to/source"
+        runtime = "runtime"
+        scratch_dir = "scratch"
+        config_mock = get_workflow_config_mock.return_value = Mock()
+        config_mock.manifest_name = "manifest_name"
+
+        osutils_mock.mkdir_temp.return_value.__enter__ = Mock(return_value=scratch_dir)
+        osutils_mock.mkdir_temp.return_value.__exit__ = Mock()
+
+        self.builder._build_function_on_container = Mock()
+        self.builder._build_function_in_process = Mock()
+
+        code_dir = "/base/dir/path/to/source"
+        artifacts_dir = "/build/dir/function_name"
+        manifest_path = os.path.join(code_dir, config_mock.manifest_name)
+
+        # Setting the container manager will make us use the container
+        self.builder._container_manager = Mock()
+
+        # Mark the container build as unsupported
+        supports_build_in_container_mock.return_value = (False, "reason")
+
+        self.builder._build_function(function_name, codeuri, runtime)
+
+        self.builder._build_function_on_container.assert_not_called()
+        self.builder._build_function_in_process.assert_called_with(config_mock,
+                                                                   code_dir,
+                                                                   artifacts_dir,
+                                                                   scratch_dir,
+                                                                   manifest_path,
+                                                                   runtime)
+        supports_build_in_container_mock.assert_called_with(config_mock)
+
 
 class TestApplicationBuilder_build_function_in_process(TestCase):