3937cb4cb8
Unlike the cleanup twins, backup can't share the music handler — it's a different DB file. Extract the music backup body into _backup_db_at(db_path, ...) (music behaviour byte-identical, now a thin wrapper over DATABASE_PATH) and add auto_backup_video_database pointing at VIDEO_DATABASE_PATH (video_library.db). New video_backup_database action (scope='video' block + registry), owned_by='video' system automation on the music cadence (every 3 days). Tests: a REAL backup behaviour test — music backup lands next to music_library.db, video backup next to video_library.db, no cross-contamination (this is the whole reason it can't be shared); scope isolation; single video-owned seed; own handler. Existing music maintenance tests (22) still green — refactor is non-regressing. EXPECTED_ACTION_NAMES updated.
234 lines
10 KiB
Python
234 lines
10 KiB
Python
"""Automation handlers: short maintenance actions.
|
|
|
|
Lifted from ``web_server._register_automation_handlers``:
|
|
- ``clear_quarantine`` → :func:`auto_clear_quarantine`
|
|
- ``cleanup_wishlist`` → :func:`auto_cleanup_wishlist`
|
|
- ``update_discovery_pool`` → :func:`auto_update_discovery_pool`
|
|
- ``backup_database`` → :func:`auto_backup_database`
|
|
- ``refresh_beatport_cache`` → :func:`auto_refresh_beatport_cache`
|
|
|
|
Each is a thin wrapper around an existing service / helper. Grouped
|
|
in one module because every body is short and they share no state
|
|
between them — splitting into per-handler files would just add
|
|
import noise.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import glob as _glob
|
|
import os
|
|
import shutil as _shutil
|
|
import sqlite3
|
|
import time
|
|
from datetime import datetime
|
|
from typing import Any, Dict
|
|
|
|
from core.automation.deps import AutomationDeps
|
|
|
|
|
|
# ─── clear_quarantine ────────────────────────────────────────────────
|
|
|
|
|
|
def auto_clear_quarantine(config: Dict[str, Any], deps: AutomationDeps) -> Dict[str, Any]:
|
|
"""Purge every file/folder under the configured ss_quarantine path."""
|
|
automation_id = config.get('_automation_id')
|
|
quarantine_path = os.path.join(
|
|
deps.docker_resolve_path(deps.config_manager.get('soulseek.download_path', './downloads')),
|
|
'ss_quarantine',
|
|
)
|
|
if not os.path.exists(quarantine_path):
|
|
deps.update_progress(automation_id, log_line='No quarantine folder found', log_type='info')
|
|
return {'status': 'completed', 'removed': '0'}
|
|
removed = 0
|
|
for f in os.listdir(quarantine_path):
|
|
fp = os.path.join(quarantine_path, f)
|
|
try:
|
|
if os.path.isfile(fp):
|
|
os.remove(fp)
|
|
removed += 1
|
|
elif os.path.isdir(fp):
|
|
_shutil.rmtree(fp)
|
|
removed += 1
|
|
except Exception as e: # noqa: BLE001 — best-effort purge
|
|
deps.logger.debug("quarantine entry purge failed: %s", e)
|
|
deps.update_progress(
|
|
automation_id,
|
|
log_line=f'Removed {removed} quarantined items',
|
|
log_type='success' if removed > 0 else 'info',
|
|
)
|
|
return {'status': 'completed', 'removed': str(removed)}
|
|
|
|
|
|
# ─── cleanup_wishlist ────────────────────────────────────────────────
|
|
|
|
|
|
def auto_cleanup_wishlist(config: Dict[str, Any], deps: AutomationDeps) -> Dict[str, Any]:
|
|
"""Drop duplicate entries from the wishlist for the active profile."""
|
|
automation_id = config.get('_automation_id')
|
|
db = deps.get_database()
|
|
removed = db.remove_wishlist_duplicates(deps.get_current_profile_id())
|
|
deps.update_progress(
|
|
automation_id,
|
|
log_line=f'Removed {removed or 0} duplicate wishlist entries',
|
|
log_type='success' if removed else 'info',
|
|
)
|
|
return {'status': 'completed', 'removed': str(removed or 0)}
|
|
|
|
|
|
# ─── update_discovery_pool ───────────────────────────────────────────
|
|
|
|
|
|
def auto_update_discovery_pool(config: Dict[str, Any], deps: AutomationDeps) -> Dict[str, Any]:
|
|
"""Run an incremental refresh of the discovery pool via the
|
|
watchlist scanner."""
|
|
automation_id = config.get('_automation_id')
|
|
try:
|
|
scanner = deps.get_watchlist_scanner(deps.spotify_client)
|
|
deps.update_progress(automation_id, log_line='Updating discovery pool...', log_type='info')
|
|
scanner.update_discovery_pool_incremental(deps.get_current_profile_id())
|
|
deps.update_progress(
|
|
automation_id, status='finished', progress=100,
|
|
phase='Complete', log_line='Discovery pool updated', log_type='success',
|
|
)
|
|
return {'status': 'completed', '_manages_own_progress': True}
|
|
except Exception as e: # noqa: BLE001 — automation handlers must never raise
|
|
deps.update_progress(
|
|
automation_id, status='error',
|
|
phase='Error', log_line=str(e), log_type='error',
|
|
)
|
|
return {'status': 'error', 'reason': str(e), '_manages_own_progress': True}
|
|
|
|
|
|
# ─── backup_database ─────────────────────────────────────────────────
|
|
|
|
|
|
_MAX_BACKUPS = 5
|
|
|
|
|
|
def _backup_db_at(db_path: str, deps: AutomationDeps, automation_id) -> Dict[str, Any]:
|
|
"""Create a hot SQLite backup of ``db_path``, then prune old backups so only
|
|
the newest ``_MAX_BACKUPS`` remain. Shared by the music and video backup
|
|
actions — only the DB file differs (they can't share one backup)."""
|
|
if not os.path.exists(db_path):
|
|
return {'status': 'error', 'reason': 'Database file not found'}
|
|
|
|
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
|
|
backup_path = f"{db_path}.backup_{timestamp}"
|
|
# safe_backup verifies source + result integrity, so an automated backup
|
|
# can never silently snapshot a corrupt DB (the incident where every
|
|
# rolling backup faithfully copied the corruption).
|
|
from core.db_integrity import DBIntegrityError, safe_backup, prune_backups
|
|
try:
|
|
safe_backup(db_path, backup_path)
|
|
except DBIntegrityError as integ:
|
|
deps.logger.error("Auto-backup refused — DB integrity check failed: %s", integ)
|
|
deps.update_progress(
|
|
automation_id,
|
|
log_line=f'Backup SKIPPED — database failed integrity check: {integ}',
|
|
log_type='error',
|
|
)
|
|
return {'status': 'error', 'reason': f'Database integrity check failed: {integ}'}
|
|
size_mb = round(os.path.getsize(backup_path) / (1024 * 1024), 1)
|
|
|
|
# Rolling cleanup — never evict the most-recent verified-healthy backup.
|
|
existing = list(_glob.glob(f"{db_path}.backup_*"))
|
|
for removed in prune_backups(existing, _MAX_BACKUPS):
|
|
try:
|
|
os.remove(removed)
|
|
except Exception as e: # noqa: BLE001 — best-effort cleanup
|
|
deps.logger.debug("rolling backup cleanup failed: %s", e)
|
|
deps.update_progress(
|
|
automation_id,
|
|
log_line=f'Backup created: {size_mb}MB ({os.path.basename(backup_path)})',
|
|
log_type='success',
|
|
)
|
|
return {'status': 'completed', 'backup_path': backup_path, 'size_mb': str(size_mb)}
|
|
|
|
|
|
def auto_backup_database(config: Dict[str, Any], deps: AutomationDeps) -> Dict[str, Any]:
|
|
"""Hot SQLite backup of the MUSIC database (``DATABASE_PATH``)."""
|
|
db_path = os.environ.get('DATABASE_PATH', 'database/music_library.db')
|
|
return _backup_db_at(db_path, deps, config.get('_automation_id'))
|
|
|
|
|
|
def auto_backup_video_database(config: Dict[str, Any], deps: AutomationDeps) -> Dict[str, Any]:
|
|
"""Hot SQLite backup of the VIDEO database (``VIDEO_DATABASE_PATH`` /
|
|
video_library.db). Same logic as the music backup but a different DB file —
|
|
the two can't share one backup, so this is a video-specific action."""
|
|
db_path = os.environ.get('VIDEO_DATABASE_PATH', 'database/video_library.db')
|
|
return _backup_db_at(db_path, deps, config.get('_automation_id'))
|
|
|
|
|
|
# ─── refresh_beatport_cache ──────────────────────────────────────────
|
|
|
|
|
|
_BEATPORT_SECTIONS = (
|
|
('hero_tracks', '/api/beatport/hero-tracks', 'Hero Tracks'),
|
|
('new_releases', '/api/beatport/new-releases', 'New Releases'),
|
|
('featured_charts', '/api/beatport/featured-charts', 'Featured Charts'),
|
|
('dj_charts', '/api/beatport/dj-charts', 'DJ Charts'),
|
|
('top_10_lists', '/api/beatport/homepage/top-10-lists', 'Top 10 Lists'),
|
|
('top_10_releases', '/api/beatport/homepage/top-10-releases-cards', 'Top 10 Releases'),
|
|
('hype_picks', '/api/beatport/hype-picks', 'Hype Picks'),
|
|
)
|
|
|
|
|
|
def auto_refresh_beatport_cache(config: Dict[str, Any], deps: AutomationDeps) -> Dict[str, Any]:
|
|
"""Refresh Beatport homepage cache by calling each endpoint internally
|
|
via Flask's ``test_client``. Invalidates the homepage cache first
|
|
so endpoints re-scrape rather than returning stale data."""
|
|
automation_id = config.get('_automation_id')
|
|
cache = deps.get_beatport_data_cache()
|
|
# Invalidate all homepage cache timestamps so endpoints re-scrape.
|
|
with cache['cache_lock']:
|
|
for key in cache['homepage']:
|
|
cache['homepage'][key]['timestamp'] = 0
|
|
cache['homepage'][key]['data'] = None
|
|
|
|
refreshed = 0
|
|
errors = []
|
|
app = deps.get_app()
|
|
with app.test_client() as client:
|
|
for idx, (_, endpoint, label) in enumerate(_BEATPORT_SECTIONS):
|
|
deps.update_progress(
|
|
automation_id,
|
|
progress=(idx / len(_BEATPORT_SECTIONS)) * 100,
|
|
phase=f'Scraping: {label}',
|
|
current_item=label,
|
|
)
|
|
try:
|
|
resp = client.get(endpoint)
|
|
if resp.status_code == 200:
|
|
refreshed += 1
|
|
deps.update_progress(
|
|
automation_id, log_line=f'{label}: cached', log_type='success',
|
|
)
|
|
else:
|
|
errors.append(label)
|
|
deps.update_progress(
|
|
automation_id,
|
|
log_line=f'{label}: HTTP {resp.status_code}',
|
|
log_type='error',
|
|
)
|
|
except Exception as e: # noqa: BLE001 — per-section best-effort
|
|
errors.append(label)
|
|
deps.update_progress(
|
|
automation_id,
|
|
log_line=f'{label}: {str(e)}',
|
|
log_type='error',
|
|
)
|
|
if idx < len(_BEATPORT_SECTIONS) - 1:
|
|
time.sleep(2)
|
|
|
|
deps.update_progress(
|
|
automation_id, status='finished', progress=100,
|
|
phase='Complete',
|
|
log_line=f'Refreshed {refreshed}/{len(_BEATPORT_SECTIONS)} sections',
|
|
log_type='success',
|
|
)
|
|
return {
|
|
'status': 'completed',
|
|
'refreshed': str(refreshed),
|
|
'errors': str(len(errors)),
|
|
'_manages_own_progress': True,
|
|
}
|