localstack-core 4.10.1.dev42__py3-none-any.whl → 4.12.1.dev18__py3-none-any.whl

localstack/services/lambda_/invocation/lambda_service.py

@@ -5,6 +5,7 @@ import io
 import logging
 import os.path
 import random
+import time
 import uuid
 from concurrent.futures import Executor, Future, ThreadPoolExecutor
 from datetime import datetime
@@ -19,6 +20,7 @@ from localstack.aws.api.lambda_ import (
     InvalidRequestContentException,
     InvocationType,
     LastUpdateStatus,
+    NoPublishedVersionException,
     ResourceConflictException,
     ResourceNotFoundException,
     State,
@@ -27,6 +29,7 @@ from localstack.aws.connect import connect_to
 from localstack.constants import AWS_REGION_US_EAST_1
 from localstack.services.lambda_ import hooks as lambda_hooks
 from localstack.services.lambda_.analytics import (
+    FunctionInitializationType,
     FunctionOperation,
     FunctionStatus,
     function_counter,
@@ -190,6 +193,9 @@ class LambdaService:
             lambda_hooks.create_function_version.run(function_version.qualified_arn)
         return self.task_executor.submit(self._start_lambda_version, version_manager)
 
+    def publish_version_async(self, function_version: FunctionVersion):
+        self.task_executor.submit(self.publish_version, function_version)
+
     def publish_version(self, function_version: FunctionVersion):
         """
         Synchronously create a function version (manager)
@@ -200,6 +206,14 @@ class LambdaService:
 
         :param function_version: Function Version to create
         """
+        # HACK: trying to match the AWS timing behavior of Lambda Managed Instances for the operation
+        # publish_version followed by get_function because transitioning LastUpdateStatus from InProgress to
+        # Successful happens too fast on LocalStack (thanks to caching in prepare_version).
+        # Without this hack, test_latest_published_update_config fails at get_function_response_postpublish
+        # and test_lifecycle_invoke is flaky, sometimes not triggering the ResourceConflictException
+        # Increasing this sleep too much (e.g., 10s) shouldn't cause any side effects apart from slow responsiveness
+        if function_version.config.CapacityProviderConfig:
+            time.sleep(0.1)
         with self.lambda_version_manager_lock:
             qualified_arn = function_version.id.qualified_arn()
             version_manager = self.lambda_starting_versions.get(qualified_arn)
@@ -225,7 +239,7 @@ class LambdaService:
     def invoke(
         self,
         function_name: str,
-        qualifier: str,
+        qualifier: str | None,
         region: str,
         account_id: str,
         invocation_type: InvocationType | None,
@@ -258,13 +272,27 @@ class LambdaService:
             account=account_id,
             region=region,
         )
-        qualifier = qualifier or "$LATEST"
         state = lambda_stores[account_id][region]
         function = state.functions.get(function_name)
 
         if function is None:
+            if not qualifier:
+                invoked_arn += ":$LATEST"
             raise ResourceNotFoundException(f"Function not found: {invoked_arn}", Type="User")
 
+        # A provided qualifier always takes precedence, but the default depends on whether $LATEST.PUBLISHED exists
+        version_latest_published = function.versions.get("$LATEST.PUBLISHED")
+        if version_latest_published:
+            qualifier = qualifier or "$LATEST.PUBLISHED"
+            invoked_arn = lambda_arn(
+                function_name=function_name,
+                qualifier=qualifier,
+                account=account_id,
+                region=region,
+            )
+        else:
+            qualifier = qualifier or "$LATEST"
+
         if qualifier_is_alias(qualifier):
             alias = function.aliases.get(qualifier)
             if not alias:
@@ -282,8 +310,27 @@ class LambdaService:
         # Need the qualified arn to exactly get the target lambda
         qualified_arn = qualified_lambda_arn(function_name, version_qualifier, account_id, region)
         version = function.versions.get(version_qualifier)
+        if version is None:
+            raise ResourceNotFoundException(f"Function not found: {invoked_arn}", Type="User")
         runtime = version.config.runtime or "n/a"
         package_type = version.config.package_type
+        # Not considering provisioned concurrency for such early errors
+        initialization_type = (
+            FunctionInitializationType.lambda_managed_instances
+            if version.config.CapacityProviderConfig
+            else FunctionInitializationType.on_demand
+        )
+        if version.config.CapacityProviderConfig and qualifier == "$LATEST":
+            if function.versions.get("$LATEST.PUBLISHED"):
+                raise InvalidParameterValueException(
+                    "Functions configured with capacity provider configuration can't be invoked with $LATEST qualifier. To invoke this function, specify a published version qualifier or $LATEST.PUBLISHED.",
+                    Type="User",
+                )
+            else:
+                raise NoPublishedVersionException(
+                    "The function can't be invoked because no published version exists. For functions with capacity provider configuration, either publish a version to $LATEST.PUBLISHED, or specify a published version qualifier.",
+                    Type="User",
+                )
         try:
             version_manager = self.get_lambda_version_manager(qualified_arn)
             event_manager = self.get_lambda_event_manager(qualified_arn)
@@ -315,6 +362,7 @@ class LambdaService:
                 status=status,
                 invocation_type=invocation_type,
                 package_type=package_type,
+                initialization_type=initialization_type,
             ).increment()
             raise ResourceConflictException(
                 f"The operation cannot be performed at this time. The function is currently in the following state: {state}"
@@ -333,6 +381,7 @@ class LambdaService:
                     status=FunctionStatus.invalid_payload_error,
                     invocation_type=invocation_type,
                     package_type=package_type,
+                    initialization_type=initialization_type,
                 ).increment()
                 # MAYBE: improve parity of detailed exception message (quite cumbersome)
                 raise InvalidRequestContentException(
@@ -377,12 +426,14 @@ class LambdaService:
             if invocation_result.is_error
             else FunctionStatus.success
         )
+        # TODO: handle initialization_type provisioned-concurrency, requires enriching invocation_result
         function_counter.labels(
             operation=FunctionOperation.invoke,
             runtime=runtime,
             status=status,
             invocation_type=invocation_type,
             package_type=package_type,
+            initialization_type=initialization_type,
         ).increment()
         return invocation_result
 
@@ -393,7 +444,10 @@ class LambdaService:
 
         :param new_version: New version (with the same qualifier as an older one)
         """
-        if new_version.qualified_arn not in self.lambda_running_versions:
+        if (
+            new_version.qualified_arn not in self.lambda_running_versions
+            and not new_version.config.CapacityProviderConfig
+        ):
             raise ValueError(
                 f"Version {new_version.qualified_arn} cannot be updated if an old one is not running"
             )
@@ -437,6 +491,11 @@ class LambdaService:
                 elif new_state.state == State.Failed:
                     update_status = UpdateStatus(status=LastUpdateStatus.Failed)
                     self.task_executor.submit(new_version_manager.stop)
+                elif (
+                    new_state.state == State.ActiveNonInvocable
+                    and function_version.config.CapacityProviderConfig
+                ):
+                    update_status = UpdateStatus(status=LastUpdateStatus.Successful)
                 else:
                     # TODO what to do if state pending or inactive is supported?
                     self.task_executor.submit(new_version_manager.stop)

localstack/services/lambda_/invocation/models.py

@@ -1,5 +1,10 @@
 from localstack.aws.api.lambda_ import EventSourceMappingConfiguration
-from localstack.services.lambda_.invocation.lambda_models import CodeSigningConfig, Function, Layer
+from localstack.services.lambda_.invocation.lambda_models import (
+    CapacityProvider,
+    CodeSigningConfig,
+    Function,
+    Layer,
+)
 from localstack.services.stores import AccountRegionBundle, BaseStore, LocalAttribute
 from localstack.utils.tagging import TaggingService
 
@@ -17,6 +22,9 @@ class LambdaStore(BaseStore):
     # maps layer names to Layers
     layers: dict[str, Layer] = LocalAttribute(default=dict)
 
+    # maps capacity provider names to respective CapacityProvider
+    capacity_providers: dict[str, CapacityProvider] = LocalAttribute(default=dict)
+
     # maps resource ARNs for EventSourceMappings and CodeSigningConfiguration to tags
     TAGS = LocalAttribute(default=TaggingService)
 

localstack/services/lambda_/invocation/version_manager.py

@@ -100,11 +100,26 @@ class LambdaVersionManager:
 
             # code and reason not set for success scenario because only failed states provide this field:
             # https://docs.aws.amazon.com/lambda/latest/dg/API_GetFunctionConfiguration.html#SSS-GetFunctionConfiguration-response-LastUpdateStatusReasonCode
-            self.state = VersionState(state=State.Active)
+            new_state = State.Active
+            if (
+                self.function_version.config.CapacityProviderConfig
+                and self.function_version.id.qualifier == "$LATEST"
+            ):
+                new_state = State.ActiveNonInvocable
+                # HACK: trying to match the AWS timing behavior of Lambda Managed Instances for the operation
+                # update_function_configuration followed by get_function because transitioning LastUpdateStatus from
+                # InProgress to Successful happens too fast on LocalStack (thanks to caching in prepare_version).
+                # Without this hack, test_latest_published_update_config fails at get_function_response_postupdate_latest
+                # TODO: this sleep has side-effects and we should be looking into alternatives
+                # Increasing this sleep too much (e.g., 3s) could cause the side effect that a created function is not
+                # ready for updates (i.e., rejected with a ResourceConflictException) and failing other tests
+                # time.sleep(0.1)
+            self.state = VersionState(state=new_state)
             LOG.debug(
-                "Changing Lambda %s (id %s) to active",
+                "Changing Lambda %s (id %s) to %s",
                 self.function_arn,
                 self.function_version.config.internal_revision,
+                new_state,
             )
         except Exception as e:
             self.state = VersionState(
@@ -113,7 +128,7 @@ class LambdaVersionManager:
                 reason=f"Error while creating lambda: {e}",
             )
             LOG.debug(
-                "Changing Lambda %s (id %s) to failed. Reason: %s",
+                "Changing Lambda %s (id %s) to Failed. Reason: %s",
                 self.function_arn,
                 self.function_version.config.internal_revision,
                 e,