localstack-core 4.6.1.dev60__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/opensearch/resource_providers/aws_opensearchservice_domain.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 import localstack.services.cloudformation.provider_utils as util
 from localstack.services.cloudformation.resource_provider import (
@@ -15,151 +15,151 @@ from localstack.services.cloudformation.resource_provider import (
 
 
 class OpenSearchServiceDomainProperties(TypedDict):
-    AccessPolicies: Optional[dict]
-    AdvancedOptions: Optional[dict]
-    AdvancedSecurityOptions: Optional[AdvancedSecurityOptionsInput]
-    Arn: Optional[str]
-    ClusterConfig: Optional[ClusterConfig]
-    CognitoOptions: Optional[CognitoOptions]
-    DomainArn: Optional[str]
-    DomainEndpoint: Optional[str]
-    DomainEndpointOptions: Optional[DomainEndpointOptions]
-    DomainEndpoints: Optional[dict]
-    DomainName: Optional[str]
-    EBSOptions: Optional[EBSOptions]
-    EncryptionAtRestOptions: Optional[EncryptionAtRestOptions]
-    EngineVersion: Optional[str]
-    Id: Optional[str]
-    LogPublishingOptions: Optional[dict]
-    NodeToNodeEncryptionOptions: Optional[NodeToNodeEncryptionOptions]
-    OffPeakWindowOptions: Optional[OffPeakWindowOptions]
-    ServiceSoftwareOptions: Optional[ServiceSoftwareOptions]
-    SnapshotOptions: Optional[SnapshotOptions]
-    SoftwareUpdateOptions: Optional[SoftwareUpdateOptions]
-    Tags: Optional[list[Tag]]
-    VPCOptions: Optional[VPCOptions]
+    AccessPolicies: dict | None
+    AdvancedOptions: dict | None
+    AdvancedSecurityOptions: AdvancedSecurityOptionsInput | None
+    Arn: str | None
+    ClusterConfig: ClusterConfig | None
+    CognitoOptions: CognitoOptions | None
+    DomainArn: str | None
+    DomainEndpoint: str | None
+    DomainEndpointOptions: DomainEndpointOptions | None
+    DomainEndpoints: dict | None
+    DomainName: str | None
+    EBSOptions: EBSOptions | None
+    EncryptionAtRestOptions: EncryptionAtRestOptions | None
+    EngineVersion: str | None
+    Id: str | None
+    LogPublishingOptions: dict | None
+    NodeToNodeEncryptionOptions: NodeToNodeEncryptionOptions | None
+    OffPeakWindowOptions: OffPeakWindowOptions | None
+    ServiceSoftwareOptions: ServiceSoftwareOptions | None
+    SnapshotOptions: SnapshotOptions | None
+    SoftwareUpdateOptions: SoftwareUpdateOptions | None
+    Tags: list[Tag] | None
+    VPCOptions: VPCOptions | None
 
 
 class ZoneAwarenessConfig(TypedDict):
-    AvailabilityZoneCount: Optional[int]
+    AvailabilityZoneCount: int | None
 
 
 class ClusterConfig(TypedDict):
-    DedicatedMasterCount: Optional[int]
-    DedicatedMasterEnabled: Optional[bool]
-    DedicatedMasterType: Optional[str]
-    InstanceCount: Optional[int]
-    InstanceType: Optional[str]
-    WarmCount: Optional[int]
-    WarmEnabled: Optional[bool]
-    WarmType: Optional[str]
-    ZoneAwarenessConfig: Optional[ZoneAwarenessConfig]
-    ZoneAwarenessEnabled: Optional[bool]
+    DedicatedMasterCount: int | None
+    DedicatedMasterEnabled: bool | None
+    DedicatedMasterType: str | None
+    InstanceCount: int | None
+    InstanceType: str | None
+    WarmCount: int | None
+    WarmEnabled: bool | None
+    WarmType: str | None
+    ZoneAwarenessConfig: ZoneAwarenessConfig | None
+    ZoneAwarenessEnabled: bool | None
 
 
 class SnapshotOptions(TypedDict):
-    AutomatedSnapshotStartHour: Optional[int]
+    AutomatedSnapshotStartHour: int | None
 
 
 class VPCOptions(TypedDict):
-    SecurityGroupIds: Optional[list[str]]
-    SubnetIds: Optional[list[str]]
+    SecurityGroupIds: list[str] | None
+    SubnetIds: list[str] | None
 
 
 class NodeToNodeEncryptionOptions(TypedDict):
-    Enabled: Optional[bool]
+    Enabled: bool | None
 
 
 class DomainEndpointOptions(TypedDict):
-    CustomEndpoint: Optional[str]
-    CustomEndpointCertificateArn: Optional[str]
-    CustomEndpointEnabled: Optional[bool]
-    EnforceHTTPS: Optional[bool]
-    TLSSecurityPolicy: Optional[str]
+    CustomEndpoint: str | None
+    CustomEndpointCertificateArn: str | None
+    CustomEndpointEnabled: bool | None
+    EnforceHTTPS: bool | None
+    TLSSecurityPolicy: str | None
 
 
 class CognitoOptions(TypedDict):
-    Enabled: Optional[bool]
-    IdentityPoolId: Optional[str]
-    RoleArn: Optional[str]
-    UserPoolId: Optional[str]
+    Enabled: bool | None
+    IdentityPoolId: str | None
+    RoleArn: str | None
+    UserPoolId: str | None
 
 
 class MasterUserOptions(TypedDict):
-    MasterUserARN: Optional[str]
-    MasterUserName: Optional[str]
-    MasterUserPassword: Optional[str]
+    MasterUserARN: str | None
+    MasterUserName: str | None
+    MasterUserPassword: str | None
 
 
 class Idp(TypedDict):
-    EntityId: Optional[str]
-    MetadataContent: Optional[str]
+    EntityId: str | None
+    MetadataContent: str | None
 
 
 class SAMLOptions(TypedDict):
-    Enabled: Optional[bool]
-    Idp: Optional[Idp]
-    MasterBackendRole: Optional[str]
-    MasterUserName: Optional[str]
-    RolesKey: Optional[str]
-    SessionTimeoutMinutes: Optional[int]
-    SubjectKey: Optional[str]
+    Enabled: bool | None
+    Idp: Idp | None
+    MasterBackendRole: str | None
+    MasterUserName: str | None
+    RolesKey: str | None
+    SessionTimeoutMinutes: int | None
+    SubjectKey: str | None
 
 
 class AdvancedSecurityOptionsInput(TypedDict):
-    AnonymousAuthDisableDate: Optional[str]
-    AnonymousAuthEnabled: Optional[bool]
-    Enabled: Optional[bool]
-    InternalUserDatabaseEnabled: Optional[bool]
-    MasterUserOptions: Optional[MasterUserOptions]
-    SAMLOptions: Optional[SAMLOptions]
+    AnonymousAuthDisableDate: str | None
+    AnonymousAuthEnabled: bool | None
+    Enabled: bool | None
+    InternalUserDatabaseEnabled: bool | None
+    MasterUserOptions: MasterUserOptions | None
+    SAMLOptions: SAMLOptions | None
 
 
 class EBSOptions(TypedDict):
-    EBSEnabled: Optional[bool]
-    Iops: Optional[int]
-    Throughput: Optional[int]
-    VolumeSize: Optional[int]
-    VolumeType: Optional[str]
+    EBSEnabled: bool | None
+    Iops: int | None
+    Throughput: int | None
+    VolumeSize: int | None
+    VolumeType: str | None
 
 
 class EncryptionAtRestOptions(TypedDict):
-    Enabled: Optional[bool]
-    KmsKeyId: Optional[str]
+    Enabled: bool | None
+    KmsKeyId: str | None
 
 
 class Tag(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 class ServiceSoftwareOptions(TypedDict):
-    AutomatedUpdateDate: Optional[str]
-    Cancellable: Optional[bool]
-    CurrentVersion: Optional[str]
-    Description: Optional[str]
-    NewVersion: Optional[str]
-    OptionalDeployment: Optional[bool]
-    UpdateAvailable: Optional[bool]
-    UpdateStatus: Optional[str]
+    AutomatedUpdateDate: str | None
+    Cancellable: bool | None
+    CurrentVersion: str | None
+    Description: str | None
+    NewVersion: str | None
+    OptionalDeployment: bool | None
+    UpdateAvailable: bool | None
+    UpdateStatus: str | None
 
 
 class WindowStartTime(TypedDict):
-    Hours: Optional[int]
-    Minutes: Optional[int]
+    Hours: int | None
+    Minutes: int | None
 
 
 class OffPeakWindow(TypedDict):
-    WindowStartTime: Optional[WindowStartTime]
+    WindowStartTime: WindowStartTime | None
 
 
 class OffPeakWindowOptions(TypedDict):
-    Enabled: Optional[bool]
-    OffPeakWindow: Optional[OffPeakWindow]
+    Enabled: bool | None
+    OffPeakWindow: OffPeakWindow | None
 
 
 class SoftwareUpdateOptions(TypedDict):
-    AutoSoftwareUpdateEnabled: Optional[bool]
+    AutoSoftwareUpdateEnabled: bool | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/opensearch/resource_providers/aws_opensearchservice_domain_plugin.py

@@ -1,5 +1,3 @@
-from typing import Optional, Type
-
 from localstack.services.cloudformation.resource_provider import (
     CloudFormationResourceProviderPlugin,
     ResourceProvider,
@@ -10,7 +8,7 @@ class OpenSearchServiceDomainProviderPlugin(CloudFormationResourceProviderPlugin
     name = "AWS::OpenSearchService::Domain"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.opensearch.resource_providers.aws_opensearchservice_domain import (

localstack/services/opensearch/versions.py

@@ -6,8 +6,6 @@ the latest install_versions from the github repository tags. Run::
 
 """
 
-from typing import Dict
-
 import semver
 
 from localstack.aws.api.opensearch import CompatibleVersionsMap, EngineType
@@ -15,20 +13,24 @@ from localstack.utils.common import get_arch
 
 # Internal representation of the OpenSearch versions (without the "OpenSearch_" prefix)
 _opensearch_install_versions = {
+    "3.1": "3.1.0",
+    "2.19": "2.19.3",
+    "2.17": "2.17.1",
+    "2.15": "2.15.0",
     "2.13": "2.13.0",
     "2.11": "2.11.1",
     "2.9": "2.9.0",
     "2.7": "2.7.0",
     "2.5": "2.5.0",
     "2.3": "2.3.0",
-    "1.3": "1.3.12",
+    "1.3": "1.3.20",
     "1.2": "1.2.4",
     "1.1": "1.1.0",
     "1.0": "1.0.0",
 }
 # Internal representation of the Elasticsearch versions (without the "Elasticsearch_" prefix)
 _elasticsearch_install_versions = {
-    "7.10": "7.10.0",
+    "7.10": "7.10.2",
     "7.9": "7.9.3",
     "7.8": "7.8.1",
     "7.7": "7.7.1",
@@ -223,6 +225,9 @@ compatible_versions = [
             "OpenSearch_2.9",
             "OpenSearch_2.11",
             "OpenSearch_2.13",
+            "OpenSearch_2.15",
+            "OpenSearch_2.17",
+            "OpenSearch_2.19",
         ],
     ),
     CompatibleVersionsMap(
@@ -233,28 +238,68 @@ compatible_versions = [
             "OpenSearch_2.9",
             "OpenSearch_2.11",
             "OpenSearch_2.13",
+            "OpenSearch_2.15",
+            "OpenSearch_2.17",
+            "OpenSearch_2.19",
         ],
     ),
     CompatibleVersionsMap(
         SourceVersion="OpenSearch_2.5",
-        TargetVersions=["OpenSearch_2.7", "OpenSearch_2.9", "OpenSearch_2.11", "OpenSearch_2.13"],
+        TargetVersions=[
+            "OpenSearch_2.7",
+            "OpenSearch_2.9",
+            "OpenSearch_2.11",
+            "OpenSearch_2.13",
+            "OpenSearch_2.15",
+            "OpenSearch_2.17",
+            "OpenSearch_2.19",
+        ],
     ),
     CompatibleVersionsMap(
         SourceVersion="OpenSearch_2.7",
-        TargetVersions=["OpenSearch_2.9", "OpenSearch_2.11", "OpenSearch_2.13"],
+        TargetVersions=[
+            "OpenSearch_2.9",
+            "OpenSearch_2.11",
+            "OpenSearch_2.13",
+            "OpenSearch_2.15",
+            "OpenSearch_2.17",
+            "OpenSearch_2.19",
+        ],
     ),
     CompatibleVersionsMap(
         SourceVersion="OpenSearch_2.9",
-        TargetVersions=["OpenSearch_2.11", "OpenSearch_2.13"],
+        TargetVersions=[
+            "OpenSearch_2.11",
+            "OpenSearch_2.13",
+            "OpenSearch_2.15",
+            "OpenSearch_2.17",
+            "OpenSearch_2.19",
+        ],
     ),
     CompatibleVersionsMap(
         SourceVersion="OpenSearch_2.11",
-        TargetVersions=["OpenSearch_2.13"],
+        TargetVersions=["OpenSearch_2.13", "OpenSearch_2.15", "OpenSearch_2.17", "OpenSearch_2.19"],
+    ),
+    CompatibleVersionsMap(
+        SourceVersion="OpenSearch_2.13",
+        TargetVersions=["OpenSearch_2.15", "OpenSearch_2.17", "OpenSearch_2.19"],
+    ),
+    CompatibleVersionsMap(
+        SourceVersion="OpenSearch_2.15",
+        TargetVersions=["OpenSearch_2.17", "OpenSearch_2.19"],
+    ),
+    CompatibleVersionsMap(
+        SourceVersion="OpenSearch_2.17",
+        TargetVersions=["OpenSearch_2.19"],
+    ),
+    CompatibleVersionsMap(
+        SourceVersion="OpenSearch_2.19",
+        TargetVersions=["OpenSearch_3.1"],
     ),
 ]
 
 
-def get_install_type_and_version(version: str) -> (EngineType, str):
+def get_install_type_and_version(version: str) -> tuple[EngineType, str]:
     engine_type = EngineType(version.split("_")[0])
 
     if version not in install_versions:
@@ -299,9 +344,11 @@ def get_download_url(install_version: str, engine_type: EngineType) -> str:
         return _opensearch_url(install_version)
     elif engine_type == EngineType.Elasticsearch:
         return _es_url(install_version)
+    else:
+        raise ValueError(f"Unknown OpenSearch engine type: {engine_type}")
 
 
-def fetch_latest_versions() -> Dict[str, str]:  # pragma: no cover
+def fetch_latest_versions() -> dict[str, str]:  # pragma: no cover
     """
     Fetches from the opensearch git repository tags the latest patch versions for a minor version and returns a
     dictionary where the key corresponds to the minor version, and the value to the patch version. Run this once in a

localstack/services/plugins.py

@@ -3,9 +3,10 @@ import functools
 import logging
 import threading
 from collections import defaultdict
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from enum import Enum
-from typing import Callable, Dict, List, Optional, Protocol, Tuple
+from typing import Protocol
 
 from plux import Plugin, PluginLifecycleListener, PluginManager, PluginSpec
 
@@ -190,7 +191,7 @@ class ServiceContainer:
     service: Service
     state: ServiceState
     lock: threading.RLock
-    errors: List[Exception]
+    errors: list[Exception]
 
     def __init__(self, service: Service, state=ServiceState.UNKNOWN):
         self.service = service
@@ -236,13 +237,13 @@ class ServiceContainer:
 class ServiceManager:
     def __init__(self) -> None:
         super().__init__()
-        self._services: Dict[str, ServiceContainer] = {}
+        self._services: dict[str, ServiceContainer] = {}
         self._mutex = threading.RLock()
 
-    def get_service_container(self, name: str) -> Optional[ServiceContainer]:
+    def get_service_container(self, name: str) -> ServiceContainer | None:
         return self._services.get(name)
 
-    def get_service(self, name: str) -> Optional[Service]:
+    def get_service(self, name: str) -> Service | None:
         container = self.get_service_container(name)
         return container.service if container else None
 
@@ -252,7 +253,7 @@ class ServiceManager:
 
         return True
 
-    def list_available(self) -> List[str]:
+    def list_available(self) -> list[str]:
         return list(self._services.keys())
 
     def exists(self, name: str) -> bool:
@@ -268,11 +269,11 @@ class ServiceManager:
     def check_all(self):
         return any(self.check(service_name) for service_name in self.list_available())
 
-    def get_state(self, name: str) -> Optional[ServiceState]:
+    def get_state(self, name: str) -> ServiceState | None:
         container = self.get_service_container(name)
         return container.state if container else None
 
-    def get_states(self) -> Dict[str, ServiceState]:
+    def get_states(self) -> dict[str, ServiceState]:
         return {name: self.get_state(name) for name in self.list_available()}
 
     @log_duration()
@@ -285,19 +286,19 @@ class ServiceManager:
         container = self.get_service_container(name)
 
         if not container:
-            raise ValueError("no such service %s" % name)
+            raise ValueError(f"no such service {name}")
 
         if container.state == ServiceState.STARTING:
             if not poll_condition(lambda: container.state != ServiceState.STARTING, timeout=30):
-                raise TimeoutError("gave up waiting for service %s to start" % name)
+                raise TimeoutError(f"gave up waiting for service {name} to start")
 
         if container.state == ServiceState.STOPPING:
             if not poll_condition(lambda: container.state == ServiceState.STOPPED, timeout=30):
-                raise TimeoutError("gave up waiting for service %s to stop" % name)
+                raise TimeoutError(f"gave up waiting for service {name} to stop")
 
         with container.lock:
             if container.state == ServiceState.DISABLED:
-                raise ServiceDisabled("service %s is disabled" % name)
+                raise ServiceDisabled(f"service {name} is disabled")
 
             if container.state == ServiceState.RUNNING:
                 return container.service
@@ -313,7 +314,7 @@ class ServiceManager:
                     raise container.errors[-1]
 
         raise ServiceStateException(
-            "service %s is not ready (%s) and could not be started" % (name, container.state)
+            f"service {name} is not ready ({container.state}) and could not be started"
         )
 
     # legacy map compatibility
@@ -397,13 +398,13 @@ class ServicePluginErrorCollector(PluginLifecycleListener):
     A PluginLifecycleListener that collects errors related to service plugins.
     """
 
-    errors: Dict[Tuple[str, str], Exception]  # keys are: (api, provider)
+    errors: dict[tuple[str, str], Exception]  # keys are: (api, provider)
 
-    def __init__(self, errors: Dict[str, Exception] = None) -> None:
+    def __init__(self, errors: dict[str, Exception] = None) -> None:
         super().__init__()
         self.errors = errors or {}
 
-    def get_key(self, plugin_name) -> Tuple[str, str]:
+    def get_key(self, plugin_name) -> tuple[str, str]:
         # the convention is <api>:<provider>, currently we don't really expose the provider
         # TODO: faulty plugin names would break this
         return tuple(plugin_name.split(":", maxsplit=1))
@@ -446,7 +447,7 @@ class ServicePluginManager(ServiceManager):
         self.provider_config = provider_config or config.SERVICE_PROVIDER_CONFIG
 
         # locks used to make sure plugin loading is thread safe - will be cleared after single use
-        self._plugin_load_locks: Dict[str, threading.RLock] = SynchronizedDefaultDict(
+        self._plugin_load_locks: dict[str, threading.RLock] = SynchronizedDefaultDict(
             threading.RLock
         )
 
@@ -469,7 +470,7 @@ class ServicePluginManager(ServiceManager):
 
     # TODO make the abstraction clearer, to provide better information if service is available versus discoverable
     # especially important when considering pro services
-    def list_available(self) -> List[str]:
+    def list_available(self) -> list[str]:
         """
         List all available services, which have an available, configured provider
 
@@ -482,8 +483,8 @@ class ServicePluginManager(ServiceManager):
         ]
 
     def _get_loaded_service_containers(
-        self, services: Optional[List[str]] = None
-    ) -> List[ServiceContainer]:
+        self, services: list[str] | None = None
+    ) -> list[ServiceContainer]:
         """
         Returns all the available service containers.
         :param services: the list of services to restrict the search to. If empty or NULL then service containers for
@@ -495,7 +496,7 @@ class ServicePluginManager(ServiceManager):
             c for s in services if (c := super(ServicePluginManager, self).get_service_container(s))
         ]
 
-    def list_loaded_services(self) -> List[str]:
+    def list_loaded_services(self) -> list[str]:
         """
         Lists all the services which have a provider that has been initialized
 
@@ -506,7 +507,7 @@ class ServicePluginManager(ServiceManager):
             for service_container in self._get_loaded_service_containers()
         ]
 
-    def list_active_services(self) -> List[str]:
+    def list_active_services(self) -> list[str]:
         """
         Lists all services that have an initialised provider and are currently running.
 
@@ -521,7 +522,7 @@ class ServicePluginManager(ServiceManager):
     def exists(self, name: str) -> bool:
         return name in self.list_available()
 
-    def get_state(self, name: str) -> Optional[ServiceState]:
+    def get_state(self, name: str) -> ServiceState | None:
         if name in self._services:
             # ServiceContainer exists, which means the plugin has been loaded
             return super().get_state(name)
@@ -537,7 +538,7 @@ class ServicePluginManager(ServiceManager):
 
         return ServiceState.AVAILABLE if is_api_enabled(name) else ServiceState.DISABLED
 
-    def get_service_container(self, name: str) -> Optional[ServiceContainer]:
+    def get_service_container(self, name: str) -> ServiceContainer | None:
         if container := self._services.get(name):
             return container
 
@@ -565,7 +566,7 @@ class ServicePluginManager(ServiceManager):
             return self._services.get(name)
 
     @property
-    def api_provider_specs(self) -> Dict[str, List[str]]:
+    def api_provider_specs(self) -> dict[str, list[str]]:
         """
         Returns all provider names within the service plugin namespace and parses their name according to the convention,
         that is "<api>:<provider>". The result is a dictionary that maps api => List[str (name of a provider)].
@@ -579,7 +580,7 @@ class ServicePluginManager(ServiceManager):
             return self._api_provider_specs
 
     @log_duration()
-    def _load_service_plugin(self, name: str) -> Optional[ServicePlugin]:
+    def _load_service_plugin(self, name: str) -> ServicePlugin | None:
         providers = self.api_provider_specs.get(name)
         if not providers:
             # no providers for this api
@@ -608,7 +609,7 @@ class ServicePluginManager(ServiceManager):
         return plugin
 
     @log_duration()
-    def _resolve_api_provider_specs(self) -> Dict[str, List[str]]:
+    def _resolve_api_provider_specs(self) -> dict[str, list[str]]:
         result = defaultdict(list)
 
         for spec in self.plugin_manager.list_plugin_specs():
@@ -619,7 +620,7 @@ class ServicePluginManager(ServiceManager):
 
         return result
 
-    def apis_with_provider(self, provider: str) -> List[str]:
+    def apis_with_provider(self, provider: str) -> list[str]:
         """
         Lists all apis where a given provider exists for.
         :param provider: Name of the provider
@@ -631,7 +632,7 @@ class ServicePluginManager(ServiceManager):
                 apis.append(api)
         return apis
 
-    def _stop_services(self, service_containers: List[ServiceContainer]) -> None:
+    def _stop_services(self, service_containers: list[ServiceContainer]) -> None:
         """
         Atomically attempts to stop all given 'ServiceState.STARTING' and 'ServiceState.RUNNING' services.
         :param service_containers: the list of service containers to be stopped.
@@ -642,7 +643,7 @@ class ServicePluginManager(ServiceManager):
                 if service_container.state in target_service_states:
                     service_container.stop()
 
-    def stop_services(self, services: List[str] = None):
+    def stop_services(self, services: list[str] = None):
         """
         Stops services for this service manager, if they are currently active.
         Will not stop services not already started or in and error state.
@@ -691,7 +692,7 @@ def check_service_health(api, expect_shutdown=False):
             LOG.warning('Service "%s" not yet available, retrying...', api)
         else:
             LOG.warning('Service "%s" still shutting down, retrying...', api)
-        raise Exception("Service check failed for api: %s" % api)
+        raise Exception(f"Service check failed for api: {api}")
 
 
 @hooks.on_infra_start(should_load=lambda: config.EAGER_SERVICE_LOADING)
@@ -707,4 +708,8 @@ def eager_load_services():
         except ServiceDisabled as e:
             LOG.debug("%s", e)
         except Exception:
-            LOG.exception("could not load service plugin %s", api)
+            LOG.error(
+                "could not load service plugin %s",
+                api,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
+            )

localstack/services/providers.py

@@ -41,7 +41,7 @@ def apigateway_legacy():
     return Service.for_provider(provider, dispatch_table_factory=MotoFallbackDispatcher)
 
 
-@aws_provider()
+@aws_provider(api="cloudformation", name="engine-legacy")
 def cloudformation():
     from localstack.services.cloudformation.provider import CloudformationProvider
 
@@ -49,7 +49,7 @@ def cloudformation():
     return Service.for_provider(provider)
 
 
-@aws_provider(api="cloudformation", name="engine-v2")
+@aws_provider(api="cloudformation")
 def cloudformation_v2():
     from localstack.services.cloudformation.v2.provider import CloudformationProviderV2
 
@@ -318,6 +318,14 @@ def sns():
     return Service.for_provider(provider, dispatch_table_factory=MotoFallbackDispatcher)
 
 
+@aws_provider(api="sns", name="v2")
+def sns_v2():
+    from localstack.services.sns.v2.provider import SnsProvider
+
+    provider = SnsProvider()
+    return Service.for_provider(provider)
+
+
 @aws_provider()
 def sqs():
     from localstack.services.sqs.provider import SqsProvider