localstack-core 4.7.1.dev139__py3-none-any.whl → 4.10.1.dev42__py3-none-any.whl

localstack/utils/aws/request_context.py

@@ -4,7 +4,6 @@ This module has utilities relating to creating/parsing AWS requests.
 
 import logging
 import re
-from typing import Optional
 
 from rolo import Request as RoloRequest
 
@@ -30,7 +29,7 @@ def get_account_id_from_request(request: RoloRequest) -> str:
     return get_account_id_from_access_key_id(access_key_id)
 
 
-def extract_region_from_auth_header(headers) -> Optional[str]:
+def extract_region_from_auth_header(headers) -> str | None:
     auth = headers.get("Authorization") or ""
     region = re.sub(r".*Credential=[^/]+/[^/]+/([^/]+)/.*", r"\1", auth)
     if region == auth:
@@ -38,12 +37,12 @@ def extract_region_from_auth_header(headers) -> Optional[str]:
     return region
 
 
-def extract_account_id_from_auth_header(headers) -> Optional[str]:
+def extract_account_id_from_auth_header(headers) -> str | None:
     if access_key_id := extract_access_key_id_from_auth_header(headers):
         return get_account_id_from_access_key_id(access_key_id)
 
 
-def extract_access_key_id_from_auth_header(headers: dict[str, str]) -> Optional[str]:
+def extract_access_key_id_from_auth_header(headers: dict[str, str]) -> str | None:
     auth = headers.get("Authorization") or ""
 
     if auth.startswith("AWS4-"):
@@ -67,7 +66,7 @@ def extract_region_from_headers(headers) -> str:
     return extract_region_from_auth_header(headers) or AWS_REGION_US_EAST_1
 
 
-def extract_service_name_from_auth_header(headers: dict) -> Optional[str]:
+def extract_service_name_from_auth_header(headers: dict) -> str | None:
     try:
         auth_header = headers.get("authorization", "")
         credential_scope = auth_header.split(",")[0].split()[1]

localstack/utils/batch_policy.py

@@ -1,6 +1,6 @@
 import copy
 import time
-from typing import Generic, Optional, TypeVar, overload
+from typing import Generic, TypeVar, overload
 
 from pydantic import Field
 from pydantic.dataclasses import dataclass
@@ -47,8 +47,8 @@ class Batcher(Generic[T]):
         assert batcher.flush() == ["item1", "item2", "item3", "item4"]
     """
 
-    max_count: Optional[int] = Field(default=None, description="Maximum number of items", ge=0)
-    max_window: Optional[float] = Field(
+    max_count: int | None = Field(default=None, description="Maximum number of items", ge=0)
+    max_window: float | None = Field(
         default=None, description="Maximum time window in seconds", ge=0
     )
 

localstack/utils/bootstrap.py

@@ -9,9 +9,9 @@ import shlex
 import signal
 import threading
 import time
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from functools import wraps
-from typing import Any, Callable, Optional, Union
+from typing import Any
 
 from localstack import config, constants
 from localstack.config import (
@@ -175,7 +175,7 @@ def get_docker_image_details(image_name: str = None) -> dict[str, str]:
     return result
 
 
-def get_image_environment_variable(env_name: str) -> Optional[str]:
+def get_image_environment_variable(env_name: str) -> str | None:
     image_name = get_docker_image_to_start()
     image_info = DOCKER_CLIENT.inspect_image(image_name)
     image_envs = image_info["Config"]["Env"]
@@ -544,7 +544,7 @@ class ContainerConfigurators:
 
     @staticmethod
     def gateway_listen(
-        port: Union[int, Iterable[int], HostAndPort, Iterable[HostAndPort]],
+        port: int | Iterable[int] | HostAndPort | Iterable[HostAndPort],
     ):
         """
         Uses the given ports to configure GATEWAY_LISTEN. For instance, ``gateway_listen([4566, 443])`` would
@@ -1000,7 +1000,7 @@ class RunningContainer:
                     return
                 raise
 
-    def inspect(self) -> dict[str, Union[dict, str]]:
+    def inspect(self) -> dict[str, dict | str]:
         return self.container_client.inspect_container(container_name_or_id=self.id)
 
     def attach(self):
