Bryan Van Deusen
288 lines
10 KiB
Python
288 lines
10 KiB
Python
"""Download history API endpoints."""
|
|
|
|
from quart import Blueprint, request, jsonify, current_app
|
|
from sqlalchemy import select, func, and_
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy.orm import selectinload
|
|
|
|
from app.models.base import utcnow
|
|
from app.models.download import Download, DownloadStatus
|
|
from app.models.source import Source
|
|
from app.tasks.downloads import process_download
|
|
|
|
bp = Blueprint("downloads", __name__)
|
|
|
|
|
|
@bp.route("", methods=["GET"])
|
|
async def list_downloads():
|
|
"""List download history with filtering and pagination."""
|
|
# Query parameters
|
|
source_id = request.args.get("source_id", type=int)
|
|
status = request.args.get("status")
|
|
from_date = request.args.get("from_date")
|
|
to_date = request.args.get("to_date")
|
|
page = int(request.args.get("page", 1))
|
|
per_page = min(int(request.args.get("per_page", 50)), 100)
|
|
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
# Build query
|
|
query = select(Download)
|
|
count_query = select(func.count()).select_from(Download)
|
|
|
|
filters = []
|
|
if source_id:
|
|
filters.append(Download.source_id == source_id)
|
|
if status:
|
|
filters.append(Download.status == status)
|
|
if from_date:
|
|
filters.append(Download.created_at >= datetime.fromisoformat(from_date))
|
|
if to_date:
|
|
filters.append(Download.created_at <= datetime.fromisoformat(to_date))
|
|
|
|
if filters:
|
|
query = query.where(and_(*filters))
|
|
count_query = count_query.where(and_(*filters))
|
|
|
|
# Get total count
|
|
total_result = await session.execute(count_query)
|
|
total = total_result.scalar()
|
|
|
|
# Apply pagination and ordering
|
|
query = query.order_by(Download.created_at.desc())
|
|
query = query.offset((page - 1) * per_page).limit(per_page)
|
|
|
|
result = await session.execute(query)
|
|
downloads = result.scalars().all()
|
|
|
|
return jsonify({
|
|
"items": [d.to_dict() for d in downloads],
|
|
"total": total,
|
|
"page": page,
|
|
"per_page": per_page,
|
|
"pages": (total + per_page - 1) // per_page,
|
|
})
|
|
|
|
|
|
@bp.route("/<int:download_id>", methods=["GET"])
|
|
async def get_download(download_id: int):
|
|
"""Get download details."""
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
result = await session.execute(select(Download).where(Download.id == download_id))
|
|
download = result.scalar()
|
|
|
|
if not download:
|
|
return jsonify({"error": "Download not found"}), 404
|
|
|
|
# Include source info if available
|
|
response = download.to_dict()
|
|
if download.source_id:
|
|
source_result = await session.execute(
|
|
select(Source)
|
|
.options(selectinload(Source.subscription))
|
|
.where(Source.id == download.source_id)
|
|
)
|
|
source = source_result.scalar()
|
|
if source:
|
|
response["source"] = {
|
|
"id": source.id,
|
|
"subscription_name": source.subscription.name if source.subscription else None,
|
|
"platform": source.platform,
|
|
}
|
|
|
|
return jsonify(response)
|
|
|
|
|
|
@bp.route("/<int:download_id>/retry", methods=["POST"])
|
|
async def retry_download(download_id: int):
|
|
"""Retry a failed download."""
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
result = await session.execute(select(Download).where(Download.id == download_id))
|
|
download = result.scalar()
|
|
|
|
if not download:
|
|
return jsonify({"error": "Download not found"}), 404
|
|
|
|
if download.status != DownloadStatus.FAILED:
|
|
return jsonify({"error": "Can only retry failed downloads"}), 400
|
|
|
|
# Reset status to queued
|
|
download.status = DownloadStatus.QUEUED
|
|
download.error_type = None
|
|
download.error_message = None
|
|
await session.commit()
|
|
|
|
# Queue Celery task to retry the download
|
|
task = process_download.delay(download_id)
|
|
|
|
current_app.logger.info(f"Queued retry for download: {download_id}")
|
|
return jsonify({
|
|
"message": "Retry queued",
|
|
"download_id": download_id,
|
|
"task_id": task.id,
|
|
}), 202
|
|
|
|
|
|
@bp.route("/recent-activity", methods=["GET"])
|
|
async def recent_activity():
|
|
"""Get recent noteworthy downloads: failures and completions with new files.
|
|
|
|
These are downloads that warrant user attention, not routine "no new content" runs.
|
|
Results are limited to the last 7 days by default.
|
|
"""
|
|
limit = min(int(request.args.get("limit", 10)), 50)
|
|
days = int(request.args.get("days", 7))
|
|
|
|
from datetime import timedelta
|
|
cutoff = utcnow() - timedelta(days=days)
|
|
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
# Get failed downloads OR completed with files (noteworthy activity)
|
|
from sqlalchemy import or_
|
|
query = select(Download).where(
|
|
and_(
|
|
Download.created_at >= cutoff,
|
|
or_(
|
|
Download.status == DownloadStatus.FAILED,
|
|
and_(
|
|
Download.status == DownloadStatus.COMPLETED,
|
|
Download.file_count > 0
|
|
)
|
|
)
|
|
)
|
|
).order_by(Download.created_at.desc()).limit(limit)
|
|
|
|
result = await session.execute(query)
|
|
downloads = result.scalars().all()
|
|
|
|
return jsonify({
|
|
"items": [d.to_dict() for d in downloads],
|
|
"count": len(downloads),
|
|
})
|
|
|
|
|
|
@bp.route("/reset-orphaned", methods=["POST"])
|
|
async def reset_orphaned_downloads():
|
|
"""Reset orphaned running downloads back to queued.
|
|
|
|
Jobs can get stuck in 'running' status if the worker crashes.
|
|
This endpoint resets them so they can be retried.
|
|
"""
|
|
from app.tasks.maintenance import reset_orphaned_jobs
|
|
|
|
# Allow specifying threshold, default to 0 to reset ALL running jobs
|
|
data = await request.get_json() or {}
|
|
threshold_minutes = data.get("threshold_minutes", 0) # 0 = reset all running
|
|
|
|
try:
|
|
if threshold_minutes == 0:
|
|
# Reset all running jobs immediately (synchronous for immediate feedback)
|
|
from app.tasks.maintenance import _reset_all_running_jobs_async
|
|
import asyncio
|
|
|
|
# Run in the current event loop
|
|
result = await _reset_all_running_jobs_async()
|
|
current_app.logger.info(f"Manual reset of running jobs: {result}")
|
|
return jsonify({
|
|
"message": f"Reset {result['reset_count']} orphaned running jobs",
|
|
"reset_count": result['reset_count'],
|
|
})
|
|
else:
|
|
# Queue the task for threshold-based reset
|
|
task = reset_orphaned_jobs.delay(threshold_minutes)
|
|
return jsonify({
|
|
"message": "Orphaned job reset queued",
|
|
"task_id": task.id,
|
|
"threshold_minutes": threshold_minutes,
|
|
}), 202
|
|
except Exception as e:
|
|
current_app.logger.error(f"Failed to reset orphaned jobs: {e}")
|
|
return jsonify({"error": str(e)}), 500
|
|
|
|
|
|
@bp.route("/requeue-stale", methods=["POST"])
|
|
async def requeue_stale_downloads():
|
|
"""Re-queue Celery tasks for downloads stuck in 'queued' status.
|
|
|
|
Downloads can get stuck in 'queued' database status if the Celery task
|
|
was lost (e.g., sent to wrong Redis DB, Redis restart, etc.).
|
|
This endpoint re-sends the Celery tasks for those jobs.
|
|
"""
|
|
from app.tasks.maintenance import requeue_stale_jobs, _requeue_all_queued_jobs_async
|
|
|
|
data = await request.get_json() or {}
|
|
threshold_minutes = data.get("threshold_minutes", 0) # 0 = re-queue ALL queued jobs
|
|
|
|
try:
|
|
if threshold_minutes == 0:
|
|
# Re-queue all queued jobs immediately (synchronous for immediate feedback)
|
|
result = await _requeue_all_queued_jobs_async()
|
|
current_app.logger.info(f"Manual re-queue of all queued jobs: {result}")
|
|
return jsonify({
|
|
"message": f"Re-queued {result['requeued_count']} queued jobs",
|
|
"requeued_count": result['requeued_count'],
|
|
})
|
|
else:
|
|
# Queue the task for threshold-based re-queue
|
|
task = requeue_stale_jobs.delay(threshold_minutes)
|
|
return jsonify({
|
|
"message": "Stale job re-queue queued",
|
|
"task_id": task.id,
|
|
"threshold_minutes": threshold_minutes,
|
|
}), 202
|
|
except Exception as e:
|
|
current_app.logger.error(f"Failed to re-queue stale jobs: {e}")
|
|
return jsonify({"error": str(e)}), 500
|
|
|
|
|
|
@bp.route("/stats", methods=["GET"])
|
|
async def get_stats():
|
|
"""Get download statistics."""
|
|
period = request.args.get("period", "week") # day, week, month
|
|
|
|
async with current_app.db_engine.connect() as conn:
|
|
session = AsyncSession(bind=conn)
|
|
|
|
# Total counts by status
|
|
status_query = select(
|
|
Download.status,
|
|
func.count(Download.id)
|
|
).group_by(Download.status)
|
|
|
|
status_result = await session.execute(status_query)
|
|
status_counts = {row[0]: row[1] for row in status_result}
|
|
|
|
# Counts by platform (through source)
|
|
platform_query = select(
|
|
Source.platform,
|
|
func.count(Download.id)
|
|
).join(Source, Download.source_id == Source.id).group_by(Source.platform)
|
|
|
|
platform_result = await session.execute(platform_query)
|
|
platform_counts = {row[0]: row[1] for row in platform_result}
|
|
|
|
# Recent downloads count
|
|
recent_query = select(func.count()).select_from(Download).where(
|
|
Download.status == DownloadStatus.COMPLETED
|
|
)
|
|
recent_result = await session.execute(recent_query)
|
|
recent_completed = recent_result.scalar()
|
|
|
|
return jsonify({
|
|
"total": sum(status_counts.values()),
|
|
"by_status": status_counts,
|
|
"by_platform": platform_counts,
|
|
"completed": status_counts.get(DownloadStatus.COMPLETED, 0),
|
|
"failed": status_counts.get(DownloadStatus.FAILED, 0),
|
|
"pending": status_counts.get(DownloadStatus.PENDING, 0),
|
|
"queued": status_counts.get(DownloadStatus.QUEUED, 0),
|
|
"running": status_counts.get(DownloadStatus.RUNNING, 0),
|
|
})
|