w1cdn/spothole
1
0
Fork 0
mirror of https://git.ianrenton.com/ian/spothole.git synced 2026-09-20 14:27:42 +00:00
Code Issues 13 Packages Projects Releases Wiki Activity

Fix a bug where solar conditions and status data were not properly persisted to disk between restarts. Release v2.0.5

Browse Source
This commit is contained in:
Ian Renton
2026-08-29 09:17:24 +01:00
parent 8451ca2727
commit ba56acd7ac
18 changed files with 89 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/constants.py
+1 -1
View File
@@ -3,7 +3,7 @@ from data.band import Band
from data.sig import SIG
# General software
SOFTWARE_VERSION = "2.0.4"
SOFTWARE_VERSION = "2.0.5"
# HTTP headers used for spot providers that use HTTP
HTTP_HEADERS = {"User-Agent": f"Spothole v{SOFTWARE_VERSION} (operated by {SERVER_OWNER_CALLSIGN})"}
core/data_store.py
+10 -19
View File
@@ -6,6 +6,7 @@ import diskcache
from core.config import MAX_ALERT_AGE, MAX_SPOT_AGE
from core.live_data_cache import LiveDataCache
from core.single_object_data_cache import SingleObjectDataCache
from data.solar_conditions import SolarConditions
logger = logging.getLogger(__name__)
@@ -34,10 +35,8 @@ class DataStore:
self.dxcc_data = None
self.dxcc_lookup_by_call_regex = []
self.sigrefs = None
self.status_data = {}
self._status = None
self.solar_conditions = {}
self._solar = None
self.status = None
self.solar_conditions = None
# ITU/CQ zone GeoJSON data is only ever loaded statically from a local file so these don't even need to be
# caches, they can just be straight objects
self.cq_zone_data = None
@@ -46,16 +45,11 @@ class DataStore:
def setup(self):
Path(CACHE_DIR).mkdir(parents=True, exist_ok=True)
# Standard disk cache for solar data and status data, but each cache contains only a single object which we
# expose to the wider application
self._solar = diskcache.Cache(f"{CACHE_DIR}solar")
if "solar_conditions" not in self._solar:
self._solar.add("solar_conditions", SolarConditions())
self.solar_conditions = self._solar.get("solar_conditions")
self._status = diskcache.Cache(f"{CACHE_DIR}status")
if "status_data" not in self._status:
self._status.add("status_data", {})
self.status_data = self._status.get("status_data")
# For solar data and status data, we use a wrapper around disk cache where each cache contains only a single
# object exposed to the wider application, and provides a store() method for callers to notify diskcache that
# the object has changed and needs to be re-cached.
self.solar_conditions = SingleObjectDataCache(f"{CACHE_DIR}solar", SolarConditions())
self.status = SingleObjectDataCache(f"{CACHE_DIR}status", {})
# Standard disk cache for static reference and SIG ref data. Separate provider threads will repopulate these on
# a regular basis but there's no need for a TTL since old data is better than no data.
@@ -116,13 +110,10 @@ class DataStore:
self.dxcc_lookup_by_call_regex.append((re.compile(entry["prefixRegex"]), entry["entityCode"]))
def close(self):
self.spots.save_snapshot()
self.alerts.save_snapshot()
self.spots.close()
self.alerts.close()
self._solar.close()
self._status.close()
self.solar.close()
self.status.close()
self.dxcc_data.close()
self.sigrefs.close()
self.callsign_data_countryfiles.close()
core/single_object_data_cache.py
+39
View File
@@ -0,0 +1,39 @@
import logging
import threading
import diskcache
logger = logging.getLogger(__name__)
class SingleObjectDataCache:
"""Cache for status and solar conditions. This uses DiskCache, but unlike the standard DiskCache users like SIG and
callsign lookup handlers, status and solar conditions are persisted as a single object. If we just load the object
from DiskCache and modify it, DiskCache doesn't know that it's been updated and needs re-caching, so we provide a
store() method that any functions updating the object can call afterwards."""
def __init__(self, cache_dir, object_if_empty):
"""Initialize a SingleObjectDataCache. Provide the directory to load the cache from and save it to. If the cache
is empty, the provided object_if_empty parameter will be used to initialise it."""
self._lock = threading.Lock()
self._cache = diskcache.Cache(cache_dir)
# This cache stores a single object, doesn't matter what it's called so "object" will do
if "object" not in self._cache:
self._cache.add("object", object_if_empty)
self._obj = self._cache.get("object")
def get(self):
"""Get the data object. This can then be manipulated as necessary across multiple threads. Any function
modifying the object must remember to call store() afterwards."""
return self._obj
def store(self):
"""Store the updated object in the cache. Any function modifying the object must remember to call this
afterwards."""
with self._lock:
self._cache.set("object", self._obj)
def close(self):
self.store()
self._cache.close()
core/status_reporter.py
+16 -14
View File
@@ -25,8 +25,9 @@ class StatusReporter:
self._stop_event = Event()
self._startup_time = datetime.now(pytz.UTC)
DATA_STORE.status_data["software_version"] = SOFTWARE_VERSION
DATA_STORE.status_data["server_owner_callsign"] = SERVER_OWNER_CALLSIGN
DATA_STORE.status.get()["software_version"] = SOFTWARE_VERSION
DATA_STORE.status.get()["server_owner_callsign"] = SERVER_OWNER_CALLSIGN
DATA_STORE.status.store()
def start(self):
"""Start the reporter thread"""
@@ -50,11 +51,11 @@ class StatusReporter:
def _report(self):
"""Write status information"""
DATA_STORE.status_data["uptime"] = (datetime.now(pytz.UTC) - self._startup_time).total_seconds()
DATA_STORE.status_data["mem_use_mb"] = round(psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024), 3)
DATA_STORE.status_data["num_spots"] = len(DATA_STORE.spots.values())
DATA_STORE.status_data["num_alerts"] = len(DATA_STORE.alerts.values())
DATA_STORE.status_data["spot_providers"] = [
DATA_STORE.status.get()["uptime"] = (datetime.now(pytz.UTC) - self._startup_time).total_seconds()
DATA_STORE.status.get()["mem_use_mb"] = round(psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024), 3)
DATA_STORE.status.get()["num_spots"] = len(DATA_STORE.spots.values())
DATA_STORE.status.get()["num_alerts"] = len(DATA_STORE.alerts.values())
DATA_STORE.status.get()["spot_providers"] = [
{
"name": p.name,
"enabled": p.enabled,
@@ -69,7 +70,7 @@ class StatusReporter:
}
for p in DATA_PROVIDERS.spot_providers
]
DATA_STORE.status_data["alert_providers"] = [
DATA_STORE.status.get()["alert_providers"] = [
{
"name": p.name,
"enabled": p.enabled,
@@ -80,7 +81,7 @@ class StatusReporter:
}
for p in DATA_PROVIDERS.alert_providers
]
DATA_STORE.status_data["solar_condition_providers"] = [
DATA_STORE.status.get()["solar_condition_providers"] = [
{
"name": p.name,
"enabled": p.enabled,
@@ -91,7 +92,7 @@ class StatusReporter:
}
for p in DATA_PROVIDERS.solar_condition_providers
]
DATA_STORE.status_data["static_data_providers"] = [
DATA_STORE.status.get()["static_data_providers"] = [
{
"name": p.name,
"enabled": p.enabled,
@@ -102,7 +103,7 @@ class StatusReporter:
}
for p in DATA_PROVIDERS.static_data_providers
]
DATA_STORE.status_data["sig_ref_data_providers"] = [
DATA_STORE.status.get()["sig_ref_data_providers"] = [
{
"sig_name": p.sig_name,
"enabled": p.enabled,
@@ -114,7 +115,7 @@ class StatusReporter:
}
for p in DATA_PROVIDERS.sig_ref_data_providers
]
DATA_STORE.status_data["callsign_data_providers"] = [
DATA_STORE.status.get()["callsign_data_providers"] = [
{
"name": p.name,
"enabled": p.enabled,
@@ -126,13 +127,13 @@ class StatusReporter:
}
for p in DATA_PROVIDERS.callsign_data_providers
]
DATA_STORE.status_data["cleanup"] = {
DATA_STORE.status.get()["cleanup"] = {
"status": CLEANUP_TIMER.status,
"last_ran": CLEANUP_TIMER.last_cleanup_time.replace(tzinfo=pytz.UTC).timestamp()
if CLEANUP_TIMER.last_cleanup_time
else 0,
}
DATA_STORE.status_data["webserver"] = {
DATA_STORE.status.get()["webserver"] = {
"status": WEB_SERVER.web_server_metrics["status"],
"last_api_access": WEB_SERVER.web_server_metrics["last_api_access_time"]
.replace(tzinfo=pytz.UTC)
@@ -147,6 +148,7 @@ class StatusReporter:
else 0,
"page_access_count": WEB_SERVER.web_server_metrics["page_access_counter"],
}
DATA_STORE.status.store()
# Update Prometheus metrics
memory_use_gauge.set(psutil.Process(os.getpid()).memory_info().rss)