@@ -1028,7 +1028,7 @@ class ContainerLogPrinter:
         self.callback = callback
 
         self._closed = threading.Event()
-        self._stream: Optional[CancellableStream] = None
+        self._stream: CancellableStream | None = None
 
     def _can_start_streaming(self):
         if self._closed.is_set():
@@ -1338,7 +1338,7 @@ def start_infra_in_docker_detached(console, cli_params: dict[str, Any] = None):
     console.log("detaching")
 
 
-def wait_container_is_ready(timeout: Optional[float] = None):
+def wait_container_is_ready(timeout: float | None = None):
     """Blocks until the localstack main container is running and the ready marker has been printed."""
     container_name = config.MAIN_CONTAINER_NAME
     started = time.time()

localstack/utils/catalog/catalog.py

@@ -0,0 +1,139 @@
+import logging
+from abc import abstractmethod
+
+from plux import Plugin
+
+from localstack.services.cloudformation.resource_provider import (
+    plugin_manager as cfn_plugin_manager,
+)
+from localstack.utils.catalog.catalog_loader import RemoteCatalogLoader
+from localstack.utils.catalog.common import (
+    AwsServiceOperationsSupportInLatest,
+    AwsServicesSupportInLatest,
+    AwsServiceSupportAtRuntime,
+    CloudFormationResourcesSupportAtRuntime,
+    CloudFormationResourcesSupportInLatest,
+    LocalstackEmulatorType,
+)
+
+ServiceName = str
+ServiceOperations = set[str]
+ProviderName = str
+CfnResourceName = str
+CfnResourceMethodName = str
+AwsServicesSupportStatus = (
+    AwsServiceSupportAtRuntime | AwsServicesSupportInLatest | AwsServiceOperationsSupportInLatest
+)
+CfnResourceSupportStatus = (
+    CloudFormationResourcesSupportInLatest | CloudFormationResourcesSupportAtRuntime
+)
+CfnResourceCatalog = dict[LocalstackEmulatorType, dict[CfnResourceName, set[CfnResourceMethodName]]]
+
+LOG = logging.getLogger(__name__)
+
+
+class CatalogPlugin(Plugin):
+    namespace = "localstack.utils.catalog"
+
+    @staticmethod
+    def _get_cfn_resources_catalog(cloudformation_resources: dict) -> CfnResourceCatalog:
+        cfn_resources_catalog = {}
+        for emulator_type, resources in cloudformation_resources.items():
+            cfn_resources_catalog[emulator_type] = {}
+            for resource_name, resource in resources.items():
+                cfn_resources_catalog[emulator_type][resource_name] = set(resource.methods)
+        return cfn_resources_catalog
+
+    @staticmethod
+    def _get_services_at_runtime() -> set[ServiceName]:
+        from localstack.services.plugins import SERVICE_PLUGINS
+
+        return set(SERVICE_PLUGINS.list_available())
+
+    @staticmethod
+    def _get_cfn_resources_available_at_runtime() -> set[CfnResourceName]:
+        return set(cfn_plugin_manager.list_names())
+
+    @abstractmethod
+    def get_aws_service_status(
+        self, service_name: str, operation_name: str | None = None
+    ) -> AwsServicesSupportStatus | None:
+        pass
+
+    @abstractmethod
+    def get_cloudformation_resource_status(
+        self, resource_name: str, service_name: str, is_pro_resource: bool = False
+    ) -> CfnResourceSupportStatus | AwsServicesSupportInLatest | None:
+        pass
+
+
+class AwsCatalogRuntimePlugin(CatalogPlugin):
+    name = "aws-catalog-runtime-only"
+
+    def get_aws_service_status(
+        self, service_name: str, operation_name: str | None = None
+    ) -> AwsServicesSupportStatus | None:
+        return None
+
+    def get_cloudformation_resource_status(
+        self, resource_name: str, service_name: str, is_pro_resource: bool = False
+    ) -> CfnResourceSupportStatus | AwsServicesSupportInLatest | None:
+        return None
+
+
+class AwsCatalogRemoteStatePlugin(CatalogPlugin):
+    name = "aws-catalog-remote-state"
+    current_emulator_type: LocalstackEmulatorType = LocalstackEmulatorType.COMMUNITY
+    services_in_latest: dict[ServiceName, dict[LocalstackEmulatorType, ServiceOperations]] = {}
+    services_at_runtime: set[ServiceName] = set()
+    cfn_resources_in_latest: CfnResourceCatalog = {}
+    cfn_resources_at_runtime: set[CfnResourceName] = set()
+
+    def __init__(self, remote_catalog_loader: RemoteCatalogLoader | None = None) -> None:
+        catalog_loader = remote_catalog_loader or RemoteCatalogLoader()
+        remote_catalog = catalog_loader.get_remote_catalog()
+        for service_name, emulators in remote_catalog.services.items():
+            for emulator_type, service_provider in emulators.items():
+                self.services_in_latest.setdefault(service_name, {})[emulator_type] = set(
+                    service_provider.operations
+                )
+
+        self.cfn_resources_in_latest = self._get_cfn_resources_catalog(
+            remote_catalog.cloudformation_resources
+        )
+        self.cfn_resources_at_runtime = self._get_cfn_resources_available_at_runtime()
+        self.services_at_runtime = self._get_services_at_runtime()
+
+    def get_aws_service_status(
+        self, service_name: str, operation_name: str | None = None
+    ) -> AwsServicesSupportStatus | None:
+        if not self.services_in_latest:
+            return None
+        if service_name not in self.services_in_latest:
+            return AwsServicesSupportInLatest.NOT_SUPPORTED
+        if self.current_emulator_type not in self.services_in_latest[service_name]:
+            return AwsServicesSupportInLatest.SUPPORTED_WITH_LICENSE_UPGRADE
+        if not operation_name:
+            return AwsServicesSupportInLatest.SUPPORTED
+        if operation_name in self.services_in_latest[service_name][self.current_emulator_type]:
+            return AwsServiceOperationsSupportInLatest.SUPPORTED
+        for emulator_type in self.services_in_latest[service_name]:
+            if emulator_type is self.current_emulator_type:
+                continue
+            if operation_name in self.services_in_latest[service_name][emulator_type]:
+                return AwsServiceOperationsSupportInLatest.SUPPORTED_WITH_LICENSE_UPGRADE
+        return AwsServiceOperationsSupportInLatest.NOT_SUPPORTED
+
+    def get_cloudformation_resource_status(
+        self, resource_name: str, service_name: str, is_pro_resource: bool = False
+    ) -> CfnResourceSupportStatus | AwsServicesSupportInLatest | None:
+        if resource_name in self.cfn_resources_at_runtime:
+            return CloudFormationResourcesSupportAtRuntime.AVAILABLE
+        if service_name in self.services_at_runtime:
+            if resource_name in self.cfn_resources_in_latest[self.current_emulator_type]:
+                return CloudFormationResourcesSupportInLatest.SUPPORTED
+            else:
+                return CloudFormationResourcesSupportInLatest.NOT_SUPPORTED
+        if service_name in self.services_in_latest:
+            return self.get_aws_service_status(service_name, operation_name=None)
+        return AwsServicesSupportInLatest.NOT_SUPPORTED

