mirror of
https://github.com/ChuckBuilds/LEDMatrix.git
synced 2026-10-04 14:25:08 +00:00
refactor(cache): remove the cache layer's duplicate cleanup and dead lookups (#613)
* refactor(cache): collapse CacheStrategy's all-60 defaults table and twin soccer branch get_sport_live_interval() without a config manager looked the sport up in a table where every value was 60, with 60 as the fallback; it now returns 60. get_data_type_from_key() had an `if 'soccer'` branch returning the same 'sports_live' as its else. test_cache_strategy_intervals pins the returned strategy for every data type x sport key x config-manager shape; it passes unchanged on the old code. A 2,544-entry dump of every CacheStrategy method over a wider grid is identical before and after. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor(cache): drop CacheStrategy's `<sport>_scoreboard` config lookup get_sport_live_interval() and get_cache_strategy() read live/recent/ upcoming intervals from config[f"{sport}_scoreboard"]. Those sections belonged to the built-in scoreboards the plugin system replaced; plugin config is keyed by plugin id ("football-scoreboard"), so on a current config the lookup always fell through to the defaults (60 live, 1800 recent, 10800 upcoming), which are now returned directly. The one input where this differs: a config.json upgraded from the pre-plugin era that still carries e.g. an "nfl_scoreboard" section (no code removes them), queried with an explicit sport key. No caller in core or the plugin monorepo passes a sport key here -- get_with_auto_strategy only derives one for keys classed sports_live/live_scores, and its callers (odds managers, odds-ticker) use odds keys -- so the stale section was unreachable in practice. A dump of every CacheStrategy method over 2,544 inputs differs from the previous commit only in those 45 legacy-config entries; the test grid now includes that shape. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * perf(cache): list cache files without holding the memory-tier lock CacheManager.list_cache_files() held the in-memory cache's lock while it listed and stat'd the whole cache directory -- 8,864 files on a real rig -- so every get()/set() from the display loop and plugins waited out the scan. The lock never protected the disk: DiskCache writes and deletes under their own lock, and a file vanishing between listdir and stat was already handled (logged and skipped). The body is unchanged apart from the dedent. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor(cache): delegate memory-tier cleanup and stats to MemoryCache CacheManager._cleanup_memory_cache() was a line-for-line copy of MemoryCache.cleanup(), and get_memory_cache_stats() a copy of MemoryCache.get_stats(), both reaching into the component's private _cache/_timestamps/_lock through "backward compatibility" aliases bound in __init__. So the component's own cleanup and stats only ever ran in tests, and the aliases went stale whenever the component was swapped (test_cache_ttl_honoured does). Both now delegate, and the aliases are gone: nothing in core, the tests, or the ledmatrix-plugins monorepo reads them. Behaviour is the same. Compared line by line, the two cleanups differ only in the sort key's fallback (0 vs 0.0, which orders identically), range+bounds check vs slice for the eviction, and the logger name on the DEBUG summary line (src.cache_manager -> src.cache.memory_cache). A differential run over 20,000 random memory states (str/None/garbage/ future timestamps, orphan keys, sizes 0-12, forced and throttled runs) gives identical removed counts, resulting dicts and last-cleanup times; the same harness catches each of three seeded mutations of MemoryCache.cleanup. The throttle clock also moves with it: CacheManager kept its own copy of last-cleanup, the component's is used now, and they started equal. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor(background): inline the sport cache key and drop the unused request queue get_sport_cache_key() constructed a whole CacheManager -- ConfigManager, config parse, cache-dir probing with test-file writes -- to return f"{sport}_{date}". It now builds the key itself in the same format as CacheManager.generate_sport_cache_key() (UTC date, %Y%m%d); tests check the two agree for explicit dates and, with a frozen clock at 03:30 UTC, for the default date. Median per call on Windows: ~0.6 ms -> ~2 us (alternating runs); on a Pi the old path also wrote a probe file per call. request_queue was a PriorityQueue nothing ever put into: requests go straight to the executor, so `priority` never did anything. The queue is gone; the `priority` parameter and FetchRequest field stay (every monorepo scoreboard passes priority=) and are documented as ignored, and get_statistics() keeps reporting queue_size, now a literal 0 as it always was in practice. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Chuck
@@ -297,3 +297,71 @@ class TestGetBackgroundService:
|
||||
shutdown_background_service()
|
||||
with pytest.raises(ValueError):
|
||||
get_background_service()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Sport cache keys
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class _FrozenDatetime:
|
||||
"""Stands in for the datetime class at a fixed instant. now() without a
|
||||
tz answers in a UTC-4 local zone, so a key built from local time shows."""
|
||||
|
||||
def __init__(self, moment):
|
||||
self._moment = moment
|
||||
|
||||
def now(self, tz=None):
|
||||
from datetime import timedelta, timezone
|
||||
if tz is None:
|
||||
return self._moment.astimezone(timezone(timedelta(hours=-4))).replace(tzinfo=None)
|
||||
return self._moment.astimezone(tz)
|
||||
|
||||
|
||||
class TestSportCacheKey:
|
||||
"""get_sport_cache_key() must produce CacheManager's key format without
|
||||
building a CacheManager (config load + cache-dir probing) to do it."""
|
||||
|
||||
@pytest.mark.parametrize("sport,date_str", [
|
||||
("nfl", "20260922"), ("ncaa_fb", "20251231"), ("soccer", ""),
|
||||
])
|
||||
def test_explicit_date_matches_cache_manager(self, service, sport, date_str):
|
||||
from src.cache_manager import CacheManager
|
||||
expected = CacheManager.generate_sport_cache_key(None, sport, date_str)
|
||||
assert service.get_sport_cache_key(sport, date_str) == expected
|
||||
|
||||
def test_default_date_is_today_in_utc_like_cache_manager(self, service):
|
||||
from datetime import datetime, timezone
|
||||
import src.cache_manager as cm_module
|
||||
# 23:30 on the 21st in New York is already the 22nd in UTC.
|
||||
frozen = _FrozenDatetime(datetime(2026, 9, 22, 3, 30, tzinfo=timezone.utc))
|
||||
with patch.object(bds_module, "datetime", frozen), \
|
||||
patch.object(cm_module, "datetime", frozen):
|
||||
ours = service.get_sport_cache_key("nba")
|
||||
theirs = cm_module.CacheManager.generate_sport_cache_key(None, "nba")
|
||||
assert ours == theirs == "nba_20260922"
|
||||
|
||||
def test_does_not_construct_a_cache_manager(self, service):
|
||||
with patch("src.cache_manager.CacheManager.__init__",
|
||||
side_effect=AssertionError("CacheManager constructed")):
|
||||
assert service.get_sport_cache_key("nhl", "20260101") == "nhl_20260101"
|
||||
assert service.get_sport_cache_key("nhl").startswith("nhl_")
|
||||
|
||||
def test_submit_without_cache_key_looks_up_todays_sport_key(
|
||||
self, service, mock_cache_manager):
|
||||
mock_cache_manager.get.return_value = {"events": []}
|
||||
with patch("src.cache_manager.CacheManager.__init__",
|
||||
side_effect=AssertionError("CacheManager constructed")):
|
||||
service.submit_fetch_request("mlb", 2026, "http://example.invalid/x")
|
||||
key = mock_cache_manager.get.call_args[0][0]
|
||||
assert key == service.get_sport_cache_key("mlb")
|
||||
|
||||
|
||||
class TestPriorityIsAcceptedAndIgnored:
|
||||
def test_priority_keyword_is_accepted(self, service, mock_cache_manager):
|
||||
mock_cache_manager.get.return_value = {"cached": True}
|
||||
rid = service.submit_fetch_request(
|
||||
"nfl", 2026, "http://example.invalid/x", cache_key="k", priority=5)
|
||||
assert service.get_result(rid).cached is True
|
||||
|
||||
def test_statistics_still_report_an_empty_queue(self, service):
|
||||
assert service.get_statistics()["queue_size"] == 0
|
||||
|
||||
@@ -0,0 +1,118 @@
|
||||
"""CacheManager's memory tier is MemoryCache's, not a copy of it.
|
||||
|
||||
CacheManager used to re-implement MemoryCache.cleanup() line for line and
|
||||
read the component's private dicts and lock through aliases bound at
|
||||
construction. Those aliases went stale the moment the component was replaced
|
||||
(tests do exactly that), and the listing of the cache *directory* held the
|
||||
memory tier's lock for the whole scan.
|
||||
"""
|
||||
|
||||
import os
|
||||
import time
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.cache.memory_cache import MemoryCache
|
||||
from src.cache_manager import CacheManager
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def cm(tmp_path):
|
||||
with patch('src.cache_manager.CacheManager._get_writable_cache_dir',
|
||||
return_value=str(tmp_path)):
|
||||
manager = CacheManager()
|
||||
# The disk sweep thread stats this directory too; keep it out of the
|
||||
# os.stat spies below.
|
||||
manager.stop_cleanup_thread()
|
||||
yield manager
|
||||
|
||||
|
||||
def test_cleanup_and_stats_follow_a_replaced_component(cm):
|
||||
"""Replace the component the way test_cache_ttl_honoured does; cleanup and
|
||||
stats must act on the new one, not on dicts captured at construction."""
|
||||
cm._memory_cache_component = MemoryCache(max_size=7, cleanup_interval=11.0)
|
||||
cm._memory_cache_component.set("fresh", {"v": 1})
|
||||
cm._memory_cache_component.set("stale", {"v": 2})
|
||||
cm._memory_cache_component._timestamps["stale"] = time.time() - 4000
|
||||
|
||||
assert cm._cleanup_memory_cache(force=True) == 1
|
||||
assert cm._memory_cache_component.get("stale") is None
|
||||
assert cm._memory_cache_component.get("fresh") == {"v": 1}
|
||||
|
||||
stats = cm.get_memory_cache_stats()
|
||||
assert stats["size"] == 1
|
||||
assert stats["max_size"] == 7
|
||||
assert stats["cleanup_interval"] == 11.0
|
||||
assert stats["usage_percent"] == pytest.approx(100 / 7)
|
||||
|
||||
|
||||
def test_periodic_cleanup_is_throttled_and_records_its_run(cm):
|
||||
mem = cm._memory_cache_component
|
||||
mem.set("stale", {"v": 1})
|
||||
mem._timestamps["stale"] = time.time() - 4000
|
||||
|
||||
# Within the interval: nothing runs, even through the get path.
|
||||
assert cm._cleanup_memory_cache() == 0
|
||||
assert mem.size() == 1
|
||||
|
||||
mem._last_cleanup = time.time() - mem._cleanup_interval - 1
|
||||
before = time.time()
|
||||
cm.get_cached_data("missing") # triggers the periodic sweep
|
||||
assert mem.size() == 0
|
||||
assert cm.get_memory_cache_stats()["last_cleanup"] >= before
|
||||
|
||||
|
||||
def test_stats_have_the_documented_shape(cm):
|
||||
cm.set("k", {"v": 1})
|
||||
stats = cm.get_memory_cache_stats()
|
||||
assert set(stats) == {"size", "max_size", "usage_percent",
|
||||
"last_cleanup", "cleanup_interval"}
|
||||
assert stats["size"] == 1
|
||||
assert stats["max_size"] == cm._memory_cache_component.max_size()
|
||||
|
||||
|
||||
def test_listing_the_cache_dir_does_not_hold_the_memory_lock(cm, tmp_path):
|
||||
"""8,864 files on a real rig: every get/set used to wait out the scan."""
|
||||
for name in ("a", "b"):
|
||||
(tmp_path / f"{name}.json").write_text("{}")
|
||||
(tmp_path / "notes.txt").write_text("x")
|
||||
|
||||
lock = cm._memory_cache_component._lock
|
||||
held_during_stat = []
|
||||
real_stat = os.stat
|
||||
|
||||
def spying_stat(path, *args, **kwargs):
|
||||
held_during_stat.append(lock.locked())
|
||||
return real_stat(path, *args, **kwargs)
|
||||
|
||||
with patch('src.cache_manager.os.stat', side_effect=spying_stat):
|
||||
files = cm.list_cache_files()
|
||||
|
||||
assert held_during_stat and not any(held_during_stat)
|
||||
assert sorted(f["key"] for f in files) == ["a", "b"]
|
||||
|
||||
|
||||
def test_listing_skips_a_file_deleted_mid_scan(cm, tmp_path):
|
||||
for name in ("a", "b"):
|
||||
(tmp_path / f"{name}.json").write_text("{}")
|
||||
real_stat = os.stat
|
||||
|
||||
def vanishing_stat(path, *args, **kwargs):
|
||||
if str(path).endswith("a.json"):
|
||||
raise FileNotFoundError(path)
|
||||
return real_stat(path, *args, **kwargs)
|
||||
|
||||
with patch('src.cache_manager.os.stat', side_effect=vanishing_stat):
|
||||
files = cm.list_cache_files()
|
||||
|
||||
assert [f["key"] for f in files] == ["b"]
|
||||
|
||||
|
||||
def test_listing_is_newest_first(cm, tmp_path):
|
||||
now = time.time()
|
||||
for i, name in enumerate(("old", "mid", "new")):
|
||||
p = tmp_path / f"{name}.json"
|
||||
p.write_text("{}")
|
||||
os.utime(p, (now - 300 + i * 100, now - 300 + i * 100))
|
||||
assert [f["key"] for f in cm.list_cache_files()] == ["new", "mid", "old"]
|
||||
@@ -0,0 +1,136 @@
|
||||
"""CacheStrategy intervals, pinned across the whole input grid.
|
||||
|
||||
The strategy table used to carry a per-sport defaults dict whose every value
|
||||
was 60, and a soccer branch identical to its else. These tests pin the
|
||||
returned strategy for every data type x sport key x config shape, so
|
||||
simplifying the lookup cannot change what any caller gets back. They were
|
||||
written against the pre-cleanup code and pass on it unchanged, except for
|
||||
the legacy `<sport>_scoreboard` config shape (see below), which that code
|
||||
still read.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
|
||||
from src.cache.cache_strategy import CacheStrategy
|
||||
|
||||
|
||||
class _Cfg:
|
||||
def __init__(self, config):
|
||||
self.config = config
|
||||
|
||||
|
||||
class _NoConfigAttr:
|
||||
pass
|
||||
|
||||
|
||||
# Plugin config sections are keyed by plugin id. Their intervals belong to the
|
||||
# plugin, and the strategy table has never read them.
|
||||
_PLUGIN_ID_CONFIG = {
|
||||
pid: {"live_update_interval": 5, "recent_update_interval": 7,
|
||||
"upcoming_update_interval": 9}
|
||||
for pid in ("football-scoreboard", "basketball-scoreboard",
|
||||
"baseball-scoreboard", "hockey-scoreboard", "soccer-scoreboard")
|
||||
}
|
||||
|
||||
# `<sport>_scoreboard` sections come from the built-in scoreboards the plugin
|
||||
# system replaced. An install upgraded from that era can still carry them in
|
||||
# config.json (nothing deletes them). No current caller passes a sport key to
|
||||
# the strategy, but a stale section must not steer cache TTLs if one does.
|
||||
_LEGACY_SCOREBOARD_CONFIG = {
|
||||
f"{sport}_scoreboard": {"live_update_interval": 5,
|
||||
"recent_update_interval": 7,
|
||||
"upcoming_update_interval": 9}
|
||||
for sport in ("nfl", "nba", "mlb", "nhl", "soccer", "ncaa_fb",
|
||||
"ncaa_baseball", "ncaam_basketball", "milb")
|
||||
}
|
||||
|
||||
CONFIG_MANAGERS = {
|
||||
"no_config_manager": None,
|
||||
"empty_config": _Cfg({}),
|
||||
"plugin_id_config": _Cfg(_PLUGIN_ID_CONFIG),
|
||||
"legacy_scoreboard_config": _Cfg(_LEGACY_SCOREBOARD_CONFIG),
|
||||
"config_is_none": _Cfg(None),
|
||||
"config_is_not_a_dict": _Cfg("x"),
|
||||
"config_manager_without_config": _NoConfigAttr(),
|
||||
}
|
||||
|
||||
SPORT_KEYS = [None, "", "nfl", "nba", "mlb", "nhl", "soccer", "ncaa_fb",
|
||||
"ncaa_baseball", "ncaam_basketball", "milb",
|
||||
"football-scoreboard", "curling"]
|
||||
|
||||
|
||||
def _fixed(max_age, memory_ttl, **extra):
|
||||
return {"max_age": max_age, "memory_ttl": memory_ttl,
|
||||
"force_refresh": False, **extra}
|
||||
|
||||
|
||||
DEFAULT = _fixed(300, 600)
|
||||
FIXED = {
|
||||
"weather_current": _fixed(300, 600),
|
||||
"stocks": _fixed(600, 1200, market_hours_only=True),
|
||||
"crypto": _fixed(300, 600),
|
||||
"sports_recent": _fixed(1800, 3600),
|
||||
"sports_upcoming": _fixed(10800, 21600),
|
||||
"sports_schedules": _fixed(86400, 172800),
|
||||
"leaderboard": _fixed(604800, 1209600),
|
||||
"news": _fixed(3600, 7200),
|
||||
"odds": _fixed(1800, 3600),
|
||||
"odds_live": _fixed(120, 240),
|
||||
"team_info": _fixed(604800, 1209600),
|
||||
"logos": _fixed(2592000, 5184000),
|
||||
"default": DEFAULT,
|
||||
}
|
||||
|
||||
|
||||
def _expected(data_type, sport_key):
|
||||
if data_type in ("live_scores", "sports_live"):
|
||||
if sport_key:
|
||||
interval = 60
|
||||
else:
|
||||
interval = 15 if data_type == "live_scores" else 30
|
||||
return {"max_age": interval, "memory_ttl": interval * 2,
|
||||
"force_refresh": True}
|
||||
return FIXED.get(data_type, DEFAULT)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("cm_name", sorted(CONFIG_MANAGERS))
|
||||
def test_live_interval_is_60_for_every_sport(cm_name):
|
||||
strategy = CacheStrategy(config_manager=CONFIG_MANAGERS[cm_name])
|
||||
for sport_key in SPORT_KEYS:
|
||||
assert strategy.get_sport_live_interval(sport_key) == 60, sport_key
|
||||
|
||||
|
||||
@pytest.mark.parametrize("cm_name", sorted(CONFIG_MANAGERS))
|
||||
def test_strategy_table_for_every_data_type_and_sport(cm_name):
|
||||
strategy = CacheStrategy(config_manager=CONFIG_MANAGERS[cm_name])
|
||||
data_types = ["live_scores", "sports_live", *FIXED, "unknown", ""]
|
||||
for data_type in data_types:
|
||||
for sport_key in SPORT_KEYS:
|
||||
got = strategy.get_cache_strategy(data_type, sport_key)
|
||||
assert got == _expected(data_type, sport_key), (data_type, sport_key)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("key", [
|
||||
"soccer_live", "soccer_current", "soccer_scoreboard", "SOCCER_LIVE",
|
||||
"nfl_live", "live", "hockey_current", "nba_live_scores",
|
||||
])
|
||||
def test_live_keys_including_soccer_are_sports_live(key):
|
||||
assert CacheStrategy().get_data_type_from_key(key) == "sports_live"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("key,data_type", [
|
||||
("odds_soccer_live", "odds_live"),
|
||||
("odds_x", "odds"),
|
||||
("weather", "weather_current"),
|
||||
("crypto_stock", "crypto"),
|
||||
("stock", "stocks"),
|
||||
("news_soccer", "news"),
|
||||
("soccer_schedule", "sports_schedules"),
|
||||
("soccer_recent", "sports_recent"),
|
||||
("soccer_upcoming", "sports_upcoming"),
|
||||
("soccer_logo", "team_info"),
|
||||
("soccer", "default"),
|
||||
("", "default"),
|
||||
])
|
||||
def test_non_live_keys_keep_their_data_type(key, data_type):
|
||||
assert CacheStrategy().get_data_type_from_key(key) == data_type
|
||||
Reference in New Issue
Block a user