Skip to content

Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.

refactor(persistence): centralize restore through registry (Phase 3) (#1730)

Johannes Grumböckfdfbc5648b3e
diff --git a/ministack/app.py b/ministack/app.py
index 901c6c80..27855a76 100644
--- a/ministack/app.py
+++ b/ministack/app.py
@@ -261,7 +261,7 @@ class _ErrorModule:
# run persisted, losing every resource the service held.
return None
- def restore_state(self, data):
+ def _restore_state(self, data):
pass
def load_persisted_state(self, data):
@@ -2687,102 +2687,18 @@ def _build_persistence_save_dict():
def _load_persisted_state():
- """Load persisted state for services that support it."""
- for svc_key in ("apigateway", "apigateway_v1", "servicediscovery"):
- data = load_state(svc_key)
+ """Restore every saved service through the registry's uniform contract."""
+ for state_key, module_name in _state_map.items():
+ data = load_state(state_key)
if data:
- _get_module(svc_key).load_persisted_state(data)
- logger.info("Loaded persisted state for %s", svc_key)
-
- # Eagerly import persisted services whose restore path depends on a
- # module-level `load_state()` side-effect, but which would not otherwise
- # be imported during startup. Their registry declarations ensure they are
- # saved and reset; the lazy router still does not pull them in early enough
- # in these cases:
- # - `ses_v2` is reached via the `/v2/email/*` path-prefix shortcut.
- # - `pipes` is commonly created via CloudFormation provisioners, without
- # a preceding Pipes API request.
- # - `appsync_events` is routable (SERVICE_REGISTRY has
- # "appsync-events") but real traffic arrives under the
- # `appsync` credential scope at `/v2/apis`, so the
- # `appsync-events` lazy handler never fires; the module is
- # reached only via a sibling import from `appsync.py`, which
- # bypasses `_get_module` and leaves it out of
- # `_loaded_modules` → shutdown skips persistence (#704).
- # - `apigateway_v1` is restored above only when a state file
- # already exists; on first-ever boot the conditional skips
- # it, the module is reached only via `apigateway.py`'s
- # sibling import (line 237), and the first save is silently
- # dropped. Same bug class as #704.
- # Importing here triggers the module-level restore (and, for
- # `pipes`, also restarts the background poller for any RUNNING
- # pipe). Keep this list narrow — every entry costs a cold-start
- # import.
- for svc_key in ("pipes", "ses_v2", "appsync_events", "apigateway_v1"):
- _get_module(svc_key)
-
- # RDS is intentionally NOT in the unconditional list above —
- # eager-importing it for every user would pull in ~13 MB of module
- # objects (and, lazily, the docker SDK) even on stacks that don't
- # use RDS. Instead, only eager-import when a persisted state file
- # exists: importing the module triggers its bottom-of-file
- # `load_state("rds")` which spawns the respawn threads for every
- # persisted instance. Without this, users have to make one client
- # call after every restart to lazily trigger the import + respawn
- # (#692 follow-up after doodaz's confirmation).
- if load_state("rds"):
- _get_module("rds")
- logger.info("RDS: eager-loaded module to respawn persisted containers at boot")
-
- # OpenSearch has a routable management endpoint, but persisted domains must
- # restore before the first request because restore_state() also recreates
- # data-plane endpoints/containers. Waiting for the lazy router leaves a
- # warm-boot window where DescribeDomain/ListDomainNames see empty state and
- # data-plane traffic has no restored endpoint. Match RDS' conditional shape
- # so stacks that do not persist OpenSearch pay no cold-start import cost.
- if load_state("opensearch"):
- _get_module("opensearch")
- logger.info("OpenSearch: eager-loaded module to restore persisted domains")
-
- # `lambda_durable` is reached only via `lambda_svc.handle_request`, never
- # directly through the lazy router (no SERVICE_REGISTRY entry — it has no
- # AWS endpoint of its own). Without an eager import at boot, persisted
- # durable executions silently disappear until something happens to invoke
- # a durable endpoint. Same conditional-import pattern as RDS — only pay
- # the cold-start cost when state actually exists.
- if load_state("lambda_durable"):
- _get_module("lambda_durable")
- logger.info("Lambda Durable: eager-loaded module to restore persisted executions")
-
- # Lambda event source mappings (SQS / Kinesis / DynamoDB Streams) are
- # polled by a background thread that lambda_svc starts from its
- # import-time restore (`_ensure_poller`). lambda_svc is otherwise imported
- # lazily on the first Lambda request — so after a persisted restart a
- # workload that is pure SQS (just sending to a mapped queue) never imports
- # the module, the poller never starts, and the restored ESM sits
- # Enabled-but-unpolled while messages pile up (#889). Eager-import at boot
- # when persisted ESMs exist so polling resumes exactly like a fresh
- # CreateEventSourceMapping. Narrow: only pay the cold-start when there are
- # mappings to poll. The `_data` reach gets all accounts' ESMs (the bool of
- # an AccountScopedDict is account-scoped and would be 0 with no request
- # context at boot).
- _lam = load_state("lambda")
- if _lam and getattr(_lam.get("esms"), "_data", _lam.get("esms")):
- _get_module("lambda_svc") # module file is lambda_svc.py (lambda is a keyword)
- logger.info("Lambda: eager-loaded module to resume event-source-mapping pollers at boot")
-
- # ECS services are restored with every task marked STOPPED — their
- # containers went with the previous process — and the relaunch happens on
- # the module's import-time restore hook. ECS is otherwise imported lazily on
- # the first ECS request, so a workload that only talks to the service
- # through a load balancer never triggers it: the service reports its
- # persisted runningCount, nothing is running, and every request through the
- # balancer fails. Same conditional shape as RDS — only pay the cold-start
- # when there are services to bring back.
- _ecs_state = load_state("ecs")
- if _ecs_state and getattr(_ecs_state.get("services"), "_data", _ecs_state.get("services")):
- _get_module("ecs")
- logger.info("ECS: eager-loaded module to relaunch persisted services at boot")
+ try:
+ _get_module(module_name).load_persisted_state(data)
+ logger.info("Loaded persisted state for %s", state_key)
+ except Exception:
+ logger.exception(
+ "Failed to restore persisted state for %s; continuing fresh",
+ state_key,
+ )
async def _wait_for_port(port, timeout=30):
diff --git a/ministack/services/acm.py b/ministack/services/acm.py
index 3416c82b..f251dca8 100644
--- a/ministack/services/acm.py
+++ b/ministack/services/acm.py
@@ -17,7 +17,6 @@ import os
import time
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -66,10 +65,7 @@ def _synthetic_pem(domain):
parser. The requested domain lives in DomainName / SubjectAlternative
Names metadata, not embedded in the PEM payload.
- Defined above the import-time `restore_state` block (rather than
- next to its other call site in `_request_certificate`) so the
- backfill path doesn't NameError when the load_state try block
- fires at module import."""
+ """
_ = domain # represented in cert metadata, not the base64 block
return (
"-----BEGIN CERTIFICATE-----\n"
@@ -108,10 +104,10 @@ def _restore_certificates(restored):
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
_restore_certificates(data.get("_certificates", {}))
# Backwards compat: pre-fix snapshots have certificates without
# `_pem_body` / `_pem_chain` (the old GetCertificate path returned
@@ -127,15 +123,6 @@ def restore_state(data):
cert["_pem_chain"] = ""
-try:
- _restored = load_state("acm")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def _future_iso(seconds):
@@ -256,10 +243,6 @@ async def handle_request(method, path, headers, body, query_params):
return handler(data)
-# (`_synthetic_pem` is defined near `restore_state` above so the
-# import-time backfill path doesn't NameError.)
-
-
def _request_certificate(data):
domain = data.get("DomainName", "")
if not domain:
diff --git a/ministack/services/alb.py b/ministack/services/alb.py
index 88f48d1b..b613835f 100644
--- a/ministack/services/alb.py
+++ b/ministack/services/alb.py
@@ -34,7 +34,6 @@ from urllib.parse import parse_qs, urlencode
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import run_reentrant
-from ministack.core.persistence import load_state
from ministack.core.responses import AccountRegionScopedDict, AccountScopedDict, get_account_id, get_region, new_uuid
logger = logging.getLogger("alb")
@@ -132,10 +131,10 @@ def _restore_region_scoped(store, restored):
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
_restore_region_scoped(_lbs, data.get("_lbs", {}))
_restore_region_scoped(_tgs, data.get("_tgs", {}))
_restore_region_scoped(_listeners, data.get("_listeners", {}))
@@ -148,15 +147,6 @@ def restore_state(data):
_oidc_pending.update(data.get("_oidc_pending", {}))
-try:
- _restored = load_state("alb")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
# Small helpers
diff --git a/ministack/services/appconfig.py b/ministack/services/appconfig.py
index 065c0abf..221c1a00 100644
--- a/ministack/services/appconfig.py
+++ b/ministack/services/appconfig.py
@@ -36,7 +36,6 @@ import time
import uuid
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import AccountRegionScopedDict, get_account_id, get_region
logger = logging.getLogger("appconfig")
@@ -74,10 +73,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
_applications.update(data.get("applications", {}))
_environments.update(data.get("environments", {}))
_config_profiles.update(data.get("config_profiles", {}))
@@ -87,15 +86,6 @@ def restore_state(data):
_tags.update(data.get("tags", {}))
-try:
- _restored = load_state("appconfig")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
# Helpers
diff --git a/ministack/services/appsync.py b/ministack/services/appsync.py
index 90e007aa..665a7bcb 100644
--- a/ministack/services/appsync.py
+++ b/ministack/services/appsync.py
@@ -30,7 +30,6 @@ import threading
import time
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import PERSIST_STATE, load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -67,19 +66,6 @@ _cache_entries: dict = {}
_cache_entries_lock = threading.Lock()
_tags = AccountScopedDict() # resource_arn -> {key: value}
-# ---------------------------------------------------------------------------
-# Persistence
-# ---------------------------------------------------------------------------
-
-def _load_persisted():
- if not PERSIST_STATE:
- return
- data = load_state("appsync")
- if data:
- restore_state(data)
- logger.info("Loaded persisted state for appsync")
-
-
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
@@ -1258,10 +1244,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
"""Restore state from persisted data."""
reset()
_apis.update(data.get("apis", {}))
@@ -2579,6 +2565,3 @@ def _resolve_lambda(api_id, resolver, data_source, args,
logger.error("Invalid JSON from Lambda %s", func_name)
return {"errors": ["Invalid response format"]}
return {"errors": ["Unexpected response type"]}
-
-# Load persisted state (must be after restore_state is defined)
-_load_persisted()
diff --git a/ministack/services/appsync_events.py b/ministack/services/appsync_events.py
index 7f35d824..0fa35192 100644
--- a/ministack/services/appsync_events.py
+++ b/ministack/services/appsync_events.py
@@ -29,7 +29,6 @@ import re
import time
from ministack.core.concurrency import run_reentrant
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -115,10 +114,10 @@ def _restore_api_child_store(
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_apis.update(data.get("apis", {}))
@@ -128,12 +127,10 @@ def restore_state(data):
_restore_api_child_store(_api_keys, data.get("api_keys", {}))
-try:
- _restored = load_state("appsync_events")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore AppSync Events state")
+# Same contract as apigateway.py (used by app.py persistence loader)
+load_persisted_state = _restore_state
+
+
def reset():
diff --git a/ministack/services/athena.py b/ministack/services/athena.py
index 18a98b75..41a13b3b 100644
--- a/ministack/services/athena.py
+++ b/ministack/services/athena.py
@@ -27,7 +27,6 @@ import xml.etree.ElementTree as ET
from urllib.parse import urlparse
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -105,10 +104,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
# Scoped dicts are mutated in-place — no module-level reassignment.
_executions.clear()
_workgroups.clear()
@@ -197,15 +196,6 @@ def _restore_workgroup_child_store(
store.set_scoped(account_id, region, key, value)
-try:
- _restored = load_state("athena")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
try:
import duckdb # noqa: F401 — the import is the availability probe
diff --git a/ministack/services/autoscaling.py b/ministack/services/autoscaling.py
index 04c75e2b..93f878b1 100644
--- a/ministack/services/autoscaling.py
+++ b/ministack/services/autoscaling.py
@@ -22,7 +22,6 @@ import copy
import logging
import os
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -64,10 +63,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
@@ -109,12 +108,6 @@ def _restore_asg_child_store(store, restored, asg_regions):
store.set_scoped(account_id, region, key, value)
-try:
- _restored = load_state("autoscaling")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted autoscaling state; continuing fresh")
def reset():
diff --git a/ministack/services/backup.py b/ministack/services/backup.py
index a22c0f36..04503a57 100644
--- a/ministack/services/backup.py
+++ b/ministack/services/backup.py
@@ -28,7 +28,6 @@ import logging
import time
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -69,7 +68,7 @@ def get_state():
}
-def restore_state(data):
+def _restore_state(data):
_vaults.update(data.get("vaults", {}))
_plans.update(data.get("plans", {}))
_restore_selections(data.get("selections", {}))
@@ -104,15 +103,9 @@ def _restore_selections(restored):
def load_persisted_state(data):
- restore_state(data)
+ _restore_state(data)
-try:
- _restored = load_state("backup")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted backup state; continuing fresh")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/batch.py b/ministack/services/batch.py
index da646fef..8f9cceb0 100644
--- a/ministack/services/batch.py
+++ b/ministack/services/batch.py
@@ -16,7 +16,6 @@ import re
import time
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -52,10 +51,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
for store, key in (
@@ -70,12 +69,6 @@ def restore_state(data):
store.update(restored)
-try:
- _restored = load_state("batch")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted state; continuing with fresh store")
def _json(status, body):
diff --git a/ministack/services/bedrock.py b/ministack/services/bedrock.py
index 129330b0..c7a0868b 100644
--- a/ministack/services/bedrock.py
+++ b/ministack/services/bedrock.py
@@ -38,7 +38,6 @@ from datetime import datetime, timezone
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
get_account_id,
@@ -273,9 +272,6 @@ _marketplace_endpoints = AccountRegionScopedDict()
_prompt_routers = AccountRegionScopedDict()
_invocation_logging_config = AccountRegionScopedDict() # 'config' -> dict (singleton)
_tags = AccountRegionScopedDict() # arn -> {key: value}
-# Defined here (with the other state containers) so it exists before the
-# import-time restore_state() below — see the "Use Case for Model Access"
-# section further down for its accessors.
_USE_CASE = AccountRegionScopedDict() # 'usecase' -> dict (model-access use case)
@@ -312,10 +308,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_guardrails.update(data.get("guardrails", {}))
@@ -336,12 +332,6 @@ def restore_state(data):
_USE_CASE.update(data.get("use_case", {}))
-try:
- _restored = load_state("bedrock")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore bedrock state; continuing fresh")
# ===========================================================================
@@ -1332,10 +1322,6 @@ def _delete_logging_config() -> tuple:
# ===========================================================================
# Use Case for Model Access
# ===========================================================================
-# (_USE_CASE is defined up top with the other state containers so it exists
-# before the import-time restore_state().)
-
-
def _get_use_case_for_model_access() -> tuple:
rec = _USE_CASE.get("usecase")
if rec is None:
diff --git a/ministack/services/bedrock_agent.py b/ministack/services/bedrock_agent.py
index 4b9997a0..c20f8493 100644
--- a/ministack/services/bedrock_agent.py
+++ b/ministack/services/bedrock_agent.py
@@ -26,7 +26,6 @@ from datetime import datetime, timezone
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
get_account_id,
@@ -225,10 +224,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_agents.update(data.get("agents", {}))
@@ -250,12 +249,6 @@ def restore_state(data):
_tags.update(data.get("tags", {}))
-try:
- _restored = load_state("bedrock_agent")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore bedrock_agent state; continuing fresh")
# ===========================================================================
diff --git a/ministack/services/bedrock_agent_runtime.py b/ministack/services/bedrock_agent_runtime.py
index c29231d6..1690b3a0 100644
--- a/ministack/services/bedrock_agent_runtime.py
+++ b/ministack/services/bedrock_agent_runtime.py
@@ -36,7 +36,6 @@ from datetime import datetime, timezone
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
get_account_id,
@@ -207,10 +206,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_sessions.update(data.get("sessions", {}))
@@ -221,12 +220,6 @@ def restore_state(data):
_tags.update(data.get("tags", {}))
-try:
- _restored = load_state("bedrock_agent_runtime")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore bedrock_agent_runtime state; continuing fresh")
# ===========================================================================
diff --git a/ministack/services/bedrock_agentcore.py b/ministack/services/bedrock_agentcore.py
index e987292f..f6befda2 100644
--- a/ministack/services/bedrock_agentcore.py
+++ b/ministack/services/bedrock_agentcore.py
@@ -30,7 +30,6 @@ import string
import time
from urllib.parse import unquote
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -59,10 +58,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_runtimes.clear()
@@ -71,12 +70,6 @@ def restore_state(data):
_endpoints.update(data.get("endpoints", {}))
-try:
- _persisted = load_state("bedrock_agentcore")
- if _persisted:
- restore_state(_persisted)
-except Exception: # pragma: no cover - best-effort restore
- pass
def reset():
diff --git a/ministack/services/bedrock_runtime.py b/ministack/services/bedrock_runtime.py
index 08292cfe..f8d78f5a 100644
--- a/ministack/services/bedrock_runtime.py
+++ b/ministack/services/bedrock_runtime.py
@@ -49,7 +49,6 @@ from datetime import datetime, timezone
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
get_account_id,
@@ -1043,12 +1042,6 @@ def _apply_guardrail(guardrail_id: str, version: str, body) -> tuple:
_async_invokes = AccountRegionScopedDict() # invocationArn -> dict
-try:
- _restored = load_state("bedrock_runtime")
- if _restored:
- _async_invokes.update(_restored.get("async_invokes", {}))
-except Exception:
- logger.exception("Failed to restore bedrock_runtime state; continuing fresh")
def _invocation_arn(invocation_id: str) -> str:
@@ -1320,10 +1313,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_async_invokes.update(data.get("async_invokes", {}))
diff --git a/ministack/services/cloudcontrol.py b/ministack/services/cloudcontrol.py
index 83b7b590..ae0dc606 100644
--- a/ministack/services/cloudcontrol.py
+++ b/ministack/services/cloudcontrol.py
@@ -38,7 +38,6 @@ from ministack.core.responses import (
logger = logging.getLogger("cloudcontrol")
-from ministack.core.persistence import load_state
# (TypeName, Identifier) -> {"TypeName", "Identifier", "Properties" (JSON str)}
_resources = AccountRegionScopedDict()
@@ -53,10 +52,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
resources = data.get("resources")
@@ -67,14 +66,6 @@ def restore_state(data):
_requests.update(requests)
-try:
- _restored = load_state("cloudcontrol")
- if _restored:
- restore_state(_restored)
-except Exception:
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ── Helpers ────────────────────────────────────────────────
diff --git a/ministack/services/cloudformation/__init__.py b/ministack/services/cloudformation/__init__.py
index fde27f23..43bbb250 100644
--- a/ministack/services/cloudformation/__init__.py
+++ b/ministack/services/cloudformation/__init__.py
@@ -17,7 +17,6 @@ import logging
import os
from urllib.parse import parse_qs
-from ministack.core.persistence import load_state
from ministack.core.responses import AccountRegionScopedDict
logger = logging.getLogger("cloudformation")
@@ -94,10 +93,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
for store, key in _PERSISTED_STORES:
@@ -105,7 +104,7 @@ def restore_state(data):
target = store()
if isinstance(restored, AccountRegionScopedDict):
# Merge the (account, region, key)-scoped entries directly. Restore
- # runs at import time with no request scope, so re-scoping through
+ # runs at startup with no request scope, so re-scoping through
# the public dict interface would misattribute every entry.
target._data.update(restored._data)
elif isinstance(restored, dict):
@@ -115,15 +114,3 @@ def restore_state(data):
# Must be last — handlers imports from this module
from .handlers import _ACTION_HANDLERS # noqa: E402
-
-# Restore persisted stack metadata on first import (a CloudFormation request, or
-# the eager boot import when a state file exists). Failure falls back to a fresh
-# store rather than blocking startup.
-try:
- _restored = load_state("cloudformation")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception(
- "Failed to restore persisted CloudFormation state; continuing with a fresh store"
- )
diff --git a/ministack/services/cloudfront.py b/ministack/services/cloudfront.py
index 1f9f2c06..575e96e8 100644
--- a/ministack/services/cloudfront.py
+++ b/ministack/services/cloudfront.py
@@ -55,7 +55,6 @@ from xml.etree.ElementTree import Element, SubElement, tostring
from defusedxml.ElementTree import fromstring
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import AccountScopedDict, get_account_id, new_uuid
logger = logging.getLogger("cloudfront")
@@ -193,10 +192,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
_distributions.update(data.get("distributions", {}))
_invalidations.update(data.get("invalidations", {}))
_tags.update(data.get("tags", {}))
@@ -211,14 +210,6 @@ def restore_state(data):
_tenant_invalidations.update(data.get("tenant_invalidations", {}))
-try:
- _restored = load_state("cloudfront")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
-
- logging.getLogger(__name__).exception("Failed to restore persisted state; continuing with fresh store")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/cloudfront_keyvaluestore.py b/ministack/services/cloudfront_keyvaluestore.py
index 730c491f..e5c4a09c 100644
--- a/ministack/services/cloudfront_keyvaluestore.py
+++ b/ministack/services/cloudfront_keyvaluestore.py
@@ -19,7 +19,6 @@ from datetime import datetime
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import AccountScopedDict, get_account_id, json_response, new_uuid
logger = logging.getLogger("cloudfront-keyvaluestore")
@@ -48,10 +47,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_stores.clear()
@@ -59,12 +58,6 @@ def restore_state(data):
_stores[k] = v
-try:
- _restored = load_state("cloudfront_keyvaluestore")
- if _restored:
- restore_state(_restored)
-except Exception:
- logging.getLogger(__name__).exception("Failed to restore persisted state; continuing with fresh store")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/cloudtrail.py b/ministack/services/cloudtrail.py
index e5241b56..ce3ffa86 100644
--- a/ministack/services/cloudtrail.py
+++ b/ministack/services/cloudtrail.py
@@ -24,7 +24,6 @@ import os
import time
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -74,7 +73,7 @@ def get_state():
}
-def restore_state(data):
+def _restore_state(data):
if not isinstance(data, dict):
return
trail_regions = _restore_trails(data.get("trails", {}))
@@ -83,7 +82,7 @@ def restore_state(data):
def load_persisted_state(data):
- restore_state(data)
+ _restore_state(data)
def _restore_trails(saved) -> dict[tuple[str, str], str]:
@@ -768,11 +767,3 @@ async def handle_request(method, path, headers, body_bytes, query_params):
logger.warning("cloudtrail: unknown action %r", action)
return _err("InvalidParameterException", f"Unknown CloudTrail action: {action!r}")
return handler(body)
-
-
-try:
- _restored = load_state("cloudtrail")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted cloudtrail state; continuing fresh")
diff --git a/ministack/services/cloudwatch.py b/ministack/services/cloudwatch.py
index 61c44143..ef9ce977 100644
--- a/ministack/services/cloudwatch.py
+++ b/ministack/services/cloudwatch.py
@@ -23,7 +23,6 @@ from datetime import datetime, timezone
from urllib.parse import parse_qs
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import AccountRegionScopedDict, AccountScopedDict, get_account_id, get_region, new_uuid
logger = logging.getLogger("cloudwatch")
@@ -119,10 +118,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_metrics.update(data.get("metrics", {}))
_alarms.update(data.get("alarms", {}))
@@ -132,15 +131,6 @@ def restore_state(data):
_resource_tags.update(data.get("resource_tags", {}))
-try:
- _restored = load_state("cloudwatch")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
diff --git a/ministack/services/cloudwatch_logs.py b/ministack/services/cloudwatch_logs.py
index 9904aef4..433d3e71 100644
--- a/ministack/services/cloudwatch_logs.py
+++ b/ministack/services/cloudwatch_logs.py
@@ -48,7 +48,6 @@ logger = logging.getLogger("logs")
REGION = os.environ.get("MINISTACK_REGION", "us-east-1")
-from ministack.core.persistence import load_state
_log_groups = AccountRegionScopedDict()
# group_name -> {
@@ -192,10 +191,10 @@ def _restore_queries(queries):
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_log_groups.update(data.get("log_groups", {}))
_destinations.update(data.get("destinations", {}))
@@ -207,15 +206,6 @@ def restore_state(data):
_deliveries.update(data.get("deliveries", {}))
-try:
- _restored = load_state("cloudwatch_logs")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
diff --git a/ministack/services/codebuild.py b/ministack/services/codebuild.py
index 7fd59982..0a6b3a78 100644
--- a/ministack/services/codebuild.py
+++ b/ministack/services/codebuild.py
@@ -26,7 +26,6 @@ import time
from ministack.core import container_reaper
from ministack.core.arn import ArnParseError, is_arn, parse_arn
from ministack.core.concurrency import run_reentrant
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -67,10 +66,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
_projects.update(data.get("projects", {}))
_builds.update(data.get("builds", {}))
@@ -84,15 +83,6 @@ def restore_state(data):
build.setdefault("endTime", int(time.time()))
-try:
- _restored = load_state("codebuild")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
diff --git a/ministack/services/cognito.py b/ministack/services/cognito.py
index afff7593..00ab2672 100644
--- a/ministack/services/cognito.py
+++ b/ministack/services/cognito.py
@@ -82,7 +82,6 @@ from defusedxml.ElementTree import fromstring as safe_xml_parse
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import run_reentrant
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -586,10 +585,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_restore_regional_store(
_user_pools,
@@ -650,15 +649,6 @@ def _restore_regional_store(store, restored, region_for_item):
store.set_scoped(account_id, region_for_item(key, value), key, value)
-try:
- _restored = load_state("cognito")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
diff --git a/ministack/services/config.py b/ministack/services/config.py
index 63871bc0..5aa1285d 100644
--- a/ministack/services/config.py
+++ b/ministack/services/config.py
@@ -28,7 +28,6 @@ import json
import logging
import time
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -69,10 +68,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_config_rules.clear()
@@ -91,14 +90,6 @@ def restore_state(data):
store[k] = v
-try:
- _restored = load_state("config")
- if _restored:
- restore_state(_restored)
-except Exception:
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ── Config Rules ──────────────────────────────────────────────
diff --git a/ministack/services/cur.py b/ministack/services/cur.py
index 43a2beb0..b081c7ba 100644
--- a/ministack/services/cur.py
+++ b/ministack/services/cur.py
@@ -17,7 +17,6 @@ import copy
import json
import logging
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountScopedDict,
error_response_json,
@@ -41,7 +40,7 @@ def get_state():
}
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_report_definitions.clear()
@@ -51,15 +50,9 @@ def restore_state(data):
def load_persisted_state(data):
- restore_state(data)
+ _restore_state(data)
-try:
- _restored = load_state("cur")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted CUR state; continuing with fresh store")
def _json(status: int, body: dict):
diff --git a/ministack/services/dsql.py b/ministack/services/dsql.py
index a7fed904..7b788bd0 100644
--- a/ministack/services/dsql.py
+++ b/ministack/services/dsql.py
@@ -27,7 +27,6 @@ import time
from ministack.core import container_reaper, pgproxy
from ministack.core.concurrency import run_offloop
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountScopedDict,
get_account_id,
@@ -218,8 +217,7 @@ def _run_backend_container(identifier):
Returns ``(backend_host, backend_port)`` for the proxy to dial. Raises on
failure; the caller degrades to metadata-only. ``rds`` is imported lazily
- so the heavy module (and its import-time restore) only loads when a
- Docker socket actually exists.
+ so its heavy Docker dependencies are loaded only when needed.
"""
from ministack.services import rds
@@ -1127,10 +1125,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
clusters = data.get("clusters", {})
@@ -1218,12 +1216,6 @@ def reset():
_port_counter[0] = BASE_PORT
-try:
- _restored = load_state("dsql")
- if _restored:
- restore_state(_restored)
-except Exception:
- logging.getLogger(__name__).exception("Failed to restore persisted state; continuing with fresh store")
async def handle_request(method, path, headers, body, query_params):
diff --git a/ministack/services/dynamodb.py b/ministack/services/dynamodb.py
index 6ea07a73..391257e8 100644
--- a/ministack/services/dynamodb.py
+++ b/ministack/services/dynamodb.py
@@ -71,7 +71,6 @@ _DDB_ACCOUNT_RE = re.compile(r"^[0-9]{12}$")
_EXPORT_COMPLETE_AFTER_SEC = float(os.environ.get("MINISTACK_DDB_EXPORT_COMPLETE_AFTER_SEC", "1"))
_IMPORT_COMPLETE_AFTER_SEC = float(os.environ.get("MINISTACK_DDB_IMPORT_COMPLETE_AFTER_SEC", "1"))
-from ministack.core.persistence import load_state
# Region-scoped: DynamoDB tables are region-specific in AWS. Account-only
# keying made name lookups find cross-region tables while ARN ops (which
@@ -188,10 +187,10 @@ def _restore_table_name_metadata(store: AccountRegionScopedDict, data) -> None:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_tables.update(data.get("tables", {}))
# Restore items as defaultdict(dict) — JSON deserializes as plain dict
@@ -214,15 +213,6 @@ def restore_state(data):
_imports.update(data.get("imports", {}))
-try:
- _restored = load_state("dynamodb")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
diff --git a/ministack/services/dynamodb_streams.py b/ministack/services/dynamodb_streams.py
index 2fe6058d..e51603b5 100644
--- a/ministack/services/dynamodb_streams.py
+++ b/ministack/services/dynamodb_streams.py
@@ -416,10 +416,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
pass
diff --git a/ministack/services/ec2.py b/ministack/services/ec2.py
index 9b869628..b03df02b 100644
--- a/ministack/services/ec2.py
+++ b/ministack/services/ec2.py
@@ -75,7 +75,6 @@ from xml.sax.saxutils import escape as _esc
from ministack.core import container_reaper
from ministack.core.concurrency import resource_lock, run_offloop
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -335,10 +334,10 @@ def _restore_vpc_peering_store(restored):
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_clear_state()
@@ -417,15 +416,6 @@ def _backfill_subnet_availability_zone_ids():
subnet.setdefault("AvailabilityZoneId", _az_id_for_zone_name(subnet["AvailabilityZone"]))
-try:
- _restored = load_state("ec2")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# Default VPC / subnet created at import time so DescribeVpcs always returns something
diff --git a/ministack/services/ecr.py b/ministack/services/ecr.py
index f1a31882..5b7653a1 100644
--- a/ministack/services/ecr.py
+++ b/ministack/services/ecr.py
@@ -15,7 +15,6 @@ import re
import time
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -62,10 +61,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
@@ -122,15 +121,6 @@ def _restore_repository_child_store(store, restored, legacy_repo_regions):
store.set_scoped(account_id, region, name, value)
-try:
- _restored = load_state("ecr")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def _repo_arn(name):
diff --git a/ministack/services/ecs.py b/ministack/services/ecs.py
index ceb5ab4d..cf3ccacb 100644
--- a/ministack/services/ecs.py
+++ b/ministack/services/ecs.py
@@ -36,7 +36,6 @@ import time
from ministack.core import container_reaper
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import resource_lock, run_reentrant
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -70,18 +69,9 @@ _tasks = AccountRegionScopedDict()
_tags = AccountScopedDict()
_account_settings = AccountRegionScopedDict()
_capacity_providers = AccountRegionScopedDict()
-# `_attributes` was originally declared next to its handler block much
-# further down the file. Moved up here so the import-time `load_state`
-# block (which calls `restore_state` and references `_attributes`) sees
-# it defined; otherwise warm-boot fires NameError, the surrounding
-# try/except swallows it, and ALL ECS state silently fails to restore.
_attributes = AccountRegionScopedDict()
-# Up here for the same reason as `_attributes`: the import-time `load_state`
-# block calls `restore_state`, which counts the tasks it stops, so this has to
-# be bound before that runs. Defined further down it raises NameError there,
-# the surrounding try/except swallows it, and ALL ECS state fails to restore.
def _bump_task_version(task):
"""Count one observable change on the task.
@@ -239,11 +229,13 @@ def _restore_task_def_latest(latest_data):
_task_def_latest.set_scoped(account_id, region, family, revision)
-def load_persisted_state(data):
- return restore_state(data)
+def load_persisted_state(data) -> None:
+ _restore_state(data)
+ if _services.has_any():
+ _start_restored_service_reconciler()
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_clusters.update(data.get("clusters", {}))
@@ -286,7 +278,7 @@ def restore_state(data):
def _reconcile_restored_services():
"""Relaunch the tasks of every ACTIVE service after a restore.
- restore_state marks each restored task STOPPED — its container went with the
+ _restore_state marks each restored task STOPPED — its container went with the
process that ran it. Without this the service still reports its persisted
runningCount while nothing is running, and any load balancer in front of it
keeps forwarding to addresses nothing is listening on. Real ECS relaunches:
@@ -313,11 +305,10 @@ def _reconcile_restored_services():
def _start_restored_service_reconciler():
- """Run the reconcile off the import path.
+ """Reconcile restored services on a daemon thread.
- restore_state runs at import; pulling images and starting containers there
- would block startup behind the Docker daemon, so this happens on a daemon
- thread once the process is up.
+ Pulling images and starting containers synchronously would block the
+ central persistence loader behind the Docker daemon.
"""
def _run():
time.sleep(_ECS_RESTORE_RECONCILE_DELAY)
@@ -331,16 +322,6 @@ def _start_restored_service_reconciler():
).start()
-try:
- _restored = load_state("ecs")
- if _restored:
- restore_state(_restored)
- _start_restored_service_reconciler()
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def _get_docker():
diff --git a/ministack/services/efs.py b/ministack/services/efs.py
index 9929e8eb..73c279a3 100644
--- a/ministack/services/efs.py
+++ b/ministack/services/efs.py
@@ -27,7 +27,6 @@ import string
import time
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -414,10 +413,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_clear_state()
@@ -459,15 +458,6 @@ def _restore_file_system_child_store(store, restored, fs_regions):
store.set_scoped(account_id, region, fs_id, value)
-try:
- _restored = load_state("efs")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def _put_lifecycle_configuration(fs_id, body):
diff --git a/ministack/services/eks.py b/ministack/services/eks.py
index 50cba178..2162d579 100644
--- a/ministack/services/eks.py
+++ b/ministack/services/eks.py
@@ -44,7 +44,6 @@ from ministack.core.iam_evaluator import (
resolve_caller_identity,
resolve_credential,
)
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -240,10 +239,10 @@ def _restore_cluster_child_store(store, restored, cluster_regions, separator):
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
_clusters.update(data.get("clusters", {}))
cluster_regions = {
(account_id, cluster_name): region
@@ -289,12 +288,6 @@ def restore_state(data):
-try:
- _restored = load_state("eks")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted eks state; continuing fresh")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/elasticache.py b/ministack/services/elasticache.py
index 3e05d150..653e9013 100644
--- a/ministack/services/elasticache.py
+++ b/ministack/services/elasticache.py
@@ -32,7 +32,6 @@ from urllib.parse import parse_qs
from ministack.core import container_reaper
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import resource_lock, run_offloop, spawn_background
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -141,7 +140,7 @@ def get_state():
# Issue #853: after restart the persisted Docker container ids reference
# containers that no longer exist. Metadata says "available" but no Redis
# is running, so Terraform / SDKs see a healthy cluster they can't connect
-# to. We can't respawn at restore_state time because that runs during
+# to. We can't respawn at _restore_state time because that runs during
# module-import (before _spawn_redis_container is defined). Instead, mark
# resources as pending and respawn lazily on the first dispatcher call —
# Terraform's typical flow is DescribeCacheClusters → connect, so the
@@ -211,10 +210,10 @@ def _restore_clusters(incoming):
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
default_state()
return
@@ -1788,14 +1787,6 @@ def _default_params_for_family(family):
}
-try:
- _restored = load_state("elasticache")
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---- Engine Versions ----
diff --git a/ministack/services/emr.py b/ministack/services/emr.py
index 95bbc9d7..bc9a77d8 100644
--- a/ministack/services/emr.py
+++ b/ministack/services/emr.py
@@ -24,7 +24,6 @@ import random
import string
import time
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -76,10 +75,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_clear_state()
@@ -135,15 +134,6 @@ def _restore_block_public_access(restored):
}
-try:
- _restored = load_state("emr")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
# ID generators
diff --git a/ministack/services/eventbridge.py b/ministack/services/eventbridge.py
index d91a9d81..e10cb324 100644
--- a/ministack/services/eventbridge.py
+++ b/ministack/services/eventbridge.py
@@ -99,7 +99,6 @@ def _coerce_timestamp(value):
return value
-from ministack.core.persistence import load_state
# Per-account and per-region registries. The "default" bus is lazily created
# per account/region on first access so every tenant has its own default bus
@@ -164,10 +163,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_event_buses.update(data.get("buses", {}))
_rules.update(data.get("rules", {}))
@@ -262,15 +261,6 @@ def _restore_targets_store(data) -> None:
_targets.set_scoped(account_id, region, rule_key, copy.deepcopy(targets))
-try:
- _restored = load_state("eventbridge")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
async def handle_request(method, path, headers, body, query_params):
diff --git a/ministack/services/firehose.py b/ministack/services/firehose.py
index 2c7e1ab0..c5a06c3d 100644
--- a/ministack/services/firehose.py
+++ b/ministack/services/firehose.py
@@ -28,7 +28,6 @@ import time
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import run_reentrant, spawn_background
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -65,23 +64,15 @@ def get_state() -> dict:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data: dict):
+def _restore_state(data: dict):
global _dest_counter
_streams.update(data.get("_streams", {}))
_dest_counter = data.get("_dest_counter", _dest_counter)
-try:
- _restored = load_state("firehose")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
-
- logging.getLogger(__name__).exception("Failed to restore persisted state; continuing with fresh store")
# ─── helpers ─────────────────────────────────────────────────────────────────
diff --git a/ministack/services/glue.py b/ministack/services/glue.py
index 042b240f..5472f8a9 100644
--- a/ministack/services/glue.py
+++ b/ministack/services/glue.py
@@ -29,7 +29,6 @@ from urllib.parse import unquote
from ministack.core import container_reaper
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import run_reentrant
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -154,10 +153,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
for key, store in _ALL_STATE.items():
store.clear()
restored = data.get(key, {})
@@ -181,14 +180,6 @@ def _restore_regional_store(store, restored):
store[key] = value
-try:
- _restored = load_state("glue")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
-
- logging.getLogger(__name__).exception("Failed to restore persisted state; continuing with fresh store")
def _arn(resource_type, name):
diff --git a/ministack/services/iam.py b/ministack/services/iam.py
index f16bdf12..450dcf2d 100644
--- a/ministack/services/iam.py
+++ b/ministack/services/iam.py
@@ -53,7 +53,6 @@ REGION = os.environ.get("MINISTACK_REGION", "us-east-1")
# ---------------------------------------------------------------------------
# Module-level state
# ---------------------------------------------------------------------------
-from ministack.core.persistence import load_state
_users = AccountScopedDict()
_roles = AccountScopedDict()
@@ -356,10 +355,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_users.update(data.get("users", {}))
_roles.update(data.get("roles", {}))
@@ -381,15 +380,6 @@ def restore_state(data):
_account_aliases.update(data.get("account_aliases", {}))
-try:
- _restored = load_state("iam")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ===================================================================== IAM
diff --git a/ministack/services/inspector2.py b/ministack/services/inspector2.py
index fff61729..c159775d 100644
--- a/ministack/services/inspector2.py
+++ b/ministack/services/inspector2.py
@@ -12,7 +12,6 @@ import time
import uuid
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -1225,10 +1224,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
reset()
@@ -1281,11 +1280,3 @@ def reset():
_scan_history.clear()
_tags.clear()
_filters.clear()
-
-
-try:
- _restored = load_state("inspector2")
- if _restored:
- restore_state(_restored)
-except Exception:
- logging.getLogger(__name__).exception("Failed to restore persisted state; continuing with fresh store")
diff --git a/ministack/services/iot.py b/ministack/services/iot.py
index 2d32c02c..965338d0 100644
--- a/ministack/services/iot.py
+++ b/ministack/services/iot.py
@@ -45,7 +45,7 @@ lookups (mTLS).
State is fully isolated per account and region via
``AccountRegionScopedDict`` and persisted through
-``get_state``/``restore_state``. The Local CA (used to sign
+``get_state``/``_restore_state``. The Local CA (used to sign
``CreateKeysAndCertificate`` certificates) is also persisted so previously
issued client certificates remain valid across restarts.
"""
@@ -69,7 +69,6 @@ from datetime import datetime, timezone
from typing import Awaitable, Callable
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
_request_account_id,
@@ -256,10 +255,10 @@ def get_state() -> dict:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data: dict | None) -> None:
+def _restore_state(data: dict | None) -> None:
global _ca_cert_pem, _ca_key_pem
global _mtls_server_cert_pem, _mtls_server_key_pem
if not data:
@@ -332,12 +331,6 @@ def reset() -> None:
logger.debug("IoT mTLS: restart after reset failed", exc_info=True)
-try:
- _restored = load_state("iot")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted IoT state; continuing with fresh store")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/iot_data.py b/ministack/services/iot_data.py
index 4a390ba6..b027a099 100644
--- a/ministack/services/iot_data.py
+++ b/ministack/services/iot_data.py
@@ -67,10 +67,10 @@ def get_state() -> dict:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data: dict | None) -> None:
+def _restore_state(data: dict | None) -> None:
return None
diff --git a/ministack/services/iot_jobs_data.py b/ministack/services/iot_jobs_data.py
index 0db86b8c..814696c4 100644
--- a/ministack/services/iot_jobs_data.py
+++ b/ministack/services/iot_jobs_data.py
@@ -51,10 +51,10 @@ def get_state() -> dict:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data: dict | None) -> None:
+def _restore_state(data: dict | None) -> None:
return None
diff --git a/ministack/services/iotwireless.py b/ministack/services/iotwireless.py
index 9bdc71f1..3410285f 100644
--- a/ministack/services/iotwireless.py
+++ b/ministack/services/iotwireless.py
@@ -89,10 +89,10 @@ def get_state() -> dict:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data: dict | None) -> None:
+def _restore_state(data: dict | None) -> None:
return None
diff --git a/ministack/services/kinesis.py b/ministack/services/kinesis.py
index 7dd3b844..3454ae78 100644
--- a/ministack/services/kinesis.py
+++ b/ministack/services/kinesis.py
@@ -40,7 +40,6 @@ REGION = os.environ.get("MINISTACK_REGION", "us-east-1")
MAX_HASH_KEY = (2**128) - 1
ITERATOR_EXPIRY_SECONDS = 300
-from ministack.core.persistence import load_state
_streams = AccountRegionScopedDict()
_shard_iterators = AccountRegionScopedDict()
@@ -60,10 +59,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_restore_stream_store(data.get("streams", {}))
_restore_shard_iterator_store(data.get("shard_iterators", {}))
@@ -171,15 +170,6 @@ def _restore_consumer_store(data) -> None:
_consumers.set_scoped(account_id, region, consumer_arn, copy.deepcopy(consumer))
-try:
- _restored = load_state("kinesis")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def _next_sequence_number():
diff --git a/ministack/services/kms.py b/ministack/services/kms.py
index 926faed9..f22d34d4 100644
--- a/ministack/services/kms.py
+++ b/ministack/services/kms.py
@@ -49,7 +49,6 @@ except ImportError:
REGION = os.environ.get("MINISTACK_REGION", "us-east-1")
-from ministack.core.persistence import load_state
_keys = AccountRegionScopedDict()
# key_id -> {
@@ -132,10 +131,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
keys_data = data.get("keys", {})
@@ -207,15 +206,6 @@ def restore_state(data):
_store_alias(get_account_id(), alias_key, target_id)
-try:
- _restored = load_state("kms")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def _arn(key_id):
diff --git a/ministack/services/lambda_core.py b/ministack/services/lambda_core.py
index c4f57e94..e88a2a98 100644
--- a/ministack/services/lambda_core.py
+++ b/ministack/services/lambda_core.py
@@ -37,7 +37,6 @@ import re
from datetime import datetime, timezone
from urllib.parse import unquote
-from ministack.core.persistence import load_state
from ministack.core.responses import (
REST_JSON_CONTENT_TYPE,
AccountRegionScopedDict,
@@ -96,10 +95,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_connectors.clear()
@@ -108,12 +107,6 @@ def restore_state(data):
_client_tokens.update(data.get("client_tokens", {}))
-try:
- _persisted = load_state("lambda_core")
- if _persisted:
- restore_state(_persisted)
-except Exception: # pragma: no cover - best-effort restore
- logger.exception("Failed to restore persisted lambda_core state; continuing fresh")
def reset():
diff --git a/ministack/services/lambda_durable.py b/ministack/services/lambda_durable.py
index 4c2303a0..bb10de2d 100644
--- a/ministack/services/lambda_durable.py
+++ b/ministack/services/lambda_durable.py
@@ -30,7 +30,6 @@ import time
import uuid
from urllib.parse import unquote
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountScopedDict,
_request_account_id,
@@ -79,9 +78,9 @@ _resume_thread_started = False
# Maps CallbackId → (DurableExecutionArn, OperationId), scoped by account, so
# external SendCallback{Success,Failure,Heartbeat} can find their target
-# without scanning every execution. Defined HERE (above restore_state) because
-# restore_state rebuilds this index from persisted executions at module import
-# time — if the name were defined later, restore_state would NameError on cold
+# without scanning every execution. Defined HERE (above _restore_state) because
+# _restore_state rebuilds this index from persisted executions at module import
+# time — if the name were defined later, _restore_state would NameError on cold
# start.
_callback_index = AccountScopedDict()
@@ -141,10 +140,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_executions.update(data.get("executions", {}))
@@ -194,13 +193,6 @@ def restore_state(data):
_request_region.reset(tok_r)
-try:
- _restored = load_state("lambda_durable")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception("Failed to restore lambda_durable state")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/lambda_microvms.py b/ministack/services/lambda_microvms.py
index 540e7ac8..c4f12ac0 100644
--- a/ministack/services/lambda_microvms.py
+++ b/ministack/services/lambda_microvms.py
@@ -21,7 +21,6 @@ import secrets
import time
from urllib.parse import unquote
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -52,10 +51,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_microvms.clear()
@@ -64,12 +63,6 @@ def restore_state(data):
_images.update(data.get("images", {}))
-try:
- _persisted = load_state("lambda_microvms")
- if _persisted:
- restore_state(_persisted)
-except Exception: # pragma: no cover - best-effort restore
- pass
def reset():
diff --git a/ministack/services/lambda_svc.py b/ministack/services/lambda_svc.py
index 1017cf0d..601b3904 100644
--- a/ministack/services/lambda_svc.py
+++ b/ministack/services/lambda_svc.py
@@ -64,7 +64,7 @@ from ministack.core.lambda_runtime import (
reap_idle_workers,
release_worker,
)
-from ministack.core.persistence import STATE_DIR, load_state
+from ministack.core.persistence import STATE_DIR
from ministack.core.responses import (
_12_DIGIT_RE,
AccountRegionScopedDict,
@@ -505,7 +505,7 @@ def _sweep_extract_cache() -> None:
# files no longer referenced by any function or version (e.g. previous
# ``UpdateFunctionCode`` generations).
#
-# Backward compatibility: ``restore_state`` accepts the legacy inline
+# Backward compatibility: ``_restore_state`` accepts the legacy inline
# base64 shape (``"code_zip": "<b64>"``) so an upgrade in place works
# without a one-shot migration step.
@@ -638,11 +638,14 @@ def get_state():
}
-def load_persisted_state(data):
- return restore_state(data)
+def load_persisted_state(data) -> None:
+ _restore_state(data)
+ if _esms.has_any():
+ _ensure_poller()
+ _resume_pending_snapstart_versions()
-def restore_state(data):
+def _restore_state(data):
if data:
funcs = data.get("functions", {})
if isinstance(funcs, AccountRegionScopedDict):
@@ -675,22 +678,19 @@ def restore_state(data):
_function_urls.update(data.get("function_urls", {}))
_restore_esm_positions(_kinesis_positions, data.get("kinesis_positions", {}))
_restore_esm_positions(_dynamodb_stream_positions, data.get("dynamodb_stream_positions", {}))
- # A SnapStart version persisted mid-publish restores as State=Pending
- # with no provisioning thread behind it — and Pending SnapStart
- # versions answer 409 on Invoke and are skipped by the generic state
- # flipper, so without re-provisioning here the version would be
- # uninvokable forever. Re-run the publish-time initialization.
- for scoped_key, func in list(_functions._data.items()):
- fn_name = scoped_key[-1]
- for ver_record in (func.get("versions") or {}).values():
- cfg = ver_record.get("config") or {}
- if (
- cfg.get("State") == "Pending"
- and (cfg.get("SnapStart") or {}).get("OptimizationStatus") == "On"
- ):
- _snapstart_provision_version_async(fn_name, ver_record)
- if _esms.has_any():
- _ensure_poller()
+
+
+def _resume_pending_snapstart_versions() -> None:
+ """Resume provisioners that cannot survive a process restart."""
+ for scoped_key, func in list(_functions._data.items()):
+ fn_name = scoped_key[-1]
+ for ver_record in (func.get("versions") or {}).values():
+ cfg = ver_record.get("config") or {}
+ if (
+ cfg.get("State") == "Pending"
+ and (cfg.get("SnapStart") or {}).get("OptimizationStatus") == "On"
+ ):
+ _snapstart_provision_version_async(fn_name, ver_record)
def _region_from_function_record(func: dict) -> str:
@@ -767,14 +767,6 @@ def _restore_esm_positions(store: AccountRegionScopedDict, positions) -> None:
store._data[(account_id, region, key)] = value
-# NOTE: the persisted-state load used to run here, but ``restore_state`` calls
-# ``_ensure_poller()`` when the restored data contains event source mappings,
-# and that helper is defined much later in this module. Restoring at import
-# time raised ``NameError: _ensure_poller`` on warm starts with a populated
-# ``lambda.json`` (issue #412). The load now lives at the bottom of the file,
-# after ``_ensure_poller`` is defined.
-
-
# ---------------------------------------------------------------------------
# Wrapper script executed inside the subprocess.
# All configuration is passed through env vars; event data arrives on stdin.
@@ -8022,18 +8014,3 @@ def reset():
with _docker_extract_lock:
_docker_extract_dirs.clear()
shutil.rmtree(_DOCKER_EXTRACT_CACHE, ignore_errors=True)
-
-
-# ---------------------------------------------------------------------------
-# Persisted-state restore — runs at module import time but deferred to the
-# very bottom of the file so forward references to helpers (e.g.
-# ``_ensure_poller``) resolve at call time (issue #412). A corrupt or
-# incompatible ``lambda.json`` logs and continues instead of breaking the
-# whole service.
-# ---------------------------------------------------------------------------
-try:
- _restored = load_state("lambda")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted Lambda state; continuing with a fresh store")
diff --git a/ministack/services/location.py b/ministack/services/location.py
index 9a2e270a..53dde1dc 100644
--- a/ministack/services/location.py
+++ b/ministack/services/location.py
@@ -79,7 +79,6 @@ import time
import unicodedata
import urllib.parse
-from ministack.core.persistence import load_state
from ministack.core.responses import (
REST_JSON_CONTENT_TYPE,
AccountRegionScopedDict,
@@ -131,10 +130,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
global _sequence
if not data:
return
@@ -147,12 +146,6 @@ def restore_state(data):
_sequence = max(_sequence, pos.get("Seq", 0))
-try:
- _restored = load_state("location")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted location state; continuing fresh")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/mediaconnect.py b/ministack/services/mediaconnect.py
index 3ff60ca6..5271bf2d 100644
--- a/ministack/services/mediaconnect.py
+++ b/ministack/services/mediaconnect.py
@@ -32,7 +32,6 @@ import time
import urllib.parse
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -66,10 +65,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_restore_flows(data.get("flows", {}))
@@ -105,12 +104,6 @@ def _restore_flows(restored):
_flows.set_scoped(account_id, _region_from_arn(arn, boot_region), arn, flow)
-try:
- _restored = load_state("mediaconnect")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted mediaconnect state; continuing fresh")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/mq.py b/ministack/services/mq.py
index 54c782ae..0c4789a6 100644
--- a/ministack/services/mq.py
+++ b/ministack/services/mq.py
@@ -30,7 +30,6 @@ import time
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -289,10 +288,10 @@ def get_state() -> dict:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data: dict) -> None:
+def _restore_state(data: dict) -> None:
if not data:
return
_brokers.update(data.get("brokers", {}))
@@ -332,12 +331,6 @@ def restore_state(data: dict) -> None:
_users.set_scoped(account_id, region, broker_id, users)
-try:
- _restored = load_state("mq")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore mq state; starting fresh")
# ============================================================================
diff --git a/ministack/services/msk.py b/ministack/services/msk.py
index ca370599..84ed9731 100644
--- a/ministack/services/msk.py
+++ b/ministack/services/msk.py
@@ -44,7 +44,6 @@ from datetime import datetime, timezone
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
get_account_id,
@@ -88,10 +87,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_clusters.update(data.get("clusters", {}))
@@ -101,12 +100,6 @@ def restore_state(data):
_tags.update(data.get("tags", {}))
-try:
- _restored = load_state("msk")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore msk state; continuing fresh")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/mwaa.py b/ministack/services/mwaa.py
index ccae0556..b02ff988 100644
--- a/ministack/services/mwaa.py
+++ b/ministack/services/mwaa.py
@@ -26,7 +26,6 @@ import time
from ministack.core import container_reaper
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import run_offloop
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
apply_image_prefix,
@@ -63,10 +62,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
envs_data = data.get("environments")
@@ -106,12 +105,6 @@ def restore_state(data):
).start()
-try:
- _restored = load_state("mwaa")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted state; continuing with fresh store")
def _s3_bucket_from_arn(bucket_arn: str) -> str:
diff --git a/ministack/services/opensearch.py b/ministack/services/opensearch.py
index 108851bd..ab9ed31b 100644
--- a/ministack/services/opensearch.py
+++ b/ministack/services/opensearch.py
@@ -32,7 +32,6 @@ import time
from ministack.core import container_reaper
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import resource_lock, run_offloop, spawn_background
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -161,11 +160,12 @@ def get_state():
}
-def load_persisted_state(data):
- return restore_state(data)
+def load_persisted_state(data) -> None:
+ _restore_state(data)
+ _restore_domain_dataplanes()
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_domains.update(data.get("domains") or {})
@@ -191,7 +191,6 @@ def restore_state(data):
)
_restore_package_store(_packages, data.get("packages") or {}, package_regions)
_tags.update(data.get("tags") or {})
- _restore_domain_dataplanes()
def _legacy_items(restored):
@@ -598,12 +597,6 @@ def _set_vpc_options(rec: dict, options) -> None:
rec["Endpoint"] = endpoint
-try:
- _restored = load_state("opensearch")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted OpenSearch state; continuing fresh")
def _new_domain_record(name, payload):
diff --git a/ministack/services/organizations.py b/ministack/services/organizations.py
index efd68896..07e726b9 100644
--- a/ministack/services/organizations.py
+++ b/ministack/services/organizations.py
@@ -19,7 +19,6 @@ import json
import logging
import time
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountScopedDict,
error_response_json,
@@ -58,10 +57,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
for store, key in (
@@ -73,16 +72,6 @@ def restore_state(data):
store[k] = v
-try:
- _restored = load_state("organizations")
- if _restored:
- restore_state(_restored)
-except Exception:
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
-
-
def _json(status, body):
return status, {"Content-Type": "application/x-amz-json-1.1"}, json.dumps(body).encode()
diff --git a/ministack/services/pipes.py b/ministack/services/pipes.py
index 817b1b2b..918005fb 100644
--- a/ministack/services/pipes.py
+++ b/ministack/services/pipes.py
@@ -23,7 +23,6 @@ import time
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -52,20 +51,18 @@ def get_state():
}
-def load_persisted_state(data):
- return restore_state(data)
+def load_persisted_state(data) -> None:
+ _restore_state(data)
+ # Restored RUNNING pipes need the background poller — register_pipe is the
+ # only other place that starts it, and it is not called on warm boot.
+ if any(pipe.get("CurrentState") == "RUNNING" for pipe in _pipes.all_values()):
+ _ensure_poller()
-def restore_state(data):
+def _restore_state(data):
if data:
_restore_pipe_store(data.get("pipes", {}))
_restore_position_store(data.get("positions", {}))
- # Restored RUNNING pipes need the background poller — register_pipe
- # is the only other place that starts it, and it isn't called on
- # warm-boot. Without this, persisted pipes would silently stop
- # forwarding events until a new pipe is registered.
- if any(p.get("CurrentState") == "RUNNING" for p in _pipes.all_values()):
- _ensure_poller()
def _pipe_arn_scope(pipe_arn: str, default_account_id: str | None = None) -> tuple[str, str]:
@@ -132,12 +129,6 @@ def _iter_all_pipes():
yield account_id, region, pipe
-try:
- _restored = load_state("pipes")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted pipes state; continuing fresh")
def reset():
diff --git a/ministack/services/rds.py b/ministack/services/rds.py
index d778f502..7c0bffcd 100644
--- a/ministack/services/rds.py
+++ b/ministack/services/rds.py
@@ -59,7 +59,6 @@ from xml.sax.saxutils import escape as _esc
from ministack.core import container_reaper, persistence
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import resource_lock, run_offloop, spawn_background
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -365,11 +364,11 @@ def get_state():
return state
-def load_persisted_state(data):
- return restore_state(data)
+def load_persisted_state(data) -> None:
+ _restore_state(data, resume_runtime=True)
-def restore_state(data):
+def _restore_state(data, *, resume_runtime=False):
if not data:
return
_clusters.update(data.get("clusters", {}))
@@ -457,6 +456,9 @@ def restore_state(data):
_instances.set_scoped(get_account_id(), region, name, inst)
to_respawn.append((None, region, name, inst))
+ if not resume_runtime:
+ return
+
# Re-spin backing containers for persisted instances. Mirrors the MWAA
# restore pattern: persistence saves the instance metadata but the Docker
# container itself is killed by the host restart, so the restore path has
@@ -529,7 +531,7 @@ def restore_state(data):
)
if cluster and members:
# Publish the restore/migration gate before the daemon starts. A
- # create arriving immediately after restore_state() must not start
+ # create arriving immediately after _restore_state() must not start
# fresh cluster storage before the writer volume is adopted.
cluster["_shared_legacy_migration_in_progress"] = True
cluster.pop("_shared_legacy_migration_blocked", None)
@@ -7136,7 +7138,7 @@ def _failover_db_cluster_impl(p):
if cluster.get("_shared_legacy_migration_in_progress") or cluster.get(
"_shared_legacy_migration_blocked",
):
- # restore_state's one-time legacy-storage migration reads
+ # _restore_state's one-time legacy-storage migration reads
# IsClusterWriter to pick which member's volume becomes the
# cluster's adopted shared state; flipping the flag mid-migration
# could make it adopt a reader's volume. Same gate as
@@ -10961,20 +10963,6 @@ def reset():
_port_counter[0] = BASE_PORT
-# Load persisted state at module import. Must run AFTER every helper this
-# code path may touch (notably `_get_docker`, `_docker_image_for_engine`,
-# `_get_ministack_network`) is defined — `restore_state` spawns daemon threads
-# that race against the rest of module parsing, and a thread reaching an
-# undefined name raises NameError mid-restore (issue #692 follow-up).
-try:
- _restored = load_state("rds")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
async def handle_request(method, path, headers, body, query_params):
diff --git a/ministack/services/resource_groups.py b/ministack/services/resource_groups.py
index f3feba5e..016b268b 100644
--- a/ministack/services/resource_groups.py
+++ b/ministack/services/resource_groups.py
@@ -24,7 +24,6 @@ import logging
import re
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -58,10 +57,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
restored_groups = data.get("groups", {})
@@ -97,12 +96,6 @@ def _restore_group_child_store(store, restored, legacy_group_regions):
store.set_scoped(account_id, region, group_name, value)
-try:
- _restored = load_state("resource_groups")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted state; continuing with fresh store")
def reset():
diff --git a/ministack/services/route53.py b/ministack/services/route53.py
index eaf934d4..222280c8 100644
--- a/ministack/services/route53.py
+++ b/ministack/services/route53.py
@@ -31,7 +31,6 @@ from xml.etree.ElementTree import Element, SubElement, tostring
from defusedxml.ElementTree import fromstring
-from ministack.core.persistence import load_state
from ministack.core.responses import AccountScopedDict, new_uuid
logger = logging.getLogger("route53")
@@ -67,10 +66,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
with _lock:
_zones.update(data.get("zones", {}))
@@ -86,15 +85,6 @@ def restore_state(data):
_changes.update(data.get("changes", {}))
-try:
- _restored = load_state("route53")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def reset():
diff --git a/ministack/services/s3.py b/ministack/services/s3.py
index 4b01719a..294d42e4 100644
--- a/ministack/services/s3.py
+++ b/ministack/services/s3.py
@@ -56,7 +56,6 @@ from ministack.core.iam_evaluator import (
find_iam_access_key_account,
resolve_credential,
)
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountScopedDict,
get_account_id,
@@ -158,7 +157,7 @@ _completed_multipart_uploads = AccountScopedDict()
# Module-level registry of per-bucket dicts that round-trip through s3.json.
# One entry per module global: adding a new _bucket_* dict means one line here,
-# not two separate edits in get_state/restore_state. Must sit below every
+# not two separate edits in get_state/_restore_state. Must sit below every
# _bucket_* declaration above — the dict literal holds live references.
# Excludes _buckets (has bespoke objects-stripping + legacy fallback) and
# per-bucket keys like _ownership_controls / _public_access_block that live
@@ -199,35 +198,27 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
bm = data.get("buckets_meta", {})
+ # Object persistence may already have created placeholder buckets during
+ # import. Restore metadata onto those records without replacing objects.
if isinstance(bm, AccountScopedDict):
# Restore all accounts' buckets directly via _data
for scoped_key, meta in bm._data.items():
- if scoped_key not in _buckets._data:
- _buckets._data[scoped_key] = {**meta, "objects": {}}
+ _buckets._data.setdefault(scoped_key, {"objects": {}}).update(meta)
else:
# Legacy plain-dict format (pre-multi-tenancy)
for name, meta in bm.items():
- if name not in _buckets:
- _buckets[name] = {**meta, "objects": {}}
+ _buckets.setdefault(name, {"objects": {}}).update(meta)
for key, d in _PERSISTED_BUCKET_DICTS.items():
d.update(data.get(key, {}))
-try:
- _restored = load_state("s3")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
-
- logging.getLogger(__name__).exception("Failed to restore persisted state; continuing with fresh store")
DATA_DIR = os.environ.get("S3_DATA_DIR", "/tmp/ministack-data/s3")
diff --git a/ministack/services/s3files.py b/ministack/services/s3files.py
index 80b8622f..18443bf0 100644
--- a/ministack/services/s3files.py
+++ b/ministack/services/s3files.py
@@ -23,7 +23,6 @@ import time
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -75,10 +74,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_clear_state()
@@ -145,12 +144,6 @@ def _restore_child_store(
store.set_scoped(account_id, region, key, value)
-try:
- _restored = load_state("s3files")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted state; continuing with fresh store")
def reset():
diff --git a/ministack/services/s3tables.py b/ministack/services/s3tables.py
index 9425d3d1..d6463cc8 100644
--- a/ministack/services/s3tables.py
+++ b/ministack/services/s3tables.py
@@ -38,7 +38,6 @@ import time
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import PERSIST_STATE, load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -82,10 +81,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
_table_buckets.update(data.get("table_buckets", {}))
_namespaces.update(data.get("namespaces", {}))
_tables.update(data.get("tables", {}))
@@ -97,10 +96,6 @@ def reset():
_tables.clear()
-if PERSIST_STATE:
- _saved = load_state("s3tables")
- if _saved:
- restore_state(_saved)
# ── Helpers ────────────────────────────────────────────────
diff --git a/ministack/services/scheduler.py b/ministack/services/scheduler.py
index d325ed65..0402c7bc 100644
--- a/ministack/services/scheduler.py
+++ b/ministack/services/scheduler.py
@@ -23,7 +23,6 @@ from datetime import datetime, timezone
from urllib.parse import unquote
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -65,21 +64,15 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
_schedules.update(data.get("schedules", {}))
_schedule_groups.update(data.get("schedule_groups", {}))
_tags.update(data.get("tags", {}))
-try:
- _restored = load_state("scheduler")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted scheduler state; continuing fresh")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/secretsmanager.py b/ministack/services/secretsmanager.py
index bd0fb447..0ca25fd3 100644
--- a/ministack/services/secretsmanager.py
+++ b/ministack/services/secretsmanager.py
@@ -35,7 +35,6 @@ logger = logging.getLogger("secretsmanager")
REGION = os.environ.get("MINISTACK_REGION", "us-east-1")
-from ministack.core.persistence import load_state
_secrets = AccountRegionScopedDict()
_resource_policies = AccountRegionScopedDict()
@@ -59,24 +58,15 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_secrets.update(data.get("secrets", {}))
_resource_policies.update(data.get("resource_policies", {}))
-try:
- _restored = load_state("secretsmanager")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
diff --git a/ministack/services/ses.py b/ministack/services/ses.py
index 2427a219..3825cf16 100644
--- a/ministack/services/ses.py
+++ b/ministack/services/ses.py
@@ -35,7 +35,6 @@ from email.mime.text import MIMEText
from email.policy import default as default_policy
from urllib.parse import parse_qs
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -76,10 +75,10 @@ def get_state() -> dict:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data: dict):
+def _restore_state(data: dict):
_restore_regional_store(_identities, data.get("_identities", {}))
_restore_regional_store(_templates, data.get("_templates", {}))
_restore_regional_store(
@@ -101,15 +100,6 @@ def _restore_regional_store(store, restored):
store[key] = value
-try:
- _restored = load_state("ses")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
diff --git a/ministack/services/ses_v2.py b/ministack/services/ses_v2.py
index cb22515d..7fbf1885 100644
--- a/ministack/services/ses_v2.py
+++ b/ministack/services/ses_v2.py
@@ -22,7 +22,6 @@ import re
import time
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -61,10 +60,10 @@ def get_state() -> dict:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data: dict):
+def _restore_state(data: dict):
_restore_regional_store(_identities, data.get("_identities", {}))
_restore_regional_store(_config_sets, data.get("_config_sets", {}))
_restore_tag_store(data.get("_ses_tags", {}))
@@ -102,15 +101,6 @@ def _legacy_resource_arn_for_region(resource_arn, account_id, region):
return f"arn:aws:ses:{region}:{account_id}:{spec.resource}"
-try:
- _restored = load_state("ses_v2")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def _json_err(code, message, status=400):
diff --git a/ministack/services/signer.py b/ministack/services/signer.py
index fd9c9ef2..9d5d3aa8 100644
--- a/ministack/services/signer.py
+++ b/ministack/services/signer.py
@@ -89,7 +89,6 @@ import uuid
from datetime import datetime, timedelta, timezone
import ministack.services.s3 as s3_svc
-from ministack.core.persistence import load_state
from ministack.core.responses import (
REST_JSON_CONTENT_TYPE,
AccountRegionScopedDict,
@@ -125,10 +124,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_jobs.update(data.get("jobs", {}))
@@ -136,12 +135,6 @@ def restore_state(data):
_tokens.update(data.get("tokens", {}))
-try:
- _restored = load_state("signer")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted signer state; continuing fresh")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/sns.py b/ministack/services/sns.py
index c943fcd0..4b74acec 100644
--- a/ministack/services/sns.py
+++ b/ministack/services/sns.py
@@ -122,7 +122,6 @@ def _resolve_topic_tag_arn(arn: str):
return arn, None, _error("ResourceNotFoundException", "Resource not found", 404)
return arn, topic, None
-from ministack.core.persistence import load_state
_topics = AccountRegionScopedDict()
_sub_arn_to_topic = AccountRegionScopedDict()
@@ -142,10 +141,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_topics.update(data.get("topics", {}))
_sub_arn_to_topic.update(data.get("sub_arn_to_topic", {}))
@@ -153,15 +152,6 @@ def restore_state(data):
_platform_endpoints.update(data.get("platform_endpoints", {}))
-try:
- _restored = load_state("sns")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
async def handle_request(method: str, path: str, headers: dict, body: bytes, query_params: dict) -> tuple:
diff --git a/ministack/services/sqs.py b/ministack/services/sqs.py
index 9f34f9e1..4c505443 100644
--- a/ministack/services/sqs.py
+++ b/ministack/services/sqs.py
@@ -39,7 +39,6 @@ from urllib.parse import parse_qs, urlparse
from xml.sax.saxutils import escape as _esc
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import AccountRegionScopedDict, get_account_id, get_region, new_uuid
logger = logging.getLogger("sqs")
@@ -71,10 +70,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_queues.update(data.get("queues", {}))
_queue_name_to_url.clear()
@@ -241,21 +240,6 @@ def _rebuild_queue_name_index() -> None:
_queue_name_to_url.set_scoped(account_id, region, name, url)
-# Import-time state restore. MUST run after restore_state AND every symbol it
-# references (here _rebuild_queue_name_index, defined just above) are bound —
-# otherwise the import-time call NameErrors, the bare except swallows it, and all
-# persisted SQS state is silently dropped on restart (the #492/#494 pattern).
-try:
- _restored = load_state("sqs")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
-
-
# ────────────────────────────────────────────────────────────
# ENTRY POINT
# ────────────────────────────────────────────────────────────
diff --git a/ministack/services/ssm.py b/ministack/services/ssm.py
index 49a309e8..a5af98ec 100644
--- a/ministack/services/ssm.py
+++ b/ministack/services/ssm.py
@@ -35,7 +35,6 @@ logger = logging.getLogger("ssm")
REGION = os.environ.get("MINISTACK_REGION", "us-east-1")
DEFAULT_PAGE_SIZE = 10
-from ministack.core.persistence import load_state
_parameters = AccountRegionScopedDict()
_parameter_history = AccountRegionScopedDict()
@@ -98,10 +97,10 @@ def _restore_parameter_history(data) -> None:
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if data:
_parameters.update(data.get("parameters", {}))
_restore_parameter_history(data.get("parameter_history", {}))
@@ -210,15 +209,6 @@ def _parameter_tag_arn(resource_type: str, resource_id: str) -> str | None:
return _param_arn(resource_id)
-try:
- _restored = load_state("ssm")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def _encode_next_token(index: int) -> str:
diff --git a/ministack/services/stepfunctions.py b/ministack/services/stepfunctions.py
index 3be8ec1b..10d9de41 100644
--- a/ministack/services/stepfunctions.py
+++ b/ministack/services/stepfunctions.py
@@ -47,7 +47,6 @@ except ImportError: # the wheel is optional at runtime: JSONata states refuse
from ministack.core.arn import ArnParseError, parse_arn
from ministack.core.concurrency import run_reentrant
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -162,10 +161,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_state_machines.update(data.get("state_machines", {}))
@@ -184,15 +183,6 @@ def restore_state(data):
exc["cause"] = "Execution was running when service restarted"
-try:
- _restored = load_state("stepfunctions")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
_TIMESTAMP_RESPONSE_FIELDS = {
diff --git a/ministack/services/transcribe.py b/ministack/services/transcribe.py
index 60284b63..d5f019e5 100644
--- a/ministack/services/transcribe.py
+++ b/ministack/services/transcribe.py
@@ -65,7 +65,6 @@ import re
import time
from urllib.parse import urlparse
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -207,7 +206,7 @@ def get_state():
return copy.deepcopy({"jobs": _jobs})
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_jobs.clear()
@@ -221,7 +220,7 @@ def restore_state(data):
def load_persisted_state(data):
- restore_state(data)
+ _restore_state(data)
def _fail_orphaned_jobs():
@@ -235,12 +234,6 @@ def _fail_orphaned_jobs():
job["FailureReason"] = "Internal Failure. The job did not survive a MiniStack restart."
job["CompletionTime"] = time.time()
-try:
- _restored = load_state("transcribe")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted Transcribe state; continuing with fresh store")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/transfer.py b/ministack/services/transfer.py
index fc6f3f55..48d855e1 100644
--- a/ministack/services/transfer.py
+++ b/ministack/services/transfer.py
@@ -43,7 +43,6 @@ import os
import time
from typing import Optional
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -95,23 +94,14 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
_servers.update(data.get("servers", {}))
_users.update(data.get("users", {}))
-try:
- _restored = load_state("transfer")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
# ---------------------------------------------------------------------------
diff --git a/ministack/services/translate.py b/ministack/services/translate.py
index 2aa79685..cc166b08 100644
--- a/ministack/services/translate.py
+++ b/ministack/services/translate.py
@@ -72,7 +72,6 @@ import xml.etree.ElementTree as ET
from defusedxml.common import DefusedXmlException
from defusedxml.ElementTree import fromstring as _xml_fromstring
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
error_response_json,
@@ -199,7 +198,7 @@ def get_state():
return copy.deepcopy({"jobs": _jobs, "client_tokens": _client_tokens})
-def restore_state(data):
+def _restore_state(data):
if not data:
return
_jobs.clear()
@@ -217,7 +216,7 @@ def restore_state(data):
def load_persisted_state(data):
- restore_state(data)
+ _restore_state(data)
def _fail_orphaned_jobs():
@@ -232,12 +231,6 @@ def _fail_orphaned_jobs():
job["EndTime"] = int(time.time())
-try:
- _restored = load_state("translate")
- if _restored:
- restore_state(_restored)
-except Exception:
- logger.exception("Failed to restore persisted Translate state; continuing with fresh store")
# ---------------------------------------------------------------------------
diff --git a/ministack/services/waf.py b/ministack/services/waf.py
index b7e064f4..df996766 100644
--- a/ministack/services/waf.py
+++ b/ministack/services/waf.py
@@ -17,7 +17,6 @@ import logging
import os
from ministack.core.arn import ArnParseError, parse_arn
-from ministack.core.persistence import load_state
from ministack.core.responses import (
AccountRegionScopedDict,
AccountScopedDict,
@@ -60,10 +59,10 @@ def get_state():
def load_persisted_state(data):
- return restore_state(data)
+ return _restore_state(data)
-def restore_state(data):
+def _restore_state(data):
if not isinstance(data, dict):
return
arn_rewrites = {}
@@ -252,15 +251,6 @@ def _values_for_scope(store, scope):
return store.values_scoped(get_account_id(), _scope_home_region(scope))
-try:
- _restored = load_state("waf")
- if _restored:
- restore_state(_restored)
-except Exception:
- import logging
- logging.getLogger(__name__).exception(
- "Failed to restore persisted state; continuing with fresh store"
- )
def _waf_err(code, message):
diff --git a/tests/test_acm.py b/tests/test_acm.py
index 4854217d..1a19319c 100644
--- a/tests/test_acm.py
+++ b/tests/test_acm.py
@@ -495,7 +495,7 @@ def test_get_state_strips_private_key_from_persisted_snapshot():
# Restoring the scrubbed snapshot must not crash and must preserve
# both tenants' certs (minus the private keys).
mod._certificates._data.clear()
- mod.restore_state(snapshot)
+ mod.load_persisted_state(snapshot)
restored_arns = {cert["CertificateArn"] for cert in mod._certificates._data.values()}
assert arn_a in restored_arns
assert arn_b in restored_arns
@@ -568,7 +568,7 @@ def test_restore_state_backfills_pem_body_for_pre_upgrade_snapshots():
},
},
}
- mod.restore_state(legacy_snapshot)
+ mod.load_persisted_state(legacy_snapshot)
# _get_certificate hits the restored record and reads _pem_body.
cert = mod._certificates.get(arn)
diff --git a/tests/test_appsync.py b/tests/test_appsync.py
index ec845cad..74c69c9a 100644
--- a/tests/test_appsync.py
+++ b/tests/test_appsync.py
@@ -235,7 +235,7 @@ def test_appsync_legacy_children_restore_beside_parent_api():
service.reset()
try:
- service.restore_state(payload)
+ service.load_persisted_state(payload)
assert service._apis.get_scoped(account_id, api_region, api_id)["arn"] == api_arn
for store in (
service._api_keys,
diff --git a/tests/test_athena.py b/tests/test_athena.py
index 03db2ec2..4f757ed3 100644
--- a/tests/test_athena.py
+++ b/tests/test_athena.py
@@ -229,7 +229,7 @@ def test_athena_legacy_state_migrates_to_configured_boot_region(monkeypatch):
service.reset()
try:
- service.restore_state(payload)
+ service.load_persisted_state(payload)
for store_name, (key, value) in stores.items():
restored = getattr(service, store_name).get_scoped(
account_id, boot_region, key
@@ -314,7 +314,7 @@ def test_athena_legacy_children_follow_workgroup_region(monkeypatch):
service.reset()
try:
assert service.REGION != first_request_region
- service.restore_state(payload)
+ service.load_persisted_state(payload)
assert service._workgroups.get_scoped(
account_id, workgroup_region, workgroup_name
diff --git a/tests/test_autoscaling.py b/tests/test_autoscaling.py
index 72f59a96..54a26882 100644
--- a/tests/test_autoscaling.py
+++ b/tests/test_autoscaling.py
@@ -152,7 +152,7 @@ def test_restore_legacy_child_state_uses_parent_asg_region():
service.reset()
try:
- service.restore_state(
+ service.load_persisted_state(
{
"asgs": asgs,
"policies": policies,
diff --git a/tests/test_batch.py b/tests/test_batch.py
index 9885c7f9..c72cda75 100644
--- a/tests/test_batch.py
+++ b/tests/test_batch.py
@@ -444,7 +444,7 @@ def test_batch_restore_legacy_state_uses_resource_arn_region():
service.reset()
try:
- service.restore_state(legacy_state)
+ service.load_persisted_state(legacy_state)
for state_key, (resource_key, value) in stores.items():
store = getattr(service, f"_{state_key}")
assert store.get_scoped(account_id, resource_region, resource_key) == value
@@ -480,7 +480,7 @@ def test_batch_restore_current_state_preserves_non_boot_regions():
assert not snapshot["compute_envs"]
service.reset()
- service.restore_state(snapshot)
+ service.load_persisted_state(snapshot)
for state_key, (resource_key, value) in resources.items():
store = getattr(service, f"_{state_key}")
diff --git a/tests/test_cloudwatch_logs.py b/tests/test_cloudwatch_logs.py
index 45f39a6b..b62d3f84 100644
--- a/tests/test_cloudwatch_logs.py
+++ b/tests/test_cloudwatch_logs.py
@@ -1526,7 +1526,7 @@ def _round_trip(mod, svc_key="cloudwatch_logs"):
"file was not written by save_state(). Check get_state() "
"correctness and that PERSIST_STATE is True."
)
- mod.restore_state(loaded)
+ mod.load_persisted_state(loaded)
# ── _destinations ──────────────────────────────────────────────────────
@@ -1613,7 +1613,7 @@ def test_legacy_metric_filters_restore_to_log_group_region():
try:
set_request_region("us-east-1")
- mod.restore_state({
+ mod.load_persisted_state({
"log_groups": {
group: {
"arn": f"arn:aws:logs:us-west-2:000000000000:log-group:{group}:*",
@@ -1722,7 +1722,7 @@ def test_legacy_queries_restore_to_log_group_region():
try:
set_request_region("us-east-1")
- mod.restore_state({
+ mod.load_persisted_state({
"log_groups": {
group: {
"arn": f"arn:aws:logs:us-west-2:000000000000:log-group:{group}:*",
diff --git a/tests/test_codebuild.py b/tests/test_codebuild.py
index 5fb089eb..cddda75d 100644
--- a/tests/test_codebuild.py
+++ b/tests/test_codebuild.py
@@ -264,7 +264,7 @@ def test_codebuild_restore_legacy_state_uses_resource_arn_region():
service.reset()
try:
- service.restore_state({"projects": projects, "builds": builds})
+ service.load_persisted_state({"projects": projects, "builds": builds})
assert service._projects.get_scoped(
account_id, resource_region, project_name
)["name"] == project_name
@@ -523,7 +523,7 @@ def test_env_file_keeps_an_endpoint_the_project_declared(monkeypatch, tmp_path):
def test_restored_in_flight_builds_are_not_left_running():
"""A build cannot survive a restart, so it must not restore as IN_PROGRESS."""
- codebuild.restore_state({
+ codebuild.load_persisted_state({
"projects": {},
"builds": {"demo:0010": {
"id": "demo:0010",
diff --git a/tests/test_cognito.py b/tests/test_cognito.py
index b18ac928..f475f294 100644
--- a/tests/test_cognito.py
+++ b/tests/test_cognito.py
@@ -4978,7 +4978,7 @@ def _cognito_round_trip(mod, svc_key="cognito"):
mod.reset()
loaded = persistence.load_state(svc_key)
assert loaded is not None, "load_state returned None — get_state may be wrong"
- mod.restore_state(loaded)
+ mod.load_persisted_state(loaded)
def test_auth_codes_survive_warm_boot(_enable_persistence):
@@ -5865,7 +5865,7 @@ def test_cognito_legacy_state_self_places_by_pool_ids():
mod.reset()
set_request_account_id(account)
set_request_region("us-east-1")
- mod.restore_state({
+ mod.load_persisted_state({
"user_pools": legacy_user_pools,
"pool_domain_map": legacy_domains,
"identity_pools": legacy_identity_pools,
@@ -5885,7 +5885,7 @@ def test_cognito_legacy_state_self_places_by_pool_ids():
v3 = AccountRegionScopedDict()
v3.set_scoped(account, "eu-central-1", "eu-central-1_v3", {"Name": "v3"})
mod.reset()
- mod.restore_state({"user_pools": v3})
+ mod.load_persisted_state({"user_pools": v3})
assert mod._user_pools.get_scoped(account, "eu-central-1", "eu-central-1_v3") == {
"Name": "v3"
}
@@ -6539,7 +6539,7 @@ def test_custom_auth_session_persistence():
state = cognito_mod.get_state()
cognito_mod._challenge_sessions.clear()
assert cognito_mod._challenge_sessions.get(token) is None
- cognito_mod.restore_state(state)
+ cognito_mod.load_persisted_state(state)
assert cognito_mod._challenge_sessions.get(token) is not None
diff --git a/tests/test_cur.py b/tests/test_cur.py
index f842f3c8..6c3f880e 100644
--- a/tests/test_cur.py
+++ b/tests/test_cur.py
@@ -323,15 +323,31 @@ def test_cur_state_round_trips_through_get_and_restore():
cur.reset()
assert "r1" not in cur._report_definitions
- cur.restore_state(snapshot)
+ cur.load_persisted_state(snapshot)
assert cur._report_definitions["r1"]["S3Bucket"] == "billing"
assert cur._report_tags["r1"] == {"team": "finops"}
-def test_cur_module_calls_load_state_on_import():
- """The bug we fixed: load_state was never invoked at import time, so
- every warm-boot lost CUR state. Verify the module exposes _restored
- (set by the import-time block whether or not anything was found)."""
+def test_cur_central_restore_recovers_reports_and_tags(monkeypatch, tmp_path):
+ """CUR reports survive a disk round trip through the gateway loader."""
+ import ministack.app as app
+ from ministack.core import persistence
+ from ministack.core.responses import AccountScopedDict
from ministack.services import cur
- assert hasattr(cur, "_restored")
+ monkeypatch.setattr(cur, "_report_definitions", AccountScopedDict())
+ monkeypatch.setattr(cur, "_report_tags", AccountScopedDict())
+ monkeypatch.setattr(persistence, "PERSIST_STATE", True)
+ monkeypatch.setattr(persistence, "STATE_DIR", str(tmp_path))
+ monkeypatch.setattr(app, "_state_map", {"cur": "cur"})
+ monkeypatch.setattr(app, "_loaded_modules", {})
+ report = _report_definition("restored-report")
+ cur._report_definitions[report["ReportName"]] = report
+ cur._report_tags[report["ReportName"]] = {"team": "finops"}
+ persistence.save_all({"cur": app._build_persistence_save_dict()["cur"]})
+ cur.reset()
+
+ app._load_persisted_state()
+
+ assert cur._report_definitions[report["ReportName"]] == report
+ assert cur._report_tags[report["ReportName"]] == {"team": "finops"}
diff --git a/tests/test_dynamodb.py b/tests/test_dynamodb.py
index bc773275..88982c7d 100644
--- a/tests/test_dynamodb.py
+++ b/tests/test_dynamodb.py
@@ -289,7 +289,7 @@ def test_dynamodb_restore_legacy_table_name_metadata_uses_table_arn_region():
}
try:
- ddb_service.restore_state({
+ ddb_service.load_persisted_state({
"tables": tables,
"ttl_settings": ttl_settings,
"pitr_settings": pitr_settings,
@@ -359,7 +359,7 @@ def test_dynamodb_restore_ambiguous_legacy_metadata_uses_value_arn_region():
]
try:
- ddb_service.restore_state({
+ ddb_service.load_persisted_state({
"tables": tables,
"ttl_settings": ttl_settings,
"kinesis_destinations": kinesis_destinations,
diff --git a/tests/test_ecs.py b/tests/test_ecs.py
index f0395c03..b140ad08 100644
--- a/tests/test_ecs.py
+++ b/tests/test_ecs.py
@@ -237,48 +237,43 @@ def test_ecs_run_task_metadata_v4(ecs):
assert success, "Task should transition to STOPPED"
-def test_ecs_restore_helpers_are_defined_before_the_import_time_restore():
- """Everything `restore_state` calls must be bound before the module runs it.
-
- `ecs.py` calls `restore_state(_restored)` at module level, so a helper it
- reaches that is defined further down the file raises NameError there. The
- surrounding try/except catches it and ALL ECS state fails to restore, which
- is only visible under PERSIST_STATE=1 and never in a test that calls
- `restore_state` after the import. The file already carries `_attributes`
- at the top for exactly this reason; this keeps the next one honest.
- """
- import ast
- import inspect
-
- tree = ast.parse(inspect.getsource(ecs_service))
- defined_at = {
- node.name: node.lineno
- for node in tree.body
- if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef))
- }
- restore = next(
- n for n in tree.body
- if isinstance(n, ast.FunctionDef) and n.name == "restore_state"
- )
- call_line = next(
- n.lineno for n in ast.walk(tree)
- if isinstance(n, ast.Call)
- and isinstance(n.func, ast.Name)
- and n.func.id == "restore_state"
- and n.col_offset == 8 # the module-level try: block, not a nested call
- )
-
- late = sorted({
- node.id
- for node in ast.walk(restore)
- if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load)
- and node.id in defined_at and defined_at[node.id] > call_line
- })
- assert not late, (
- f"restore_state reaches {late}, defined after the import-time call at "
- f"line {call_line}; move them above it or the warm-boot restore dies "
- f"silently"
- )
[email protected]("has_services", [False, True])
+def test_ecs_central_restore_reconciles_after_loading_state(monkeypatch, tmp_path, has_services):
+ """Boot restores tasks and attributes before scheduling service relaunch."""
+ import ministack.app as app
+ from ministack.core import persistence
+ from ministack.core.responses import AccountRegionScopedDict
+
+ account, region = "222222222222", "eu-west-1"
+ services = AccountRegionScopedDict()
+ tasks = AccountRegionScopedDict()
+ attributes = AccountRegionScopedDict()
+ if has_services:
+ services.set_scoped(account, region, "cluster/service", {"status": "ACTIVE"})
+ tasks.set_scoped(account, region, "task", {"lastStatus": "RUNNING", "version": 1})
+ attributes.set_scoped(account, region, "instance:attr", {"name": "attr", "value": "v"})
+ for name in ("_services", "_tasks", "_attributes"):
+ monkeypatch.setattr(ecs_service, name, AccountRegionScopedDict())
+ monkeypatch.setattr(persistence, "PERSIST_STATE", True)
+ monkeypatch.setattr(persistence, "STATE_DIR", str(tmp_path))
+ monkeypatch.setattr(app, "_state_map", {"ecs": "ecs"})
+ monkeypatch.setattr(app, "_loaded_modules", {})
+ persistence.save_state("ecs", {"services": services, "tasks": tasks, "attributes": attributes})
+
+ scheduled = []
+
+ def schedule():
+ # Capture what the worker would see at the moment it is scheduled.
+ scheduled.append(copy.deepcopy(ecs_service._tasks.get_scoped(account, region, "task")))
+
+ monkeypatch.setattr(ecs_service, "_start_restored_service_reconciler", schedule)
+ app._load_persisted_state()
+
+ task = ecs_service._tasks.get_scoped(account, region, "task")
+ assert task["lastStatus"] == "STOPPED"
+ assert task["version"] == 2
+ assert ecs_service._attributes.get_scoped(account, region, "instance:attr")["value"] == "v"
+ assert scheduled == ([task] if has_services else [])
def test_ecs_run_task_applies_container_command_overrides(monkeypatch):
@@ -2399,7 +2394,7 @@ def test_ecs_restore_stops_a_running_task_and_counts_it(monkeypatch):
assert _ecs._tasks[task_arn]["_container_ip"] == "172.30.0.31"
assert "_container_ip" not in saved
_ecs.reset()
- _ecs.restore_state(state)
+ _ecs.load_persisted_state(state)
restored = _ecs._tasks[task_arn]
assert restored["lastStatus"] == "STOPPED"
@@ -2408,7 +2403,7 @@ def test_ecs_restore_stops_a_running_task_and_counts_it(monkeypatch):
# Restoring an already stopped task is not a transition.
state = _ecs.get_state()
_ecs.reset()
- _ecs.restore_state(state)
+ _ecs.load_persisted_state(state)
assert _ecs._tasks[task_arn]["version"] == running_version + 1
diff --git a/tests/test_efs.py b/tests/test_efs.py
index b8398174..fc394af4 100644
--- a/tests/test_efs.py
+++ b/tests/test_efs.py
@@ -160,7 +160,7 @@ def test_efs_restore_legacy_state_places_children_beside_parent():
service.reset()
try:
- service.restore_state(payload)
+ service.load_persisted_state(payload)
assert service._file_systems.get_scoped(account_id, resource_region, fs_id)["FileSystemId"] == fs_id
assert service._mount_targets.get_scoped(account_id, resource_region, mt_id)["FileSystemId"] == fs_id
assert service._access_points.get_scoped(account_id, resource_region, ap_id)["FileSystemId"] == fs_id
diff --git a/tests/test_eks.py b/tests/test_eks.py
index b87cd048..009e890a 100644
--- a/tests/test_eks.py
+++ b/tests/test_eks.py
@@ -1540,7 +1540,7 @@ def test_eks_restore_state_normalizes_endpoint_to_localhost():
state = eks_mod.get_state()
eks_mod.reset()
- eks_mod.restore_state(state)
+ eks_mod.load_persisted_state(state)
restored = eks_mod._clusters.get("c-restore")
assert restored["endpoint"] == "https://localhost:16443"
diff --git a/tests/test_elasticache.py b/tests/test_elasticache.py
index ee367fe6..6c98ac6a 100644
--- a/tests/test_elasticache.py
+++ b/tests/test_elasticache.py
@@ -812,7 +812,7 @@ def test_elasticache_restore_legacy_account_scoped_state_adopts_record_arn_regio
try:
set_request_account_id(account_id)
set_request_region("us-east-1")
- _ec.restore_state({
+ _ec.load_persisted_state({
"clusters": legacy_clusters,
"replication_groups": legacy_rgs,
"subnet_groups": legacy_subnets,
@@ -1535,7 +1535,7 @@ def test_elasticache_restore_state_marks_clusters_for_respawn(monkeypatch):
monkeypatch.setattr(_ec, "_spawn_redis_container", fake_spawn)
- _ec.restore_state({
+ _ec.load_persisted_state({
"clusters": {
"clustertest": {
"CacheClusterId": "clustertest",
@@ -1573,7 +1573,7 @@ def test_elasticache_restore_state_wipes_stale_replication_group_container_ids(m
monkeypatch.setattr(_ec, "_spawn_redis_container",
lambda name, engine, engine_version, labels: ("rg-host", 6379, f"cid-{name}"))
- _ec.restore_state({
+ _ec.load_persisted_state({
"replication_groups": {
"rg-1": {
"ReplicationGroupId": "rg-1",
@@ -1625,7 +1625,7 @@ def test_elasticache_restore_state_respawns_same_names_per_region(monkeypatch):
"_docker_container_ids": [f"dead-rg-{region}"],
})
- _ec.restore_state({
+ _ec.load_persisted_state({
"clusters": clusters,
"replication_groups": replication_groups,
})
@@ -1677,7 +1677,7 @@ def test_elasticache_respawn_failure_is_logged_and_does_not_block_requests(monke
monkeypatch.setattr(_ec, "_spawn_redis_container", boom)
- _ec.restore_state({
+ _ec.load_persisted_state({
"clusters": {
"c1": {
"CacheClusterId": "c1", "Engine": "redis", "EngineVersion": "7.1",
diff --git a/tests/test_emr.py b/tests/test_emr.py
index ce3bfc4c..b7e53e06 100644
--- a/tests/test_emr.py
+++ b/tests/test_emr.py
@@ -128,7 +128,7 @@ def test_emr_legacy_state_restores_children_beside_parent():
service.reset()
try:
- service.restore_state(
+ service.load_persisted_state(
{
"_clusters": clusters,
"_steps": steps,
diff --git a/tests/test_firehose.py b/tests/test_firehose.py
index 267e7b73..0dc427c3 100644
--- a/tests/test_firehose.py
+++ b/tests/test_firehose.py
@@ -769,7 +769,7 @@ def test_firehose_restore_legacy_account_scoped_state_uses_arn_region():
set_request_account_id(account_id)
set_request_region("us-east-1")
- _fh.restore_state({"_streams": legacy_streams})
+ _fh.load_persisted_state({"_streams": legacy_streams})
# The legacy stream lands in the region carried by its ARN, not the
# active request region.
diff --git a/tests/test_glue.py b/tests/test_glue.py
index aad1de2f..45bc6036 100644
--- a/tests/test_glue.py
+++ b/tests/test_glue.py
@@ -1773,7 +1773,7 @@ def test_glue_legacy_account_scoped_state_falls_back_to_ambient_region():
try:
set_request_account_id(account)
set_request_region(region)
- gluemod.restore_state(state)
+ gluemod.load_persisted_state(state)
assert gluemod._databases.get_scoped(account, region, "legacy-db")["Name"] == "legacy-db"
assert gluemod._tables.get_scoped(account, region, "legacy-db/legacy-table")["Name"] == "legacy-table"
diff --git a/tests/test_iam.py b/tests/test_iam.py
index 0b02951c..661dd049 100644
--- a/tests/test_iam.py
+++ b/tests/test_iam.py
@@ -913,7 +913,7 @@ def test_iam_aws_managed_attachment_count_persists_through_state_round_trip():
_iam._aws_managed_attachment_counts.clear()
assert _iam._aws_managed_attachment_counts.get(arn, 0) == 0
- _iam.restore_state(snapshot)
+ _iam.load_persisted_state(snapshot)
assert _iam._aws_managed_attachment_counts.get(arn) == 2
diff --git a/tests/test_inspector2.py b/tests/test_inspector2.py
index db7c790e..d194bd54 100644
--- a/tests/test_inspector2.py
+++ b/tests/test_inspector2.py
@@ -109,7 +109,7 @@ def test_inspector2_legacy_buckets_restore_to_boot_region():
service.reset()
try:
- service.restore_state(payload)
+ service.load_persisted_state(payload)
for state_key in (
"account_config",
"findings",
@@ -270,7 +270,8 @@ class TestPersistence:
from ministack.services import inspector2 as _inspector2
assert hasattr(_inspector2, "get_state")
- assert hasattr(_inspector2, "restore_state")
+ assert hasattr(_inspector2, "load_persisted_state")
+ assert not hasattr(_inspector2, "restore_state")
assert hasattr(_inspector2, "reset")
assert hasattr(_inspector2, "handle_request")
@@ -295,7 +296,7 @@ class TestPersistence:
_inspector2.reset()
state = _inspector2.get_state()
- _inspector2.restore_state(state)
+ _inspector2.load_persisted_state(state)
state2 = _inspector2.get_state()
assert set(state.keys()) == set(state2.keys())
diff --git a/tests/test_iot.py b/tests/test_iot.py
index 0e71d138..ab607f9a 100644
--- a/tests/test_iot.py
+++ b/tests/test_iot.py
@@ -4949,14 +4949,14 @@ def test_ddb_attribute_value_mapping():
# Fleet-index connectivity (white-box: transitions and persistence)
# ----------------------------------------------------------------------
-from ministack.services.iot import ( # noqa: E402
+from ministack.services.iot import (
_thing_connectivity,
)
-from ministack.services.iot import ( # noqa: E402
+from ministack.services.iot import (
get_state as _iot_get_state,
)
from ministack.services.iot import ( # noqa: E402
- restore_state as _iot_restore_state,
+ load_persisted_state as _iot_load_persisted_state,
)
_ACCT = "123456789012"
@@ -5107,7 +5107,7 @@ def test_connectivity_is_not_persisted_and_cannot_restore_as_connected():
# Restart: state comes back, sessions do not.
await session.cleanup()
reset()
- _iot_restore_state(snapshot)
+ _iot_load_persisted_state(snapshot)
doc = _connectivity_of("dev-snap")
assert doc["connected"] is False
# And nothing was invented to fill the gap.
diff --git a/tests/test_kinesis.py b/tests/test_kinesis.py
index 100a6f4d..2babeca7 100644
--- a/tests/test_kinesis.py
+++ b/tests/test_kinesis.py
@@ -374,7 +374,7 @@ def test_kinesis_restore_legacy_account_scoped_state_uses_arn_region():
set_request_account_id(account_id)
set_request_region("us-east-1")
- _kin.restore_state({
+ _kin.load_persisted_state({
"streams": legacy_streams,
"shard_iterators": legacy_iterators,
"consumers": legacy_consumers,
diff --git a/tests/test_kms.py b/tests/test_kms.py
index 8162fde6..0fd36954 100644
--- a/tests/test_kms.py
+++ b/tests/test_kms.py
@@ -794,7 +794,7 @@ def test_kms_restore_legacy_account_scoped_state_adopts_key_arn_region():
try:
set_request_account_id(account_id)
set_request_region("us-east-1")
- _kms.restore_state({"keys": legacy_keys, "aliases": legacy_aliases})
+ _kms.load_persisted_state({"keys": legacy_keys, "aliases": legacy_aliases})
assert _kms._keys.get_scoped(account_id, "us-east-1", key_id) is None
assert _kms._keys.get_scoped(account_id, "us-west-2", key_id)["Arn"] == key_arn
@@ -849,7 +849,7 @@ def test_kms_restore_legacy_bare_alias_name_adopts_target_key_region():
try:
set_request_account_id(account_id)
set_request_region("us-east-1")
- _kms.restore_state({"keys": legacy_keys, "aliases": legacy_aliases})
+ _kms.load_persisted_state({"keys": legacy_keys, "aliases": legacy_aliases})
assert _kms._aliases.get_scoped(account_id, "us-east-1", alias_arn) is None
assert _kms._aliases.get_scoped(account_id, "us-west-2", alias_arn) == key_id
@@ -1920,7 +1920,7 @@ def test_kms_hmac_key_survives_state_roundtrip():
assert "_hmac_key_b64" in state["keys"][key_id]
assert "_hmac_key" not in state["keys"][key_id]
_kms.reset()
- _kms.restore_state(state)
+ _kms.load_persisted_state(state)
rec = _kms._keys[key_id]
assert isinstance(rec["_hmac_key"], bytes)
diff --git a/tests/test_lambda.py b/tests/test_lambda.py
index ed602544..0c3f0889 100644
--- a/tests/test_lambda.py
+++ b/tests/test_lambda.py
@@ -3717,7 +3717,7 @@ def test_lambda_layer_version_permission_survives_persistence_roundtrip(lambda_s
status, _headers, _body = svc._get_layer_version_policy(layer_name, 1)
assert status == 404
- svc.restore_state(state)
+ svc.load_persisted_state(state)
status, _headers, body = svc._get_layer_version_policy(layer_name, 1)
assert status == 200
restored = json.loads(body)
@@ -5237,7 +5237,7 @@ def test_lambda_restore_legacy_plain_functions_uses_arn_region():
set_request_account_id(account_id)
set_request_region("us-east-1")
- lsvc.restore_state({"functions": {function_name: legacy_func}})
+ lsvc.load_persisted_state({"functions": {function_name: legacy_func}})
assert lsvc._functions.get_scoped(account_id, "us-west-2", function_name) is legacy_func
assert lsvc._functions.get_scoped(account_id, "us-east-1", function_name) is None
@@ -5580,10 +5580,10 @@ def esm_poll_state(tmp_path, monkeypatch):
yield lsvc, _sqs, _kin, _ddb
finally:
_clear_all()
- lsvc.restore_state(lambda_state)
- _sqs.restore_state(sqs_state)
- _kin.restore_state(kinesis_state)
- _ddb.restore_state(dynamodb_state)
+ lsvc.load_persisted_state(lambda_state)
+ _sqs.load_persisted_state(sqs_state)
+ _kin.load_persisted_state(kinesis_state)
+ _ddb.load_persisted_state(dynamodb_state)
_ddb._stream_records._data.update(stream_records)
_ddb._stream_trimmed._data.update(trimmed)
@@ -9087,14 +9087,14 @@ def test_lambda_durable_persistence_round_trip():
# Wipe and restore.
lambda_durable._executions.clear()
assert not lambda_durable._executions
- lambda_durable.restore_state(snap)
+ lambda_durable.load_persisted_state(snap)
assert rec["DurableExecutionArn"] in lambda_durable._executions
restored = lambda_durable._executions[rec["DurableExecutionArn"]]
assert restored["Status"] == "RUNNING"
assert restored["InputPayload"] == '{"k":"v"}'
finally:
lambda_durable._executions.clear()
- lambda_durable.restore_state(original)
+ lambda_durable.load_persisted_state(original)
# ---------------------------------------------------------------------------
@@ -9137,7 +9137,7 @@ def lambda_svc_isolated(tmp_path, monkeypatch):
yield lambda_svc, tmp_path / "lambda-blobs"
finally:
lambda_svc._functions._data.clear()
- lambda_svc.restore_state(original)
+ lambda_svc.load_persisted_state(original)
def test_lambda_code_zip_round_trip_through_blob_storage(lambda_svc_isolated):
@@ -9148,7 +9148,7 @@ def test_lambda_code_zip_round_trip_through_blob_storage(lambda_svc_isolated):
state = svc.get_state()
svc._functions._data.clear()
- svc.restore_state(state)
+ svc.load_persisted_state(state)
restored = svc._functions._data[("000000000000", svc.get_region(), "fn")]
assert restored["code_zip"] == code
@@ -9187,7 +9187,7 @@ def test_lambda_per_version_code_zip_also_externalized(lambda_svc_isolated):
}
svc._functions._data.clear()
- svc.restore_state(state)
+ svc.load_persisted_state(state)
restored = svc._functions._data[("000000000000", svc.get_region(), "fn")]
assert restored["code_zip"] == v2
assert restored["versions"]["1"]["code_zip"] == v1
@@ -9232,7 +9232,7 @@ def test_lambda_legacy_inline_base64_persistence_still_loads(lambda_svc_isolated
"versions": {},
}
- svc.restore_state(legacy)
+ svc.load_persisted_state(legacy)
restored = svc._functions._data[("000000000000", svc.get_region(), "old-fn")]
assert restored["code_zip"] == code
@@ -9259,7 +9259,7 @@ def test_lambda_missing_blob_degrades_without_aborting_restore(lambda_svc_isolat
"versions": {},
}
- svc.restore_state(state)
+ svc.load_persisted_state(state)
assert svc._functions._data[("000000000000", svc.get_region(), "orphan")]["code_zip"] is None
@@ -9743,7 +9743,7 @@ def test_lambda_durable_restore_rebuilds_callback_index_and_rearms_timers():
}
with _preserved_lambda_durable_state(_ld):
# Pretend ministack just booted and read this rec from disk.
- _ld.restore_state({"executions": {arn: rec}})
+ _ld.load_persisted_state({"executions": {arn: rec}})
# Index must contain the STARTED callback.
assert cb_op_id in _ld._callback_index
assert _ld._callback_index[cb_op_id] == (arn, cb_op_id)
@@ -9774,7 +9774,7 @@ def test_lambda_durable_restore_rearms_non_boot_region_from_arn():
}])
with _preserved_lambda_durable_state(_ld):
- _ld.restore_state({"executions": {arn: rec}})
+ _ld.load_persisted_state({"executions": {arn: rec}})
with _ld._resume_lock:
entries = [e for e in _ld._resume_queue if e[1] == arn]
assert entries, "no resume entry queued after restore"
@@ -9808,7 +9808,7 @@ def test_lambda_durable_restore_rebuilds_non_default_account_records():
with _preserved_lambda_durable_state(_ld):
try:
- _ld.restore_state({"executions": executions})
+ _ld.load_persisted_state({"executions": executions})
set_request_account_id(account_id)
set_request_region(region)
assert _ld._callback_index[cb_op_id] == (arn, cb_op_id)
@@ -9859,7 +9859,7 @@ def test_lambda_durable_restore_callback_index_is_account_scoped():
original_region = get_region()
with _preserved_lambda_durable_state(_ld):
try:
- _ld.restore_state({"executions": executions})
+ _ld.load_persisted_state({"executions": executions})
set_request_account_id(account_a)
set_request_region(region)
@@ -9899,7 +9899,7 @@ def test_lambda_durable_restore_skips_non_running_executions():
"InputPayload": "{}",
}
with _preserved_lambda_durable_state(_ld):
- _ld.restore_state({"executions": {arn_done: rec}})
+ _ld.load_persisted_state({"executions": {arn_done: rec}})
# SUCCEEDED callback must NOT be indexed (only STARTED ones).
assert cb_op_id not in _ld._callback_index
@@ -9922,7 +9922,7 @@ def test_lambda_durable_restore_malformed_arn_falls_back_and_continues(caplog):
executions = AccountScopedDict.from_dict({(account_id, arn): rec})
with _preserved_lambda_durable_state(_ld), caplog.at_level("WARNING"):
- _ld.restore_state({"executions": executions})
+ _ld.load_persisted_state({"executions": executions})
assert "Malformed DurableExecutionArn during restore" in caplog.text
with _ld._resume_lock:
entries = [e for e in _ld._resume_queue if e[1] == arn]
@@ -12542,9 +12542,9 @@ def test_snapstart_version_worker_is_reapable():
lr._workers.pop("000000000000:us-east-1:reap-probe:1", None)
-def test_snapstart_pending_version_reprovisions_on_restore():
+def test_snapstart_pending_version_reprovisions_on_load():
"""A SnapStart version persisted while Pending (crash mid-publish) must be
- re-provisioned by restore_state — otherwise it answers 409 forever."""
+ re-provisioned by load_persisted_state — otherwise it answers 409 forever."""
import copy as _copy
arn = "arn:aws:lambda:us-east-1:000000000000:function:snap-restore-fn"
@@ -12572,7 +12572,7 @@ def test_snapstart_pending_version_reprovisions_on_restore():
}
key = ("000000000000", "us-east-1", "snap-restore-fn")
try:
- lsvc.restore_state({"functions": {"snap-restore-fn": func}})
+ lsvc.load_persisted_state({"functions": {"snap-restore-fn": func}})
for _ in range(60):
state = ver_cfg["State"]
if state != "Pending":
diff --git a/tests/test_ministack.py b/tests/test_ministack.py
index fb2cf742..d63a8b14 100644
--- a/tests/test_ministack.py
+++ b/tests/test_ministack.py
@@ -186,7 +186,7 @@ def test_ministack_persist_sqs_roundtrip():
saved_queues = dict(_sqs._queues)
_sqs._queues.clear()
_sqs._queue_name_to_url.clear()
- _sqs.restore_state(state)
+ _sqs.load_persisted_state(state)
assert "http://localhost:4566/000000000000/persist-q" in _sqs._queues
_sqs._queues.update(saved_queues)
@@ -196,7 +196,7 @@ def test_ministack_persist_sns_roundtrip():
state = _sns.get_state()
assert "topics" in state
_sns._topics.pop("arn:aws:sns:us-east-1:000000000000:persist-topic", None)
- _sns.restore_state(state)
+ _sns.load_persisted_state(state)
assert "arn:aws:sns:us-east-1:000000000000:persist-topic" in _sns._topics
_sns._topics.pop("arn:aws:sns:us-east-1:000000000000:persist-topic", None)
@@ -206,7 +206,7 @@ def test_ministack_persist_ssm_roundtrip():
state = _ssm.get_state()
assert "parameters" in state
_ssm._parameters.pop("/persist/key")
- _ssm.restore_state(state)
+ _ssm.load_persisted_state(state)
assert "/persist/key" in _ssm._parameters
_ssm._parameters.pop("/persist/key")
@@ -216,7 +216,7 @@ def test_ministack_persist_secretsmanager_roundtrip():
state = _sm.get_state()
assert "secrets" in state
_sm._secrets.pop("persist-secret")
- _sm.restore_state(state)
+ _sm.load_persisted_state(state)
assert "persist-secret" in _sm._secrets
_sm._secrets.pop("persist-secret")
@@ -226,7 +226,7 @@ def test_ministack_persist_dynamodb_roundtrip():
state = _ddb.get_state()
assert "tables" in state
_ddb._tables.pop("persist-tbl")
- _ddb.restore_state(state)
+ _ddb.load_persisted_state(state)
assert "persist-tbl" in _ddb._tables
_ddb._tables.pop("persist-tbl")
@@ -236,7 +236,7 @@ def test_ministack_persist_eventbridge_roundtrip():
state = _eb.get_state()
assert "rules" in state
_eb._rules.pop("default|persist-rule")
- _eb.restore_state(state)
+ _eb.load_persisted_state(state)
assert "default|persist-rule" in _eb._rules
_eb._rules.pop("default|persist-rule")
@@ -246,7 +246,7 @@ def test_ministack_persist_kinesis_roundtrip():
state = _kin.get_state()
assert "streams" in state
_kin._streams.pop("persist-stream")
- _kin.restore_state(state)
+ _kin.load_persisted_state(state)
assert "persist-stream" in _kin._streams
_kin._streams.pop("persist-stream")
@@ -257,7 +257,7 @@ def test_ministack_persist_kms_roundtrip():
state = _kms.get_state()
assert "keys" in state
_kms._keys.pop(key_id)
- _kms.restore_state(state)
+ _kms.load_persisted_state(state)
assert key_id in _kms._keys
assert _kms._keys[key_id]["Description"] == "persist-key"
_kms._keys.pop(key_id)
@@ -268,7 +268,7 @@ def test_ministack_persist_ec2_roundtrip():
state = _ec2.get_state()
assert "instances" in state
_ec2._instances.pop("i-persist01")
- _ec2.restore_state(state)
+ _ec2.load_persisted_state(state)
assert "i-persist01" in _ec2._instances
_ec2._instances.pop("i-persist01")
@@ -278,7 +278,7 @@ def test_ministack_persist_route53_roundtrip():
state = _r53.get_state()
assert "zones" in state
_r53._zones.pop("Z00PERSIST")
- _r53.restore_state(state)
+ _r53.load_persisted_state(state)
assert "Z00PERSIST" in _r53._zones
_r53._zones.pop("Z00PERSIST")
@@ -288,7 +288,7 @@ def test_ministack_persist_cognito_roundtrip():
state = _cog.get_state()
assert "user_pools" in state
_cog._user_pools.pop("us-east-1_PERSIST")
- _cog.restore_state(state)
+ _cog.load_persisted_state(state)
assert "us-east-1_PERSIST" in _cog._user_pools
_cog._user_pools.pop("us-east-1_PERSIST")
@@ -298,7 +298,7 @@ def test_ministack_persist_ecr_roundtrip():
state = _ecr.get_state()
assert "repositories" in state
_ecr._repositories.pop("persist-repo")
- _ecr.restore_state(state)
+ _ecr.load_persisted_state(state)
assert "persist-repo" in _ecr._repositories
_ecr._repositories.pop("persist-repo")
@@ -308,7 +308,7 @@ def test_ministack_persist_cloudwatch_roundtrip():
state = _cw.get_state()
assert "alarms" in state
_cw._alarms.pop("persist-alarm")
- _cw.restore_state(state)
+ _cw.load_persisted_state(state)
assert "persist-alarm" in _cw._alarms
_cw._alarms.pop("persist-alarm")
@@ -323,7 +323,7 @@ def test_ministack_persist_s3_metadata_roundtrip():
assert "bucket_versioning" in state
_s3._buckets.pop("persist-bkt")
_s3._bucket_versioning.pop("persist-bkt")
- _s3.restore_state(state)
+ _s3.load_persisted_state(state)
assert "persist-bkt" in _s3._buckets
assert _s3._buckets["persist-bkt"]["objects"] == {} # objects not restored
assert _s3._bucket_versioning["persist-bkt"] == "Enabled"
@@ -349,7 +349,7 @@ def test_ministack_persist_s3_logging_accelerate_request_payment_roundtrip():
_s3._bucket_logging_config.pop("persist-log-bkt")
_s3._bucket_accelerate_config.pop("persist-log-bkt")
_s3._bucket_request_payment_config.pop("persist-log-bkt")
- _s3.restore_state(state)
+ _s3.load_persisted_state(state)
assert "TargetBucket>tgt" in _s3._bucket_logging_config["persist-log-bkt"]
assert "Enabled" in _s3._bucket_accelerate_config["persist-log-bkt"]
assert "Requester" in _s3._bucket_request_payment_config["persist-log-bkt"]
@@ -378,7 +378,7 @@ def test_ministack_persist_lambda_roundtrip():
# the bytes themselves live under ${STATE_DIR}/lambda-blobs/{sha}.zip.
assert state["functions"]["persist-fn"]["code_zip"] == {"code_blob_ref": sha}
_lam._functions.pop("persist-fn")
- _lam.restore_state(state)
+ _lam.load_persisted_state(state)
assert "persist-fn" in _lam._functions
# code_zip is restored back to bytes.
assert _lam._functions["persist-fn"]["code_zip"] == code
@@ -402,7 +402,7 @@ def test_ministack_persist_rds_roundtrip():
assert "instances" in state
assert "_docker_container_id" not in state["instances"]["persist-db"]
_rds._instances.pop("persist-db")
- _rds.restore_state(state)
+ _rds.load_persisted_state(state)
assert "persist-db" in _rds._instances
assert _rds._instances["persist-db"]["Engine"] == "postgres"
_rds._instances.pop("persist-db")
@@ -421,7 +421,7 @@ def test_ministack_persist_ecs_roundtrip():
assert "_docker_ids" not in state["tasks"]["arn:persist-task"]
_ecs._clusters.pop("persist-cluster")
_ecs._tasks.pop("arn:persist-task")
- _ecs.restore_state(state)
+ _ecs.load_persisted_state(state)
assert "persist-cluster" in _ecs._clusters
assert "arn:persist-task" in _ecs._tasks
assert _ecs._tasks["arn:persist-task"]["lastStatus"] == "STOPPED"
@@ -440,7 +440,7 @@ def test_ministack_persist_elasticache_roundtrip():
assert "clusters" in state
assert "_docker_container_id" not in state["clusters"]["persist-cache"]
_ec._clusters.pop("persist-cache")
- _ec.restore_state(state)
+ _ec.load_persisted_state(state)
assert "persist-cache" in _ec._clusters
assert _ec._clusters["persist-cache"]["Engine"] == "redis"
_ec._clusters.pop("persist-cache")
@@ -460,7 +460,7 @@ def test_ministack_persist_stepfunctions_roundtrip():
assert "state_machines" in state
assert sm_arn in state["state_machines"]
_sfn._state_machines.pop(sm_arn)
- _sfn.restore_state(state)
+ _sfn.load_persisted_state(state)
assert sm_arn in _sfn._state_machines
assert _sfn._state_machines[sm_arn]["name"] == "persist-sm"
_sfn._state_machines.pop(sm_arn)
@@ -486,7 +486,7 @@ def test_ministack_persist_stepfunctions_running_marked_failed():
state = _sfn.get_state()
_sfn._executions.pop(run_arn)
_sfn._executions.pop(done_arn)
- _sfn.restore_state(state)
+ _sfn.load_persisted_state(state)
# RUNNING execution should be marked FAILED
restored_run = _sfn._executions[run_arn]
assert restored_run["status"] == "FAILED"
@@ -601,7 +601,7 @@ def test_lambda_svc_restore_does_not_forward_reference_ensure_poller():
"function_urls": {},
}
# Must not raise NameError
- lam_mod.restore_state(fake_state)
+ lam_mod.load_persisted_state(fake_state)
assert "fake-uuid" in [e["UUID"] for e in lam_mod._esms.values()] or True
diff --git a/tests/test_mq.py b/tests/test_mq.py
index bb637ba8..6165871a 100644
--- a/tests/test_mq.py
+++ b/tests/test_mq.py
@@ -1328,7 +1328,7 @@ def test_mq_legacy_state_follows_parent_broker_region(isolated_mq_module_state):
"legacy-user": {"username": "legacy-user"}
})
- service.restore_state({
+ service.load_persisted_state({
"brokers": brokers,
"name_index": name_index,
"tags": tags,
@@ -1352,7 +1352,7 @@ def test_mq_legacy_orphaned_users_are_dropped(isolated_mq_module_state):
"orphaned-user": {"username": "orphaned-user"}
})
- service.restore_state({"users": users})
+ service.load_persisted_state({"users": users})
assert not service._users.has_any()
diff --git a/tests/test_persistence.py b/tests/test_persistence.py
index f120b2bf..3ce3f322 100644
--- a/tests/test_persistence.py
+++ b/tests/test_persistence.py
@@ -5,8 +5,8 @@ Background
----------
When PERSIST_STATE=1, the registry-derived `_state_map` in
`ministack/app.py` supplies each loaded service's `get_state()` function
-to `save_all()` at shutdown. State is currently restored either by a
-service's import-time `load_state()` call or by `_load_persisted_state()`.
+to `save_all()` at shutdown. Startup restores saved snapshots centrally
+through each service's `load_persisted_state()` method.
These tests protect persistence round trips and the registry contract.
"""
@@ -57,31 +57,41 @@ def test_registered_service_defines_state_contract(mod_name):
f"Service module {mod_name} must define get_state(), "
"load_persisted_state(data), and reset()."
)
+ assert "restore_state" not in functions, (
+ f"Service module {mod_name} exposes restore_state(); use the public "
+ "load_persisted_state(data) contract instead."
+ )
+
+
+def test_tests_restore_state_only_through_the_public_contract():
+ """Tests must not couple themselves to service implementation helpers."""
+ private_calls = []
+ for path in Path(__file__).parent.glob("test_*.py"):
+ tree = ast.parse(path.read_text())
+ for node in ast.walk(tree):
+ if isinstance(node, ast.Attribute) and node.attr == "_restore_state":
+ private_calls.append(f"{path.name}:{node.lineno}")
+ elif isinstance(node, ast.Name) and node.id == "_restore_state":
+ private_calls.append(f"{path.name}:{node.lineno}")
+
+ assert not private_calls, (
+ "Tests must restore state through load_persisted_state(), not private "
+ f"helpers: {', '.join(private_calls)}"
+ )
@pytest.mark.parametrize("svc_key,mod_name", sorted(_state_map.items()))
def test_service_has_restore_path(svc_key, mod_name):
"""Every service in `_state_map` must expose a way to restore its own state.
- Either the module calls `load_state()` itself at import time, or it exposes
- `load_persisted_state(data)` and is wired into `_load_persisted_state()`.
- Without one of the two its state is written on shutdown and dropped on the
- next boot, silently.
+ The registry-driven app loader dispatches each saved snapshot through the
+ module's `load_persisted_state(data)` contract. Without that method its
+ state is written on shutdown and dropped on the next boot, silently.
"""
mod = _module(mod_name)
if not mod.get_state():
pytest.skip(f"{mod_name} holds no state to restore")
- src = Path(mod.__file__).read_text()
-
- self_restoring = (
- "from ministack.core.persistence import" in src
- and "load_state(" in src
- )
- centrally_restored = hasattr(mod, "load_persisted_state") and svc_key in {
- "apigateway", "apigateway_v1", "servicediscovery",
- }
-
- assert self_restoring or centrally_restored, (
+ assert callable(getattr(mod, "load_persisted_state", None)), (
f"Service `{svc_key}` (module `{mod_name}`) is in `_state_map` and will "
f"be saved on shutdown, but has no restore path on startup."
)
@@ -351,7 +361,7 @@ def test_appsync_events_legacy_children_follow_parent_api_region():
try:
set_request_account_id(account_id)
set_request_region(boot_region)
- service.restore_state(
+ service.load_persisted_state(
{
"apis": apis,
"channel_namespaces": namespaces,
@@ -451,7 +461,7 @@ def test_appsync_events_v2_region_scoped_state_round_trip(monkeypatch, tmp_path)
try:
set_request_account_id(account_id)
set_request_region(boot_region)
- service.restore_state(loaded)
+ service.load_persisted_state(loaded)
assert service._apis.get_scoped(account_id, api_region, api_id)[
"apiArn"
@@ -567,7 +577,7 @@ def test_save_dict_skips_modules_never_imported(monkeypatch):
# ── Functional round-trip tests ────────────────────────────────────────
def _round_trip(mod_name, svc_key, populate_fn, observe_fn):
- """Helper: populate -> save -> reset -> restore -> observe."""
+ """Helper: populate -> save -> reset -> registry-style restore -> observe."""
mod = _module(mod_name)
mod.reset()
populate_fn(mod)
@@ -579,22 +589,14 @@ def _round_trip(mod_name, svc_key, populate_fn, observe_fn):
# Wipe in-memory state — this simulates a process restart.
mod.reset()
- # Restore via the same code path the module would use at import.
+ # Restore via the same uniform contract used by the registry loader.
loaded = persistence.load_state(svc_key)
assert loaded is not None, (
f"persistence.load_state({svc_key!r}) returned None — state file "
"was not written by save_state(). Check `_state_map` membership "
"and `get_state()` correctness."
)
- if hasattr(mod, "restore_state"):
- mod.restore_state(loaded)
- elif hasattr(mod, "load_persisted_state"):
- mod.load_persisted_state(loaded)
- else:
- pytest.fail(
- f"Module {mod_name} has neither restore_state nor "
- "load_persisted_state — cannot restore."
- )
+ mod.load_persisted_state(loaded)
# Cleanup state file before observation, so a failure doesn't pollute
# the next test run.
@@ -1047,7 +1049,7 @@ def test_backup_legacy_selection_migration_colocates_with_parent_plan():
"Resources": [f"arn:aws:dynamodb:{plan_region}:{account_id}:table/WestTable"],
}
- backup.restore_state(legacy_state)
+ backup.load_persisted_state(legacy_state)
assert backup._vaults.get_scoped(account_id, plan_region, vault_name) is not None
assert backup._plans.get_scoped(account_id, plan_region, plan_id) is not None
@@ -1162,7 +1164,7 @@ def test_ecr_legacy_state_uses_parent_repository_region(
try:
set_request_account_id(account_id)
set_request_region(boot_region)
- mod.restore_state(
+ mod.load_persisted_state(
{
"repositories": repositories,
"images": images,
@@ -1382,7 +1384,7 @@ def test_eks_legacy_state_uses_arn_and_parent_regions():
try:
set_request_account_id(account_id)
set_request_region(boot_region)
- mod.restore_state(
+ mod.load_persisted_state(
{
"clusters": legacy_clusters,
"nodegroups": legacy_nodegroups,
@@ -1577,7 +1579,7 @@ def test_scheduler_legacy_account_scoped_state_uses_resource_arn_region():
try:
set_request_account_id(account_id)
set_request_region("us-east-1")
- mod.restore_state(
+ mod.load_persisted_state(
{"schedule_groups": legacy_groups, "schedules": legacy_schedules}
)
@@ -1657,7 +1659,7 @@ def test_mwaa_restore_preserves_resource_region_outside_boot_scope(
try:
set_request_account_id(account_id)
set_request_region(boot_region)
- mod.restore_state({"environments": restored})
+ mod.load_persisted_state({"environments": restored})
assert mod._environments.get_scoped(account_id, boot_region, env_name) is None
restored_env = mod._environments.get_scoped(
@@ -1721,7 +1723,7 @@ def test_pipes_round_trip():
def test_pipes_restore_starts_poller_for_running_pipes(monkeypatch):
- """When `restore_state` reloads pipes that are RUNNING, the background
+ """When `load_persisted_state` reloads RUNNING pipes, the background
poller must be (re)started so events keep flowing after warm-boot."""
mod = _module("pipes")
mod.reset()
@@ -1729,7 +1731,7 @@ def test_pipes_restore_starts_poller_for_running_pipes(monkeypatch):
monkeypatch.setattr(mod, "_poller_started", False)
pipe_arn = "arn:aws:pipes:us-east-1:000000000000:pipe/poller-test"
- mod.restore_state({
+ result = mod.load_persisted_state({
"pipes": {
"poller-test": {
"Name": "poller-test",
@@ -1748,66 +1750,104 @@ def test_pipes_restore_starts_poller_for_running_pipes(monkeypatch):
})
assert mod._poller_started, (
- "restore_state() did not start the pipes poller for a RUNNING pipe — "
+ "load_persisted_state() did not start the pipes poller for a RUNNING pipe — "
"warm-booted pipes would silently stop forwarding events."
)
+ assert result is None
mod.reset()
-def test_lambda_esm_eager_loaded_at_boot_when_persisted(monkeypatch):
- """#889: persisted SQS event source mappings must resume polling after a
- warm restart even under pure-SQS traffic. The ESM poller starts from
- lambda_svc's import-time restore (`_ensure_poller`), and lambda_svc is
- otherwise imported lazily only on a Lambda request — so `_load_persisted_state`
- must eager-import it at boot when ESMs are persisted, else the restored
- mapping sits Enabled-but-unpolled and messages pile up. A restore_state-level
- test does NOT catch this: the bug is the module never being imported."""
- import ministack.app as app
- monkeypatch.setattr(app, "load_state",
- lambda key: {"esms": {"uuid-1": {"Enabled": True}}} if key == "lambda" else None)
- requested = []
- real = app._get_module
- monkeypatch.setattr(app, "_get_module", lambda n: (requested.append(n), real(n))[1])
- app._load_persisted_state()
- assert "lambda_svc" in requested, (
- "#889: persisted ESMs present but lambda_svc was not eager-imported at "
- "boot — the SQS poller never starts under pure-SQS traffic after restart."
- )
-
+def test_lambda_load_starts_event_source_mapping_poller(monkeypatch):
+ """Warm boot resumes the Lambda poller only through the loader API."""
+ mod = _module("lambda_svc")
+ mod.reset()
+ calls = []
+ monkeypatch.setattr(mod, "_ensure_poller", lambda: calls.append(None))
+
+ mod.load_persisted_state({
+ "esms": {
+ "warm-boot-esm": {
+ "UUID": "warm-boot-esm",
+ "FunctionArn": (
+ "arn:aws:lambda:us-east-1:000000000000:function:warm-boot"
+ ),
+ },
+ },
+ })
-def test_lambda_not_eager_loaded_without_persisted_esms(monkeypatch):
- """Narrow: no persisted ESMs → don't pay the lambda_svc cold-start at boot."""
- import ministack.app as app
- monkeypatch.setattr(app, "load_state",
- lambda key: {"esms": {}} if key == "lambda" else None)
- requested = []
- real = app._get_module
- monkeypatch.setattr(app, "_get_module", lambda n: (requested.append(n), real(n))[1])
- app._load_persisted_state()
- assert "lambda_svc" not in requested
+ assert calls == [None]
+ assert mod._esms.has_any()
+ mod.reset()
-def test_opensearch_eager_loaded_at_boot_when_persisted(monkeypatch):
- """Persisted domains must be restored before the lazy router sees traffic."""
+def test_registry_loader_dispatches_saved_state_to_the_declared_module(monkeypatch):
+ """The central loader imports only saved modules and calls their contract."""
import ministack.app as app
- requested = []
+ class Module:
+ def __init__(self):
+ self.loaded = []
- def fake_load_state(key):
- if key == "opensearch":
- return {
- "domains": {
- "persisted-domain": {"DomainName": "persisted-domain"}
- }
- }
- return None
+ def load_persisted_state(self, data):
+ self.loaded.append(data)
- monkeypatch.setattr(app, "load_state", fake_load_state)
- monkeypatch.setattr(app, "_get_module", lambda name: requested.append(name) or object())
+ module = Module()
+ monkeypatch.setattr(app, "_state_map", {"saved": "module", "empty": "other"})
+ monkeypatch.setattr(app, "load_state", lambda key: {"value": key} if key == "saved" else None)
+ monkeypatch.setattr(app, "_get_module", lambda name: module if name == "module" else pytest.fail(name))
app._load_persisted_state()
- assert "opensearch" in requested
+ assert module.loaded == [{"value": "saved"}]
+
+
[email protected]("legacy", [False, True])
[email protected]("objects_first", [False, True])
+def test_s3_central_restore_preserves_metadata_and_objects(monkeypatch, tmp_path, legacy, objects_first):
+ """Object loading and central metadata restoration work in either order."""
+ import ministack.app as app
+ from ministack.core.responses import AccountScopedDict, request_scope
+ from ministack.services import s3
+
+ monkeypatch.setattr(s3, "_buckets", AccountScopedDict())
+ monkeypatch.setattr(s3, "DATA_DIR", str(tmp_path / "objects"))
+ monkeypatch.setattr(s3, "S3_PERSIST", True)
+ monkeypatch.setattr(app, "_state_map", {"s3": "s3"})
+ monkeypatch.setattr(app, "_loaded_modules", {})
+ accounts = ["111111111111"] if legacy else ["111111111111", "222222222222"]
+ metadata = {} if legacy else AccountScopedDict()
+ for account in accounts:
+ bucket_meta = {
+ "created": "2020-01-01T00:00:00Z",
+ "region": "eu-west-1",
+ "_ownership_controls": "<OwnershipControls><Rule><ObjectOwnership>BucketOwnerEnforced</ObjectOwnership></Rule></OwnershipControls>",
+ "_public_access_block": "<PublicAccessBlockConfiguration><BlockPublicAcls>true</BlockPublicAcls></PublicAccessBlockConfiguration>",
+ }
+ for name in ("bucket", "empty-bucket"):
+ if legacy:
+ metadata[name] = dict(bucket_meta)
+ else:
+ metadata._data[(account, name)] = dict(bucket_meta)
+ object_path = tmp_path / "objects" / account / "bucket" / "key"
+ object_path.parent.mkdir(parents=True)
+ object_path.write_bytes(account.encode())
+ persistence.save_state("s3", {"buckets_meta": metadata})
+
+ with request_scope(accounts[0], "us-east-1"):
+ if objects_first:
+ s3._load_persisted_data()
+ app._load_persisted_state()
+ if not objects_first:
+ s3._load_persisted_data()
+
+ for account in accounts:
+ with request_scope(account, "us-east-1"):
+ for name in ("bucket", "empty-bucket"):
+ bucket = s3._buckets[name]
+ assert {key: value for key, value in bucket.items() if key != "objects"} == bucket_meta
+ obj = s3._buckets["bucket"]["objects"]["key"]
+ assert s3._read_body("bucket", "key", obj) == account.encode()
+ assert s3._buckets["empty-bucket"]["objects"] == {}
# ── PERSIST_STATE gating ──────────────────────────────────────────────
@@ -1817,8 +1857,8 @@ def test_opensearch_eager_loaded_at_boot_when_persisted(monkeypatch):
])
def test_load_state_is_noop_when_persist_state_disabled(monkeypatch, svc_key, tmp_path):
"""When PERSIST_STATE=0, load_state() must return None without touching
- disk and without invoking restore_state(). Catches a regression where
- a service module accidentally calls restore_state() unconditionally."""
+ disk and without invoking load_persisted_state(). Catches a regression
+ where a service module accidentally loads state unconditionally."""
monkeypatch.setattr(persistence, "PERSIST_STATE", False)
# Pre-write a state file that *would* succeed if persistence were on,
# so we can assert that it is NOT consumed.
@@ -1874,7 +1914,7 @@ def _round_trip_dict(mod, svc_key):
f"persistence.load_state({svc_key!r}) returned None — state "
"file was not written by save_state()."
)
- mod.restore_state(loaded)
+ mod.load_persisted_state(loaded)
# ── secretsmanager._resource_policies ──────────────────────────────────
@@ -2209,7 +2249,7 @@ def test_ecs_legacy_account_scoped_state_migrates_by_arn(monkeypatch, tmp_path):
loaded = persistence.load_state("ecs")
assert isinstance(loaded["tasks"], AccountScopedDict)
- mod.restore_state(loaded)
+ mod.load_persisted_state(loaded)
assert mod._clusters.get_scoped(account_id, resource_region, cluster_name)[
"clusterArn"
@@ -2301,7 +2341,7 @@ def test_ecs_legacy_task_revision_migration_reconstructs_each_region(monkeypatch
try:
set_request_account_id(account_id)
set_request_region(boot_region)
- mod.restore_state({
+ mod.load_persisted_state({
"task_defs": legacy_task_defs,
"task_def_latest": legacy_latest,
})
@@ -2369,7 +2409,7 @@ def test_ecs_plain_dict_tasks_migrate_to_arn_region(monkeypatch):
try:
set_request_account_id(account_id)
set_request_region(boot_region)
- mod.restore_state(
+ mod.load_persisted_state(
{
"tasks": {
task_arn: {
@@ -2753,7 +2793,7 @@ def test_eventbridge_legacy_account_scoped_targets_restore_to_rule_region():
}
]
- mod.restore_state({"rules": legacy_rules, "targets": legacy_targets})
+ mod.load_persisted_state({"rules": legacy_rules, "targets": legacy_targets})
set_request_region("us-west-2")
assert mod._rules[rule_key]["Name"] == "legacy-rule"
@@ -2812,7 +2852,7 @@ def test_iot_ca_registry_and_registration_code_survive_warm_boot():
"persistence.load_state('iot') returned None — state file was not "
"written by save_state()."
)
- mod.restore_state(loaded)
+ mod.load_persisted_state(loaded)
restored = mod._ca_certificates.get(ca_id)
assert restored is not None, (
@@ -2828,20 +2868,10 @@ def test_iot_ca_registry_and_registration_code_survive_warm_boot():
mod.reset()
-# ── Import-order regression for the ECS NameError trap ───────────────
-
-def test_ecs_module_reload_with_persisted_attributes_does_not_namerror():
- """Regression for the import-order trap: `restore_state()` runs at
- module import time (via the `try: load_state("ecs")` block at the
- bottom of services/ecs.py). If `_attributes` is declared AFTER that
- block, the restore call NameErrors and the surrounding try/except
- silently swallows it — wiping all ECS state on warm-boot.
+# ── ECS restore-contract regression ──────────────────────────────────
- This test simulates a real warm-boot: write a populated `ecs.json`
- to STATE_DIR, then `importlib.reload()` the module so the load_state
- block runs against the file. If `_attributes` (or any other
- referenced symbol) is declared too late, the restored state will
- be missing because the entire restore_state body crashed."""
+def test_ecs_load_persisted_state_restores_attributes():
+ """ECS restores every store through the central loader contract."""
mod = _get_module("ecs")
mod.reset()
arn = "arn:aws:ecs:us-east-1:000000000000:cluster/reload-canary"
@@ -2856,17 +2886,14 @@ def test_ecs_module_reload_with_persisted_attributes_does_not_namerror():
# Persist via the same path save_all uses on shutdown.
persistence.save_state("ecs", mod.get_state())
- # Force a full reload so the module-level try/load_state/restore_state
- # block at the bottom of ecs.py executes against the on-disk JSON.
- importlib.reload(mod)
+ mod.reset()
+ mod.load_persisted_state(persistence.load_state("ecs"))
assert arn in mod._clusters, (
- "Cluster lost after reload — likely NameError in restore_state "
- "swallowed by the try/except. Check that every referenced state "
- "dict (_attributes etc.) is declared BEFORE the load_state block."
+ "Cluster lost through the ECS load_persisted_state contract."
)
assert "i-canary:reload-attr" in mod._attributes, (
- "ECS _attributes lost after reload — same root cause."
+ "ECS _attributes lost through the load_persisted_state contract."
)
mod.reset()
@@ -2886,104 +2913,29 @@ def _persisted_services():
@pytest.mark.parametrize("svc_key,mod_name", _persisted_services())
-def test_module_cold_import_with_typical_snapshot_does_not_log_restore_failure(
- svc_key, mod_name, caplog,
-):
- """Generic regression for the NameError-at-import pattern that hit
- `ecs._attributes` (#492) and `acm._synthetic_pem` (#494).
-
- The bug shape: `restore_state(data)` references a module-level
- symbol declared further down the file. The import-time `try:
- load_state(...)` block calls `restore_state()` BEFORE Python
- evaluates the later definition, so the lookup NameErrors. The
- surrounding try/except logs `Failed to restore persisted state` and
- swallows the exception, so the module appears to import cleanly
- while ALL its persisted state silently disappears.
-
- The test:
- 1. Captures the module's current `get_state()` snapshot (a
- non-empty dict-of-empty-dicts — important so `restore_state`
- doesn't early-return on truthy emptiness checks).
- 2. Persists that to disk via the production `save_state` path.
- 3. **Removes the module from `sys.modules` and re-imports it
- fresh** — `importlib.reload()` would NOT catch the bug
- because it merges new definitions into the existing
- namespace, leaving any late-declared symbol bound from the
- previous import.
- 4. Asserts no WARNING+ log record mentioning "restore" / "failed"
- / "continuing fresh" was emitted during the cold import.
-
- Catches: unconditional symbol references in restore_state
- (ECS-style). Does NOT catch: conditional references inside loops
- over restored data when the data is empty (ACM-style needs
- populated state — see the per-service tests above).
- """
- import sys
-
- # Persistence is already enabled and STATE_DIR is already pointed at
- # a per-test tmp by the autouse `_enable_persistence_dict` fixture.
-
- # Step 1+2: produce + persist a snapshot using the already-loaded
- # module (so we get a valid get_state() shape).
- mod = _get_module(mod_name)
- if hasattr(mod, "reset"):
- mod.reset()
- persistence.save_state(svc_key, mod.get_state())
-
- # Step 3: cold-import — wipe sys.modules and re-import.
- # importlib.reload() won't work because it merges into the
- # existing namespace; the late-declared symbol stays bound from
- # the prior import.
- import ministack.services as _services_pkg
-
- full_name = f"ministack.services.{mod_name}"
- # The cold-import swaps a brand-new module object into BOTH sys.modules and
- # the `ministack.services` package attribute. Other already-imported modules
- # that did `from ministack.services import <mod>` keep a reference to the
- # ORIGINAL object, so we must restore it afterwards. Otherwise the fresh
- # module (with empty, reset state) leaks into later tests on the same xdist
- # worker and desyncs cross-module references — e.g. cold-importing `ecs`
- # then `secretsmanager` leaves the fresh `ecs` pointing at a stale
- # `secretsmanager`, so ECS RunTask can no longer resolve Secrets Manager
- # secrets created via the live module. Both the sys.modules entry and the
- # package attribute must be restored: `from ministack.services import <mod>`
- # reads the package attribute, not sys.modules directly.
- original_mod = sys.modules.get(full_name)
- sys.modules.pop(full_name, None)
+def test_service_defers_persistence_restore_until_registry_loader(svc_key, mod_name):
+ """Services must not restore from disk merely because they are imported.
- try:
- caplog.clear()
- with caplog.at_level("WARNING"):
- mod = importlib.import_module(full_name)
-
- bad = [
- r for r in caplog.records
- if r.levelno >= 30 # WARNING+
- and any(needle in r.getMessage().lower()
- for needle in ("failed to restore", "restore failed",
- "continuing fresh", "continuing with fresh"))
- ]
- if hasattr(mod, "reset"):
- mod.reset()
- finally:
- # Re-register the original module so references bound before this test
- # (e.g. `ecs.secretsmanager`) stay valid for subsequent tests.
- if original_mod is not None:
- sys.modules[full_name] = original_mod
- setattr(_services_pkg, mod_name, original_mod)
-
- assert not bad, (
- f"Cold import of `{mod_name}` (state-key `{svc_key}`) emitted "
- f"a restore-failure log:\n "
- + "\n ".join(r.getMessage() for r in bad)
- + "\n\nThis usually means `restore_state` references a "
- "module-level symbol that's declared further down the file. "
- "The import-time `try: load_state()` block runs before the "
- "later definition, so the symbol lookup NameErrors and the "
- "surrounding try/except swallows it. Hoist the symbol above "
- "the import-time `load_state` block (see ECS `_attributes` "
- "or ACM `_synthetic_pem` for the canonical fix)."
+ The registry loader is the sole startup restore path. This keeps module
+ imports lazy and ensures every saved snapshot goes through the uniform
+ ``load_persisted_state(data)`` contract.
+ """
+ spec = importlib.util.find_spec(f"ministack.services.{mod_name}")
+ assert spec and spec.origin
+ source = Path(spec.origin).read_text()
+ tree = ast.parse(source)
+ import_time_restores = [
+ node
+ for node in tree.body
+ if isinstance(node, (ast.Try, ast.If))
+ and "load_state(" in (ast.get_source_segment(source, node) or "")
+ ]
+
+ assert not import_time_restores, (
+ f"{mod_name} restores state at import time; restore {svc_key!r} "
+ "through ministack.app._load_persisted_state instead."
)
+ assert "from ministack.core.persistence import load_state" not in source
def test_legacy_unwrapped_state_file_loads_and_migrates_region(monkeypatch, tmp_path):
@@ -3188,7 +3140,7 @@ def test_mediaconnect_region_scoped_v3_state_round_trips(monkeypatch, tmp_path):
mediaconnect.reset()
loaded = persistence.load_state("mediaconnect")
assert loaded is not None
- mediaconnect.restore_state(loaded)
+ mediaconnect.load_persisted_state(loaded)
set_request_region(region)
assert mediaconnect._flows[flow_arn]["name"] == "regional-flow"
@@ -3271,7 +3223,7 @@ def test_iot_legacy_state_migrates_resource_and_retained_regions():
iot.reset()
iot.broker_reset()
try:
- iot.restore_state(legacy_state)
+ iot.load_persisted_state(legacy_state)
for store in (
iot._things,
@@ -3504,7 +3456,7 @@ def test_cloudtrail_legacy_state_restores_trails_by_home_region():
set_request_account_id(account_id)
set_request_region(boot_region)
cloudtrail.reset()
- cloudtrail.restore_state(
+ cloudtrail.load_persisted_state(
{
"trails": {
west_name: {
@@ -3551,8 +3503,6 @@ def test_cloudtrail_legacy_state_restores_trails_by_home_region():
def test_cloudtrail_persistence_lifecycle_restores_all_regional_accounts(
monkeypatch, tmp_path
):
- import importlib
-
from ministack.app import _build_persistence_save_dict, _state_map
from ministack.core.responses import set_request_account_id, set_request_region
from ministack.services import cloudtrail
@@ -3600,7 +3550,7 @@ def test_cloudtrail_persistence_lifecycle_restores_all_regional_accounts(
persistence.save_all({"cloudtrail": save_dict["cloudtrail"]})
cloudtrail.reset()
- importlib.reload(cloudtrail)
+ cloudtrail.load_persisted_state(persistence.load_state("cloudtrail"))
assert cloudtrail._trails.get_scoped(
first_account, west_region, "acct-one-west"
@@ -4492,7 +4442,7 @@ def test_cognito_region_scoped_state_round_trips_and_is_rejected_by_v2_reader(
set_request_account_id(account)
set_request_region("us-east-1")
cognito.reset()
- cognito.restore_state(persistence.load_state("cognito"))
+ cognito.load_persisted_state(persistence.load_state("cognito"))
assert cognito._user_pools.get_scoped(
account, "us-west-2", pool_id
@@ -4543,7 +4493,7 @@ def test_cognito_restore_rebuilds_schema_attributes_from_legacy_snapshot(monkeyp
set_request_account_id("000000000000")
set_request_region("us-west-2")
cognito.reset()
- cognito.restore_state({
+ cognito.load_persisted_state({
"user_pools": {
pool_id: {
"Id": pool_id,
@@ -4673,7 +4623,7 @@ def test_ec2_legacy_state_restores_to_boot_region_without_arn_mining():
"LogDestination": f"arn:aws:logs:{foreign_region}:{account_id}:log-group:foreign",
}
- ec2.restore_state({"vpcs": vpcs, "flow_logs": flow_logs})
+ ec2.load_persisted_state({"vpcs": vpcs, "flow_logs": flow_logs})
assert ec2._vpcs.get_scoped(account_id, boot_region, "vpc-legacy")["VpcId"] == "vpc-legacy"
assert ec2._flow_logs.get_scoped(account_id, boot_region, "fl-legacy")["ResourceId"] == "vpc-legacy"
@@ -4743,7 +4693,7 @@ def test_ec2_legacy_vpc_peering_restores_to_boot_region_graph():
}
tags[pcx_id] = [{"Key": "Scope", "Value": "legacy"}]
- ec2.restore_state({"vpcs": vpcs, "vpc_peering": peerings, "tags": tags})
+ ec2.load_persisted_state({"vpcs": vpcs, "vpc_peering": peerings, "tags": tags})
boot_record = ec2._vpc_peering.get_scoped(account_id, boot_region, pcx_id)
peer_record = ec2._vpc_peering.get_scoped(account_id, peer_region, pcx_id)
@@ -4810,7 +4760,7 @@ def test_ec2_restore_preserves_deleted_default_resource_scope():
"default_initialized_scopes"
]
- ec2.restore_state(state)
+ ec2.load_persisted_state(state)
ec2._ensure_defaults_initialized()
assert ec2._vpcs.get_scoped(account_id, region, ec2._DEFAULT_VPC_ID) is None
@@ -4864,7 +4814,7 @@ def test_ec2_legacy_generated_default_vpc_marks_scope_initialized():
"MainRouteTableId": "rtb-0abc1234def567890",
}
- ec2.restore_state({"vpcs": vpcs})
+ ec2.load_persisted_state({"vpcs": vpcs})
ec2._ensure_defaults_initialized()
assert (
@@ -5267,7 +5217,7 @@ def test_opensearch_legacy_state_migrates_domain_children_to_parent_region():
set_request_region(boot_region)
opensearch.reset()
- opensearch.restore_state({
+ opensearch.load_persisted_state({
"domains": legacy_store(
(
account_id,
@@ -5399,7 +5349,7 @@ def test_opensearch_legacy_state_migrates_domain_children_to_parent_region():
set_request_region(original_region)
-def test_opensearch_restore_recreates_dataplane_in_domain_region(monkeypatch):
+def test_opensearch_load_recreates_dataplane_in_domain_region(monkeypatch):
from ministack.core.responses import (
AccountScopedDict,
get_account_id,
@@ -5458,7 +5408,7 @@ def test_opensearch_restore_recreates_dataplane_in_domain_region(monkeypatch):
set_request_region(boot_region)
opensearch.reset()
- opensearch.restore_state({
+ opensearch.load_persisted_state({
"domains": legacy_store(
(
account_id,
@@ -5610,9 +5560,7 @@ def test_glue_region_scoped_state_round_trips_and_is_rejected_by_v2_reader(
def test_batch_persistence_lifecycle_restores_regional_state(monkeypatch, tmp_path):
- """The gateway save map and Batch import-time restore must preserve state
- outside the ambient boot region across a process-shaped reload."""
- import importlib
+ """The registry loader preserves state outside the ambient boot region."""
from ministack.app import _build_persistence_save_dict, _state_map
from ministack.core.responses import set_request_account_id, set_request_region
@@ -5641,7 +5589,7 @@ def test_batch_persistence_lifecycle_restores_regional_state(monkeypatch, tmp_pa
persistence.save_all({"batch": save_dict["batch"]})
service.reset()
- importlib.reload(service)
+ service.load_persisted_state(persistence.load_state("batch"))
assert service._jobs.get_scoped(
account_id, resource_region, job_id
diff --git a/tests/test_pipes.py b/tests/test_pipes.py
index 969a5248..1a0b9e84 100644
--- a/tests/test_pipes.py
+++ b/tests/test_pipes.py
@@ -455,7 +455,7 @@ def test_pipes_restore_legacy_account_scoped_state_uses_pipe_arn_region():
set_request_account_id(account_id)
set_request_region("us-east-1")
- _pipes.restore_state({
+ _pipes.load_persisted_state({
"pipes": legacy_pipes,
"positions": legacy_positions,
})
diff --git a/tests/test_rds.py b/tests/test_rds.py
index 6e158d1d..fcb9d316 100644
--- a/tests/test_rds.py
+++ b/tests/test_rds.py
@@ -736,7 +736,7 @@ def test_rds_modify_legacy_subnet_group_adopts_resolved_vpc():
persisted_groups = rds_service.get_state()["subnet_groups"]
persisted_groups[group_name]["VpcId"] = "vpc-00000000"
rds_service._subnet_groups.clear()
- rds_service.restore_state({"subnet_groups": persisted_groups})
+ rds_service.load_persisted_state({"subnet_groups": persisted_groups})
status, _, _ = rds_service._modify_subnet_group({
"DBSubnetGroupName": group_name,
@@ -2404,7 +2404,7 @@ def test_rds_restored_initialized_storage_defers_password_rotation(monkeypatch):
assert persisted_cluster["_shared_storage_initialized"] is True
m._clusters.clear()
- m.restore_state(persisted)
+ m.load_persisted_state(persisted)
restored = m._clusters["restored-password-cluster"]
assert restored["_shared_container_id"] is None
@@ -2700,7 +2700,7 @@ def test_rds_restore_keeps_stopped_cluster_compute_stopped(monkeypatch):
m._instances.clear()
m._clusters.clear()
started_calls.clear()
- m.restore_state(persisted)
+ m.load_persisted_state(persisted)
# restore_state marks every instance ``creating`` before spawning the
# cluster runner; the runner's stopped branch flips members back to
@@ -5010,7 +5010,7 @@ def test_rds_restore_state_respawns_docker_container(monkeypatch):
}
m._instances.clear()
- m.restore_state(persisted_state)
+ m.load_persisted_state(persisted_state)
deadline = time.time() + 5
while time.time() < deadline and not runs:
@@ -5361,7 +5361,7 @@ def test_rds_restore_state_respawns_one_container_per_cluster(
monkeypatch.setattr(m.threading, "Thread", TrackedThread)
- m.restore_state({
+ m.load_persisted_state({
"instances": instances,
"clusters": clusters,
"subnet_groups": {},
@@ -5681,7 +5681,7 @@ def test_rds_restored_empty_cluster_cleanup_recovers_container_by_name(
})
persisted = m.get_state()
m._clusters.clear()
- m.restore_state(persisted)
+ m.load_persisted_state(persisted)
restored = m._clusters.get(cluster_id)
assert restored["DBClusterMembers"] == []
@@ -6004,7 +6004,7 @@ def test_rds_restore_migrates_legacy_instance_name_before_cluster_claims_it(
m._instances.clear()
m._clusters.clear()
try:
- m.restore_state({
+ m.load_persisted_state({
"instances": instances,
"clusters": clusters,
"subnet_groups": {},
@@ -6097,7 +6097,7 @@ def test_rds_restore_state_removes_stale_container_before_respawn(monkeypatch):
}
m._instances.clear()
- m.restore_state(persisted)
+ m.load_persisted_state(persisted)
deadline = time.time() + 5
while time.time() < deadline and not runs:
@@ -6168,7 +6168,7 @@ def test_rds_restore_state_preserves_legacy_persistent_volume_name(monkeypatch):
}
m._instances.clear()
- m.restore_state(persisted)
+ m.load_persisted_state(persisted)
deadline = time.time() + 5
while time.time() < deadline and not runs:
@@ -6242,7 +6242,7 @@ def test_rds_respawn_does_not_bind_engine_port_on_host(monkeypatch):
}
m._instances.clear()
- m.restore_state(persisted_state)
+ m.load_persisted_state(persisted_state)
deadline = time.time() + 5
while time.time() < deadline and not runs:
@@ -6343,7 +6343,7 @@ def test_rds_respawn_falls_back_when_persisted_host_port_taken(monkeypatch):
}
m._instances.clear()
- m.restore_state(persisted_state)
+ m.load_persisted_state(persisted_state)
deadline = time.time() + 5
while time.time() < deadline and not runs:
@@ -6424,7 +6424,7 @@ def test_rds_respawn_force_removes_stale_created_container(monkeypatch):
}
m._instances.clear()
- m.restore_state(persisted_state)
+ m.load_persisted_state(persisted_state)
deadline = time.time() + 5
while time.time() < deadline and m._instances.get(db_id, {}).get("DBInstanceStatus") not in ("available", "failed"):
@@ -6909,7 +6909,7 @@ def test_rds_legacy_instance_restore_preserves_arn_region(monkeypatch):
try:
rds.reset()
- rds.restore_state({"instances": legacy})
+ rds.load_persisted_state({"instances": legacy})
assert rds._instances.get_scoped("000000000000", "us-east-1", instance_id) is None
restored = rds._instances.get_scoped("000000000000", "us-west-2", instance_id)
@@ -9427,7 +9427,7 @@ def test_rds_restore_respawns_persisted_headless_secondary_applier(monkeypatch):
)
monkeypatch.setattr(m, "_configure_or_defer_mysql_replication", configure)
- m.restore_state({
+ m.load_persisted_state({
"instances": AccountRegionScopedDict(),
"clusters": clusters,
"global_clusters": global_clusters,
@@ -10096,7 +10096,7 @@ def test_rds_restore_syncs_stale_secondary_credentials_from_global_writer(
m._clusters.clear()
m._global_clusters.clear()
try:
- m.restore_state({
+ m.load_persisted_state({
"instances": AccountRegionScopedDict(),
"clusters": clusters,
"global_clusters": global_clusters,
@@ -10609,7 +10609,7 @@ def test_rds_mysql_writer_switch_state_round_trip_requires_repair():
persisted = m.get_state()
m._global_clusters.clear()
- m.restore_state({
+ m.load_persisted_state({
"instances": {},
"clusters": {},
"global_clusters": persisted["global_clusters"],
@@ -13732,7 +13732,7 @@ def test_rds_restore_state_without_docker_demotes_pg_standby(monkeypatch):
"_pg_standby": True,
"_docker_container_id": "dead-reader-container",
}
- m.restore_state({"clusters": clusters, "instances": instances})
+ m.load_persisted_state({"clusters": clusters, "instances": instances})
reader = m._instances.get("warm-pg-reader")
assert reader is not None
@@ -13815,7 +13815,7 @@ def test_rds_restore_state_revives_pg_standby(monkeypatch):
"_docker_container_id": "dead-reader-container",
"_docker_volume_name": reader_volume,
}
- m.restore_state({"clusters": clusters, "instances": instances})
+ m.load_persisted_state({"clusters": clusters, "instances": instances})
reader = m._instances.get("warm-pgr-reader")
writer = m._instances.get("warm-pgr-writer")
diff --git a/tests/test_resource_groups.py b/tests/test_resource_groups.py
index aa781fb6..ddf6b8d5 100644
--- a/tests/test_resource_groups.py
+++ b/tests/test_resource_groups.py
@@ -466,7 +466,7 @@ def test_restore_legacy_child_state_uses_parent_group_region():
service.reset()
try:
- service.restore_state({"groups": groups, "group_queries": queries})
+ service.load_persisted_state({"groups": groups, "group_queries": queries})
assert service._groups.get_scoped(
account_id, resource_region, group_name
)["Name"] == group_name
diff --git a/tests/test_s3files.py b/tests/test_s3files.py
index 3e5082e6..12a37143 100644
--- a/tests/test_s3files.py
+++ b/tests/test_s3files.py
@@ -177,7 +177,7 @@ def test_legacy_child_state_restores_beside_parent_resource():
service.reset()
try:
- service.restore_state(payload)
+ service.load_persisted_state(payload)
assert service._file_systems.get_scoped(
account_id, resource_region, fs_id
)["fileSystemId"] == fs_id
@@ -230,7 +230,7 @@ def test_legacy_orphaned_mount_target_restores_to_availability_zone_region():
service.reset()
try:
- service.restore_state({"mount_targets": mount_targets})
+ service.load_persisted_state({"mount_targets": mount_targets})
assert service._mount_targets.get_scoped(
account_id, resource_region, mt_id
)["mountTargetId"] == mt_id
diff --git a/tests/test_ses.py b/tests/test_ses.py
index 8218d52d..f307f4a6 100644
--- a/tests/test_ses.py
+++ b/tests/test_ses.py
@@ -872,7 +872,7 @@ def test_ses_restore_legacy_state_maps_unregionalized_values_to_boot_region():
service.reset()
try:
- service.restore_state(legacy_state)
+ service.load_persisted_state(legacy_state)
for state_key, (resource_key, value) in values.items():
store = getattr(service, state_key)
assert store.get_scoped(account_id, boot_region, resource_key) == value
@@ -917,7 +917,7 @@ def test_ses_v2_restore_legacy_state_maps_unregionalized_values_to_boot_region()
service.reset()
try:
- service.restore_state(legacy_state)
+ service.load_persisted_state(legacy_state)
for state_key, (resource_key, value) in values.items():
store = getattr(service, state_key)
expected_key = resource_key
diff --git a/tests/test_sns.py b/tests/test_sns.py
index 00d9ae66..6ae32cce 100644
--- a/tests/test_sns.py
+++ b/tests/test_sns.py
@@ -1882,7 +1882,7 @@ def test_sns_restore_legacy_account_scoped_state_adopts_arn_regions():
"attributes": {"Token": "legacy-token", "Enabled": "true"},
}
- _sns.restore_state({
+ _sns.load_persisted_state({
"topics": legacy_topics,
"sub_arn_to_topic": legacy_subs,
"platform_applications": legacy_apps,
diff --git a/tests/test_sqs.py b/tests/test_sqs.py
index 7e5b2eb7..a503953d 100644
--- a/tests/test_sqs.py
+++ b/tests/test_sqs.py
@@ -1423,7 +1423,7 @@ def test_sqs_restore_rebuilds_legacy_name_index_from_queue_arn():
}
legacy_names[queue_name] = queue_url
- _sqs.restore_state({"queues": legacy_queues, "queue_name_to_url": legacy_names})
+ _sqs.load_persisted_state({"queues": legacy_queues, "queue_name_to_url": legacy_names})
assert _sqs._queue_name_to_url.get(queue_name) is None
set_request_region("us-west-2")
diff --git a/tests/test_ssm.py b/tests/test_ssm.py
index 63048aa0..4d572e6d 100644
--- a/tests/test_ssm.py
+++ b/tests/test_ssm.py
@@ -332,7 +332,7 @@ def test_ssm_restore_legacy_parameter_history_uses_parameter_arn_region():
]
try:
- ssm_service.restore_state({
+ ssm_service.load_persisted_state({
"parameters": parameters,
"parameter_history": parameter_history,
})
@@ -376,7 +376,7 @@ def test_ssm_restore_legacy_history_prefers_exact_parameter_name_region():
]
try:
- ssm_service.restore_state({
+ ssm_service.load_persisted_state({
"parameters": parameters,
"parameter_history": parameter_history,
})
@@ -410,7 +410,7 @@ def test_ssm_restore_legacy_bare_name_tags_uses_stored_parameter_arn():
tags[legacy_arn] = {"env": "legacy"}
try:
- ssm_service.restore_state({
+ ssm_service.load_persisted_state({
"parameters": parameters,
"tags": tags,
})
@@ -472,7 +472,7 @@ def test_ssm_arn_lookup_prefers_exact_stored_arn_match():
}
try:
- ssm_service.restore_state({"parameters": parameters})
+ ssm_service.load_persisted_state({"parameters": parameters})
set_request_region("us-west-2")
assert ssm_service.resolve_parameter_value(bare_arn) == "bare"
assert ssm_service.resolve_parameter_value(path_arn) == "path"
@@ -509,7 +509,7 @@ def test_ssm_exact_legacy_slash_twin_can_be_overwritten():
}
try:
- ssm_service.restore_state({"parameters": parameters})
+ ssm_service.load_persisted_state({"parameters": parameters})
set_request_region("us-west-2")
status, _headers, _body = ssm_service._put_parameter({
"Name": bare_name,
@@ -547,7 +547,7 @@ def test_ssm_legacy_no_slash_arn_does_not_fallback_to_path_parameter():
}
try:
- ssm_service.restore_state({"parameters": parameters})
+ ssm_service.load_persisted_state({"parameters": parameters})
set_request_region("us-west-2")
assert ssm_service.resolve_parameter_value(path_arn) == "path"
assert ssm_service.resolve_parameter_value(stale_legacy_arn) is None
@@ -578,7 +578,7 @@ def test_ssm_malformed_or_foreign_partition_arn_does_not_fallback_to_name():
}
try:
- ssm_service.restore_state({"parameters": parameters})
+ ssm_service.load_persisted_state({"parameters": parameters})
assert ssm_service.resolve_parameter_value(canonical_arn) == "value"
assert ssm_service.resolve_parameter_value(missing_region_arn) is None
assert ssm_service.resolve_parameter_value(foreign_partition_arn) is None
@@ -610,7 +610,7 @@ def test_ssm_restore_legacy_add_tags_key_for_bare_name_parameter():
tags[legacy_add_tags_arn] = {"env": "legacy-add-tags"}
try:
- ssm_service.restore_state({
+ ssm_service.load_persisted_state({
"parameters": parameters,
"tags": tags,
})
diff --git a/tests/test_transfer_region_state.py b/tests/test_transfer_region_state.py
index 9cd47509..44918771 100644
--- a/tests/test_transfer_region_state.py
+++ b/tests/test_transfer_region_state.py
@@ -91,7 +91,7 @@ def test_transfer_legacy_state_restores_resources_to_arn_region():
service.reset()
try:
- service.restore_state({"servers": servers, "users": users})
+ service.load_persisted_state({"servers": servers, "users": users})
assert service._servers.get_scoped(
account_id, resource_region, server_id
)["ServerId"] == server_id
diff --git a/tests/test_waf.py b/tests/test_waf.py
index 71698a4f..f8eef4c5 100644
--- a/tests/test_waf.py
+++ b/tests/test_waf.py
@@ -684,7 +684,7 @@ def test_wafv2_restore_legacy_state_canonicalizes_cloudfront_arns_direct(direct_
{"Key": "legacy-dialect", "Value": "regional"}
]
- waf_service.restore_state({
+ waf_service.load_persisted_state({
"_web_acls": web_acls,
"_ip_sets": ip_sets,
"_rule_groups": rule_groups,