localstack-core 4.11.2.dev14__py3-none-any.whl → 4.12.1.dev18__py3-none-any.whl

localstack/services/cloudformation/v2/provider.py

@@ -103,6 +103,9 @@ from localstack.services.cloudformation.engine.v2.change_set_model_transform imp
 from localstack.services.cloudformation.engine.v2.change_set_model_validator import (
     ChangeSetModelValidator,
 )
+from localstack.services.cloudformation.engine.v2.change_set_resource_support_checker import (
+    ChangeSetResourceSupportChecker,
+)
 from localstack.services.cloudformation.engine.validations import ValidationError
 from localstack.services.cloudformation.provider import (
     ARN_CHANGESET_REGEX,
@@ -222,6 +225,12 @@ def find_stack_instance(stack_set: StackSet, account: str, region: str) -> Stack
 
 class CloudformationProviderV2(CloudformationProvider, ServiceLifecycleHook):
     def on_before_start(self):
+        # TODO: make sure to bring `_validate_config` from the base class when removing it
+        # as this ensures we have a valid CFN_NO_WAIT_ITERATIONS value
+        super().on_before_start()
+        self._log_create_issue_info()
+
+    def _log_create_issue_info(self):
         base = "https://github.com/localstack/localstack/issues/new"
         query_args = {
             "template": "bug-report.yml",
@@ -417,6 +426,38 @@ class CloudformationProviderV2(CloudformationProvider, ServiceLifecycleHook):
                 update_model.node_template.change_type = ChangeType.MODIFIED
         change_set.processed_template = transformed_after_template
 
+        if not config.CFN_IGNORE_UNSUPPORTED_RESOURCE_TYPES:
+            support_visitor = ChangeSetResourceSupportChecker()
+            support_visitor.visit(change_set.update_model.node_template)
+            failure_messages = support_visitor.failure_messages
+            if failure_messages:
+                reason_suffix = ", ".join(failure_messages)
+                status_reason = f"{ChangeSetResourceSupportChecker.TITLE_MESSAGE} {reason_suffix}"
+
+                change_set.status_reason = status_reason
+                change_set.set_change_set_status(ChangeSetStatus.FAILED)
+                failure_transitions = {
+                    ChangeSetType.CREATE: (
+                        StackStatus.ROLLBACK_IN_PROGRESS,
+                        StackStatus.CREATE_FAILED,
+                    ),
+                    ChangeSetType.UPDATE: (
+                        StackStatus.UPDATE_ROLLBACK_IN_PROGRESS,
+                        StackStatus.UPDATE_ROLLBACK_FAILED,
+                    ),
+                    ChangeSetType.IMPORT: (
+                        StackStatus.IMPORT_ROLLBACK_IN_PROGRESS,
+                        StackStatus.IMPORT_ROLLBACK_FAILED,
+                    ),
+                }
+                transitions = failure_transitions.get(change_set.change_set_type)
+                if transitions:
+                    first_status, *remaining_statuses = transitions
+                    change_set.stack.set_stack_status(first_status, status_reason)
+                    for status in remaining_statuses:
+                        change_set.stack.set_stack_status(status)
+                return
+
     @handler("CreateChangeSet", expand=False)
     def create_change_set(
         self, context: RequestContext, request: CreateChangeSetInput

localstack/services/kinesis/packages.py

@@ -7,7 +7,7 @@ from localstack.packages import InstallTarget, Package
 from localstack.packages.core import GitHubReleaseInstaller, NodePackageInstaller
 from localstack.packages.java import JavaInstallerMixin, java_package
 
-_KINESIS_MOCK_VERSION = os.environ.get("KINESIS_MOCK_VERSION") or "0.5.1"
+_KINESIS_MOCK_VERSION = os.environ.get("KINESIS_MOCK_VERSION") or "0.5.2"
 
 
 class KinesisMockEngine(StrEnum):

localstack/services/kms/models.py

@@ -232,7 +232,10 @@ class KmsCryptoKey:
 
         if key_spec.startswith("RSA"):
             key_size = RSA_CRYPTO_KEY_LENGTHS.get(key_spec)
-            key = rsa.generate_private_key(public_exponent=65537, key_size=key_size)
+            if key_material:
+                key = crypto_serialization.load_der_private_key(key_material, password=None)
+            else:
+                key = rsa.generate_private_key(public_exponent=65537, key_size=key_size)
         elif key_spec.startswith("ECC"):
             curve = ECC_CURVES.get(key_spec)
             if key_material:
@@ -636,7 +639,8 @@ class KmsKey:
         # https://docs.aws.amazon.com/kms/latest/APIReference/API_TagResource.html
         # "To edit a tag, specify an existing tag key and a new tag value."
         for i, tag in enumerate(tags, start=1):
-            validate_tag(i, tag)
+            if tag.get("TagKey") != TAG_KEY_CUSTOM_KEY_MATERIAL:
+                validate_tag(i, tag)
             self.tags[tag.get("TagKey")] = tag.get("TagValue")
 
     def schedule_key_deletion(self, pending_window_in_days: int) -> None:

localstack/services/lambda_/analytics.py

@@ -14,9 +14,10 @@ function_counter = LabeledCounter(
         "status",
         "runtime",
         "package_type",
-        # only for operation "invoke"
-        "invocation_type",
+        "invocation_type",  # only for operation "invoke", otherwise "n/a"
+        "initialization_type",
     ],
+    schema_version=2,
 )
 
 
@@ -38,6 +39,14 @@ class FunctionStatus(StrEnum):
     invocation_error = "invocation_error"
 
 
+class FunctionInitializationType(StrEnum):
+    # Maps to the Lambda environment variable AWS_LAMBDA_INITIALIZATION_TYPE
+    on_demand = "on-demand"
+    lambda_managed_instances = "lambda-managed-instances"
+    # Only applies to the operation "invoke" because provisioned concurrency is not configured on "create"
+    provisioned_concurrency = "provisioned-concurrency"
+
+
 esm_counter = LabeledCounter(namespace=NAMESPACE, name="esm", labels=["source", "status"])
 
 

localstack/services/lambda_/invocation/event_manager.py

@@ -13,6 +13,7 @@ from botocore.config import Config
 from localstack import config
 from localstack.aws.api.lambda_ import InvocationType, TooManyRequestsException
 from localstack.services.lambda_.analytics import (
+    FunctionInitializationType,
     FunctionOperation,
     FunctionStatus,
     function_counter,
@@ -198,22 +199,22 @@ class Poller:
     def handle_message(self, message: dict) -> None:
         failure_cause = None
         qualifier = self.version_manager.function_version.id.qualifier
+        function_config = self.version_manager.function_version.config
         event_invoke_config = self.version_manager.function.event_invoke_configs.get(qualifier)
         runtime = None
         status = None
+        # TODO: handle initialization_type provisioned-concurrency, which requires enriching invocation_result
+        initialization_type = (
+            FunctionInitializationType.lambda_managed_instances
+            if function_config.CapacityProviderConfig
+            else FunctionInitializationType.on_demand
+        )
         try:
             sqs_invocation = SQSInvocation.decode(message["Body"])
             invocation = sqs_invocation.invocation
             try:
                 invocation_result = self.version_manager.invoke(invocation=invocation)
-                function_config = self.version_manager.function_version.config
-                function_counter.labels(
-                    operation=FunctionOperation.invoke,
-                    runtime=function_config.runtime or "n/a",
-                    status=FunctionStatus.success,
-                    invocation_type=InvocationType.Event,
-                    package_type=function_config.package_type,
-                ).increment()
+                status = FunctionStatus.success
             except Exception as e:
                 # Reserved concurrency == 0
                 if self.version_manager.function.reserved_concurrent_executions == 0:
@@ -223,6 +224,7 @@ class Poller:
                 elif not has_enough_time_for_retry(sqs_invocation, event_invoke_config):
                     failure_cause = "EventAgeExceeded"
                     status = FunctionStatus.event_age_exceeded_error
+
                 if failure_cause:
                     invocation_result = InvocationResult(
                         is_error=True, request_id=invocation.request_id, payload=None, logs=None
@@ -240,14 +242,14 @@ class Poller:
                 sqs_client.delete_message(
                     QueueUrl=self.event_queue_url, ReceiptHandle=message["ReceiptHandle"]
                 )
-                # status MUST be set before returning
-                package_type = self.version_manager.function_version.config.package_type
+                assert status, "status MUST be set before returning"
                 function_counter.labels(
                     operation=FunctionOperation.invoke,
                     runtime=runtime or "n/a",
                     status=status,
                     invocation_type=InvocationType.Event,
-                    package_type=package_type,
+                    package_type=function_config.package_type,
+                    initialization_type=initialization_type,
                 ).increment()
 
             # Good summary blogpost: https://haithai91.medium.com/aws-lambdas-retry-behaviors-edff90e1cf1b
@@ -257,6 +259,8 @@ class Poller:
             if event_invoke_config and event_invoke_config.maximum_retry_attempts is not None:
                 max_retry_attempts = event_invoke_config.maximum_retry_attempts
 
+            assert invocation_result, "Invocation result MUST exist if we are not returning before"
+
             # An invocation error either leads to a terminal failure or to a scheduled retry
             if invocation_result.is_error:  # invocation error
                 failure_cause = None

localstack/services/lambda_/invocation/lambda_models.py

@@ -30,6 +30,7 @@ from localstack.aws.api.lambda_ import (
     CodeSigningPolicies,
     Cors,
     DestinationConfig,
+    FunctionScalingConfig,
     FunctionUrlAuthType,
     InstanceRequirements,
     InvocationType,
@@ -625,6 +626,9 @@ class Function:
     provisioned_concurrency_configs: dict[str, ProvisionedConcurrencyConfiguration] = (
         dataclasses.field(default_factory=dict)
     )
+    function_scaling_configs: dict[str, FunctionScalingConfig] = dataclasses.field(
+        default_factory=dict
+    )
 
     lock: threading.RLock = dataclasses.field(default_factory=threading.RLock)
     next_version: int = 1

localstack/services/lambda_/invocation/lambda_service.py

@@ -29,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,
@@ -313,6 +314,12 @@ class LambdaService:
             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(
@@ -355,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}"
@@ -373,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(
@@ -417,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
 

localstack/services/lambda_/provider.py

@@ -43,6 +43,7 @@ from localstack.aws.api.lambda_ import (
     DeleteFunctionResponse,
     Description,
     DestinationConfig,
+    DurableExecutionName,
     EventSourceMappingConfiguration,
     FunctionCodeLocation,
     FunctionConfiguration,
@@ -157,6 +158,7 @@ from localstack.services.edge import ROUTER
 from localstack.services.lambda_ import api_utils
 from localstack.services.lambda_ import hooks as lambda_hooks
 from localstack.services.lambda_.analytics import (
+    FunctionInitializationType,
     FunctionOperation,
     FunctionStatus,
     function_counter,
@@ -255,6 +257,7 @@ from localstack.utils.urls import localstack_host
 
 LOG = logging.getLogger(__name__)
 
+CAPACITY_PROVIDER_ARN_NAME = "arn:aws[a-zA-Z-]*:lambda:(eusc-)?[a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:\\d{12}:capacity-provider:[a-zA-Z0-9-_]+"
 LAMBDA_DEFAULT_TIMEOUT = 3
 LAMBDA_DEFAULT_MEMORY_SIZE = 128
 
@@ -304,20 +307,26 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             for region_name, state in account_bundle.items():
                 for fn in state.functions.values():
                     for fn_version in fn.versions.values():
-                        # restore the "Pending" state for every function version and start it
                         try:
-                            new_state = VersionState(
-                                state=State.Pending,
-                                code=StateReasonCode.Creating,
-                                reason="The function is being created.",
-                            )
-                            new_config = dataclasses.replace(fn_version.config, state=new_state)
-                            new_version = dataclasses.replace(fn_version, config=new_config)
-                            fn.versions[fn_version.id.qualifier] = new_version
-                            # TODO: consider skipping this for $LATEST versions of functions with a capacity provider
-                            self.lambda_service.create_function_version(fn_version).result(
-                                timeout=5
+                            # $LATEST is not invokable for Lambda functions with a capacity provider
+                            # and has a different State (i.e., ActiveNonInvokable)
+                            is_capacity_provider_latest = (
+                                fn_version.config.CapacityProviderConfig
+                                and fn_version.id.qualifier == "$LATEST"
                             )
+                            if not is_capacity_provider_latest:
+                                # Restore the "Pending" state for the function version and start it
+                                new_state = VersionState(
+                                    state=State.Pending,
+                                    code=StateReasonCode.Creating,
+                                    reason="The function is being created.",
+                                )
+                                new_config = dataclasses.replace(fn_version.config, state=new_state)
+                                new_version = dataclasses.replace(fn_version, config=new_config)
+                                fn.versions[fn_version.id.qualifier] = new_version
+                                self.lambda_service.create_function_version(fn_version).result(
+                                    timeout=5
+                                )
                         except Exception:
                             LOG.warning(
                                 "Failed to restore function version %s",
@@ -853,6 +862,30 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 )
             visited_layers[layer_arn] = layer_version_arn
 
+    def _validate_capacity_provider_config(
+        self, capacity_provider_config: CapacityProviderConfig, context: RequestContext
+    ):
+        if not capacity_provider_config.get("LambdaManagedInstancesCapacityProviderConfig"):
+            raise ValidationException(
+                "1 validation error detected: Value null at 'capacityProviderConfig.lambdaManagedInstancesCapacityProviderConfig' failed to satisfy constraint: Member must not be null"
+            )
+
+        capacity_provider_arn = capacity_provider_config.get(
+            "LambdaManagedInstancesCapacityProviderConfig", {}
+        ).get("CapacityProviderArn")
+        if not capacity_provider_arn:
+            raise ValidationException(
+                "1 validation error detected: Value null at 'capacityProviderConfig.lambdaManagedInstancesCapacityProviderConfig.capacityProviderArn' failed to satisfy constraint: Member must not be null"
+            )
+
+        if not re.match(CAPACITY_PROVIDER_ARN_NAME, capacity_provider_arn):
+            raise ValidationException(
+                f"1 validation error detected: Value '{capacity_provider_arn}' at 'capacityProviderConfig.lambdaManagedInstancesCapacityProviderConfig.capacityProviderArn' failed to satisfy constraint: Member must satisfy regular expression pattern: {CAPACITY_PROVIDER_ARN_NAME}"
+            )
+
+        capacity_provider_name = capacity_provider_arn.split(":")[-1]
+        self.get_capacity_provider(context, capacity_provider_name)
+
     @staticmethod
     def map_layers(new_layers: list[str]) -> list[LayerVersion]:
         layers = []
@@ -1029,11 +1062,12 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 # Runtime management controls are not available when providing a custom image
                 runtime_version_config = None
 
-            # TODO: validations and figure out in which order
             capacity_provider_config = None
             memory_size = request.get("MemorySize", LAMBDA_DEFAULT_MEMORY_SIZE)
             if "CapacityProviderConfig" in request:
                 capacity_provider_config = request["CapacityProviderConfig"]
+                self._validate_capacity_provider_config(capacity_provider_config, context)
+
                 default_config = CapacityProviderConfig(
                     LambdaManagedInstancesCapacityProviderConfig=LambdaManagedInstancesCapacityProviderConfig(
                         ExecutionEnvironmentMemoryGiBPerVCpu=2.0,
@@ -1142,12 +1176,18 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                 )
             fn.versions["$LATEST"] = version_post_response or version
             state.functions[function_name] = fn
+        initialization_type = (
+            FunctionInitializationType.lambda_managed_instances
+            if capacity_provider_config
+            else FunctionInitializationType.on_demand
+        )
         function_counter.labels(
             operation=FunctionOperation.create,
             runtime=runtime or "n/a",
             status=FunctionStatus.success,
             invocation_type="n/a",
             package_type=package_type,
+            initialization_type=initialization_type,
         )
         # TODO: consider potential other side effects of not having a function version for $LATEST
         # Provisioning happens upon publishing for functions using a capacity provider
@@ -1363,6 +1403,19 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
             if new_mode:
                 replace_kwargs["tracing_config_mode"] = new_mode
 
+        if "CapacityProviderConfig" in request:
+            if latest_version.config.CapacityProviderConfig and not request[
+                "CapacityProviderConfig"
+            ].get("LambdaManagedInstancesCapacityProviderConfig"):
+                raise ValidationException(
+                    "1 validation error detected: Value null at 'capacityProviderConfig.lambdaManagedInstancesCapacityProviderConfig' failed to satisfy constraint: Member must not be null"
+                )
+            if not latest_version.config.CapacityProviderConfig:
+                raise InvalidParameterValueException(
+                    "CapacityProviderConfig isn't supported for Lambda Default functions.",
+                    Type="User",
+                )
+
         new_latest_version = dataclasses.replace(
             latest_version,
             config=dataclasses.replace(
@@ -1701,6 +1754,7 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
         invocation_type: InvocationType | None = None,
         log_type: LogType | None = None,
         client_context: String | None = None,
+        durable_execution_name: DurableExecutionName | None = None,
         payload: IO[Blob] | None = None,
         qualifier: NumericLatestPublishedOrAliasQualifier | None = None,
         tenant_id: TenantId | None = None,
@@ -2210,6 +2264,9 @@ class LambdaProvider(LambdaApi, ServiceLifecycleHook):
                     raise Exception("unknown version")  # TODO: cover via test
             elif qualifier == "$LATEST":
                 pass
+            elif qualifier == "$LATEST.PUBLISHED":
+                if fn.versions.get(qualifier):
+                    pass
             else:
                 raise Exception("invalid functionname")  # TODO: cover via test
             fn_arn = api_utils.qualified_lambda_arn(function_name, qualifier, account, region)

localstack/services/opensearch/packages.py

@@ -107,19 +107,31 @@ class OpensearchPackageInstaller(PackageInstaller):
                 # setup security based on the version
                 self._setup_security(install_dir, parsed_version)
 
+                # Determine network configuration to use for plugin downloads
+                sys_props = {
+                    **java_system_properties_proxy(),
+                    **java_system_properties_ssl(
+                        os.path.join(install_dir, "jdk", "bin", "keytool"),
+                        {"JAVA_HOME": os.path.join(install_dir, "jdk")},
+                    ),
+                }
+                java_opts = system_properties_to_cli_args(sys_props)
+
+                keystore_binary = os.path.join(install_dir, "bin", "opensearch-keystore")
+                if os.path.exists(keystore_binary):
+                    # initialize and create the keystore. Concurrent starts of ES will all try to create it at the same
+                    # time, and fail with a race condition. Creating once when installing solves the issue without
+                    # the need to lock the starts
+                    # Ultimately, each cluster should have its own `config` file and maybe not share the same one
+                    output = run(
+                        [keystore_binary, "create"],
+                        env_vars={"OPENSEARCH_JAVA_OPTS": " ".join(java_opts)},
+                    )
+                    LOG.debug("Keystore init output: %s", output)
+
                 # install other default plugins for opensearch 1.1+
                 # https://forum.opensearch.org/t/ingest-attachment-cannot-be-installed/6494/12
                 if parsed_version >= "1.1.0":
-                    # Determine network configuration to use for plugin downloads
-                    sys_props = {
-                        **java_system_properties_proxy(),
-                        **java_system_properties_ssl(
-                            os.path.join(install_dir, "jdk", "bin", "keytool"),
-                            {"JAVA_HOME": os.path.join(install_dir, "jdk")},
-                        ),
-                    }
-                    java_opts = system_properties_to_cli_args(sys_props)
-
                     for plugin in OPENSEARCH_PLUGIN_LIST:
                         plugin_binary = os.path.join(install_dir, "bin", "opensearch-plugin")
                         plugin_dir = os.path.join(install_dir, "plugins", plugin)
@@ -322,6 +334,18 @@ class ElasticsearchPackageInstaller(PackageInstaller):
                         if not os.environ.get("IGNORE_ES_DOWNLOAD_ERRORS"):
                             raise
 
+            keystore_binary = os.path.join(install_dir, "bin", "elasticsearch-keystore")
+            if os.path.exists(keystore_binary):
+                # initialize and create the keystore. Concurrent starts of ES will all try to create it at the same
+                # time, and fail with a race condition. Creating once when installing solves the issue without
+                # the need to lock the starts
+                # Ultimately, each cluster should have its own `config` file and maybe not share the same one
+                output = run(
+                    [keystore_binary, "create"],
+                    env_vars={"ES_JAVA_OPTS": " ".join(java_opts)},
+                )
+                LOG.debug("Keystore init output: %s", output)
+
         # delete some plugins to free up space
         for plugin in ELASTICSEARCH_DELETE_MODULES:
             module_dir = os.path.join(install_dir, "modules", plugin)
@@ -341,16 +365,6 @@ class ElasticsearchPackageInstaller(PackageInstaller):
             if jvm_options != jvm_options_replaced:
                 save_file(jvm_options_file, jvm_options_replaced)
 
-        # patch JVM options file - replace hardcoded heap size settings
-        jvm_options_file = os.path.join(install_dir, "config", "jvm.options")
-        if os.path.exists(jvm_options_file):
-            jvm_options = load_file(jvm_options_file)
-            jvm_options_replaced = re.sub(
-                r"(^-Xm[sx][a-zA-Z0-9.]+$)", r"# \1", jvm_options, flags=re.MULTILINE
-            )
-            if jvm_options != jvm_options_replaced:
-                save_file(jvm_options_file, jvm_options_replaced)
-
     def _get_install_marker_path(self, install_dir: str) -> str:
         return os.path.join(install_dir, "bin", "elasticsearch")
 

localstack/services/route53/provider.py

@@ -26,9 +26,16 @@ from localstack.aws.api.route53 import (
 from localstack.aws.connect import connect_to
 from localstack.services.moto import call_moto
 from localstack.services.plugins import ServiceLifecycleHook
+from localstack.state import StateVisitor
 
 
 class Route53Provider(Route53Api, ServiceLifecycleHook):
+    def accept_state_visitor(self, visitor: StateVisitor):
+        from localstack.services.route53.models import route53_stores
+
+        visitor.visit(route53_backends)
+        visitor.visit(route53_stores)
+
     def create_hosted_zone(
         self,
         context: RequestContext,

localstack/services/route53resolver/provider.py

@@ -100,6 +100,7 @@ from localstack.services.route53resolver.utils import (
     validate_mutation_protection,
     validate_priority,
 )
+from localstack.state import StateVisitor
 from localstack.utils.aws import arns
 from localstack.utils.aws.arns import extract_account_id_from_arn, extract_region_from_arn
 from localstack.utils.collections import select_from_typed_dict
@@ -107,6 +108,10 @@ from localstack.utils.patch import patch
 
 
 class Route53ResolverProvider(Route53ResolverApi):
+    def accept_state_visitor(self, visitor: StateVisitor):
+        visitor.visit(route53resolver_backends)
+        visitor.visit(route53resolver_stores)
+
     @staticmethod
     def get_store(account_id: str, region: str) -> Route53ResolverStore:
         return route53resolver_stores[account_id][region]

localstack/services/s3/constants.py

@@ -1,4 +1,5 @@
 from localstack.aws.api.s3 import (
+    BucketLocationConstraint,
     ChecksumAlgorithm,
     Grantee,
     Permission,
@@ -66,6 +67,10 @@ CHECKSUM_ALGORITHMS: list[ChecksumAlgorithm] = [
     ChecksumAlgorithm.CRC64NVME,
 ]
 
+BUCKET_LOCATION_CONSTRAINTS = [constraint.value for constraint in BucketLocationConstraint]
+
+EU_WEST_1_LOCATION_CONSTRAINTS = [BucketLocationConstraint.EU, BucketLocationConstraint.eu_west_1]
+
 # response header overrides the client may request
 ALLOWED_HEADER_OVERRIDES = {
     "ResponseContentType": "ContentType",

localstack/services/s3/exceptions.py

@@ -51,3 +51,12 @@ class InvalidBucketOwnerAWSAccountID(CommonServiceException):
 class TooManyConfigurations(CommonServiceException):
     def __init__(self, message=None) -> None:
         super().__init__("TooManyConfigurations", status_code=400, message=message)
+
+
+class IllegalLocationConstraintException(CommonServiceException):
+    def __init__(self, location_constraint: str):
+        super().__init__(
+            "IllegalLocationConstraintException",
+            status_code=400,
+            message=f"The {location_constraint} location constraint is incompatible for the region specific endpoint this request was sent to.",
+        )

localstack/services/s3/models.py

@@ -16,6 +16,7 @@ from localstack.aws.api.s3 import (
     BadDigest,
     BucketAccelerateStatus,
     BucketKeyEnabled,
+    BucketLocationConstraint,
     BucketName,
     BucketRegion,
     BucketVersioningStatus,
@@ -76,7 +77,11 @@ from localstack.services.s3.constants import (
     S3_UPLOAD_PART_MIN_SIZE,
 )
 from localstack.services.s3.exceptions import InvalidRequest
-from localstack.services.s3.utils import CombinedCrcHash, get_s3_checksum, rfc_1123_datetime
+from localstack.services.s3.utils import (
+    CombinedCrcHash,
+    get_s3_checksum,
+    rfc_1123_datetime,
+)
 from localstack.services.stores import (
     AccountRegionBundle,
     BaseStore,
@@ -101,6 +106,7 @@ class S3Bucket:
     name: BucketName
     bucket_account_id: AccountId
     bucket_region: BucketRegion
+    location_constraint: BucketLocationConstraint | Literal[""]
     creation_date: datetime
     multiparts: dict[MultipartUploadId, "S3Multipart"]
     objects: Union["KeyStore", "VersionedKeyStore"]
@@ -137,10 +143,12 @@ class S3Bucket:
         acl: AccessControlPolicy = None,
         object_ownership: ObjectOwnership = None,
         object_lock_enabled_for_bucket: bool = None,
+        location_constraint: BucketLocationConstraint | Literal[""] = "",
     ):
         self.name = name
         self.bucket_account_id = account_id
         self.bucket_region = bucket_region
+        self.location_constraint = location_constraint
         # If ObjectLock is enabled, it forces the bucket to be versioned as well
         self.versioning_status = None if not object_lock_enabled_for_bucket else "Enabled"
         self.objects = KeyStore() if not object_lock_enabled_for_bucket else VersionedKeyStore()