Add better errors for too large deployments

chalice/awsclient.py

@@ -22,6 +22,9 @@
 import json
 
 import botocore.session  # noqa
+from botocore.exceptions import ClientError
+from botocore.vendored.requests import ConnectionError as \
+    RequestsConnectionError
 from typing import Any, Optional, Dict, Callable, List, Iterator  # noqa
 
 from chalice.constants import DEFAULT_STAGE_NAME
@@ -33,16 +36,29 @@
 _CLIENT_METHOD = Callable[..., Dict[str, Any]]
 
 
+def _get_mb(value):
+    # type: (int) -> str
+    return '%.1f MB' % (float(value) / (1024 ** 2))
+
+
 class ResourceDoesNotExistError(Exception):
     pass
 
 
+class DeploymentPackageTooLargeError(Exception):
+    def __init__(self, msg, additional_details=None):
+        # type: (str, str) -> None
+        self.additional_details = additional_details
+        super(DeploymentPackageTooLargeError, self).__init__(msg)
+
+
 class TypedAWSClient(object):
 
     # 30 * 5 == 150 seconds or 2.5 minutes for the initial lambda
     # creation + role propagation.
     LAMBDA_CREATE_ATTEMPTS = 30
     DELAY_TIME = 5
+    MAX_LAMBDA_DEPLOYMENT_SIZE = 50 * (1024 ** 2)
 
     def __init__(self, session, sleep=time.sleep):
         # type: (botocore.session.Session, Callable[[int], None]) -> None