localstack/utils/catalog/catalog_loader.py

@@ -0,0 +1,119 @@
+import json
+import logging
+from json import JSONDecodeError
+from pathlib import Path
+
+import requests
+from pydantic import BaseModel
+
+from localstack import config, constants
+from localstack.utils.catalog.common import AwsRemoteCatalog
+from localstack.utils.http import get_proxies
+from localstack.utils.json import FileMappedDocument
+
+LOG = logging.getLogger(__name__)
+
+AWS_CATALOG_FILE_NAME = "aws_catalog.json"
+
+
+class RemoteCatalogVersionResponse(BaseModel):
+    emulator_type: str
+    version: str
+
+
+class AwsCatalogLoaderException(Exception):
+    def __init__(self, msg: str, *args):
+        super().__init__(msg, *args)
+
+
+class RemoteCatalogLoader:
+    supported_schema_version = "v1"
+    api_endpoint_catalog = f"{constants.API_ENDPOINT}/license/catalog"
+    catalog_file_path = Path(config.dirs.cache) / AWS_CATALOG_FILE_NAME
+
+    def get_remote_catalog(self) -> AwsRemoteCatalog:
+        catalog_doc = FileMappedDocument(self.catalog_file_path)
+        cached_catalog = AwsRemoteCatalog(**catalog_doc) if catalog_doc else None
+        if cached_catalog:
+            cached_catalog_version = cached_catalog.localstack.version
+            if not self._should_update_cached_catalog(cached_catalog_version):
+                return cached_catalog
+        catalog = self._get_catalog_from_platform()
+        self._save_catalog_to_cache(catalog_doc, catalog)
+        return catalog
+
+    def _get_latest_localstack_version(self) -> str:
+        try:
+            proxies = get_proxies()
+            response = requests.get(
+                f"{self.api_endpoint_catalog}/aws/version",
+                verify=not config.is_env_true("SSL_NO_VERIFY"),
+                proxies=proxies,
+            )
+            if response.ok:
+                return RemoteCatalogVersionResponse.model_validate(response.content).version
+            self._raise_server_error(response)
+        except requests.exceptions.RequestException as e:
+            raise AwsCatalogLoaderException(
+                f"An unexpected network error occurred when trying to fetch latest localstack version: {e}"
+            ) from e
+
+    def _should_update_cached_catalog(self, current_catalog_version: str) -> bool:
+        try:
+            latest_version = self._get_latest_localstack_version()
+            return latest_version != current_catalog_version
+        except Exception as e:
+            LOG.warning(
+                "Failed to retrieve the latest catalog version, cached catalog update skipped: %s",
+                e,
+            )
+            return False
+
+    def _save_catalog_to_cache(self, catalog_doc: FileMappedDocument, catalog: AwsRemoteCatalog):
+        catalog_doc.clear()
+        catalog_doc.update(catalog.model_dump())
+        catalog_doc.save()
+
+    def _get_catalog_from_platform(self) -> AwsRemoteCatalog:
+        try:
+            proxies = get_proxies()
+            response = requests.post(
+                self.api_endpoint_catalog,
+                verify=not config.is_env_true("SSL_NO_VERIFY"),
+                proxies=proxies,
+            )
+
+            if response.ok:
+                return self._parse_catalog(response.content)
+            self._raise_server_error(response)
+        except requests.exceptions.RequestException as e:
+            raise AwsCatalogLoaderException(
+                f"An unexpected network error occurred when trying to fetch remote catalog: {e}"
+            ) from e
+
+    def _parse_catalog(self, document: bytes) -> AwsRemoteCatalog | None:
+        try:
+            catalog_json = json.loads(document)
+        except JSONDecodeError as e:
+            raise AwsCatalogLoaderException(f"Could not de-serialize json catalog: {e}") from e
+        remote_catalog = AwsRemoteCatalog.model_validate(catalog_json)
+        if remote_catalog.schema_version != self.supported_schema_version:
+            raise AwsCatalogLoaderException(
+                f"Unsupported schema version: '{remote_catalog.schema_version}'. Only '{self.supported_schema_version}' is supported"
+            )
+        return remote_catalog
+
+    def _raise_server_error(self, response: requests.Response):
+        try:
+            server_error = response.json()
+            if error_message := server_error.get("message"):
+                raise AwsCatalogLoaderException(
+                    f"Unexpected AWS catalog server error: {response.text}"
+                )
+            raise AwsCatalogLoaderException(
+                f"A server error occurred while calling remote catalog API (HTTP {response.status_code}): {error_message}"
+            )
+        except Exception:
+            raise AwsCatalogLoaderException(
+                f"An unexpected server error occurred while calling remote catalog API (HTTP {response.status_code}): {response.text}"
+            )

