localstack-core 4.13.2.dev63__py3-none-any.whl → 4.13.2.dev67__py3-none-any.whl

localstack/services/dynamodb/models.py

@@ -3,10 +3,15 @@ from typing import TypedDict
 
 from localstack.aws.api.dynamodb import (
     AttributeMap,
+    BackupDetails,
+    ContinuousBackupsDescription,
+    GlobalTableDescription,
     Key,
+    KinesisDataStreamDestination,
     RegionName,
     ReplicaDescription,
     StreamViewType,
+    TableDescription,
     TableName,
     TimeToLiveSpecification,
 )
@@ -91,9 +96,20 @@ class TableRecords(TypedDict):
 RecordsMap = dict[TableName, TableRecords]
 
 
+class TableProperties(TypedDict, total=False):
+    ContinuousBackupsDescription: ContinuousBackupsDescription
+
+
+@dataclasses.dataclass
+class Backup:
+    details: BackupDetails
+    backup_file: str
+    table_name: str
+
+
 class DynamoDBStore(BaseStore):
     # maps global table names to configurations (for the legacy v.2017 tables)
-    GLOBAL_TABLES: dict[str, dict] = CrossRegionAttribute(default=dict)
+    GLOBAL_TABLES: dict[str, GlobalTableDescription] = CrossRegionAttribute(default=dict)
 
     # Maps table name to the region they exist in on DDBLocal (for v.2019 global tables)
     TABLE_REGION: dict[TableName, RegionName] = CrossRegionAttribute(default=dict)
@@ -104,19 +120,24 @@ class DynamoDBStore(BaseStore):
     )
 
     # cache table taggings - maps table ARN to tags dict
-    TABLE_TAGS: dict[str, dict] = CrossRegionAttribute(default=dict)
+    TABLE_TAGS: dict[str, dict[str, str]] = CrossRegionAttribute(default=dict)
 
     # maps table names to cached table definitions
-    table_definitions: dict[str, dict] = LocalAttribute(default=dict)
+    table_definitions: dict[str, TableDescription] = LocalAttribute(default=dict)
+
+    # map table name to streaming destinations
+    streaming_destinations: dict[str, list[KinesisDataStreamDestination]] = LocalAttribute(
+        default=dict
+    )
 
     # maps table names to additional table properties that are not stored upstream (e.g., ReplicaUpdates)
-    table_properties: dict[str, dict] = LocalAttribute(default=dict)
+    table_properties: dict[str, TableProperties] = LocalAttribute(default=dict)
 
     # maps table names to TTL specifications
     ttl_specifications: dict[str, TimeToLiveSpecification] = LocalAttribute(default=dict)
 
     # maps backups
-    backups: dict[str, dict] = LocalAttribute(default=dict)
+    backups: dict[str, Backup] = LocalAttribute(default=dict)
 
 
 dynamodb_stores = AccountRegionBundle("dynamodb", DynamoDBStore)

localstack/services/dynamodb/provider.py

@@ -6,7 +6,6 @@ import random
 import re
 import threading
 import time
