Skip to content

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

feat(rds): expose retained reboot events through DescribeEvents (#2218)

Jay Janssen198fb49055e1
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 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.py
index 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.py
index 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.py
index 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.py
new file mode 100644
index 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.py
index 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_plane
def test_reboot_preserves_mysql_data_and_breaks_sessions(monkeypatch, instance):
+ import socket
+
import docker
import pymysql
-
- import socket
client = docker.from_env()
with socket.socket() as sock:
sock.bind(("127.0.0.1", 0))