fix: use get_function utility

Author: monroeclinton

samcli/commands/local/lib/local_lambda.py

@@ -96,15 +96,16 @@ def __init__(
         self.container_host_interface = container_host_interface
         self.extra_hosts = extra_hosts
 
-    def get_function(self, function_identifier: str) -> Function:
+    def get_function(self, function_identifier: str, tenant_id: Optional[str] = None) -> Function:
         """
         Get a Lambda function by identifier, raising FunctionNotFound if not found.
 
         Parameters
         ----------
         function_identifier : str
             Identifier of the Lambda function, it can be logicalID, function name or full path
-
+        tenant_id : Optional[str]
+            Optional tenant ID for multi-tenant functions
         Returns
         -------
         Function
@@ -116,6 +117,14 @@ def get_function(self, function_identifier: str) -> Function:
             When the function identifier doesn't match AWS Lambda's validation pattern
         FunctionNotFound
             When we cannot find a function with the given identifier
+        TenantIdValidationError
+            When the tenant ID is not provided for multi-tenant functions
+        UnsupportedInlineCodeError
+            When the function has inline code and is being invoked locally
+        InvalidIntermediateImageError
+            When the function has an intermediate image and is being invoked locally
+        UnsupportedRuntimeArchitectureError
+            When the function runtime and architecture are not compatible
         """
         # Normalize function identifier from ARN if provided
         normalized_function_identifier = normalize_sam_function_identifier(function_identifier)
@@ -131,6 +140,36 @@ def get_function(self, function_identifier: str) -> Function:
             LOG.info(available_function_message)
             raise FunctionNotFound("Unable to find a Function with name '{}'".format(function_identifier))
 
+        LOG.debug("Found one Lambda function with name '%s'", function_identifier)
+        if function.packagetype == ZIP:
+            if function.inlinecode:
+                raise UnsupportedInlineCodeError(
+                    "Inline code is not supported for sam local commands."
+                    f" Please write your code in a separate file for the function {function.function_id}."
+                )
+            LOG.info("Invoking %s (%s)", function.handler, function.runtime)
+        elif function.packagetype == IMAGE:
+            if not function.imageuri:
+                raise InvalidIntermediateImageError(
+                    f"ImageUri not provided for Function: {function_identifier} of PackageType: {function.packagetype}"
+                )
+            LOG.info("Invoking Container created from %s", function.imageuri)
+
+        validate_architecture_runtime(function)
+
+        # Validate tenant-id for multi-tenant functions
+        if function.tenancy_config and isinstance(function.tenancy_config, dict):
+            if not tenant_id:
+                raise TenantIdValidationError(
+                    "The invoked function is enabled with tenancy configuration. "
+                    "Add a valid tenant ID in your request and try again."
+                )
+        elif tenant_id:
+            raise TenantIdValidationError(
+                "The invoked function is not enabled with tenancy configuration. "
+                "Remove the tenant ID from your request and try again."
+            )
+
         return function
 
     def invoke(
@@ -143,6 +182,7 @@ def invoke(
         override_runtime: Optional[str] = None,
         invocation_type: str = "RequestResponse",
         durable_execution_name: Optional[str] = None,
+        function: Optional[Function] = None,
     ) -> Optional[Dict[str, str]]:
         """
         Find the Lambda function with given name and invoke it. Pass the given event to the function and return
@@ -176,37 +216,8 @@ def invoke(
             When we cannot find a function with the given name
         """
         # Get the function configuration
-        function = self.get_function(function_identifier)
-
-        LOG.debug("Found one Lambda function with name '%s'", function_identifier)
-        if function.packagetype == ZIP:
-            if function.inlinecode:
-                raise UnsupportedInlineCodeError(
-                    "Inline code is not supported for sam local commands."
-                    f" Please write your code in a separate file for the function {function.function_id}."
-                )
-            LOG.info("Invoking %s (%s)", function.handler, function.runtime)
-        elif function.packagetype == IMAGE:
-            if not function.imageuri:
-                raise InvalidIntermediateImageError(
-                    f"ImageUri not provided for Function: {function_identifier} of PackageType: {function.packagetype}"
-                )
-            LOG.info("Invoking Container created from %s", function.imageuri)
-
-        validate_architecture_runtime(function)
-
-        # Validate tenant-id for multi-tenant functions
-        if function.tenancy_config and isinstance(function.tenancy_config, dict):
-            if not tenant_id:
-                raise TenantIdValidationError(
-                    "The invoked function is enabled with tenancy configuration. "
-                    "Add a valid tenant ID in your request and try again."
-                )
-        elif tenant_id:
-            raise TenantIdValidationError(
-                "The invoked function is not enabled with tenancy configuration. "
-                "Remove the tenant ID from your request and try again."
-            )
+        if not function:
+            function = self.get_function(function_identifier, tenant_id)
 
         config = self.get_invoke_config(function, override_runtime)
 

samcli/local/lambda_service/local_lambda_http_service.py

@@ -12,7 +12,12 @@
 from werkzeug.routing import BaseConverter
 
 from samcli.commands.local.cli_common.durable_context import DurableContext
-from samcli.commands.local.lib.exceptions import TenantIdValidationError, UnsupportedInlineCodeError
+from samcli.commands.local.lib.exceptions import (
+    TenantIdValidationError,
+    UnsupportedInlineCodeError,
+    InvalidIntermediateImageError,
+)
+from samcli.lib.providers.provider import Function
 from samcli.lib.utils.invocation_type import EVENT
 from samcli.lib.utils.name_utils import InvalidFunctionNameException, normalize_sam_function_identifier
 from samcli.lib.utils.stream_writer import StreamWriter
@@ -244,42 +249,41 @@ def _invoke_request_handler(self, function_name):
         # Extract durable execution name from headers
         durable_execution_name = flask_request.headers.get("X-Amz-Durable-Execution-Name")
 
+        headers = {"Content-Type": "application/json"}
+
+        try:
+            function = self.lambda_runner.get_function(function_name, tenant_id)
+        except (InvalidFunctionNameException, TenantIdValidationError, InvalidIntermediateImageError) as e:
+            LOG.error("Validation error: %s", str(e))
+            return LambdaErrorResponses.validation_exception(str(e))
+        except FunctionNotFound:
+            normalized_function_name = normalize_sam_function_identifier(function_name)
+            LOG.debug("%s was not found to invoke.", normalized_function_name)
+            return LambdaErrorResponses.resource_not_found(normalized_function_name)
+        except UnsupportedInlineCodeError:
+            return LambdaErrorResponses.not_implemented_locally(
+                "Inline code is not supported for sam local commands. Please write your code in a separate file."
+            )
+
         arguments = {
             "function_name": function_name,
             "request_data": request_data,
             "invocation_type": invocation_type,
             "durable_execution_name": durable_execution_name,
             "tenant_id": tenant_id,
+            "function": function,
         }
 
-        headers = {"Content-Type": "application/json"}
-
         if invocation_type == EVENT:
-            # Validate function exists before submitting async task
-            if validation_error := self._validate_function_for_invocation(function_name):
-                return validation_error
-
-            # LocalLambdaService is blocking, so threads used by ThreadPoolExecutor
-            # will be cleaned up when Python exits by the ThreadPoolExecutor implementation
             self.executor.submit(self._invoke_async_lambda, **arguments)
             return self.service_response("", headers, 202)
-
         try:
             invoke_headers, stdout_stream_string, stdout_stream_bytes = self._invoke_lambda(**arguments)
-        except (InvalidFunctionNameException, TenantIdValidationError) as e:
-            LOG.error("Validation error: %s", str(e))
-            return LambdaErrorResponses.validation_exception(str(e))
         except UnsupportedInvocationType as e:
             LOG.warning(
-                "invocation-type: %s is not supported. Event and RequestResponse are only supported.", invocation_type
+                "invocation-type: %s is not supported. Only Event and RequestResponse are supported.", invocation_type
             )
             return LambdaErrorResponses.not_implemented_locally(str(e))
-        except FunctionNotFound:
-            return self._handle_function_not_found(function_name)
-        except UnsupportedInlineCodeError:
-            return LambdaErrorResponses.not_implemented_locally(
-                "Inline code is not supported for sam local commands. Please write your code in a separate file."
-            )
         except DockerContainerCreationFailedException as ex:
             return LambdaErrorResponses.container_creation_failed(ex.message)
 
@@ -296,47 +300,6 @@ def _invoke_request_handler(self, function_name):
 
         return self.service_response(lambda_response, headers, 200)
 
-    def _validate_function_for_invocation(self, function_name: str) -> Optional[Response]:
-        """
-        Validates that a function exists and can be invoked.
-
-        Parameters
-        ----------
-        function_name : str
-            Name or ARN of the function to validate
-
-        Returns
-        -------
-        Flask.Response or None
-            Error response if validation fails, None if validation succeeds
-        """
-        try:
-            self.lambda_runner.get_function(function_name)
-            return None
-        except FunctionNotFound:
-            return self._handle_function_not_found(function_name)
-        except InvalidFunctionNameException as e:
-            LOG.error("Validation error: %s", str(e))
-            return LambdaErrorResponses.validation_exception(str(e))
-
-    def _handle_function_not_found(self, function_name: str) -> Response:
-        """
-        Handles FunctionNotFound exception by returning appropriate error response.
-
-        Parameters
-        ----------
-        function_name : str
-            Name or ARN of the function that was not found
-
-        Returns
-        -------
-        Flask.Response
-            Error response for function not found
-        """
-        normalized_function_name = normalize_sam_function_identifier(function_name)
-        LOG.debug("%s was not found to invoke.", normalized_function_name)
-        return LambdaErrorResponses.resource_not_found(normalized_function_name)
-
     def _invoke_async_lambda(self, function_name: str, **kwargs) -> None:
         """
         Wrapper for _invoke_lambda that runs in an async context (Event invocation type)
@@ -353,6 +316,7 @@ def _invoke_lambda(
         invocation_type: str,
         durable_execution_name: Optional[str],
         tenant_id: Optional[str],
+        function: Optional[Function],
     ) -> Tuple[Optional[Dict[str, str]], io.StringIO, io.BytesIO]:
         """
         Invokes a Lambda function and returns the result
@@ -370,6 +334,7 @@ def _invoke_lambda(
             invocation_type=invocation_type,
             durable_execution_name=durable_execution_name,
             tenant_id=tenant_id,
+            function=function,
             stdout=stdout_stream_writer,
             stderr=self.stderr,
         )

samcli/local/lambdafn/runtime.py

@@ -309,7 +309,7 @@ def invoke(
                 if invocation_type not in [EVENT, REQUEST_RESPONSE]:
                     raise UnsupportedInvocationType(
                         f"invocation-type: {invocation_type} is not supported. "
-                        "Event and RequestResponse are only supported."
+                        "Only Event and RequestResponse are supported."
                     )
 
                 # The container handles concurrency control internally via its semaphore.