@@ -92,8 +108,12 @@ def create_function(self,
             kwargs['Timeout'] = timeout
         if memory_size is not None:
             kwargs['MemorySize'] = memory_size
-        return self._call_client_method_with_retries(
-            self._client('lambda').create_function, kwargs)['FunctionArn']
+        try:
+            return self._call_client_method_with_retries(
+                self._client('lambda').create_function, kwargs)['FunctionArn']
+        except Exception as e:
+            self._raise_large_deployment_related_errors(e, len(zip_contents))
+            raise e
 
     def _call_client_method_with_retries(self, method, kwargs):
         # type: (_CLIENT_METHOD, Dict[str, Any]) -> Dict[str, Any]
@@ -102,18 +122,60 @@ def _call_client_method_with_retries(self, method, kwargs):
         while True:
             try:
                 response = method(**kwargs)
-            except client.exceptions.InvalidParameterValueException:
+            except client.exceptions.InvalidParameterValueException as e:
                 # We're assuming that if we receive an
                 # InvalidParameterValueException, it's because
                 # the role we just created can't be used by
                 # Lambda so retry until it can be.
                 self._sleep(self.DELAY_TIME)
                 attempts += 1
-                if attempts >= self.LAMBDA_CREATE_ATTEMPTS:
+                message = e.response['Error'].get('Message', '')
+                retryable_message = (
+                    'The role defined for the function cannot be assumed '
+                    'by Lambda.'
+                )
+                if attempts >= self.LAMBDA_CREATE_ATTEMPTS or \
+                        retryable_message not in message:
                     raise
                 continue
             return response
 
+    def _raise_large_deployment_related_errors(self, error,
+                                               deployment_size):
+        # type: (Any, int) -> None
+        error_message = str(error)
+        should_raise = False
+        additional_details = None
+        if (isinstance(error, RequestsConnectionError) and
+                deployment_size > self.MAX_LAMBDA_DEPLOYMENT_SIZE):
+            # When the zip deployment package is too large and Lambda
+            # aborts the connection as chalice is still sending it
+            # data
+            additional_details = (
+                'This is likely because the deployment package is %s. '
+                'Lambda only allows deployment packages that are %s or '
+                'less in size.' % (
+                    _get_mb(deployment_size),
+                    _get_mb(self.MAX_LAMBDA_DEPLOYMENT_SIZE)
+                )
+            )
+            should_raise = True
+        elif isinstance(error, ClientError):
+            code = error.response['Error'].get('Code')
+            message = error.response['Error'].get('Message')
+            if code == 'RequestEntityTooLargeException':
+                # Happens when the zipped deployment package sent to lambda
+                # is too large
+                should_raise = True
+            elif code == 'InvalidParameterValueException' and \
+                    'Unzipped size must be smaller' in message:
+                # Happens when the contents of the unzipped deployment
+                # package sent to lambda is too large
+                should_raise = True
+        if should_raise:
+            raise DeploymentPackageTooLargeError(
+                error_message, additional_details)
+
     def delete_function(self, function_name):
         # type: (str) -> None
         lambda_client = self._client('lambda')
@@ -140,8 +202,12 @@ def update_function(self,
         the targeted lambda function.
         """
         lambda_client = self._client('lambda')
-        return_value = lambda_client.update_function_code(
-            FunctionName=function_name, ZipFile=zip_contents)
+        try:
+            return_value = lambda_client.update_function_code(
+                FunctionName=function_name, ZipFile=zip_contents)
+        except Exception as e:
+            self._raise_large_deployment_related_errors(e, len(zip_contents))
+            raise e
 
         kwargs = {}  # type: Dict[str, Any]
         if environment_variables is not None:

chalice/deploy/deployer.py

@@ -17,6 +17,7 @@
 from chalice import __version__ as chalice_version
 from chalice import policy
 from chalice.awsclient import TypedAWSClient, ResourceDoesNotExistError
+from chalice.awsclient import DeploymentPackageTooLargeError
 from chalice.config import Config, DeployedResources  # noqa
 from chalice.deploy.packager import LambdaDeploymentPackager
 from chalice.deploy.swagger import SwaggerGenerator
@@ -29,6 +30,7 @@
 
 NULLARY = Callable[[], str]
 OPT_RESOURCES = Optional[DeployedResources]
+OPT_STR = Optional[str]
 
 
 def create_default_deployer(session, prompter=None):
@@ -169,6 +171,19 @@ def _validate_manage_iam_role(config):
             )
 
 
+class ChaliceDeploymentError(Exception):
+    def __init__(self, error_msg, where=None, suggestion=None):
+        # type: (str, OPT_STR, OPT_STR) -> None
+        msg = 'DEPLOYMENT ERROR - '
+        if where:
+            msg += 'While %s, received the following error: ' % where
+        msg += error_msg
+        if suggestion:
+            msg += '. '
+            msg += suggestion
+        super(ChaliceDeploymentError, self).__init__(msg)
+
+
 class NoPrompt(object):
     def confirm(self, text, default=False, abort=False):
         # type: (str, bool, bool) -> bool
@@ -206,6 +221,13 @@ def deploy(self, config, chalice_stage_name=DEFAULT_STAGE_NAME):
             rest api, lambda function, role, etc.
 
         """
+        try:
+            return self._do_deploy(config, chalice_stage_name)
+        except Exception as error:
+            raise self._get_chalice_deployment_error(error)
+
+    def _do_deploy(self, config, chalice_stage_name=DEFAULT_STAGE_NAME):
+        # type: (Config, str) -> Dict[str, Any]
         validate_configuration(config)
         existing_resources = config.deployed_resources(chalice_stage_name)
         deployed_values = self._lambda_deploy.deploy(
@@ -229,6 +251,22 @@ def deploy(self, config, chalice_stage_name=DEFAULT_STAGE_NAME):
             chalice_stage_name: deployed_values
         }
 
+    def _get_chalice_deployment_error(self, error):
+        # type: (Any) -> ChaliceDeploymentError
+        suggestion = None
+        where = None
+        if isinstance(error, DeploymentPackageTooLargeError):
+            where = 'sending your chalice handler code to Lambda'
+            suggestion = (
+                'To avoid this error, decrease the size of your chalice '
+                'application by removing code or removing '
+                'dependencies from your chalice application.'
+            )
+            if error.additional_details:
+                suggestion = error.additional_details + ' ' + suggestion
+        return ChaliceDeploymentError(
+            str(error), where=where, suggestion=suggestion)
+
 
 class LambdaDeployer(object):
     def __init__(self,

tests/conftest.py

@@ -1,5 +1,6 @@
 import botocore.session
 from botocore.stub import Stubber
+import mock
 import pytest
 from pytest import fixture
 
@@ -98,6 +99,15 @@ def stubbed_session():
     return s
 
 
+@fixture
+def mock_lambda_client():
+    session = botocore.session.Session()
+    lambda_client = session.create_client('lambda')
+    mock_client = mock.Mock(lambda_client)
+    mock_client.exceptions = lambda_client.exceptions
+    return mock_client
+
+
 @fixture
 def no_local_config(monkeypatch):
     """Ensure no local AWS configuration is used.