fix: prune old detail after publication (#100)
This commit is contained in:
xavierk
@@ -0,0 +1,279 @@
|
||||
"""Normal-collection retention acceptance tests for issue #100."""
|
||||
import sqlite3
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
|
||||
|
||||
from fenris.collector import run_collection
|
||||
from fenris.local_day import query_local_day_summary
|
||||
from fenris.pruning import prune_old_samples
|
||||
from fenris.status import read_status
|
||||
from fenris.store import init_store
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sysfs_controller(tmp_path):
|
||||
controller = tmp_path / "sys" / "class" / "nvme" / "nvme0"
|
||||
controller.mkdir(parents=True)
|
||||
(controller / "subsysnqn").write_text("nqn.example:drive-1\n")
|
||||
(controller / "model").write_text("Fenris Test Drive\n")
|
||||
(controller / "serial").write_text("drive-1\n")
|
||||
(controller / "firmware_rev").write_text("1.0\n")
|
||||
transport = controller / "transport"
|
||||
transport.mkdir()
|
||||
(transport / "address").write_text("0000:00:01.0\n")
|
||||
(transport / "trstring").write_text("pcie\n")
|
||||
return controller
|
||||
|
||||
|
||||
class FakeClock:
|
||||
def __init__(self, now):
|
||||
self.now = now
|
||||
|
||||
def utcnow(self):
|
||||
return self.now
|
||||
|
||||
|
||||
def _smartctl(written, read):
|
||||
return {
|
||||
"nvme_smart_health_information_log": {
|
||||
"critical_warning": 0,
|
||||
"temperature": 35,
|
||||
"available_spare": 100,
|
||||
"percentage_used": 1,
|
||||
"data_units_written": written,
|
||||
"data_units_read": read,
|
||||
"power_on_hours": 100,
|
||||
"power_cycles": 1,
|
||||
"unsafe_shutdowns": 0,
|
||||
"media_errors": 0,
|
||||
},
|
||||
"user_capacity": {"bytes": 1_000_000_000_000},
|
||||
"model_name": "Fenris Test Drive",
|
||||
"serial_number": "drive-1",
|
||||
"firmware_version": "1.0",
|
||||
}
|
||||
|
||||
|
||||
def _collect(config, controller, now, written, read):
|
||||
return run_collection(
|
||||
smartctl_data=_smartctl(written, read),
|
||||
sysfs_path=controller,
|
||||
config=config,
|
||||
clock=FakeClock(now),
|
||||
)
|
||||
|
||||
|
||||
def test_normal_collection_expires_detail_and_keeps_local_day_evidence(
|
||||
tmp_path, sysfs_controller, monkeypatch,
|
||||
):
|
||||
monkeypatch.setenv("TZ", "UTC")
|
||||
store_path = tmp_path / "observations.db"
|
||||
config = {"device": "/dev/nvme0", "store_path": str(store_path)}
|
||||
first_time = datetime(2026, 9, 1, 0, 0, tzinfo=timezone.utc)
|
||||
second_time = first_time + timedelta(days=15)
|
||||
|
||||
first = _collect(config, sysfs_controller, first_time, 1000, 2000)
|
||||
assert first["ok"] is True, first
|
||||
second = _collect(config, sysfs_controller, second_time, 1001, 2003)
|
||||
assert second["ok"] is True, second
|
||||
|
||||
with sqlite3.connect(store_path) as conn:
|
||||
assert conn.execute("SELECT ts FROM samples ORDER BY id").fetchall() == [
|
||||
(second_time.isoformat(),)
|
||||
]
|
||||
assert conn.execute(
|
||||
"SELECT bytes_written, bytes_read, reason "
|
||||
"FROM local_day_unallocated_evidence"
|
||||
).fetchall() == [(512_000, 1_536_000, "local_midnight")]
|
||||
assert conn.execute("SELECT COUNT(*) FROM pending_publications").fetchone()[0] == 0
|
||||
assert conn.execute("SELECT COUNT(*) FROM controller_segments").fetchone()[0] == 1
|
||||
assert conn.execute("SELECT COUNT(*) FROM day_aggregates").fetchone()[0] == 15
|
||||
|
||||
monkeypatch.setenv("TZ", "Asia/Kolkata")
|
||||
with read_status(store_path, second_time, query_services=False) as (reader, state):
|
||||
assert reader is not None
|
||||
assert state.store_fault is None
|
||||
old_day = query_local_day_summary(
|
||||
reader, "2026-09-01", "UTC", second_time,
|
||||
)
|
||||
assert old_day["utc_start"] == "2026-09-01T00:00:00+00:00"
|
||||
assert old_day["utc_end"] == "2026-09-02T00:00:00+00:00"
|
||||
assert old_day["bytes_written"] is None
|
||||
assert old_day["shared_bytes_written"] == 512_000
|
||||
assert old_day["shared_bytes_read"] == 1_536_000
|
||||
assert old_day["shared_evidence_count"] == 1
|
||||
|
||||
|
||||
def test_pruning_keeps_samples_when_replacement_evidence_is_missing(tmp_path):
|
||||
store_path = tmp_path / "incomplete.db"
|
||||
conn = init_store(store_path)
|
||||
now = datetime(2026, 9, 30, tzinfo=timezone.utc)
|
||||
old_time = now - timedelta(days=20)
|
||||
next_time = now - timedelta(days=1)
|
||||
conn.execute(
|
||||
"INSERT INTO controller_segments (id, opened_at, identity_key) "
|
||||
"VALUES (1, ?, 'test')",
|
||||
(old_time.isoformat(),),
|
||||
)
|
||||
conn.execute(
|
||||
"INSERT INTO samples (ts, device, bytes_written, bytes_read, segment_id, local_tz) "
|
||||
"VALUES (?, '/dev/nvme0', 100, 100, 1, 'UTC')",
|
||||
(old_time.isoformat(),),
|
||||
)
|
||||
conn.execute(
|
||||
"INSERT INTO samples (ts, device, bytes_written, bytes_read, segment_id, local_tz) "
|
||||
"VALUES (?, '/dev/nvme0', 200, 200, 1, 'UTC')",
|
||||
(next_time.isoformat(),),
|
||||
)
|
||||
conn.commit()
|
||||
|
||||
assert prune_old_samples(conn, now) == 0
|
||||
assert conn.execute("SELECT COUNT(*) FROM samples").fetchone()[0] == 2
|
||||
conn.close()
|
||||
|
||||
|
||||
def test_pruning_keeps_oldest_unpaired_sample_as_successor_anchor(tmp_path):
|
||||
store_path = tmp_path / "anchor.db"
|
||||
conn = init_store(store_path)
|
||||
now = datetime(2026, 9, 30, tzinfo=timezone.utc)
|
||||
old_time = now - timedelta(days=20)
|
||||
conn.execute(
|
||||
"INSERT INTO controller_segments (id, opened_at, identity_key) "
|
||||
"VALUES (1, ?, 'test')",
|
||||
(old_time.isoformat(),),
|
||||
)
|
||||
conn.execute(
|
||||
"INSERT INTO samples (ts, device, bytes_written, bytes_read, segment_id, local_tz) "
|
||||
"VALUES (?, '/dev/nvme0', 100, 100, 1, 'UTC')",
|
||||
(old_time.isoformat(),),
|
||||
)
|
||||
conn.commit()
|
||||
|
||||
assert prune_old_samples(conn, now) == 0
|
||||
assert conn.execute("SELECT ts FROM samples").fetchone()[0] == old_time.isoformat()
|
||||
conn.close()
|
||||
|
||||
|
||||
def test_pruning_never_expires_pending_publications(tmp_path):
|
||||
store_path = tmp_path / "pending.db"
|
||||
conn = init_store(store_path)
|
||||
old_time = datetime(2026, 9, 1, tzinfo=timezone.utc)
|
||||
conn.execute(
|
||||
"INSERT INTO pending_publications (sample_ts, payload) VALUES (?, '{}')",
|
||||
(old_time.isoformat(),),
|
||||
)
|
||||
conn.commit()
|
||||
|
||||
assert prune_old_samples(
|
||||
conn, datetime(2026, 9, 30, tzinfo=timezone.utc),
|
||||
) == 0
|
||||
assert conn.execute(
|
||||
"SELECT sample_ts FROM pending_publications"
|
||||
).fetchone()[0] == old_time.isoformat()
|
||||
conn.close()
|
||||
|
||||
|
||||
def test_pruning_preserves_unparseable_legacy_timestamp(tmp_path):
|
||||
store_path = tmp_path / "legacy.db"
|
||||
conn = init_store(store_path)
|
||||
conn.execute(
|
||||
"INSERT INTO samples (ts, device, bytes_written, bytes_read) "
|
||||
"VALUES ('legacy timestamp', '/dev/nvme0', 100, 100)"
|
||||
)
|
||||
conn.commit()
|
||||
|
||||
assert prune_old_samples(conn, datetime(2026, 9, 30, tzinfo=timezone.utc)) == 0
|
||||
assert conn.execute("SELECT ts FROM samples").fetchone()[0] == "legacy timestamp"
|
||||
conn.close()
|
||||
|
||||
|
||||
def test_collection_defers_interrupted_pruning_and_retries_next_run(
|
||||
tmp_path, sysfs_controller, monkeypatch,
|
||||
):
|
||||
monkeypatch.setenv("TZ", "UTC")
|
||||
store_path = tmp_path / "interrupted.db"
|
||||
config = {"device": "/dev/nvme0", "store_path": str(store_path)}
|
||||
first_time = datetime(2026, 9, 1, 0, 0, tzinfo=timezone.utc)
|
||||
second_time = first_time + timedelta(days=15)
|
||||
assert _collect(config, sysfs_controller, first_time, 1000, 2000)["ok"] is True
|
||||
|
||||
writer = sqlite3.connect(store_path)
|
||||
writer.execute(
|
||||
"CREATE TRIGGER stop_retention BEFORE DELETE ON samples "
|
||||
"BEGIN SELECT RAISE(ABORT, 'simulated retention interruption'); END"
|
||||
)
|
||||
writer.commit()
|
||||
writer.close()
|
||||
|
||||
second = _collect(config, sysfs_controller, second_time, 1001, 2001)
|
||||
assert second["ok"] is True, second
|
||||
assert "simulated retention interruption" in second["retention_error"]
|
||||
with sqlite3.connect(store_path) as conn:
|
||||
assert conn.execute("SELECT COUNT(*) FROM samples").fetchone()[0] == 2
|
||||
assert conn.execute("SELECT COUNT(*) FROM pending_publications").fetchone()[0] == 0
|
||||
assert conn.execute("SELECT COUNT(*) FROM local_day_unallocated_evidence").fetchone()[0] == 1
|
||||
|
||||
writer = sqlite3.connect(store_path)
|
||||
writer.execute("DROP TRIGGER stop_retention")
|
||||
writer.commit()
|
||||
writer.close()
|
||||
|
||||
third_time = second_time + timedelta(days=15)
|
||||
third = _collect(config, sysfs_controller, third_time, 1002, 2002)
|
||||
assert third["ok"] is True, third
|
||||
assert third["retention_error"] is None
|
||||
with sqlite3.connect(store_path) as conn:
|
||||
assert conn.execute("SELECT ts FROM samples ORDER BY id").fetchall() == [
|
||||
(third_time.isoformat(),)
|
||||
]
|
||||
|
||||
|
||||
def test_collection_recovers_old_pending_work_before_pruning(
|
||||
tmp_path, sysfs_controller, monkeypatch,
|
||||
):
|
||||
monkeypatch.setenv("TZ", "UTC")
|
||||
store_path = tmp_path / "pending-recovery.db"
|
||||
config = {"device": "/dev/nvme0", "store_path": str(store_path)}
|
||||
first_time = datetime(2026, 9, 1, 0, 0, tzinfo=timezone.utc)
|
||||
second_time = first_time + timedelta(days=15)
|
||||
assert _collect(config, sysfs_controller, first_time, 1000, 2000)["ok"] is True
|
||||
|
||||
writer = sqlite3.connect(store_path)
|
||||
writer.execute(
|
||||
"CREATE TRIGGER interrupt_publication "
|
||||
"BEFORE INSERT ON local_day_unallocated_evidence "
|
||||
"BEGIN SELECT RAISE(ABORT, 'simulated publication interruption'); END"
|
||||
)
|
||||
writer.commit()
|
||||
writer.close()
|
||||
|
||||
failed = _collect(config, sysfs_controller, second_time, 1001, 2001)
|
||||
assert failed["ok"] is False
|
||||
assert "simulated publication interruption" in failed["error"]
|
||||
with sqlite3.connect(store_path) as conn:
|
||||
assert conn.execute("SELECT COUNT(*) FROM samples").fetchone()[0] == 1
|
||||
assert conn.execute("SELECT COUNT(*) FROM pending_publications").fetchone()[0] == 1
|
||||
|
||||
writer = sqlite3.connect(store_path)
|
||||
writer.execute("DROP TRIGGER interrupt_publication")
|
||||
writer.commit()
|
||||
writer.close()
|
||||
|
||||
third_time = second_time + timedelta(minutes=5)
|
||||
recovered = _collect(config, sysfs_controller, third_time, 1002, 2002)
|
||||
assert recovered["ok"] is True, recovered
|
||||
assert recovered["retention_error"] is None
|
||||
with sqlite3.connect(store_path) as conn:
|
||||
assert conn.execute("SELECT COUNT(*) FROM pending_publications").fetchone()[0] == 0
|
||||
assert conn.execute("SELECT ts FROM samples ORDER BY id").fetchall() == [
|
||||
(second_time.isoformat(),),
|
||||
(third_time.isoformat(),),
|
||||
]
|
||||
assert conn.execute(
|
||||
"SELECT COUNT(*) FROM local_day_unallocated_evidence"
|
||||
).fetchone()[0] == 1
|
||||
@@ -151,8 +151,8 @@ class TestDetailExpiresSummariesRemain:
|
||||
# Run pruning
|
||||
pruned = prune_old_samples(conn, now, retention_days=14)
|
||||
|
||||
# Old samples should be pruned, recent ones retained
|
||||
assert pruned >= 1
|
||||
# The handcrafted totals lack replacement provenance, so retain samples.
|
||||
assert pruned == 0
|
||||
|
||||
# Local-day summaries must still be queryable
|
||||
old_result = query_local_day_summary(conn, "2026-09-16")
|
||||
@@ -434,10 +434,10 @@ class TestExistingEntryPoints:
|
||||
_insert_sample(conn, ts, bw=days_ago * 100)
|
||||
|
||||
pruned = prune_old_samples(conn, now, retention_days=14)
|
||||
assert pruned == 15
|
||||
assert pruned == 0
|
||||
|
||||
cursor = conn.execute("SELECT COUNT(*) FROM samples")
|
||||
assert cursor.fetchone()[0] == 14
|
||||
assert cursor.fetchone()[0] == 29
|
||||
conn.close()
|
||||
|
||||
def test_repair_with_real_temp_store(self, tmp_path):
|
||||
|
||||
+17
-15
@@ -27,9 +27,14 @@ def store_conn(tmp_path: Path):
|
||||
|
||||
|
||||
def _insert_sample(conn, ts_iso, device="/dev/nvme0"):
|
||||
conn.execute(
|
||||
"INSERT OR IGNORE INTO controller_segments "
|
||||
"(id, opened_at, identity_key) VALUES (1, '2026-01-01T00:00:00+00:00', 'test')"
|
||||
)
|
||||
conn.execute(
|
||||
"INSERT INTO samples (ts, device, data_units_written, data_units_read, "
|
||||
" bytes_written, bytes_read, percentage_used) VALUES (?, ?, 0, 0, 0, 0, 0)",
|
||||
" bytes_written, bytes_read, percentage_used, segment_id, local_tz) "
|
||||
"VALUES (?, ?, 0, 0, 0, 0, 0, 1, 'UTC')",
|
||||
(ts_iso, device),
|
||||
)
|
||||
conn.commit()
|
||||
@@ -50,33 +55,30 @@ class TestPruneOldSamples:
|
||||
cursor = store_conn.execute("SELECT COUNT(*) FROM samples")
|
||||
assert cursor.fetchone()[0] == 1
|
||||
|
||||
def test_removes_old_samples(self, store_conn):
|
||||
def test_keeps_old_samples_without_replacement_evidence(self, store_conn):
|
||||
now = datetime(2026, 9, 15, 12, 0, 0, tzinfo=timezone.utc)
|
||||
# Insert samples at 10, 14, and 15 days ago
|
||||
# All three are before the cutoff (2026-09-01T12:00:00)
|
||||
# The 15-day-old sample is not a boundary anchor because
|
||||
# the next sample (14 days ago) is also before the cutoff
|
||||
# Old samples stay until UTC and local-day evidence replace them.
|
||||
for days_ago in [10, 14, 15]:
|
||||
ts = (now - timedelta(days=days_ago)).isoformat()
|
||||
_insert_sample(store_conn, ts)
|
||||
|
||||
pruned = prune_old_samples(store_conn, now, retention_days=14)
|
||||
assert pruned == 1 # Only the 15-day-old sample removed
|
||||
assert pruned == 0
|
||||
|
||||
cursor = store_conn.execute("SELECT COUNT(*) FROM samples")
|
||||
assert cursor.fetchone()[0] == 2
|
||||
assert cursor.fetchone()[0] == 3
|
||||
|
||||
def test_removes_many_old_samples(self, store_conn):
|
||||
def test_keeps_many_old_samples_without_replacement_evidence(self, store_conn):
|
||||
now = datetime(2026, 9, 15, 12, 0, 0, tzinfo=timezone.utc)
|
||||
for days_ago in range(1, 30):
|
||||
ts = (now - timedelta(days=days_ago)).isoformat()
|
||||
_insert_sample(store_conn, ts)
|
||||
|
||||
pruned = prune_old_samples(store_conn, now, retention_days=14)
|
||||
assert pruned == 15 # Days 15-29 removed
|
||||
assert pruned == 0
|
||||
|
||||
cursor = store_conn.execute("SELECT COUNT(*) FROM samples")
|
||||
assert cursor.fetchone()[0] == 14 # Days 1-14 kept
|
||||
assert cursor.fetchone()[0] == 29
|
||||
|
||||
def test_empty_store_no_error(self, store_conn):
|
||||
now = datetime(2026, 9, 15, 12, 0, 0, tzinfo=timezone.utc)
|
||||
@@ -130,8 +132,8 @@ class TestPruneOldSamples:
|
||||
)
|
||||
assert cursor.fetchone()[0] == 1
|
||||
|
||||
def test_old_sample_with_derived_interval_removed(self, store_conn):
|
||||
"""Old samples with fully derived intervals are removed."""
|
||||
def test_hour_rows_alone_do_not_replace_local_day_evidence(self, store_conn):
|
||||
"""An hour row alone cannot authorize source-sample deletion."""
|
||||
now = datetime(2026, 9, 30, 12, 0, 0, tzinfo=timezone.utc)
|
||||
|
||||
# Old sample with derived interval
|
||||
@@ -148,8 +150,8 @@ class TestPruneOldSamples:
|
||||
# Run pruning
|
||||
pruned = prune_old_samples(store_conn, now, retention_days=14)
|
||||
|
||||
# Old sample should be removed (interval is derived)
|
||||
# Keep the source samples until local-day replacement evidence exists.
|
||||
cursor = store_conn.execute(
|
||||
"SELECT COUNT(*) FROM samples WHERE ts = '2026-09-10T10:00:00+00:00'"
|
||||
)
|
||||
assert cursor.fetchone()[0] == 0
|
||||
assert cursor.fetchone()[0] == 1
|
||||
|
||||
@@ -235,8 +235,8 @@ class TestBoundaryAnchorRetention:
|
||||
# the interval spans the retention boundary
|
||||
assert needs_boundary_anchor(store_conn, "2026-09-15T23:55:00+00:00", now)
|
||||
|
||||
def test_not_boundary_anchor_if_fully_derived(self, store_conn):
|
||||
"""Sample that's fully derived is not a boundary anchor."""
|
||||
def test_hour_only_derivation_does_not_replace_local_day_evidence(self, store_conn):
|
||||
"""UTC hour evidence alone does not make a sample safe to prune."""
|
||||
now = datetime(2026, 9, 30, 12, 0, 0, tzinfo=timezone.utc)
|
||||
|
||||
# Insert sample and fully derive its interval
|
||||
@@ -247,8 +247,7 @@ class TestBoundaryAnchorRetention:
|
||||
_insert_hour(store_conn, "2026-09-14T10:00:00+00:00",
|
||||
bytes_written_delta=1000000)
|
||||
|
||||
# Not a boundary anchor
|
||||
assert not needs_boundary_anchor(store_conn, "2026-09-14T10:00:00+00:00", now)
|
||||
assert needs_boundary_anchor(store_conn, "2026-09-14T10:00:00+00:00", now)
|
||||
|
||||
def test_pruning_retains_boundary_anchors(self, store_conn):
|
||||
"""Pruning keeps samples needed as boundary anchors."""
|
||||
@@ -274,8 +273,8 @@ class TestBoundaryAnchorRetention:
|
||||
)
|
||||
assert cursor.fetchone()[0] == 1
|
||||
|
||||
def test_pruning_removes_old_sample_with_derived_interval(self, store_conn):
|
||||
"""Pruning removes old samples when interval is fully derived."""
|
||||
def test_pruning_keeps_samples_without_local_day_replacement(self, store_conn):
|
||||
"""Pruning keeps samples when only the UTC-hour row exists."""
|
||||
now = datetime(2026, 9, 30, 12, 0, 0, tzinfo=timezone.utc)
|
||||
|
||||
# Old sample with derived interval
|
||||
@@ -289,11 +288,11 @@ class TestBoundaryAnchorRetention:
|
||||
# Run pruning
|
||||
pruned = prune_old_samples(store_conn, now, retention_days=14)
|
||||
|
||||
# Old sample should be removed (interval is derived)
|
||||
# The source remains until local-day evidence is also durable.
|
||||
cursor = store_conn.execute(
|
||||
"SELECT COUNT(*) FROM samples WHERE ts = '2026-09-10T10:00:00+00:00'"
|
||||
)
|
||||
assert cursor.fetchone()[0] == 0
|
||||
assert cursor.fetchone()[0] == 1
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user