Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
feat(rds): expose retained reboot events through DescribeEvents (#2218)
Jay Janssen198fb49055e1
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 8b4928f3..5fc96563 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -7,6 +7,12 @@ Versioning follows [Semantic Versioning](https://semver.org/).## [Unreleased]+### Added+- **RDS — reboot event history** — `DescribeEvents` returns account/region-scoped reboot completion events with source, category and time filtering, markers, 14-day retention, persistence and reset support. Reboot events are recorded after readiness succeeds; other RDS lifecycle event producers are not yet implemented.++### Changed+- **RDS — real instance reboot** — `RebootDBInstance` now returns `rebooting`, stops and starts its backing database container, and waits for SQL readiness before reporting `available`. Data and endpoint bindings are preserved. Optional `RDS_REBOOT_DOWNTIME_SECONDS` (0–3600, default 0) holds the engine stopped for local outage testing. Docker failures no longer report a successful reboot.+### Changed- **RDS — real instance reboot** — `RebootDBInstance` now returns `rebooting`, stops and starts its backing database container, and waits for SQL readiness before reporting `available`. Data and endpoint bindings are preserved. Optional `RDS_REBOOT_DOWNTIME_SECONDS` (0–3600, default 0) holds the engine stopped for local outage testing. Docker failures no longer report a successful reboot.diff --git a/ministack/core/router.py b/ministack/core/router.pyindex 5a57563c..162de2fb 100644--- a/ministack/core/router.py+++ b/ministack/core/router.py@@ -1042,6 +1042,7 @@ def detect_service(method: str, path: str, headers: dict, query_params: dict) ->"StartDBInstance": "rds","StopDBInstance": "rds","RebootDBInstance": "rds",+ "DescribeEvents": "rds","ModifyDBInstance": "rds","CreateDBCluster": "rds","DeleteDBCluster": "rds",diff --git a/ministack/services/rds.py b/ministack/services/rds.pyindex 290e0811..e0492132 100644--- a/ministack/services/rds.py+++ b/ministack/services/rds.py@@ -108,6 +108,7 @@ RDS_PG_CLUSTER_REPLICATION = os.environ.get().lower() in ("1", "true", "yes")_instances = AccountRegionScopedDict()+_events = AccountRegionScopedDict()_clusters = AccountRegionScopedDict()_subnet_groups = AccountRegionScopedDict()_param_groups = AccountRegionScopedDict()@@ -338,6 +339,7 @@ def get_state():clusters = copy.deepcopy(_clusters)state = {"instances": instances,+ "events": copy.deepcopy(_events),"clusters": clusters,"subnet_groups": copy.deepcopy(_subnet_groups),"param_groups": copy.deepcopy(_param_groups),@@ -374,6 +376,7 @@ def load_persisted_state(data) -> None:def _restore_state(data, *, resume_runtime=False):if not data:return+ _events.update(data.get("events", {}))_clusters.update(data.get("clusters", {}))for key in list(_clusters._data):cluster = _clusters._data[key]@@ -5652,6 +5655,70 @@ def _begin_instance_reboot(p):return response+def _record_reboot_event(instance):+ now = time.time()+ with _shared_container_lock:+ for key, event in list(_events.items()):+ if event["Date"] < now - 14 * 86400:+ del _events[key]+ _events[new_uuid()] = {+ "SourceIdentifier": instance["DBInstanceIdentifier"],+ "SourceType": "db-instance", "SourceArn": instance.get("DBInstanceArn", ""),+ "Message": "DB instance restarted", "Date": now,+ "EventCategories": ["availability"],+ }+++def _describe_events(p):+ now = time.time()+ source = _p(p, "SourceIdentifier")+ kind = _p(p, "SourceType")+ if source and not kind:+ return _error("InvalidParameterCombination", "SourceIdentifier requires SourceType.", 400)+ if kind and kind not in ("db-instance", "db-cluster", "db-parameter-group", "db-security-group", "db-snapshot", "db-cluster-snapshot", "db-proxy", "blue-green-deployment", "zero-etl"):+ return _error("InvalidParameterValue", "Invalid SourceType.", 400)+ def timestamp(value, default):+ if not value:+ return default+ date = datetime.datetime.fromisoformat(value.replace("Z", "+00:00"))+ if date.tzinfo is None:+ date = date.replace(tzinfo=datetime.timezone.utc)+ return date.timestamp()+ try:+ limit = int(_p(p, "MaxRecords", "100"))+ duration = int(_p(p, "Duration", "60"))+ start = timestamp(_p(p, "StartTime"), now - duration * 60)+ end = timestamp(_p(p, "EndTime"), now)+ if not 20 <= limit <= 100 or not 0 <= duration <= 20160 or start > end:+ raise ValueError+ except (ValueError, OverflowError):+ return _error("InvalidParameterValue", "Invalid event time range, duration or MaxRecords.", 400)+ categories = _parse_member_list(p, "EventCategories")+ with _shared_container_lock:+ events = sorted(+ ((key, dict(event)) for key, event in _events.items()+ if max(start, now - 14 * 86400) <= event["Date"] <= end+ and (not source or event["SourceIdentifier"] == source)+ and (not kind or event["SourceType"] == kind)+ and (not categories or set(categories).intersection(event["EventCategories"]))),+ key=lambda pair: (pair[1]["Date"], pair[0]),+ )+ marker = _p(p, "Marker")+ if marker:+ positions = [i for i, (key, _) in enumerate(events) if key == marker]+ if not positions:+ return _error("InvalidParameterValue", "Invalid event Marker.", 400)+ events = events[positions[0] + 1:]+ page = events[:limit]+ members = ""+ for _, event in page:+ fields = "".join(f"<{field}>{_esc(event[field])}</{field}>" for field in ("SourceIdentifier", "SourceType", "SourceArn", "Message"))+ categories_xml = "".join(f"<EventCategory>{_esc(category)}</EventCategory>" for category in event["EventCategories"])+ members += f"<Event>{fields}<Date>{_format_time(event['Date'])}</Date><EventCategories>{categories_xml}</EventCategories></Event>"+ next_marker = f"<Marker>{page[-1][0]}</Marker>" if len(events) > limit else ""+ return _xml(200, "DescribeEventsResponse", f"<DescribeEventsResult><Events>{members}</Events>{next_marker}</DescribeEventsResult>")++def _finish_instance_reboot(instance, cluster, downtime):db_id = instance["DBInstanceIdentifier"]@@ -5689,6 +5756,7 @@ def _finish_instance_reboot(instance, cluster, downtime):elif downtime:time.sleep(downtime)if current():+ _record_reboot_event(instance)instance["DBInstanceStatus"] = "available"except Exception:logger.exception("RDS: reboot failed for %s", db_id)@@ -11359,6 +11427,7 @@ _ACTION_MAP = {"StartDBInstance": _start_db_instance,"StopDBInstance": _stop_db_instance,"RebootDBInstance": _reboot_db_instance,+ "DescribeEvents": _describe_events,"CreateDBInstanceReadReplica": _create_read_replica,"RestoreDBInstanceFromDBSnapshot": _restore_from_snapshot,"CreateDBCluster": _create_db_cluster,@@ -11481,6 +11550,7 @@ def reset():e,)_instances.clear()+ _events.clear()_clusters.clear()_subnet_groups.clear()_param_groups.clear()diff --git a/tests/test_rds.py b/tests/test_rds.pyindex 6da03ad7..686cc35a 100644--- a/tests/test_rds.py+++ b/tests/test_rds.py@@ -4846,6 +4846,8 @@ def test_rds_reboot_db_instance(rds):desc = rds.describe_db_instances(DBInstanceIdentifier="reboot-test")assert desc["DBInstances"][0]["DBInstanceStatus"] == "available"+ events = rds.describe_events(SourceIdentifier="reboot-test", SourceType="db-instance")["Events"]+ assert any(event["Message"] == "DB instance restarted" for event in events)finally:rds.delete_db_instance(DBInstanceIdentifier="reboot-test", SkipFinalSnapshot=True)diff --git a/tests/test_rds_events.py b/tests/test_rds_events.pynew file mode 100644index 00000000..1db813c2--- /dev/null+++ b/tests/test_rds_events.py@@ -0,0 +1,96 @@+"""DescribeEvents wire contract checked with the botocore Query parser."""+import time+from types import SimpleNamespace++import botocore.session+import pytest+from botocore.parsers import QueryParser++from ministack.services import rds++[email protected](autouse=True)+def clean_events():+ saved = dict(rds._events.items())+ for key in list(rds._events):+ del rds._events[key]+ yield+ for key in list(rds._events):+ del rds._events[key]+ rds._events.update(saved)+++def describe(**params):+ status, headers, body = rds._describe_events(params)+ shape = botocore.session.get_session().get_service_model("rds").operation_model("DescribeEvents").output_shape+ return status, QueryParser().parse({"status_code": status, "headers": headers, "body": body}, shape)+++def record(name="example"):+ rds._record_reboot_event({"DBInstanceIdentifier": name, "DBInstanceArn": f"arn:aws:rds:us-east-1:000000000000:db:{name}"})+++def test_reboot_event_wire_shape_and_filters():+ record("example")+ record("other")+ status, result = describe(SourceIdentifier="example", SourceType="db-instance")+ assert status == 200+ event, = result["Events"]+ assert event["Message"] == "DB instance restarted"+ assert event["EventCategories"] == ["availability"]+ assert event["SourceArn"].endswith(":db:example")+ assert abs(event["Date"].timestamp() - time.time()) < 2+ assert describe(SourceType="db-cluster")[1]["Events"] == []+ assert describe(**{"EventCategories.member.1": "failure"})[1]["Events"] == []+ assert describe(StartTime="2100-01-01T00:00:00Z", EndTime="2100-01-02T00:00:00Z")[1]["Events"] == []+++def test_pagination_has_no_duplicates():+ for i in range(23):+ record(str(i))+ _, first = describe(MaxRecords="20")+ _, second = describe(MaxRecords="20", Marker=first["Marker"])+ assert len(first["Events"]) == 20+ assert len(second["Events"]) == 3+ assert "Marker" not in second+ assert len({e["SourceIdentifier"] for e in first["Events"] + second["Events"]}) == 23++[email protected]("params", [{"SourceIdentifier": "x"}, {"MaxRecords": "19"}, {"MaxRecords": "101"}, {"Duration": "bad"}, {"Marker": "missing"}, {"StartTime": "bad"}])+def test_invalid_requests(params):+ assert describe(**params)[0] == 400+++def test_events_survive_persistence_and_are_region_scoped():+ from ministack.core.responses import get_region, set_request_region+ region = get_region()+ record()+ snapshot = rds.get_state()+ try:+ set_request_region("eu-north-1" if region != "eu-north-1" else "us-east-2")+ assert describe()[1]["Events"] == []+ finally:+ set_request_region(region)+ for key in list(rds._events):+ del rds._events[key]+ rds.load_persisted_state(snapshot)+ assert len(describe()[1]["Events"]) == 1+++def test_completion_only_after_success(monkeypatch):+ instance = {"DBInstanceIdentifier": "event-reboot", "DBInstanceStatus": "rebooting"}+ rds._instances["event-reboot"] = instance+ try:+ monkeypatch.setattr(rds, "_get_docker", lambda: None)+ rds._finish_instance_reboot(instance, None, 0)+ assert len(describe()[1]["Events"]) == 1+ instance["DBInstanceStatus"] = "rebooting"+ instance["_docker_container_id"] = "missing"+ def fail(_):+ raise RuntimeError("missing container")+ monkeypatch.setattr(rds, "_get_docker", lambda: SimpleNamespace(containers=SimpleNamespace(get=fail)))+ rds._finish_instance_reboot(instance, None, 0)+ assert len(describe()[1]["Events"]) == 1+ assert instance["DBInstanceStatus"] == "failed"+ finally:+ rds._instances.pop("event-reboot", None)diff --git a/tests/test_rds_reboot.py b/tests/test_rds_reboot.pyindex 82e8f849..c5e015af 100644--- a/tests/test_rds_reboot.py+++ b/tests/test_rds_reboot.py@@ -62,10 +62,10 @@ def test_reboot_is_async_and_waits_for_sql(monkeypatch, instance):@pytest.mark.data_planedef test_reboot_preserves_mysql_data_and_breaks_sessions(monkeypatch, instance):+ import socket+import dockerimport pymysql-- import socketclient = docker.from_env()with socket.socket() as sock:sock.bind(("127.0.0.1", 0))