-import traceback
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
@@ -64,6 +63,7 @@ from localstack.aws.api.dynamodb import (
     GetItemOutput,
     GlobalTableAlreadyExistsException,
     GlobalTableNotFoundException,
+    KinesisDataStreamDestination,
     KinesisStreamingDestinationOutput,
     ListGlobalTablesOutput,
     ListTablesInputLimit,
@@ -274,7 +274,12 @@ class EventForwarder:
             table_arn = arns.dynamodb_table_arn(table_name, account_id, region_name)
             records = table_records["records"]
             table_def = store.table_definitions.get(table_name) or {}
-            stream_arn = table_def["KinesisDataStreamDestinations"][-1]["StreamArn"]
+            destinations = store.streaming_destinations.get(table_name)
+            if not destinations:
+                LOG.debug("Table %s has no Kinesis streaming destinations enabled", table_name)
+                continue
+
+            stream_arn = destinations[-1]["StreamArn"]
             for record in records:
                 kinesis_record = dict(
                     tableName=table_name,
@@ -1665,34 +1670,32 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         if not stream:
             raise ValidationException("User does not have a permission to use kinesis stream")
 
-        table_def = get_store(context.account_id, context.region).table_definitions.setdefault(
-            table_name, {}
-        )
-
-        dest_status = table_def.get("KinesisDataStreamDestinationStatus")
-        if dest_status not in ["DISABLED", "ENABLE_FAILED", None]:
-            raise ValidationException(
-                "Table is not in a valid state to enable Kinesis Streaming "
-                "Destination:EnableKinesisStreamingDestination must be DISABLED or ENABLE_FAILED "
-                "to perform ENABLE operation."
-            )
+        store = get_store(context.account_id, context.region)
+        streaming_destinations = store.streaming_destinations.get(table_name) or []
 
-        table_def.setdefault("KinesisDataStreamDestinations", [])
+        destinations = [d for d in streaming_destinations if d["StreamArn"] == stream_arn]
+        if destinations:
+            status = destinations[0].get("DestinationStatus", None)
+            if status not in ["DISABLED", "ENABLED_FAILED", None]:
+                raise ValidationException(
+                    "Table is not in a valid state to enable Kinesis Streaming "
+                    "Destination:EnableKinesisStreamingDestination must be DISABLED or ENABLE_FAILED "
+                    "to perform ENABLE operation."
+                )
 
         # remove the stream destination if already present
-        table_def["KinesisDataStreamDestinations"] = [
-            t for t in table_def["KinesisDataStreamDestinations"] if t["StreamArn"] != stream_arn
+        store.streaming_destinations[table_name] = [
+            _d for _d in streaming_destinations if _d["StreamArn"] != stream_arn
         ]
         # append the active stream destination at the end of the list
-        table_def["KinesisDataStreamDestinations"].append(
-            {
-                "DestinationStatus": DestinationStatus.ACTIVE,
-                "DestinationStatusDescription": "Stream is active",
-                "StreamArn": stream_arn,
-                "ApproximateCreationDateTimePrecision": ApproximateCreationDateTimePrecision.MILLISECOND,
-            }
+        store.streaming_destinations[table_name].append(
+            KinesisDataStreamDestination(
+                DestinationStatus=DestinationStatus.ACTIVE,
+                DestinationStatusDescription="Stream is active",
+                StreamArn=stream_arn,
+                ApproximateCreationDateTimePrecision=ApproximateCreationDateTimePrecision.MILLISECOND,
+            )
         )
-        table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.ACTIVE
         return KinesisStreamingDestinationOutput(
             DestinationStatus=DestinationStatus.ENABLING,
             StreamArn=stream_arn,
@@ -1715,34 +1718,25 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
             error_message=f"Requested resource not found: Table: {table_name} not found",
         )
 
-        # TODO: Must raise if invoked before KinesisStreamingDestination is ACTIVE
-
         stream = self._event_forwarder.is_kinesis_stream_exists(stream_arn=stream_arn)
         if not stream:
             raise ValidationException(
                 "User does not have a permission to use kinesis stream",
             )
 
-        table_def = get_store(context.account_id, context.region).table_definitions.setdefault(
-            table_name, {}
-        )
-
-        stream_destinations = table_def.get("KinesisDataStreamDestinations")
-        if stream_destinations:
-            if table_def["KinesisDataStreamDestinationStatus"] == DestinationStatus.ACTIVE:
-                for dest in stream_destinations:
-                    if (
-                        dest["StreamArn"] == stream_arn
-                        and dest["DestinationStatus"] == DestinationStatus.ACTIVE
-                    ):
-                        dest["DestinationStatus"] = DestinationStatus.DISABLED
-                        dest["DestinationStatusDescription"] = ("Stream is disabled",)
-                        table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.DISABLED
-                        return KinesisStreamingDestinationOutput(
-                            DestinationStatus=DestinationStatus.DISABLING,
-                            StreamArn=stream_arn,
-                            TableName=table_name,
-                        )
+        store = get_store(context.account_id, context.region)
+        streaming_destinations = store.streaming_destinations.get(table_name) or []
+
+        # Get the right destination based on the arn
+        destinations = [d for d in streaming_destinations if d["StreamArn"] == stream_arn]
+        if destinations:
+            destinations[0]["DestinationStatus"] = DestinationStatus.DISABLED
+            destinations[0]["DestinationStatusDescription"] = "Stream is disabled"
+            return KinesisStreamingDestinationOutput(
+                DestinationStatus=DestinationStatus.DISABLING,
+                StreamArn=stream_arn,
+                TableName=table_name,
+            )
         raise ValidationException(
             "Table is not in a valid state to disable Kinesis Streaming Destination:"
             "DisableKinesisStreamingDestination must be ACTIVE to perform DISABLE operation."
@@ -1753,12 +1747,9 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
     ) -> DescribeKinesisStreamingDestinationOutput:
         self.ensure_table_exists(context.account_id, context.region, table_name)
 
-        table_def = (
-            get_store(context.account_id, context.region).table_definitions.get(table_name) or {}
-        )
-
-        stream_destinations = table_def.get("KinesisDataStreamDestinations") or []
-        stream_destinations = copy.deepcopy(stream_destinations)
+        store = get_store(context.account_id, context.region)
+        table_destinations = store.streaming_destinations.get(table_name) or []
+        stream_destinations = copy.deepcopy(table_destinations)
 
         for destination in stream_destinations:
             destination.pop("ApproximateCreationDateTimePrecision", None)
@@ -1799,23 +1790,21 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
             )
 
         store = get_store(context.account_id, context.region)
+        table_destinations = store.streaming_destinations.get(table_name) or []
 
-        table_def = store.table_definitions.get(table_name) or {}
-        table_def.setdefault("KinesisDataStreamDestinations", [])
-
-        table_id = table_def["TableId"]
-
-        destination = None
-        for stream in table_def["KinesisDataStreamDestinations"]:
-            if stream["StreamArn"] == stream_arn:
-                destination = stream
-
-        if destination is None:
+        # filter the right destination based on the stream ARN
+        destinations = [d for d in table_destinations if d["StreamArn"] == stream_arn]
+        if not destinations:
             raise ValidationException(
                 "Table is not in a valid state to enable Kinesis Streaming Destination: "
                 f"No streaming destination with streamArn: {stream_arn} found for table with tableName: {table_name}"
             )
 
+        destination = destinations[0]
+        table_def = store.table_definitions.get(table_name) or {}
+        table_def.setdefault("KinesisDataStreamDestinations", [])
+
+        table_id = store.table_definitions.get(table_name, {}).get("TableId")
         if (
             existing_precision := destination["ApproximateCreationDateTimePrecision"]
         ) == update_kinesis_streaming_configuration["ApproximateCreationDateTimePrecision"]:
@@ -1823,7 +1812,6 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 f"Invalid Request: Precision is already set to the desired value of {existing_precision} "
                 f"for tableId: {table_id}, kdsArn: {stream_arn}"
             )
-
         destination["ApproximateCreationDateTimePrecision"] = time_precision
 
         return UpdateKinesisStreamingDestinationOutput(
@@ -2317,19 +2305,20 @@ def get_table_stream_type(
     :return: a TableStreamViewType object if the table has streams enabled. If not, return None
     """
     if not table_name_or_arn:
-        return
+        return None
 
     table_name = table_name_or_arn.split(":table/")[-1]
 
     is_kinesis = False
     stream_view_type = None
 
-    if table_definition := get_store(account_id, region_name).table_definitions.get(table_name):
-        if table_definition.get("KinesisDataStreamDestinationStatus") == "ACTIVE":
+    # To determine if stream to kinesis is enabled, we look for active kinesis destinations
+    destinations = get_store(account_id, region_name).streaming_destinations.get(table_name) or []
+    for destination in destinations:
+        if destination["DestinationStatus"] == DestinationStatus.ACTIVE:
             is_kinesis = True
 
     table_arn = arns.dynamodb_table_arn(table_name, account_id=account_id, region_name=region_name)
-
     if (
         stream := dynamodbstreams_api.get_stream_for_table(account_id, region_name, table_arn)
     ) and stream["StreamStatus"] in (StreamStatus.ENABLING, StreamStatus.ENABLED):
@@ -2337,6 +2326,7 @@ def get_table_stream_type(
 
     if is_kinesis or stream_view_type:
         return TableStreamType(stream_view_type, is_kinesis=is_kinesis)
+    return None
 
 
 def get_updated_records(
@@ -2410,7 +2400,9 @@ def get_updated_records(
     return {table_name: TableRecords(records=result, table_stream_type=table_stream_type)}
 
 
-def create_dynamodb_stream(account_id: str, region_name: str, data, latest_stream_label):
+def create_dynamodb_stream(
+    account_id: str, region_name: str, data: CreateTableInput, latest_stream_label: str | None
+) -> None:
     stream = data["StreamSpecification"]
     enabled = stream.get("StreamEnabled")
 
@@ -2428,22 +2420,6 @@ def create_dynamodb_stream(account_id: str, region_name: str, data, latest_strea
         )
 
 
-def dynamodb_get_table_stream_specification(account_id: str, region_name: str, table_name: str):
-    try:
-        table_schema = SchemaExtractor.get_table_schema(
-            table_name, account_id=account_id, region_name=region_name
-        )
-        return table_schema["Table"].get("StreamSpecification")
-    except Exception as e:
-        LOG.info(
-            "Unable to get stream specification for table %s: %s %s",
-            table_name,
-            e,
-            traceback.format_exc(),
-        )
-        raise e
-
-
 def find_item_for_keys_values_in_batch(
     table_name: str, item_keys: dict, batch: BatchGetResponseMap
 ) -> AttributeMap | None:

localstack/services/dynamodb/v2/provider.py

@@ -58,6 +58,7 @@ from localstack.aws.api.dynamodb import (
     GetItemOutput,
     GlobalTableAlreadyExistsException,
     GlobalTableNotFoundException,
+    KinesisDataStreamDestination,
     KinesisStreamingDestinationOutput,
     ListGlobalTablesOutput,
     ListTablesInputLimit,
@@ -1196,34 +1197,32 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         if not kinesis_stream_exists(stream_arn=stream_arn):
             raise ValidationException("User does not have a permission to use kinesis stream")
 
-        table_def = get_store(context.account_id, context.region).table_definitions.setdefault(
-            table_name, {}
-        )
-
-        dest_status = table_def.get("KinesisDataStreamDestinationStatus")
-        if dest_status not in ["DISABLED", "ENABLE_FAILED", None]:
-            raise ValidationException(
-                "Table is not in a valid state to enable Kinesis Streaming "
-                "Destination:EnableKinesisStreamingDestination must be DISABLED or ENABLE_FAILED "
-                "to perform ENABLE operation."
-            )
+        store = get_store(context.account_id, context.region)
+        streaming_destinations = store.streaming_destinations.get(table_name) or []
 
-        table_def.setdefault("KinesisDataStreamDestinations", [])
+        destinations = [d for d in streaming_destinations if d["StreamArn"] == stream_arn]
+        if destinations:
+            status = destinations[0].get("DestinationStatus", None)
+            if status not in ["DISABLED", "ENABLED_FAILED", None]:
+                raise ValidationException(
+                    "Table is not in a valid state to enable Kinesis Streaming "
+                    "Destination:EnableKinesisStreamingDestination must be DISABLED or ENABLE_FAILED "
+                    "to perform ENABLE operation."
+                )
 
         # remove the stream destination if already present
-        table_def["KinesisDataStreamDestinations"] = [
-            t for t in table_def["KinesisDataStreamDestinations"] if t["StreamArn"] != stream_arn
+        store.streaming_destinations[table_name] = [
+            _d for _d in streaming_destinations if _d["StreamArn"] != stream_arn
         ]
         # append the active stream destination at the end of the list
-        table_def["KinesisDataStreamDestinations"].append(
-            {
-                "DestinationStatus": DestinationStatus.ACTIVE,
-                "DestinationStatusDescription": "Stream is active",
-                "StreamArn": stream_arn,
-                "ApproximateCreationDateTimePrecision": ApproximateCreationDateTimePrecision.MILLISECOND,
-            }
+        store.streaming_destinations[table_name].append(
+            KinesisDataStreamDestination(
+                DestinationStatus=DestinationStatus.ACTIVE,
+                DestinationStatusDescription="Stream is active",
+                StreamArn=stream_arn,
+                ApproximateCreationDateTimePrecision=ApproximateCreationDateTimePrecision.MILLISECOND,
+            )
         )
-        table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.ACTIVE
         return KinesisStreamingDestinationOutput(
             DestinationStatus=DestinationStatus.ENABLING,
             StreamArn=stream_arn,
@@ -1251,26 +1250,19 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 "User does not have a permission to use kinesis stream",
             )
 
-        table_def = get_store(context.account_id, context.region).table_definitions.setdefault(
-            table_name, {}
-        )
-
-        stream_destinations = table_def.get("KinesisDataStreamDestinations")
-        if stream_destinations:
-            if table_def["KinesisDataStreamDestinationStatus"] == DestinationStatus.ACTIVE:
-                for dest in stream_destinations:
-                    if (
-                        dest["StreamArn"] == stream_arn
-                        and dest["DestinationStatus"] == DestinationStatus.ACTIVE
-                    ):
-                        dest["DestinationStatus"] = DestinationStatus.DISABLED
-                        dest["DestinationStatusDescription"] = ("Stream is disabled",)
-                        table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.DISABLED
-                        return KinesisStreamingDestinationOutput(
-                            DestinationStatus=DestinationStatus.DISABLING,
-                            StreamArn=stream_arn,
-                            TableName=table_name,
-                        )
+        store = get_store(context.account_id, context.region)
+        streaming_destinations = store.streaming_destinations.get(table_name) or []
+
+        # Get the right destination based on the arn
+        destinations = [d for d in streaming_destinations if d["StreamArn"] == stream_arn]
+        if destinations:
+            destinations[0]["DestinationStatus"] = DestinationStatus.DISABLED
+            destinations[0]["DestinationStatusDescription"] = "Stream is disabled"
+            return KinesisStreamingDestinationOutput(
+                DestinationStatus=DestinationStatus.DISABLING,
+                StreamArn=stream_arn,
+                TableName=table_name,
+            )
         raise ValidationException(
             "Table is not in a valid state to disable Kinesis Streaming Destination:"
             "DisableKinesisStreamingDestination must be ACTIVE to perform DISABLE operation."
@@ -1281,12 +1273,9 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
     ) -> DescribeKinesisStreamingDestinationOutput:
         self.ensure_table_exists(context.account_id, context.region, table_name)
 
-        table_def = (
-            get_store(context.account_id, context.region).table_definitions.get(table_name) or {}
-        )
-
-        stream_destinations = table_def.get("KinesisDataStreamDestinations") or []
-        stream_destinations = copy.deepcopy(stream_destinations)
+        store = get_store(context.account_id, context.region)
+        table_destinations = store.streaming_destinations.get(table_name) or []
+        stream_destinations = copy.deepcopy(table_destinations)
 
         for destination in stream_destinations:
             destination.pop("ApproximateCreationDateTimePrecision", None)
@@ -1327,23 +1316,21 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
             )
 
         store = get_store(context.account_id, context.region)
+        table_destinations = store.streaming_destinations.get(table_name) or []
 
-        table_def = store.table_definitions.get(table_name) or {}
-        table_def.setdefault("KinesisDataStreamDestinations", [])
-
-        table_id = table_def["TableId"]
-
-        destination = None
-        for stream in table_def["KinesisDataStreamDestinations"]:
-            if stream["StreamArn"] == stream_arn:
-                destination = stream
-
-        if destination is None:
+        # filter the right destination based on the stream ARN
+        destinations = [d for d in table_destinations if d["StreamArn"] == stream_arn]
+        if not destinations:
             raise ValidationException(
                 "Table is not in a valid state to enable Kinesis Streaming Destination: "
                 f"No streaming destination with streamArn: {stream_arn} found for table with tableName: {table_name}"
             )
 
+        destination = destinations[0]
+        table_def = store.table_definitions.get(table_name) or {}
+        table_def.setdefault("KinesisDataStreamDestinations", [])
+
+        table_id = store.table_definitions.get(table_name, {}).get("TableId")
         if (
             existing_precision := destination["ApproximateCreationDateTimePrecision"]
         ) == update_kinesis_streaming_configuration["ApproximateCreationDateTimePrecision"]:
@@ -1351,7 +1338,6 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 f"Invalid Request: Precision is already set to the desired value of {existing_precision} "
                 f"for tableId: {table_id}, kdsArn: {stream_arn}"
             )
-
         destination["ApproximateCreationDateTimePrecision"] = time_precision
 
         return UpdateKinesisStreamingDestinationOutput(
@@ -1625,7 +1611,7 @@ def is_index_query_valid(account_id: str, region_name: str, query_data: dict) ->
     return True
 
 
-def kinesis_stream_exists(stream_arn):
+def kinesis_stream_exists(stream_arn: str) -> bool:
     account_id = extract_account_id_from_arn(stream_arn)
     region_name = extract_region_from_arn(stream_arn)
 

localstack/services/dynamodbstreams/dynamodbstreams_api.py

@@ -6,10 +6,19 @@ from bson.json_util import dumps
 
 from localstack import config
 from localstack.aws.api import RequestContext
-from localstack.aws.api.dynamodbstreams import StreamStatus, StreamViewType, TableName
+from localstack.aws.api.dynamodbstreams import (
+    StreamDescription,
+    StreamStatus,
+    StreamViewType,
+    TableName,
+)
 from localstack.aws.connect import connect_to
 from localstack.services.dynamodb.v2.provider import DynamoDBProvider
-from localstack.services.dynamodbstreams.models import DynamoDbStreamsStore, dynamodbstreams_stores
+from localstack.services.dynamodbstreams.models import (
+    DynamoDbStreamsStore,
+    StreamWrapper,
+    dynamodbstreams_stores,
+)
 from localstack.utils.aws import arns, resources
 from localstack.utils.common import now_utc
 from localstack.utils.threads import FuncThread
@@ -65,28 +74,32 @@ def add_dynamodb_stream(
         stream_name=stream_name,
     )
     latest_stream_label = latest_stream_label or "latest"
-    stream = {
-        "StreamArn": arns.dynamodb_stream_arn(
-            table_name=table_name,
-            latest_stream_label=latest_stream_label,
-            account_id=account_id,
-            region_name=region_name,
-        ),
-        "TableName": table_name,
-        "StreamLabel": latest_stream_label,
-        "StreamStatus": StreamStatus.ENABLING,
-        "KeySchema": [],
-        "Shards": [],
-        "StreamViewType": view_type,
-        "shards_id_map": {},
-    }
-    store.ddb_streams[table_name] = stream
-
-
-def get_stream_for_table(account_id: str, region_name: str, table_arn: str) -> dict:
+    stream_arn = arns.dynamodb_stream_arn(
+        table_name=table_name,
+        latest_stream_label=latest_stream_label,
+        account_id=account_id,
+        region_name=region_name,
+    )
+    stream = StreamDescription(
+        TableName=table_name,
+        StreamArn=stream_arn,
+        StreamLabel=latest_stream_label,
+        StreamStatus=StreamStatus.ENABLING,
+        KeySchema=[],
+        Shards=[],
+        StreamViewType=view_type,
+    )
+    store.ddb_streams[table_name] = StreamWrapper(StreamDescription=stream)
+
+
+def get_stream_for_table(
+    account_id: str, region_name: str, table_arn: str
+) -> StreamDescription | None:
     store = get_dynamodbstreams_store(account_id, region_name)
     table_name = table_name_from_stream_arn(table_arn)
-    return store.ddb_streams.get(table_name)
+    if stream := store.ddb_streams.get(table_name):
+        return stream.StreamDescription
+    return None
 
 
 def _process_forwarded_records(
@@ -206,11 +219,11 @@ def kinesis_shard_id(dynamodbstream_shard_id: str) -> str:
     return f"{shard_params[0]}-{shard_params[-1]}"
 
 
-def get_shard_id(stream: dict, kinesis_shard_id: str) -> str:
-    ddb_stream_shard_id = stream.get("shards_id_map", {}).get(kinesis_shard_id)
+def get_shard_id(stream: StreamWrapper, kinesis_shard_id: str) -> str:
+    ddb_stream_shard_id = stream.shards_id_map.get(kinesis_shard_id)
     if not ddb_stream_shard_id:
         ddb_stream_shard_id = shard_id(kinesis_shard_id)
-        stream["shards_id_map"][kinesis_shard_id] = ddb_stream_shard_id
+        stream.shards_id_map[kinesis_shard_id] = ddb_stream_shard_id
 
     return ddb_stream_shard_id
 

localstack/services/dynamodbstreams/models.py

@@ -1,9 +1,19 @@
+import dataclasses
+
+from localstack.aws.api.dynamodbstreams import StreamDescription
 from localstack.services.stores import AccountRegionBundle, BaseStore, LocalAttribute
 
 
+@dataclasses.dataclass
+class StreamWrapper:
+    """Wrapper for the API stub and additional information about a store"""
+
+    StreamDescription: StreamDescription
+    shards_id_map: dict[str, str] = dataclasses.field(default_factory=dict)
+
+
 class DynamoDbStreamsStore(BaseStore):
-    # maps table names to DynamoDB stream descriptions
-    ddb_streams: dict[str, dict] = LocalAttribute(default=dict)
+    ddb_streams: dict[str, StreamWrapper] = LocalAttribute(default=dict)
 
 
 dynamodbstreams_stores = AccountRegionBundle("dynamodbstreams", DynamoDbStreamsStore)

localstack/services/dynamodbstreams/provider.py

@@ -20,7 +20,6 @@ from localstack.aws.api.dynamodbstreams import (
     ShardIteratorType,
     Stream,
     StreamArn,
-    StreamDescription,
     StreamStatus,
     TableName,
 )
@@ -77,20 +76,21 @@ class DynamoDBStreamsProvider(DynamodbstreamsApi, ServiceLifecycleHook):
         store = get_dynamodbstreams_store(context.account_id, og_region)
         kinesis = get_kinesis_client(account_id=context.account_id, region_name=og_region)
         for stream in store.ddb_streams.values():
+            stream_description = stream.StreamDescription
             _stream_arn = stream_arn
             if context.region != og_region:
                 _stream_arn = change_region_in_ddb_stream_arn(_stream_arn, og_region)
-            if stream["StreamArn"] == _stream_arn:
+            if stream_description["StreamArn"] == _stream_arn:
                 # get stream details
                 dynamodb = connect_to(
                     aws_access_key_id=context.account_id, region_name=og_region
                 ).dynamodb
-                table_name = table_name_from_stream_arn(stream["StreamArn"])
+                table_name = table_name_from_stream_arn(stream_description["StreamArn"])
                 stream_name = get_kinesis_stream_name(table_name)
                 stream_details = kinesis.describe_stream(StreamName=stream_name)
                 table_details = dynamodb.describe_table(TableName=table_name)
-                stream["KeySchema"] = table_details["Table"]["KeySchema"]
-                stream["StreamStatus"] = STREAM_STATUS_MAP.get(
+                stream_description["KeySchema"] = table_details["Table"]["KeySchema"]
+                stream_description["StreamStatus"] = STREAM_STATUS_MAP.get(
                     stream_details["StreamDescription"]["StreamStatus"]
                 )
 
@@ -110,8 +110,7 @@ class DynamoDBStreamsProvider(DynamodbstreamsApi, ServiceLifecycleHook):
                     # slicing the resulting shards after the exclusive_start_shard_id parameters
                     stream_shards = stream_shards[start_index + 1 :]
 
-                stream["Shards"] = stream_shards
-                stream_description = select_from_typed_dict(StreamDescription, stream)
+                stream_description["Shards"] = stream_shards
                 stream_description["StreamArn"] = _stream_arn
                 return DescribeStreamOutput(StreamDescription=stream_description)
 
@@ -190,7 +189,10 @@ class DynamoDBStreamsProvider(DynamodbstreamsApi, ServiceLifecycleHook):
     ) -> ListStreamsOutput:
         og_region = get_original_region(context=context, table_name=table_name)
         store = get_dynamodbstreams_store(context.account_id, og_region)
-        result = [select_from_typed_dict(Stream, res) for res in store.ddb_streams.values()]
+        result = [
+            select_from_typed_dict(Stream, _s.StreamDescription)
+            for _s in store.ddb_streams.values()
+        ]
         if table_name:
             result: list[Stream] = [res for res in result if res["TableName"] == table_name]
             # If this is a stream from a table replica, we need to change the region in the stream ARN, as LocalStack

localstack/utils/analytics/service_request_aggregator.py

@@ -11,7 +11,7 @@ from localstack.utils.scheduler import Scheduler
 
 LOG = logging.getLogger(__name__)
 
-DEFAULT_FLUSH_INTERVAL_SECS = 15
+DEFAULT_FLUSH_INTERVAL_SECS = 60
 EVENT_NAME = "aws_request_agg"
 OPTIONAL_FIELDS = ["err_type"]
 

localstack/utils/container_utils/docker_cmd_client.py

@@ -411,6 +411,8 @@ class CmdDockerClient(ContainerClient):
                 raise AccessDenied(docker_image)
             if "failed to authorize: failed to fetch oauth token" in to_str(e.stdout):
                 raise AccessDenied(docker_image)
+            if "insufficient_scope: authorization failed" in to_str(e.stdout):
+                raise AccessDenied(docker_image)
             if "does not exist" in to_str(e.stdout):
                 raise NoSuchImage(docker_image)
             if "connection refused" in to_str(e.stdout):

localstack/utils/container_utils/docker_sdk_client.py

@@ -390,6 +390,8 @@ class SdkDockerClient(ContainerClient):
                     raise AccessDenied(docker_image)
                 if "unauthorized: authentication required" in to_str(result):
                     raise AccessDenied(docker_image)
+                if "insufficient_scope: authorization failed" in to_str(result):
+                    raise AccessDenied(docker_image)
                 if "connection refused" in to_str(result):
                     raise RegistryConnectionError(result)
                 if "failed to do request:" in to_str(result):

localstack/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '4.13.2.dev63'
-__version_tuple__ = version_tuple = (4, 13, 2, 'dev63')
+__version__ = version = '4.13.2.dev67'
+__version_tuple__ = version_tuple = (4, 13, 2, 'dev67')
 
 __commit_id__ = commit_id = None

{localstack_core-4.13.2.dev63.dist-info → localstack_core-4.13.2.dev67.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localstack-core
-Version: 4.13.2.dev63
+Version: 4.13.2.dev67
 Summary: The core library and runtime of LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License-Expression: Apache-2.0

{localstack_core-4.13.2.dev63.dist-info → localstack_core-4.13.2.dev67.dist-info}/RECORD

@@ -4,7 +4,7 @@ localstack/deprecations.py,sha256=-3IYgCd6LEC3PjO7hbr3Dg-p0PIS6phjmv1qZnj1uo0,15
 localstack/openapi.yaml,sha256=jFUzv-NKkJttxb8HRrmKiNYOmJD-zVfPxG3DDMrRwfg,30865
 localstack/plugins.py,sha256=BIJC9dlo0WbP7lLKkCiGtd_2q5oeqiHZohvoRTcejXM,2457
 localstack/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-localstack/version.py,sha256=D3wnwO8fZjDKQB_D0OeZBRud8mwwGvytF3vh7OSuolE,721
+localstack/version.py,sha256=3esNR0t1TCuYgUH8jPLKK9-TUD3VWtpTLlweUOktgjU,721
 localstack/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack/aws/accounts.py,sha256=102zpGowOxo0S6UGMpfjw14QW7WCLVAGsnFK5xFMLoo,3043
 localstack/aws/app.py,sha256=n9bJCfJRuMz_gLGAH430c3bIQXgUXeWO5NPfcdL2MV8,5145
@@ -352,10 +352,10 @@ localstack/services/cloudwatch/resource_providers/aws_cloudwatch_compositealarm_
 localstack/services/configservice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack/services/configservice/provider.py,sha256=4sjKODGrTjUxzwvd_Q03U24CbEmtQiQGPnrFIYnGXoE,279
 localstack/services/dynamodb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-localstack/services/dynamodb/models.py,sha256=HVCbm5TbF5QJ-OLs2lCRL0vAr5Yj5buvhl58xbOpNUM,4008
+localstack/services/dynamodb/models.py,sha256=Y5ushp-rwJv8K42cAHmWf9WpbFJ8l369jk-W_Z-aP2k,4584
 localstack/services/dynamodb/packages.py,sha256=TEOAyWzae5jTv0hiKf2SYRQK6zuLdFfS0v2EIZU8B3A,4108
 localstack/services/dynamodb/plugins.py,sha256=DraVGanzrytMltMMrDTg8CiDUosbnIuujjrT25Y7H3E,234
-localstack/services/dynamodb/provider.py,sha256=bgj0sIDyz1MvaA6KqgD6rrdyQMZieOa_C_uPxrIDz3U,100927
+localstack/services/dynamodb/provider.py,sha256=jArNEyw5e5GnSEWbScBtCOZU3dakIPPcIahpn-C7TJo,100331
 localstack/services/dynamodb/server.py,sha256=sjZNg5UIkX3Ld1hvlSDlJibg4lZYNmo0YnJzUIS7rIg,8355
 localstack/services/dynamodb/utils.py,sha256=_ww13-O7FEGLADvZNI4rt9AW8VTxo1jCBSRl7QMAt6g,14829
 localstack/services/dynamodb/resource_providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -366,11 +366,11 @@ localstack/services/dynamodb/resource_providers/aws_dynamodb_table.py,sha256=3yE
 localstack/services/dynamodb/resource_providers/aws_dynamodb_table.schema.json,sha256=jFjMq5M2rLTtDRoJog7RnSofYuFJOXa_3RMOFfeIASc,12160
 localstack/services/dynamodb/resource_providers/aws_dynamodb_table_plugin.py,sha256=4_WJxaAS7kyOYyAFb-FoBIpXfZ8ToJrLnz8bl2JXUnU,527
 localstack/services/dynamodb/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-localstack/services/dynamodb/v2/provider.py,sha256=0Xhd5N0LRXHhZ_1HA1ta1MbIgJzNYXJYoOHXBQ9vA7Y,65895
+localstack/services/dynamodb/v2/provider.py,sha256=hOxY2mpmXF52nrz9p_wLrDpxAsi6eDZXQ17VCI8nMes,65557
 localstack/services/dynamodbstreams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-localstack/services/dynamodbstreams/dynamodbstreams_api.py,sha256=sMuB6PHbOmwsZq_brKtZNT1X-fjfsJqAC6ASUP8HhAk,9070
-localstack/services/dynamodbstreams/models.py,sha256=WU6AT0ttEO6K2k4tes3y8bhp1KJ9vEvhk4Fb8Uhbnvg,334
-localstack/services/dynamodbstreams/provider.py,sha256=pUY0xpLV9KvPncZiyy64lmXQw3YcsW1omE3AnLPqHrA,8999
+localstack/services/dynamodbstreams/dynamodbstreams_api.py,sha256=SKiuEer1F3yRc4Dtx8mtHzzqZkPYVOoGUHRYtMX2tgk,9234
+localstack/services/dynamodbstreams/models.py,sha256=keJOQlqp8U5y_TTjh6-wY6_UqFJ9-teDcmlNgVNFMFg,613
+localstack/services/dynamodbstreams/provider.py,sha256=K2zT46n8gnBtT7TVOrc5jjearsUpHiCLwHWUI3qw8io,9057
 localstack/services/dynamodbstreams/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack/services/dynamodbstreams/v2/provider.py,sha256=OpkpXoX-tTgkstI3AQaA9pglQ-P200fAcozNDTKGwlk,5969
 localstack/services/ec2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1274,7 +1274,7 @@ localstack/utils/analytics/logger.py,sha256=-sA_zjptY7o2kOXP2sDduQPzfNwULYIRnoqw
 localstack/utils/analytics/metadata.py,sha256=M_h0iXZz-nYs0gNuN-g-sgeYtCMKCQoVDC4vezN7nTY,9169
 localstack/utils/analytics/publisher.py,sha256=96DqGgLMgyvB5U7mD_UczJ0Wu9p5ti5hCqH_9UZx5_A,5020
 localstack/utils/analytics/service_providers.py,sha256=2FwjdfuEED-03Kqi49qrwR2QF7opWF7IsE5VEK90VC8,604
-localstack/utils/analytics/service_request_aggregator.py,sha256=XIukyhU68fAW96v2O10sHXWr1sepiRSbEnwN57BdNwA,3988
+localstack/utils/analytics/service_request_aggregator.py,sha256=FEM4gFLbCmK8HF5-PqqDjE63-VVjbSLQ82ESM-O1poE,3988
 localstack/utils/analytics/metrics/__init__.py,sha256=APJa7ulgGseR4dl4EPAhKOEuXxxNiP0f_MwLbNmgc4Y,233
 localstack/utils/analytics/metrics/api.py,sha256=5TfPqbvfgikMhQYSoT5hOaxTpNUIJo2iQYFOb0e0DgQ,1595
 localstack/utils/analytics/metrics/counter.py,sha256=AYXcJreYYOsdV6PuG-Muzjuu3N3SSa5z0sY8X9z3FT0,6830
@@ -1301,8 +1301,8 @@ localstack/utils/cloudwatch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 localstack/utils/cloudwatch/cloudwatch_util.py,sha256=urSfRKSoO_6B1J-pusjK30450k7jJLLBWzrU5CyqNWw,8453
 localstack/utils/container_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack/utils/container_utils/container_client.py,sha256=A-t7r-Sv6WEsZoG-MRp7kScyhOFG6-1uOoc2CMDh1-k,59597
-localstack/utils/container_utils/docker_cmd_client.py,sha256=kZlIk-kyH-L523PT5pU9SaYa4Yo_PE43ReV3-ywwNpc,40066
-localstack/utils/container_utils/docker_sdk_client.py,sha256=If7Hjln5uVk_AEB8W3yG1xoPF7EOU5EDN4UqmViqYR8,40432
+localstack/utils/container_utils/docker_cmd_client.py,sha256=cLYL3CopPqXLS4MnjdqvblNLGNk4n1HQpCEFSZIL-kg,40194
+localstack/utils/container_utils/docker_sdk_client.py,sha256=AhzGt2GlixqPvswSGSqDoGFY4IW89THZ_rWx-GbFtW4,40566
 localstack/utils/kinesis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack/utils/kinesis/kclipy_helper.py,sha256=D3GPG9eT21IXuS94iIrJSAEtxGbcoDOkuRyCnHGd4Ek,4022
 localstack/utils/kinesis/kinesis_connector.py,sha256=rtVAuKENjDQz6AjKXj9lULXGIAYobsABw7p-ffgdHNk,15085
@@ -1311,10 +1311,10 @@ localstack/utils/server/tcp_proxy.py,sha256=y2NJAmvftTiAYsLU_8qe4W5LGqwUw21i90Pu
 localstack/utils/xray/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack/utils/xray/trace_header.py,sha256=ahXk9eonq7LpeENwlqUEPj3jDOCiVRixhntQuxNor-Q,6209
 localstack/utils/xray/traceid.py,sha256=GKO-R2sMMjlrH2UaLPXlQlZ6flbE7ZKb6IZMtMu_M5U,1110
-localstack_core-4.13.2.dev63.data/scripts/localstack-supervisor,sha256=nm1Il2d6ASyOB6Vo4CRHd90w7TK9FdRl9VPp0NN6hUk,6378
-localstack_core-4.13.2.dev63.dist-info/licenses/LICENSE.txt,sha256=3PC-9Z69UsNARuQ980gNR_JsLx8uvMjdG6C7cc4LBYs,606
-localstack_core-4.13.2.dev63.dist-info/METADATA,sha256=qbMkujIkEryvVlT1MvW3KvW5xBr0_DeRKLfAo2duBMM,5867
-localstack_core-4.13.2.dev63.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
-localstack_core-4.13.2.dev63.dist-info/entry_points.txt,sha256=59aAnn8KVHWAHkMg2dOgmgYtRZ-xTX9T4UiIchWgK6k,20975
-localstack_core-4.13.2.dev63.dist-info/top_level.txt,sha256=3sqmK2lGac8nCy8nwsbS5SpIY_izmtWtgaTFKHYVHbI,11
-localstack_core-4.13.2.dev63.dist-info/RECORD,,
+localstack_core-4.13.2.dev67.data/scripts/localstack-supervisor,sha256=nm1Il2d6ASyOB6Vo4CRHd90w7TK9FdRl9VPp0NN6hUk,6378
+localstack_core-4.13.2.dev67.dist-info/licenses/LICENSE.txt,sha256=3PC-9Z69UsNARuQ980gNR_JsLx8uvMjdG6C7cc4LBYs,606
+localstack_core-4.13.2.dev67.dist-info/METADATA,sha256=Gyo4i-Z-6QY6NIJrJw8zZMPL1GoED0cgCSbyEYCUewk,5867
+localstack_core-4.13.2.dev67.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+localstack_core-4.13.2.dev67.dist-info/entry_points.txt,sha256=59aAnn8KVHWAHkMg2dOgmgYtRZ-xTX9T4UiIchWgK6k,20975
+localstack_core-4.13.2.dev67.dist-info/top_level.txt,sha256=3sqmK2lGac8nCy8nwsbS5SpIY_izmtWtgaTFKHYVHbI,11
+localstack_core-4.13.2.dev67.dist-info/RECORD,,