localstack/utils/catalog/common.py

@@ -0,0 +1,58 @@
+from enum import StrEnum
+
+from pydantic import BaseModel
+
+
+class CloudFormationResource(BaseModel):
+    methods: list[str]
+
+
+class AwsServiceCatalog(BaseModel):
+    provider: str
+    operations: list[str]
+    plans: list[str]
+
+
+class LocalStackMetadata(BaseModel):
+    version: str
+
+
+class AwsRemoteCatalog(BaseModel):
+    schema_version: str
+    localstack: LocalStackMetadata
+    services: dict[str, dict[str, AwsServiceCatalog]]
+    cloudformation_resources: dict[str, dict[str, CloudFormationResource]]
+
+
+class LocalstackEmulatorType(StrEnum):
+    COMMUNITY = "community"
+    PRO = "pro"
+
+
+class AwsServiceSupportAtRuntime(StrEnum):
+    AVAILABLE = "AVAILABLE"
+    AVAILABLE_WITH_LICENSE_UPGRADE = "AVAILABLE_WITH_LICENSE_UPGRADE"
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED"
+
+
+class AwsServicesSupportInLatest(StrEnum):
+    SUPPORTED = "SUPPORTED"
+    SUPPORTED_WITH_LICENSE_UPGRADE = "SUPPORTED_WITH_LICENSE_UPGRADE"
+    NOT_SUPPORTED = "NOT_SUPPORTED"
+    NON_DEFAULT_PROVIDER = "NON_DEFAULT_PROVIDER"
+
+
+class AwsServiceOperationsSupportInLatest(StrEnum):
+    SUPPORTED = "SUPPORTED"
+    SUPPORTED_WITH_LICENSE_UPGRADE = "SUPPORTED_WITH_LICENSE_UPGRADE"
+    NOT_SUPPORTED = "NOT_SUPPORTED"
+
+
+class CloudFormationResourcesSupportInLatest(StrEnum):
+    SUPPORTED = "SUPPORTED"
+    NOT_SUPPORTED = "NOT_SUPPORTED"
+
+
+class CloudFormationResourcesSupportAtRuntime(StrEnum):
+    AVAILABLE = "AVAILABLE"
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED"

