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

localstack/services/lambda_/resource_providers/aws_lambda_function.py

@@ -19,11 +19,24 @@ from localstack.utils.strings import is_base64, to_bytes
 from localstack.utils.testutil import create_zip_file
 
 
+class LambdaManagedInstancesCapacityProviderConfig(TypedDict):
+    CapacityProviderArn: str | None
+    PerExecutionEnvironmentMaxConcurrency: int | None
+    ExecutionEnvironmentMemoryGiBPerVCpu: float | None
+
+
+class CapacityProviderConfig(TypedDict):
+    LambdaManagedInstancesCapacityProviderConfig: (
+        LambdaManagedInstancesCapacityProviderConfig | None
+    )
+
+
 class LambdaFunctionProperties(TypedDict):
     Code: Code | None
     Role: str | None
     Architectures: list[str] | None
     Arn: str | None
+    CapacityProviderConfig: CapacityProviderConfig | None
     CodeSigningConfigArn: str | None
     DeadLetterConfig: DeadLetterConfig | None
     Description: str | None
@@ -297,6 +310,7 @@ def _transform_function_to_model(function):
         "Arn",
         "EphemeralStorage",
         "Architectures",
+        "CapacityProviderConfig",
     ]
     response_model = util.select_attributes(function, model_properties)
     response_model["Arn"] = function["FunctionArn"]
@@ -387,6 +401,7 @@ class LambdaFunctionProvider(ResourceProvider[LambdaFunctionProperties]):
                     "TracingConfig",
                     "VpcConfig",
                     "LoggingConfig",
+                    "CapacityProviderConfig",
                 ],
             )
             if "Timeout" in kwargs:
@@ -408,11 +423,27 @@ class LambdaFunctionProvider(ResourceProvider[LambdaFunctionProperties]):
                 }
 
             kwargs["Code"] = _get_lambda_code_param(model)
+
+            # For managed instance lambdas, we publish them immediately
+            if "CapacityProviderConfig" in kwargs:
+                kwargs["Publish"] = True
+                kwargs["PublishTo"] = "LATEST_PUBLISHED"
+
             create_response = lambda_client.create_function(**kwargs)
+            # TODO: if version is in the schema, just put it in the model instead of the custom context
+            request.custom_context["Version"] = create_response["Version"]  # $LATEST.PUBLISHED
             model["Arn"] = create_response["FunctionArn"]
 
-        get_fn_response = lambda_client.get_function(FunctionName=model["Arn"])
+        if request.custom_context.get("Version") == "$LATEST.PUBLISHED":
+            # for managed instance lambdas, we need to wait until the version is published & active
+            get_fn_response = lambda_client.get_function(
+                FunctionName=model["FunctionName"], Qualifier=request.custom_context["Version"]
+            )
+        else:
+            get_fn_response = lambda_client.get_function(FunctionName=model["Arn"])
+
         match get_fn_response["Configuration"]["State"]:
+            # TODO: explicitly handle new ActiveNonInvocable state?
             case "Pending":
                 return ProgressEvent(
                     status=OperationStatus.IN_PROGRESS,
@@ -541,6 +572,7 @@ class LambdaFunctionProvider(ResourceProvider[LambdaFunctionProperties]):
             "TracingConfig",
             "VpcConfig",
             "LoggingConfig",
+            "CapacityProviderConfig",
         ]
         update_config_props = util.select_attributes(request.desired_state, config_keys)
         function_name = request.previous_state["FunctionName"]

localstack/services/lambda_/runtimes.py

