257 lines
9.0 KiB
Python
257 lines
9.0 KiB
Python
"""Bound pending-publication admission before device acquisition."""
|
|
import json
|
|
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 import collector
|
|
|
|
|
|
class FakeClock:
|
|
def __init__(self, now):
|
|
self.now = now
|
|
|
|
def utcnow(self):
|
|
return self.now
|
|
|
|
|
|
@pytest.fixture
|
|
def sysfs_controller(tmp_path):
|
|
controller_path = tmp_path / "sys" / "class" / "nvme" / "nvme0"
|
|
controller_path.mkdir(parents=True)
|
|
(controller_path / "subsysnqn").write_text("nqn.test:drive\n")
|
|
(controller_path / "model").write_text("Test NVMe\n")
|
|
(controller_path / "serial").write_text("test-serial\n")
|
|
(controller_path / "firmware_rev").write_text("1.0\n")
|
|
transport = controller_path / "transport"
|
|
transport.mkdir()
|
|
(transport / "trstring").write_text("pcie\n")
|
|
return controller_path
|
|
|
|
|
|
def _smartctl(units_written):
|
|
return {
|
|
"nvme_smart_health_information_log": {
|
|
"critical_warning": 0,
|
|
"temperature": 35,
|
|
"available_spare": 100,
|
|
"percentage_used": 5,
|
|
"data_units_written": units_written,
|
|
"data_units_read": 500,
|
|
"power_on_hours": 100,
|
|
},
|
|
"user_capacity": {"bytes": 1_024_000_000_000},
|
|
"model_name": "Test NVMe",
|
|
"serial_number": "test-serial",
|
|
"firmware_version": "1.0",
|
|
}
|
|
|
|
|
|
def _collect(config, controller, now, units_written):
|
|
return collector.run_collection(
|
|
config=config,
|
|
clock=FakeClock(now),
|
|
acquire=lambda: (_smartctl(units_written), controller),
|
|
)
|
|
|
|
|
|
def test_partial_recovery_frees_admission_and_keeps_pending_order(
|
|
tmp_path, sysfs_controller, monkeypatch,
|
|
):
|
|
"""A freed slot admits one observation behind older pending evidence."""
|
|
assert collector.PENDING_PUBLICATION_LIMIT == 6_720
|
|
monkeypatch.setenv("TZ", "UTC")
|
|
monkeypatch.setattr(collector, "PENDING_PUBLICATION_LIMIT", 2)
|
|
|
|
store_path = tmp_path / "observations.db"
|
|
config = {"device": "/dev/nvme0", "store_path": str(store_path)}
|
|
old_time = datetime(2026, 8, 1, tzinfo=timezone.utc)
|
|
controller = sysfs_controller
|
|
|
|
assert _collect(config, controller, old_time, 1000)["ok"] is True
|
|
|
|
original_derive = collector.derive_hours_from_interval
|
|
|
|
def unavailable_derivation(*_args):
|
|
raise RuntimeError("derivation unavailable")
|
|
|
|
monkeypatch.setattr(collector, "derive_hours_from_interval", unavailable_derivation)
|
|
first_pending = _collect(
|
|
config, controller, old_time + timedelta(minutes=5), 1010,
|
|
)
|
|
assert first_pending["ok"] is False
|
|
|
|
second_pending = _collect(
|
|
config, controller, old_time + timedelta(minutes=10), 1020,
|
|
)
|
|
assert second_pending["ok"] is False
|
|
with sqlite3.connect(store_path) as conn:
|
|
assert conn.execute(
|
|
"SELECT COUNT(*) FROM pending_publications"
|
|
).fetchone()[0] == 2
|
|
|
|
called = False
|
|
|
|
def must_not_acquire():
|
|
nonlocal called
|
|
called = True
|
|
return _smartctl(1030), controller
|
|
|
|
full = collector.run_collection(
|
|
config=config,
|
|
clock=FakeClock(old_time + timedelta(days=40)),
|
|
acquire=must_not_acquire,
|
|
)
|
|
assert full["ok"] is False
|
|
assert "capacity full (2 observations)" in full["error"]
|
|
assert called is False
|
|
with sqlite3.connect(store_path) as conn:
|
|
assert conn.execute(
|
|
"SELECT COUNT(*), MIN(sample_ts) FROM pending_publications"
|
|
).fetchone() == (
|
|
2,
|
|
(old_time + timedelta(minutes=5)).isoformat(),
|
|
)
|
|
assert conn.execute("SELECT COUNT(*) FROM samples").fetchone()[0] == 1
|
|
|
|
def fail_second_pending(conn, previous, current):
|
|
if current["data_units_written"] == 1020:
|
|
raise RuntimeError("second observation still blocked")
|
|
return original_derive(conn, previous, current)
|
|
|
|
monkeypatch.setattr(collector, "derive_hours_from_interval", fail_second_pending)
|
|
acquired = False
|
|
|
|
def acquire_after_partial_recovery():
|
|
nonlocal acquired
|
|
acquired = True
|
|
return _smartctl(1030), controller
|
|
|
|
partial = collector.run_collection(
|
|
config=config,
|
|
clock=FakeClock(old_time + timedelta(days=40, minutes=5)),
|
|
acquire=acquire_after_partial_recovery,
|
|
)
|
|
assert partial["ok"] is False
|
|
assert acquired is True, partial
|
|
|
|
with sqlite3.connect(store_path) as conn:
|
|
assert conn.execute(
|
|
"SELECT data_units_written FROM samples ORDER BY id"
|
|
).fetchall() == [(1000,), (1010,)]
|
|
queued_units = [
|
|
json.loads(row[0])["sample"]["data_units_written"]
|
|
for row in conn.execute(
|
|
"SELECT payload FROM pending_publications ORDER BY id"
|
|
)
|
|
]
|
|
assert queued_units == [1020, 1030]
|
|
assert conn.execute("SELECT COUNT(*) FROM monitoring_periods").fetchone()[0] == 1
|
|
|
|
recovered_in_order = []
|
|
|
|
def record_recovery_order(conn, previous, current):
|
|
recovered_in_order.append(current["data_units_written"])
|
|
return original_derive(conn, previous, current)
|
|
|
|
monkeypatch.setattr(collector, "derive_hours_from_interval", record_recovery_order)
|
|
recovered = collector.run_collection(
|
|
config=config,
|
|
clock=FakeClock(old_time + timedelta(days=40, minutes=10)),
|
|
acquire=lambda: (_smartctl(1040), controller),
|
|
)
|
|
assert recovered["ok"] is True, recovered
|
|
assert recovered_in_order == [1020, 1030, 1040]
|
|
|
|
with sqlite3.connect(store_path) as conn:
|
|
assert conn.execute(
|
|
"SELECT data_units_written FROM samples ORDER BY id DESC LIMIT 1"
|
|
).fetchone() == (1040,)
|
|
assert conn.execute("SELECT COUNT(*) FROM pending_publications").fetchone()[0] == 0
|
|
|
|
|
|
def test_actual_pending_limit_fails_before_acquisition_and_keeps_old_evidence(
|
|
tmp_path, sysfs_controller, monkeypatch,
|
|
):
|
|
"""The production limit retains every old row and refuses device acquisition."""
|
|
monkeypatch.setenv("TZ", "UTC")
|
|
store_path = tmp_path / "full-observations.db"
|
|
config = {"device": "/dev/nvme0", "store_path": str(store_path)}
|
|
controller = sysfs_controller
|
|
old_time = datetime(2026, 7, 1, tzinfo=timezone.utc)
|
|
assert _collect(config, controller, old_time, 1000)["ok"] is True
|
|
|
|
def unavailable_derivation(*_args):
|
|
raise RuntimeError("derivation unavailable")
|
|
|
|
monkeypatch.setattr(collector, "derive_hours_from_interval", unavailable_derivation)
|
|
failed = _collect(
|
|
config, controller, old_time + timedelta(minutes=5), 1010,
|
|
)
|
|
assert failed["ok"] is False
|
|
|
|
with sqlite3.connect(store_path) as conn:
|
|
payload_row = conn.execute(
|
|
"SELECT payload FROM pending_publications ORDER BY id LIMIT 1"
|
|
).fetchone()
|
|
assert payload_row is not None
|
|
base = json.loads(payload_row[0])
|
|
base_observed_at = datetime.fromisoformat(base["sample"]["ts"])
|
|
base_units = base["sample"]["data_units_written"]
|
|
rows = []
|
|
for offset in range(1, collector.PENDING_PUBLICATION_LIMIT):
|
|
observation = json.loads(payload_row[0])
|
|
units_written = base_units + offset
|
|
observed_at = base_observed_at + timedelta(minutes=5 * offset)
|
|
observation["sample"]["ts"] = observed_at.isoformat()
|
|
observation["sample"]["data_units_written"] = units_written
|
|
observation["sample"]["bytes_written"] = units_written * 512_000
|
|
rows.append((observed_at.isoformat(), json.dumps(observation)))
|
|
conn.executemany(
|
|
"INSERT INTO pending_publications (sample_ts, payload) VALUES (?, ?)",
|
|
rows,
|
|
)
|
|
conn.commit()
|
|
|
|
called = False
|
|
|
|
def must_not_acquire():
|
|
nonlocal called
|
|
called = True
|
|
return _smartctl(9000), controller
|
|
|
|
result = collector.run_collection(
|
|
config=config,
|
|
clock=FakeClock(old_time + timedelta(days=40)),
|
|
acquire=must_not_acquire,
|
|
)
|
|
assert result["ok"] is False
|
|
assert f"capacity full ({collector.PENDING_PUBLICATION_LIMIT} observations)" in result[
|
|
"error"
|
|
]
|
|
assert called is False
|
|
|
|
with sqlite3.connect(store_path) as conn:
|
|
pending_rows = conn.execute(
|
|
"SELECT sample_ts, payload FROM pending_publications ORDER BY id"
|
|
).fetchall()
|
|
assert len(pending_rows) == collector.PENDING_PUBLICATION_LIMIT
|
|
assert (pending_rows[0][0], pending_rows[-1][0]) == (
|
|
(old_time + timedelta(minutes=5)).isoformat(),
|
|
(
|
|
old_time
|
|
+ timedelta(minutes=5 * collector.PENDING_PUBLICATION_LIMIT)
|
|
).isoformat(),
|
|
)
|
|
assert [
|
|
json.loads(payload)["sample"]["data_units_written"]
|
|
for _, payload in pending_rows
|
|
] == list(range(1010, 1010 + collector.PENDING_PUBLICATION_LIMIT))
|
|
assert conn.execute("SELECT COUNT(*) FROM samples").fetchone()[0] == 1
|
|
assert conn.execute("SELECT COUNT(*) FROM monitoring_periods").fetchone()[0] == 1
|