localstack/utils/catalog/plugins.py

@@ -0,0 +1,28 @@
+import logging
+
+from plux import PluginManager
+
+from localstack.utils.catalog.catalog import CatalogPlugin
+from localstack.utils.objects import singleton_factory
+
+LOG = logging.getLogger(__name__)
+
+
+@singleton_factory
+def get_aws_catalog() -> CatalogPlugin:
+    plugin_manager = PluginManager(CatalogPlugin.namespace)
+    try:
+        plugin_name = "aws-catalog-remote-state-with-license"
+        if not plugin_manager.exists(plugin_name):
+            plugin_name = "aws-catalog-remote-state"
+        return plugin_manager.load(plugin_name)
+    except Exception as e:
+        LOG.debug(
+            "Failed to load catalog plugin with the latest LocalStack services support data, falling back to catalog without remote state: %s",
+            e,
+        )
+        # Try to load runtime catalog from pro version first
+        fallback_plugin_name = "aws-catalog-runtime-only-with-license"
+        if not plugin_manager.exists(fallback_plugin_name):
+            fallback_plugin_name = "aws-catalog-runtime-only"
+        return plugin_manager.load(fallback_plugin_name)

localstack/utils/cloudwatch/cloudwatch_util.py

@@ -2,7 +2,7 @@ import logging
 import time
 from datetime import datetime, timezone
 from itertools import islice
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 from werkzeug import Response as WerkzeugResponse
 
@@ -20,8 +20,8 @@ LOG = logging.getLogger(__name__)
 class SqsMetricBatchData(TypedDict, total=False):
     MetricName: str
     QueueName: str
-    Value: Optional[int]
-    Unit: Optional[str]
+    Value: int | None
+    Unit: str | None
 
 
 def dimension_lambda(kwargs):
@@ -30,7 +30,7 @@ def dimension_lambda(kwargs):
 
 
 def publish_lambda_metric(
-    metric, value, kwargs, account_id: Optional[str] = None, region_name: Optional[str] = None
+    metric, value, kwargs, account_id: str | None = None, region_name: str | None = None
 ):
     # publish metric only if CloudWatch service is available
     if not is_api_enabled("cloudwatch"):
@@ -155,7 +155,7 @@ def store_cloudwatch_logs(
     log_stream_name,
     log_output,
     start_time=None,
-    auto_create_group: Optional[bool] = True,
+    auto_create_group: bool | None = True,
 ):
     if not is_api_enabled("logs"):
         return