@@ -34,6 +34,7 @@ from localstack.aws.api.lambda_ import Runtime
 # => Synchronize the order with the "Supported runtimes" under "AWS Lambda runtimes" (a)
 # => Add comments for deprecated runtimes using <Deprecation date> => <Block function create> => <Block function update>
 IMAGE_MAPPING: dict[Runtime, str] = {
+    Runtime.nodejs24_x: "nodejs:24",
     Runtime.nodejs22_x: "nodejs:22",
     Runtime.nodejs20_x: "nodejs:20",
     Runtime.nodejs18_x: "nodejs:18",
@@ -112,6 +113,7 @@ ALL_RUNTIMES: list[Runtime] = list(IMAGE_MAPPING.keys())
 # => Remove deprecated runtimes from this testing list
 RUNTIMES_AGGREGATED = {
     "nodejs": [
+        Runtime.nodejs24_x,
         Runtime.nodejs22_x,
         Runtime.nodejs20_x,
         Runtime.nodejs18_x,
@@ -166,6 +168,6 @@ SNAP_START_SUPPORTED_RUNTIMES = [
 ]
 
 # An ordered list of all Lambda runtimes considered valid by AWS. Matching snapshots in test_create_lambda_exceptions
-VALID_RUNTIMES: str = "[nodejs20.x, python3.14, provided.al2023, python3.12, python3.13, nodejs22.x, java17, nodejs16.x, java25, dotnet8, python3.10, java11, python3.11, dotnet6, java21, nodejs18.x, provided.al2, ruby3.3, ruby3.4, java8.al2, ruby3.2, python3.8, python3.9]"
+VALID_RUNTIMES: str = "[nodejs20.x, python3.14, provided.al2023, python3.12, python3.13, nodejs24.x, nodejs22.x, java17, nodejs16.x, java25, dotnet8, python3.10, java11, python3.11, dotnet6, java21, nodejs18.x, provided.al2, ruby3.3, ruby3.4, java8.al2, ruby3.2, python3.8, python3.9]"
 # An ordered list of all Lambda runtimes for layers considered valid by AWS. Matching snapshots in test_layer_exceptions
 VALID_LAYER_RUNTIMES: str = "[ruby3.5, ruby2.6, dotnetcore1.0, python3.7, nodejs8.10, nasa, ruby2.7, python2.7-greengrass, dotnetcore2.0, python3.8, java21, dotnet6, dotnetcore2.1, python3.9, java11, nodejs6.10, provided, dotnetcore3.1, dotnet8, java25, java17, nodejs, nodejs4.3, java8.al2, go1.x, dotnet10, nodejs20.x, go1.9, byol, nodejs10.x, provided.al2023, nodejs22.x, python3.10, java8, nodejs12.x, python3.11, nodejs24.x, nodejs8.x, python3.12, nodejs14.x, nodejs8.9, nodejs26.x, python3.13, python3.14, nodejs16.x, python3.15, provided.al2, nodejs4.3-edge, nodejs18.x, ruby3.2, python3.4, ruby3.3, ruby3.4, ruby2.5, python3.6, python2.7]"

localstack/services/logs/provider.py

@@ -14,6 +14,7 @@ from moto.logs.models import LogStream as MotoLogStream
 from localstack.aws.api import CommonServiceException, RequestContext, handler
 from localstack.aws.api.logs import (
     AmazonResourceName,
+    DeletionProtectionEnabled,
     DescribeLogGroupsRequest,
     DescribeLogGroupsResponse,
     DescribeLogStreamsRequest,
@@ -43,6 +44,7 @@ from localstack.services import moto
 from localstack.services.logs.models import get_moto_logs_backend, logs_stores
 from localstack.services.moto import call_moto
 from localstack.services.plugins import ServiceLifecycleHook
+from localstack.state import StateVisitor
 from localstack.utils.aws import arns
 from localstack.utils.aws.client_types import ServicePrincipal
 from localstack.utils.bootstrap import is_api_enabled
@@ -57,6 +59,12 @@ class LogsProvider(LogsApi, ServiceLifecycleHook):
         super().__init__()
         self.cw_client = connect_to().cloudwatch
 
+    def accept_state_visitor(self, visitor: StateVisitor):
+        from moto.logs.models import logs_backends
+
+        visitor.visit(logs_backends)
+        visitor.visit(logs_stores)
+
     def put_log_events(
         self,
         context: RequestContext,
@@ -163,6 +171,7 @@ class LogsProvider(LogsApi, ServiceLifecycleHook):
         kms_key_id: KmsKeyId | None = None,
         tags: Tags | None = None,
         log_group_class: LogGroupClass | None = None,
+        deletion_protection_enabled: DeletionProtectionEnabled | None = None,
         **kwargs,
     ) -> None:
         call_moto(context)

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/opensearch/provider.py

@@ -116,6 +116,11 @@ DEFAULT_OPENSEARCH_DOMAIN_ENDPOINT_OPTIONS = DomainEndpointOptions(
     CustomEndpointEnabled=False,
 )
 
+DEFAULT_AUTOTUNE_OPTIONS = AutoTuneOptionsOutput(
+    State=AutoTuneState.ENABLED,
+    UseOffPeakWindow=False,
+)
+
 
 def cluster_manager() -> ClusterManager:
     global __CLUSTER_MANAGER
@@ -203,6 +208,13 @@ def _status_to_config(status: DomainStatus) -> DomainConfig:
     cluster_cfg = status.get("ClusterConfig") or {}
     default_cfg = DEFAULT_OPENSEARCH_CLUSTER_CONFIG
     config_status = get_domain_config_status()
+    autotune_options = status.get("AutoTuneOptions") or DEFAULT_AUTOTUNE_OPTIONS
+    autotune_state = autotune_options.get("State") or AutoTuneState.ENABLED
+    desired_state = (
+        AutoTuneDesiredState.ENABLED
+        if autotune_state == AutoTuneState.ENABLED
+        else AutoTuneDesiredState.DISABLED
+    )
     return DomainConfig(
         AccessPolicies=AccessPoliciesStatus(
             Options=status.get("AccessPolicies", ""),
@@ -275,15 +287,16 @@ def _status_to_config(status: DomainStatus) -> DomainConfig:
         ),
         AutoTuneOptions=AutoTuneOptionsStatus(
             Options=AutoTuneOptions(
-                DesiredState=AutoTuneDesiredState.ENABLED,
+                DesiredState=desired_state,
                 RollbackOnDisable=RollbackOnDisable.NO_ROLLBACK,
                 MaintenanceSchedules=[],
+                UseOffPeakWindow=autotune_options.get("UseOffPeakWindow", False),
             ),
             Status=AutoTuneStatus(
                 CreationDate=config_status.get("CreationDate"),
                 UpdateDate=config_status.get("UpdateDate"),
                 UpdateVersion=config_status.get("UpdateVersion"),
-                State=AutoTuneState.ENABLED,
+                State=autotune_state,
                 PendingDeletion=config_status.get("PendingDeletion"),
             ),
         ),
@@ -315,6 +328,22 @@ def get_domain_status(
         stored_status.update(request)
         default_cfg.update(request.get("ClusterConfig", {}))
 
+    autotune_options = stored_status.get("AutoTuneOptions") or deepcopy(DEFAULT_AUTOTUNE_OPTIONS)
+    if request and (request_options := request.get("AutoTuneOptions")):
+        desired_state = request_options.get("DesiredState") or AutoTuneDesiredState.ENABLED
+        state = (
+            AutoTuneState.ENABLED
+            if desired_state == AutoTuneDesiredState.ENABLED
+            else AutoTuneState.DISABLED
+        )
+        autotune_options = AutoTuneOptionsOutput(
+            State=state,
+            UseOffPeakWindow=request_options.get(
+                "UseOffPeakWindow", autotune_options.get("UseOffPeakWindow", False)
+            ),
+        )
+    stored_status["AutoTuneOptions"] = autotune_options
+
     domain_processing_status = stored_status.get("DomainProcessingStatus", None)
     processing = stored_status.get("Processing", True)
     if deleted:
@@ -377,7 +406,10 @@ def get_domain_status(
         AdvancedSecurityOptions=AdvancedSecurityOptions(
             Enabled=False, InternalUserDatabaseEnabled=False
         ),
-        AutoTuneOptions=AutoTuneOptionsOutput(State=AutoTuneState.ENABLE_IN_PROGRESS),
+        AutoTuneOptions=AutoTuneOptionsOutput(
+            State=stored_status.get("AutoTuneOptions", {}).get("State"),
+            UseOffPeakWindow=autotune_options.get("UseOffPeakWindow", False),
+        ),
     )
     return new_status
 
@@ -582,6 +614,24 @@ class OpensearchProvider(OpensearchApi, ServiceLifecycleHook):
             if domain_status is None:
                 raise ResourceNotFoundException(f"Domain not found: {domain_key.domain_name}")
 
+            if payload.get("AutoTuneOptions"):
+                auto_request = payload.pop("AutoTuneOptions")
+                desired_state = auto_request.get("DesiredState") or AutoTuneDesiredState.ENABLED
+
+                state = (
+                    AutoTuneState.ENABLED
+                    if desired_state == AutoTuneDesiredState.ENABLED
+                    else AutoTuneState.DISABLED
+                )
+
+                current_autotune = domain_status.get("AutoTuneOptions", {})
+                domain_status["AutoTuneOptions"] = AutoTuneOptionsOutput(
+                    State=state,
+                    UseOffPeakWindow=auto_request.get(
+                        "UseOffPeakWindow", current_autotune.get("UseOffPeakWindow", False)
+                    ),
+                )
+
             status_update: dict = _update_domain_config_request_to_status(payload)
             domain_status.update(status_update)
 

localstack/services/resource_groups/provider.py

@@ -1,5 +1,9 @@
 from localstack.aws.api.resource_groups import ResourceGroupsApi
+from localstack.state import StateVisitor
 
 
 class ResourceGroupsProvider(ResourceGroupsApi):
-    pass
+    def accept_state_visitor(self, visitor: StateVisitor):
+        from moto.resourcegroups.models import resourcegroups_backends
+
+        visitor.visit(resourcegroups_backends)

localstack/services/resourcegroupstaggingapi/provider.py

@@ -1,7 +1,12 @@
 from abc import ABC
 
 from localstack.aws.api.resourcegroupstaggingapi import ResourcegroupstaggingapiApi
+from localstack.state import StateVisitor
 
 
 class ResourcegroupstaggingapiProvider(ResourcegroupstaggingapiApi, ABC):
-    pass
+    def accept_state_visitor(self, visitor: StateVisitor):
+        # currently, Moto resourcegroupstaggingapi stores all tags into the other services backend, so their backend
+        # does not hold any state and is not worth saving. It only holds direct references to other services
+        # It only holds pagination tokens that are not worth keeping
+        pass

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()

localstack/services/s3/provider.py

@@ -33,6 +33,7 @@ from localstack.aws.api.s3 import (
     BucketAlreadyOwnedByYou,
     BucketCannedACL,
     BucketLifecycleConfiguration,
+    BucketLocationConstraint,
     BucketLoggingStatus,
     BucketName,
     BucketNotEmpty,
@@ -117,7 +118,6 @@ from localstack.aws.api.s3 import (
     InvalidArgument,
     InvalidBucketName,
     InvalidDigest,
-    InvalidLocationConstraint,
     InvalidObjectState,
     InvalidPartNumber,
     InvalidPartOrder,
@@ -229,7 +229,7 @@ from localstack.aws.handlers import (
     preprocess_request,
     serve_custom_service_request_handlers,
 )
-from localstack.constants import AWS_REGION_US_EAST_1
+from localstack.constants import AWS_REGION_EU_WEST_1, AWS_REGION_US_EAST_1
 from localstack.services.edge import ROUTER
 from localstack.services.plugins import ServiceLifecycleHook
 from localstack.services.s3.codec import AwsChunkedDecoder
@@ -278,6 +278,7 @@ from localstack.services.s3.utils import (
     etag_to_base_64_content_md5,
     extract_bucket_key_version_id_from_copy_source,
     generate_safe_version_id,
+    get_bucket_location_xml,
     get_canned_acl,
     get_class_attrs_from_spec_class,
     get_failed_precondition_copy_source,
@@ -304,6 +305,7 @@ from localstack.services.s3.utils import (
     validate_dict_fields,
     validate_failed_precondition,
     validate_kms_key_id,
+    validate_location_constraint,
     validate_tag_set,
 )
 from localstack.services.s3.validation import (
@@ -323,6 +325,7 @@ from localstack.services.s3.validation import (
 from localstack.services.s3.website_hosting import register_website_hosting_routes
 from localstack.state import AssetDirectory, StateVisitor
 from localstack.utils.aws.arns import s3_bucket_name
+from localstack.utils.aws.aws_stack import get_valid_regions_for_service
 from localstack.utils.collections import select_from_typed_dict
 from localstack.utils.strings import short_uid, to_bytes, to_str
 
@@ -491,34 +494,20 @@ class S3Provider(S3Api, ServiceLifecycleHook):
         if not is_bucket_name_valid(bucket_name):
             raise InvalidBucketName("The specified bucket is not valid.", BucketName=bucket_name)
 
-        # the XML parser returns an empty dict if the body contains the following:
-        # <CreateBucketConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/" />
-        # but it also returns an empty dict if the body is fully empty. We need to differentiate the 2 cases by checking
-        # if the body is empty or not
-        if context.request.data and (
-            (create_bucket_configuration := request.get("CreateBucketConfiguration")) is not None
-        ):
-            if not (bucket_region := create_bucket_configuration.get("LocationConstraint")):
-                raise MalformedXML()
-
-            if context.region == AWS_REGION_US_EAST_1:
-                if bucket_region in ("us-east-1", "aws-global"):
-                    raise InvalidLocationConstraint(
-                        "The specified location-constraint is not valid",
-                        LocationConstraint=bucket_region,
-                    )
-            elif context.region != bucket_region:
-                raise CommonServiceException(
-                    code="IllegalLocationConstraintException",
-                    message=f"The {bucket_region} location constraint is incompatible for the region specific endpoint this request was sent to.",
-                )
-        else:
+        create_bucket_configuration = request.get("CreateBucketConfiguration") or {}
+
+        bucket_tags = create_bucket_configuration.get("Tags")
+        if bucket_tags:
+            validate_tag_set(bucket_tags, type_set="create-bucket")
+
+        location_constraint = create_bucket_configuration.get("LocationConstraint", "")
+        validate_location_constraint(context.region, location_constraint)
+
+        bucket_region = location_constraint
+        if not location_constraint:
             bucket_region = AWS_REGION_US_EAST_1
-            if context.region != bucket_region:
-                raise CommonServiceException(
-                    code="IllegalLocationConstraintException",
-                    message="The unspecified location constraint is incompatible for the region specific endpoint this request was sent to.",
-                )
+        if location_constraint == BucketLocationConstraint.EU:
+            bucket_region = AWS_REGION_EU_WEST_1
 
         store = self.get_store(context.account_id, bucket_region)
 
@@ -527,8 +516,9 @@ class S3Provider(S3Api, ServiceLifecycleHook):
             if existing_bucket_owner != context.account_id:
                 raise BucketAlreadyExists()
 
-            # if the existing bucket has the same owner, the behaviour will depend on the region
-            if bucket_region != "us-east-1":
+            # if the existing bucket has the same owner, the behaviour will depend on the region and if the request has
+            # tags
+            if bucket_region != AWS_REGION_US_EAST_1 or bucket_tags:
                 raise BucketAlreadyOwnedByYou(
                     "Your previous request to create the named bucket succeeded and you already own it.",
                     BucketName=bucket_name,
@@ -547,6 +537,7 @@ class S3Provider(S3Api, ServiceLifecycleHook):
         # see https://docs.aws.amazon.com/AmazonS3/latest/API/API_Owner.html
         owner = get_owner_for_account_id(context.account_id)
         acl = get_access_control_policy_for_new_resource_request(request, owner=owner)
+
         s3_bucket = S3Bucket(
             name=bucket_name,
             account_id=context.account_id,
@@ -555,10 +546,16 @@ class S3Provider(S3Api, ServiceLifecycleHook):
             acl=acl,
             object_ownership=request.get("ObjectOwnership"),
             object_lock_enabled_for_bucket=request.get("ObjectLockEnabledForBucket"),
+            location_constraint=location_constraint,
         )
 
         store.buckets[bucket_name] = s3_bucket
         store.global_bucket_map[bucket_name] = s3_bucket.bucket_account_id
+        if bucket_tags:
+            store.TAGS.tag_resource(
+                arn=s3_bucket.bucket_arn,
+                tags=bucket_tags,
+            )
         self._cors_handler.invalidate_cache()
         self._storage_backend.create_bucket(bucket_name)
 
@@ -607,6 +604,13 @@ class S3Provider(S3Api, ServiceLifecycleHook):
         bucket_region: BucketRegion = None,
         **kwargs,
     ) -> ListBucketsOutput:
+        if bucket_region and not config.ALLOW_NONSTANDARD_REGIONS:
+            if bucket_region not in get_valid_regions_for_service(self.service):
+                raise InvalidArgument(
+                    f"Argument value {bucket_region} is not a valid AWS Region",
+                    ArgumentName="bucket-region",
+                )
+
         owner = get_owner_for_account_id(context.account_id)
         store = self.get_store(context.account_id, context.region)
 
@@ -698,16 +702,18 @@ class S3Provider(S3Api, ServiceLifecycleHook):
         """
         store, s3_bucket = self._get_cross_account_bucket(context, bucket)
 
-        location_constraint = (
-            '<?xml version="1.0" encoding="UTF-8"?>\n'
-            '<LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/">{{location}}</LocationConstraint>'
-        )
-
-        location = s3_bucket.bucket_region if s3_bucket.bucket_region != "us-east-1" else ""
-        location_constraint = location_constraint.replace("{{location}}", location)
+        # TODO: Remove usage of getattr once persistence mechanism is updated.
+        # If the stored constraint is None the bucket was made before the storage of location_constraint.
+        # The EU location constraint wasn't supported before this point so we can safely default to the region.
+        location_constraint = getattr(s3_bucket, "location_constraint", None)
+        if location_constraint is None:
+            location_constraint = (
+                s3_bucket.bucket_region if s3_bucket.bucket_region != "us-east-1" else ""
+            )
 
-        response = GetBucketLocationOutput(LocationConstraint=location_constraint)
-        return response
+        return GetBucketLocationOutput(
+            LocationConstraint=get_bucket_location_xml(location_constraint)
+        )
 
     @handler("PutObject", expand=False)
     def put_object(
@@ -1189,12 +1195,14 @@ class S3Provider(S3Api, ServiceLifecycleHook):
             response["ChecksumType"] = checksum_type
 
         add_encryption_to_response(response, s3_object=s3_object)
+        object_tags = store.TAGS.tags.get(
+            get_unique_key_id(bucket_name, object_key, s3_object.version_id)
+        )
+        if object_tags:
+            response["TagCount"] = len(object_tags)
 
         # if you specify the VersionId, AWS won't return the Expiration header, even if that's the current version
         if not version_id and s3_bucket.lifecycle_rules:
-            object_tags = store.TAGS.tags.get(
-                get_unique_key_id(bucket_name, object_key, s3_object.version_id)
-            )
             if expiration_header := self._get_expiration_header(
                 s3_bucket.lifecycle_rules,
                 bucket_name,