localstack/utils/collections.py

@@ -5,10 +5,9 @@ and manipulate python collection (dicts, list, sets).
 
 import logging
 import re
-from collections.abc import Iterable, Iterator, Mapping, Sized
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sized
 from typing import (
     Any,
-    Callable,
     Optional,
     TypedDict,
     TypeVar,
@@ -116,7 +115,7 @@ class PaginatedList(list[_ListType]):
         next_token: str = None,
         page_size: int = None,
         filter_function: Callable[[_ListType], bool] = None,
-    ) -> tuple[list[_ListType], Optional[str]]:
+    ) -> tuple[list[_ListType], str | None]:
         if filter_function is not None:
             result_list = list(filter(filter_function, self))
         else:
@@ -148,7 +147,7 @@ class PaginatedList(list[_ListType]):
 class CustomExpiryTTLCache(cachetools.TTLCache):
     """TTLCache that allows to set custom expiry times for individual keys."""
 
-    def set_expiry(self, key: Any, ttl: Union[float, int]) -> float:
+    def set_expiry(self, key: Any, ttl: float | int) -> float:
         """Set the expiry of the given key in a TTLCache to (<current_time> + <ttl>)"""
         with self.timer as time:
             # note: need to access the internal dunder API here
@@ -315,7 +314,7 @@ def is_list_or_tuple(obj) -> bool:
     return isinstance(obj, (list, tuple))
 
 
-def ensure_list(obj: Any, wrap_none=False) -> Optional[list]:
+def ensure_list(obj: Any, wrap_none=False) -> list | None:
     """Wrap the given object in a list, or return the object itself if it already is a list."""
     if obj is None and not wrap_none:
         return obj
@@ -414,7 +413,7 @@ def items_equivalent(list1, list2, comparator):
     return True
 
 
-def is_none_or_empty(obj: Union[Optional[str], Optional[list]]) -> bool:
+def is_none_or_empty(obj: str | None | list | None) -> bool:
     return (
         obj is None
         or (isinstance(obj, str) and obj.strip() == "")
@@ -475,7 +474,7 @@ def convert_to_typed_dict(typed_dict: type[T], obj: dict, strict: bool = False)
     return result
 
 
-def dict_multi_values(elements: Union[list, dict]) -> dict[str, list[Any]]:
+def dict_multi_values(elements: list | dict) -> dict[str, list[Any]]:
     """
     Return a dictionary with the original keys from the list of dictionary and the
     values are the list of values of the original dictionary.
@@ -516,7 +515,7 @@ def split_list_by(
     return truthy, falsy
 
 
-def is_comma_delimited_list(string: str, item_regex: Optional[str] = None) -> bool:
+def is_comma_delimited_list(string: str, item_regex: str | None = None) -> bool:
     """
     Checks if the given string is a comma-delimited list of items.
     The optional `item_regex` parameter specifies the regex pattern for each item in the list.

localstack/utils/config_listener.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import re
-from typing import Callable
+from collections.abc import Callable
 
 from requests.models import Response
 

localstack/utils/container_networking.py

@@ -2,7 +2,6 @@ import logging
 import os
 import re
 from functools import lru_cache
-from typing import Optional
 
 from localstack import config, constants
 from localstack.utils.container_utils.container_client import ContainerException
@@ -13,7 +12,7 @@ LOG = logging.getLogger(__name__)
 
 
 @lru_cache
-def get_main_container_network() -> Optional[str]:
+def get_main_container_network() -> str | None:
     """
     Gets the main network of the LocalStack container (if we run in one, bridge otherwise)
     If there are multiple networks connected to the LocalStack container, we choose the first as "main" network
@@ -50,7 +49,7 @@ def get_main_container_network() -> Optional[str]:
 
 
 @lru_cache
-def get_endpoint_for_network(network: Optional[str] = None) -> str:
+def get_endpoint_for_network(network: str | None = None) -> str:
     """
     Get the LocalStack endpoint (= IP address) on the given network.
     If a network is given, it will return the IP address/hostname of LocalStack on that network