diff --git a/CHANGELOG.md b/CHANGELOG.md index 49fa1f504..4375c031e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ All notable changes to Bambuddy will be documented in this file. ## [1.2.6b1] - Unreleased ### Added +- **Printer file downloads can be selected in ranges and print-history videos can be downloaded (#2850)** — The printer file browser's multi-select download now prepares large selections on the app data volume instead of buffering them in server and browser memory, uses per-file compression (videos stored, G-code/3MF compressed), reports partial results and preparation progress, supports cancellation, rejects over-large or under-space selections, and preserves the legacy API contract. Shift-click selects a contiguous visible range and hidden selections are discarded when navigating or filtering. Print History now offers attached timelapses, matching printer timelapses, and `/ipcam` chunks when available; offline or unreadable storage is distinguished from an empty directory. Download tokens are single-use and resource-bound, API-key printer allowlists are enforced, FTP short reads are rejected, and abandoned staging is pruned. Translated in all locales; wiki updated. Covered by backend and frontend regression tests. - **Bambuddy now asks a printer that refuses FTPS what it actually said (#2780, measured by @grolmus)** — When a printer's file service answers port 990 with something that is not TLS, Python reports `[SSL: WRONG_VERSION_NUMBER]` and the bytes that caused it are gone, consumed by the TLS layer before the error surfaces. That has left #2780 open on a theory rather than a finding. The client now opens one plain connection straight afterwards and reads what the printer says, so the log carries the printer's own words — an FTP refusal such as `421 Too many connections` would identify the fault outright — and the line is marked as the one to quote in a report. Reading nothing is informative too, and says so: a healthy implicit-FTPS service stays silent until it gets a handshake, so silence means the refusal had already passed. It asks once per cool-off window rather than once per attempt, which keeps it to one extra connection per printer per five minutes — the suspected fault is a printer running out of connections, so the diagnosis must not add to it. What made this worth doing is a measurement from a nine-printer farm, reproduced here: a cleartext banner on the TLS port produces exactly the error the field reports, a genuine TLS version mismatch produces a different one, and a client with no version cap reaches a TLS-1.2-only peer unaided. So this failure was never a TLS-version problem, and the per-model `cap_tls_v1_2` knob cannot affect it. Two of the three entries carrying that knob were added on the belief that it could; they are kept, since their reporters saw the symptom clear and nobody here has the hardware to re-test on, but they are now marked for re-test and the reasoning recorded next to them is what was measured rather than what was assumed. Both measurements are pinned by tests, so the explanation stays falsifiable. - **The K value is on the AMS slot itself, not only in the popover (#2532, requested and contributed by @gyrene2083)** — Reading back a slot's pressure-advance value meant hovering it: the K factor lived in the filament popover alone, so checking whether a calibration had actually taken across four slots was four hovers, and comparing two of them side by side was not possible at all. Every slot card now carries the value under the material name, the way Bambu Studio shows it per slot — on regular AMS units, on AMS-HT, and on the external spool of a dual-nozzle machine. Only a value the printer actually reported is shown: a loaded but never-calibrated slot stays blank rather than inheriting the 0.020 that fills the popover's own field, and a slot the firmware reports as exactly 0 counts as uncalibrated the same way the stored K-profiles do. The label is shortened to **K** with the full localized name on hover, because "K Factor", "K-Faktor" and "Facteur K" ate the value itself — the whole point of the line — on cards under about 350px, and the figure is set in tabular numerals so it measures the same in Safari as in Chromium. Where one slot of a unit is calibrated and its neighbours are not, the neighbours hold the same row open so the fill bars stay level across the card. diff --git a/backend/app/api/routes/archives.py b/backend/app/api/routes/archives.py index 539b75634..f5dcc16b6 100644 --- a/backend/app/api/routes/archives.py +++ b/backend/app/api/routes/archives.py @@ -1,3 +1,4 @@ +import asyncio import io import json import logging @@ -13,27 +14,35 @@ from fastapi.responses import FileResponse, Response from sqlalchemy import and_, case, func, or_, select from sqlalchemy.ext.asyncio import AsyncSession +from backend.app.core import database from backend.app.core.auth import ( RequireCameraStreamTokenIfAuthEnabled, RequirePermissionIfAuthEnabled, + check_printer_access, + current_api_key_if_present, + probe_permissions_if_auth_enabled, require_ownership_permission, ) from backend.app.core.config import settings from backend.app.core.database import get_db from backend.app.core.permissions import Permission +from backend.app.models.api_key import APIKey from backend.app.models.archive import PrintArchive from backend.app.models.filament import Filament +from backend.app.models.printer import Printer from backend.app.models.spool_usage_history import SpoolUsageHistory from backend.app.models.user import User from backend.app.schemas.archive import ArchiveResponse, ArchiveSlim, ArchiveStats, ArchiveUpdate from backend.app.schemas.print_log import PrintLogResponse from backend.app.schemas.slicer import SliceRequest from backend.app.services.archive import ArchiveService +from backend.app.services.bambu_ftp import ftps_handshake_blocked, list_files_result_async from backend.app.services.design_settings import overrides_from_config from backend.app.services.filament_requirements import annotate_rack_groups from backend.app.services.print_storage import REASON_INTERNAL_STORAGE, REASON_NO_EXTERNAL_STORAGE +from backend.app.services.printer_media import VIDEO_SUFFIXES, match_ipcam_chunks from backend.app.utils.archive_paths import archive_photos_dir, find_archive_photo -from backend.app.utils.http import build_content_disposition +from backend.app.utils.http import build_content_disposition, download_error_response, safe_download_filename from backend.app.utils.threemf_tools import ( default_plate_gcode_name, expand_to_project_slots, @@ -46,6 +55,7 @@ from backend.app.utils.threemf_tools import ( logger = logging.getLogger(__name__) router = APIRouter(prefix="/archives", tags=["archives"]) +_PRINTER_MEDIA_LIST_TIMEOUT_SECONDS = 8.0 # Path of the embedded slicer config inside a BambuStudio/OrcaSlicer 3MF. _PROJECT_SETTINGS_PATH = "Metadata/project_settings.config" @@ -2293,6 +2303,203 @@ async def get_thumbnail( ) +@router.get("/{archive_id}/printer-media") +async def get_archive_printer_media( + archive_id: int, + auth_result: tuple[User | None, bool] = Depends( + require_ownership_permission( + Permission.ARCHIVES_READ_ALL, + Permission.ARCHIVES_READ_OWN, + ) + ), + can_list_printer_files: bool = Depends(probe_permissions_if_auth_enabled(Permission.PRINTERS_FILES)), + api_key: APIKey | None = Depends(current_api_key_if_present), +): + """Find downloadable timelapse and `/ipcam` files for one print. + + Local attached timelapses are returned without touching the printer. + Printer directories are listed only when the caller also has + ``printers:files``; otherwise the local result is returned with a warning. + Files are downloaded only after the user explicitly selects them in the UI. + """ + + user, can_read_all = auth_result + async with database.async_session() as db: + archive = _ensure_archive_visible(await ArchiveService(db).get_archive(archive_id), user, can_read_all) + printer = None + claimed_timelapse_stems: set[str] = set() + if archive.printer_id is not None: + printer = (await db.execute(select(Printer).where(Printer.id == archive.printer_id))).scalar_one_or_none() + if printer is not None and archive.timelapse_path is None: + claimed_timelapse_stems = await _claimed_timelapse_stems(db, archive.printer_id, archive_id) + + local_timelapse = None + if archive.timelapse_path: + local_path = settings.base_dir / archive.timelapse_path + if await asyncio.to_thread(local_path.is_file): + local_timelapse = { + "name": local_path.name, + "size": (await asyncio.to_thread(local_path.stat)).st_size, + } + + response = { + "archive_id": archive.id, + "printer_id": archive.printer_id, + "local_timelapse": local_timelapse, + "remote_files": [], + "warnings": [], + } + if archive.printer_id is None or archive.started_at is None: + return response + if not can_list_printer_files: + response["warnings"].append("printer_files_forbidden") + return response + + if printer is None: + response["warnings"].append("printer_missing") + return response + if api_key is not None: + check_printer_access(api_key, printer.id) + + if ftps_handshake_blocked(printer.ip_address): + if local_timelapse is None: + response["warnings"].append("timelapse_unavailable") + response["warnings"].append("ipcam_unavailable") + return response + + remote_files: list[dict] = [] + + # If no copy was attached to the archive, offer the matching printer-side + # timelapse without mutating the archive or deleting anything from the SD. + if local_timelapse is None: + videos: list[dict] = [] + any_timelapse_directory_available = False + for timelapse_dir in ("/timelapse", "/timelapse/video", "/record", "/recording"): + if ftps_handshake_blocked(printer.ip_address): + break + listing = await list_files_result_async( + printer.ip_address, + printer.access_code, + timelapse_dir, + timeout=_PRINTER_MEDIA_LIST_TIMEOUT_SECONDS, + printer_model=printer.model, + ) + any_timelapse_directory_available |= listing.available + candidates = [ + file + for file in listing.files + if not file.get("is_directory") and str(file.get("name") or "").lower().endswith(VIDEO_SUFFIXES) + ] + if candidates: + videos = candidates + break + if not any_timelapse_directory_available: + response["warnings"].append("timelapse_unavailable") + if videos: + baseline = set(archive.timelapse_baseline or []) + eligible = [ + file + for file in videos + if str(file.get("name") or "") not in baseline + and Path(str(file.get("name") or "")).stem not in claimed_timelapse_stems + ] + if archive.timelapse_baseline is not None: + candidate = eligible[0] if len(eligible) == 1 else None + else: + candidate, _ = _match_timelapse_by_timestamp(eligible, archive.started_at) + if candidate is not None: + remote_files.append( + { + "name": candidate.get("name"), + "path": candidate.get("path"), + "size": candidate.get("size") or 0, + "mtime": candidate.get("mtime"), + "kind": "timelapse", + } + ) + + if ftps_handshake_blocked(printer.ip_address): + response["warnings"].append("ipcam_unavailable") + response["remote_files"] = remote_files + return response + + ipcam_listing = await list_files_result_async( + printer.ip_address, + printer.access_code, + "/ipcam", + timeout=_PRINTER_MEDIA_LIST_TIMEOUT_SECONDS, + printer_model=printer.model, + ) + if ipcam_listing.available: + for file in match_ipcam_chunks(ipcam_listing.files, archive.started_at, archive.completed_at): + remote_files.append( + { + "name": file.get("name"), + "path": file.get("path") or f"/ipcam/{file.get('name')}", + "size": file.get("size") or 0, + "mtime": file.get("mtime"), + "kind": "ipcam", + } + ) + else: + response["warnings"].append("ipcam_unavailable") + + response["remote_files"] = remote_files + return response + + +@router.post("/{archive_id}/media-download-token") +async def create_archive_media_download_token( + archive_id: int, + auth_result: tuple[User | None, bool] = Depends( + require_ownership_permission(Permission.ARCHIVES_READ_ALL, Permission.ARCHIVES_READ_OWN) + ), +): + """Mint a single-use token bound to an archive's attached timelapse.""" + + from backend.app.core.auth import create_slicer_download_token + + user, can_read_all = auth_result + async with database.async_session() as db: + archive = _ensure_archive_visible(await ArchiveService(db).get_archive(archive_id), user, can_read_all) + if not archive.timelapse_path: + raise HTTPException(404, "Timelapse not found") + timelapse_path = settings.base_dir / archive.timelapse_path + if not await asyncio.to_thread(timelapse_path.is_file): + raise HTTPException(404, "Timelapse file not found") + return { + "token": await create_slicer_download_token("archive-timelapse", archive_id), + "filename": timelapse_path.name, + } + + +@router.get("/{archive_id}/media/dl/{token}/{filename}") +async def download_archive_media_with_token( + archive_id: int, + token: str, + filename: str, +): + """Consume a resource-bound token and stream an attached timelapse.""" + + from backend.app.core.auth import verify_slicer_download_token + + if not await verify_slicer_download_token(token, "archive-timelapse", archive_id): + return download_error_response(403, "This download link has already been used or has expired.") + async with database.async_session() as db: + archive = await ArchiveService(db).get_archive(archive_id) + if not archive or not archive.timelapse_path: + return download_error_response(404, "This print has no attached timelapse.") + timelapse_path = settings.base_dir / archive.timelapse_path + if not await asyncio.to_thread(timelapse_path.is_file): + return download_error_response(404, "The attached timelapse is no longer on disk.") + safe_filename = safe_download_filename(filename, fallback=timelapse_path.name) + return FileResponse( + path=timelapse_path, + filename=safe_filename, + headers={"Content-Disposition": build_content_disposition(safe_filename)}, + ) + + @router.get("/{archive_id}/timelapse") async def get_timelapse( archive_id: int, diff --git a/backend/app/api/routes/printers.py b/backend/app/api/routes/printers.py index ff3e460f6..d04ea28ef 100644 --- a/backend/app/api/routes/printers.py +++ b/backend/app/api/routes/printers.py @@ -1,19 +1,22 @@ import asyncio import logging import re +import secrets import zipfile from pathlib import Path from fastapi import APIRouter, Depends, HTTPException, Query -from fastapi.responses import Response +from fastapi.responses import FileResponse, Response from sqlalchemy import func, select from sqlalchemy.ext.asyncio import AsyncSession +from starlette.background import BackgroundTask from backend.app.core import database from backend.app.core.auth import ( RequireCameraStreamTokenIfAuthEnabled, RequireOverlayTokenIfAuthEnabled, RequirePermissionIfAuthEnabled, + RequirePrinterPermissionIfAuthEnabled, is_auth_enabled, ) from backend.app.core.config import settings @@ -36,6 +39,8 @@ from backend.app.schemas.printer import ( NozzleRackSlot, PrinterCreate, PrinterDiagnosticResult, + PrinterFilesDownloadRequest, + PrinterFilesJobRequest, PrinterResponse, PrinterResponseWithSecret, PrinterStatus, @@ -51,7 +56,7 @@ from backend.app.services.bambu_ftp import ( ftps_handshake_blocked, get_cached_3mf, get_storage_info_async, - list_files_async, + list_files_result_async, ) from backend.app.services.print_storage import ftp_probe_paths, print_file_reachable_over_ftp from backend.app.services.printer_diagnostic import run_connection_diagnostic @@ -68,10 +73,23 @@ from backend.app.services.printer_manager import ( supports_drying_while_printing, uniform_tray_filament_hint, ) +from backend.app.services.printer_media import ( + MAX_PRINTER_ZIP_PREPARE_SECONDS, + PrinterFilesZipInsufficientSpaceError, + PrinterFilesZipTooLargeError, + build_printer_file, + build_printer_files_zip, + cancel_printer_files_job, + get_printer_files_job, + printer_file_path, + printer_files_zip_path, + remove_printer_files_zip, + start_printer_files_job, +) from backend.app.utils.filament_ids import filament_id_to_setting_id from backend.app.utils.filament_types import printer_filament_type from backend.app.utils.fts_routing import slot_extruder -from backend.app.utils.http import build_content_disposition +from backend.app.utils.http import build_content_disposition, download_error_response, safe_download_filename from backend.app.utils.printer_models import MAX_CHAMBER_TEMP_C, uses_exhaust_fan_label logger = logging.getLogger(__name__) @@ -1553,12 +1571,18 @@ async def _load_printer_or_404(printer_id: int) -> Printer: async def list_printer_files( printer_id: int, path: str = "/", - _=RequirePermissionIfAuthEnabled(Permission.PRINTERS_FILES), + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), ): """List files on the printer at the specified path.""" printer = await _load_printer_or_404(printer_id) - files = await list_files_async(printer.ip_address, printer.access_code, path, printer_model=printer.model) + listing = await list_files_result_async( + printer.ip_address, + printer.access_code, + path, + printer_model=printer.model, + ) + files = listing.files # Add full path to each file for f in files: @@ -1567,6 +1591,7 @@ async def list_printer_files( return { "path": path, "files": files, + "warnings": [] if listing.available else ["printer_unavailable"], } @@ -1574,14 +1599,27 @@ async def list_printer_files( async def download_printer_file( printer_id: int, path: str, - _=RequirePermissionIfAuthEnabled(Permission.PRINTERS_FILES), + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), ): """Download a file from the printer.""" printer = await _load_printer_or_404(printer_id) - data = await download_file_bytes_async(printer.ip_address, printer.access_code, path, printer_model=printer.model) - if data is None: + try: + async with asyncio.timeout(MAX_PRINTER_ZIP_PREPARE_SECONDS): + result = await build_printer_file( + printer, + path, + None, + bundle_key=f"single-{secrets.token_urlsafe(18)}", + ) + except PrinterFilesZipTooLargeError as exc: + raise HTTPException(413, str(exc)) from exc + except PrinterFilesZipInsufficientSpaceError as exc: + raise HTTPException(507, str(exc)) from exc + except FileNotFoundError: raise HTTPException(404, f"File not found: {path}") + except TimeoutError as exc: + raise HTTPException(504, "Printer download exceeded the 30-minute limit") from exc # Determine content type based on extension filename = path.split("/")[-1] @@ -1600,10 +1638,12 @@ async def download_printer_file( } content_type = content_types.get(ext, "application/octet-stream") - return Response( - content=data, + return FileResponse( + path=result.path, + filename=filename, media_type=content_type, headers={"Content-Disposition": build_content_disposition(filename)}, + background=BackgroundTask(remove_printer_files_zip, result.path), ) @@ -1611,7 +1651,7 @@ async def download_printer_file( async def get_printer_file_gcode( printer_id: int, path: str, - _=RequirePermissionIfAuthEnabled(Permission.PRINTERS_FILES), + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), ): """Get gcode for a file stored on a printer (for preview).""" import io @@ -1645,7 +1685,7 @@ async def get_printer_file_gcode( async def get_printer_file_plates( printer_id: int, path: str = Query(..., description="Full path to the 3MF file on the printer"), - _=RequirePermissionIfAuthEnabled(Permission.PRINTERS_FILES), + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), ): """Get available plates from a multi-plate 3MF file stored on a printer.""" import io @@ -1885,7 +1925,7 @@ async def get_printer_file_plate_thumbnail( printer_id: int, plate_index: int, path: str = Query(..., description="Full path to the 3MF file on the printer"), - _=RequirePermissionIfAuthEnabled(Permission.PRINTERS_FILES), + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), ): """Get a plate thumbnail image from a printer-stored 3MF file.""" import io @@ -1911,43 +1951,133 @@ async def get_printer_file_plate_thumbnail( @router.post("/{printer_id}/files/download-zip") async def download_printer_files_as_zip( printer_id: int, - request: dict, - _=RequirePermissionIfAuthEnabled(Permission.PRINTERS_FILES), + request: PrinterFilesDownloadRequest, + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), ): - """Download multiple files from the printer as a ZIP archive.""" - import io + """Download multiple files using a disk-backed ZIP. - paths = request.get("paths", []) - if not paths: + Kept backward-compatible for API clients: relative paths are rooted, + duplicate paths receive collision-safe names, and an all-failed request + returns an empty ZIP as the historical endpoint did. The browser uses the + asynchronous preparation endpoints below. + """ + if not request.paths: raise HTTPException(400, "No files specified") - printer = await _load_printer_or_404(printer_id) - - # Create ZIP in memory - zip_buffer = io.BytesIO() - with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf: - for path in paths: - try: - data = await download_file_bytes_async( - printer.ip_address, printer.access_code, path, printer_model=printer.model - ) - if data: - filename = path.split("/")[-1] - zf.writestr(filename, data) - except Exception as e: - logging.warning("Failed to add %s to ZIP: %s", path, e) - continue - - zip_buffer.seek(0) - zip_data = zip_buffer.read() - - if len(zip_data) == 0: - raise HTTPException(404, "No files could be downloaded") - - return Response( - content=zip_data, + normalized_paths = [path if path.startswith("/") else f"/{path}" for path in request.paths] + normalized_sizes = {path if path.startswith("/") else f"/{path}": size for path, size in request.sizes.items()} + try: + async with asyncio.timeout(MAX_PRINTER_ZIP_PREPARE_SECONDS): + result = await build_printer_files_zip( + printer, + normalized_paths, + normalized_sizes, + preserve_paths=False, + allow_empty=True, + ) + except PrinterFilesZipTooLargeError as exc: + raise HTTPException(413, str(exc)) from exc + except PrinterFilesZipInsufficientSpaceError as exc: + raise HTTPException(507, str(exc)) from exc + except TimeoutError as exc: + raise HTTPException(504, "Printer ZIP preparation exceeded the 30-minute limit") from exc + return FileResponse( + path=result.path, + filename="printer-files.zip", media_type="application/zip", - headers={"Content-Disposition": 'attachment; filename="printer-files.zip"'}, + headers={ + "X-Bambuddy-Files-Requested": str(result.requested), + "X-Bambuddy-Files-Downloaded": str(result.successful), + "X-Bambuddy-Files-Failed": str(len(result.failed_paths)), + }, + background=BackgroundTask(remove_printer_files_zip, result.path), + ) + + +@router.post("/{printer_id}/files/download-job") +async def create_printer_files_download_job( + printer_id: int, + request: PrinterFilesJobRequest, + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), +): + """Start a cancellable disk-backed preparation without holding the request.""" + + if not request.paths: + raise HTTPException(400, "No files specified") + if len(set(request.paths)) != len(request.paths): + raise HTTPException(400, "Selected printer paths must be unique") + if not request.as_zip and len(request.paths) != 1: + raise HTTPException(400, "Native downloads require exactly one file") + printer = await _load_printer_or_404(printer_id) + try: + status = await start_printer_files_job( + printer, + request.paths, + request.sizes, + request.filename, + as_zip=request.as_zip, + ) + except PrinterFilesZipTooLargeError as exc: + raise HTTPException(413, str(exc)) from exc + except PrinterFilesZipInsufficientSpaceError as exc: + raise HTTPException(507, str(exc)) from exc + except ValueError as exc: + raise HTTPException(400, str(exc)) from exc + return status.__dict__ + + +@router.get("/{printer_id}/files/download-jobs/{job_id}") +async def get_printer_files_download_job( + printer_id: int, + job_id: str, + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), +): + status = await get_printer_files_job(job_id, printer_id) + if status is None: + raise HTTPException(404, "Printer download job not found") + return status.__dict__ + + +@router.delete("/{printer_id}/files/download-jobs/{job_id}") +async def cancel_printer_files_download_job( + printer_id: int, + job_id: str, + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), +): + if not await cancel_printer_files_job(job_id, printer_id): + raise HTTPException(404, "Printer download job not found") + return {"status": "cancelled"} + + +@router.get("/{printer_id}/files/dl/{token}/{filename}") +async def download_prepared_printer_files( + printer_id: int, + token: str, + filename: str, +): + """Consume a resource-bound token and stream a prepared file natively.""" + + from backend.app.core.auth import verify_slicer_download_token + + if not await verify_slicer_download_token(token, "printer-files", printer_id): + return download_error_response(403, "This download link has already been used or has expired.") + zip_path = printer_files_zip_path(printer_id, token) + raw_path = printer_file_path(printer_id, token) + if zip_path is not None and await asyncio.to_thread(zip_path.is_file): + prepared_path = zip_path + media_type = "application/zip" + elif raw_path is not None and await asyncio.to_thread(raw_path.is_file): + prepared_path = raw_path + media_type = "application/octet-stream" + else: + return download_error_response(404, "The prepared download is no longer on the server.") + safe_filename = safe_download_filename(filename, fallback="printer-download") + return FileResponse( + path=prepared_path, + filename=safe_filename, + media_type=media_type, + headers={"Content-Disposition": build_content_disposition(safe_filename)}, + background=BackgroundTask(remove_printer_files_zip, prepared_path), ) @@ -1955,7 +2085,7 @@ async def download_printer_files_as_zip( async def delete_printer_file( printer_id: int, path: str, - _=RequirePermissionIfAuthEnabled(Permission.PRINTERS_FILES), + _=RequirePrinterPermissionIfAuthEnabled(Permission.PRINTERS_FILES), ): """Delete a file from the printer.""" printer = await _load_printer_or_404(printer_id) diff --git a/backend/app/core/auth.py b/backend/app/core/auth.py index c9e3616f0..53f41ccf8 100644 --- a/backend/app/core/auth.py +++ b/backend/app/core/auth.py @@ -4,6 +4,7 @@ import logging import os import secrets import time +from contextvars import ContextVar from datetime import datetime, timedelta, timezone from typing import Annotated @@ -1129,6 +1130,15 @@ async def _user_from_api_key(db: AsyncSession, api_key: APIKey) -> User | None: return user +# The row a successful validation produced for the request in flight. Printer- +# scoped routes validate the same credential twice -- once in the permission +# gate, once for the key's printer allowlist -- and a validation is a pbkdf2 +# verify plus a ``last_used`` write, so the second one is pure cost. Keyed by +# the raw credential so a request carrying two of them can never cross their +# rows, and held in a ContextVar so it cannot outlive the task that set it. +_validated_api_key: ContextVar[tuple[str, APIKey] | None] = ContextVar("_validated_api_key", default=None) + + async def _validate_api_key(db: AsyncSession, api_key_value: str) -> APIKey | None: """Validate an API key and return the APIKey object if valid, None otherwise. @@ -1163,6 +1173,7 @@ async def _validate_api_key(db: AsyncSession, api_key_value: str) -> APIKey | No # Update last_used timestamp api_key.last_used = datetime.now(timezone.utc) await db.commit() + _validated_api_key.set((api_key_value, api_key)) return api_key except Exception as e: # SEC-AUTH-EXC: validation failure returns None; every caller treats None as "invalid key" → 401 (fail-closed) logger.warning("API key validation error: %s", e) @@ -1625,6 +1636,67 @@ def check_printer_access(api_key: APIKey, printer_id: int) -> None: ) +async def validated_api_key_from_request( + credentials: HTTPAuthorizationCredentials | None, + x_api_key: str | None, +) -> APIKey | None: + """Return the validated API key carried by a request, if any. + + Permission dependencies intentionally return ``None`` for API-key callers so + routes do not mistake a key for a user identity. Printer-bound routes still + need the key row to enforce ``printer_ids`` after the normal scope/owner + permission gate has run. This helper recognizes both supported transports. + """ + + candidate = x_api_key + if candidate is None and credentials is not None and credentials.credentials.startswith("bb_"): + candidate = credentials.credentials + if candidate is None: + return None + cached = _validated_api_key.get() + if cached is not None and cached[0] == candidate: + return cached[1] + async with async_session() as db: + api_key = await _validate_api_key(db, candidate) + if api_key is None: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid API key", + headers={"WWW-Authenticate": "Bearer"}, + ) + # Touch the JSON-backed value before detaching the row from the session. + _ = api_key.printer_ids + return api_key + + +async def current_api_key_if_present( + credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(security)] = None, + x_api_key: Annotated[str | None, Header(alias="X-API-Key")] = None, +) -> APIKey | None: + """FastAPI dependency exposing only an authenticated API-key principal.""" + + return await validated_api_key_from_request(credentials, x_api_key) + + +def require_printer_permission_if_auth_enabled(permission: str | Permission): + """Require a permission and enforce an API key's per-printer allowlist.""" + + permission_checker = require_permission_if_auth_enabled(permission) + + async def checker( + printer_id: int, + credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(security)] = None, + x_api_key: Annotated[str | None, Header(alias="X-API-Key")] = None, + ) -> User | None: + user = await permission_checker(credentials=credentials, x_api_key=x_api_key) + api_key = await validated_api_key_from_request(credentials, x_api_key) + if api_key is not None: + check_printer_access(api_key, printer_id) + return user + + return checker + + # Convenience dependencies - these are functions that return Depends objects def RequireAdmin(): """Dependency that requires admin role.""" @@ -1834,6 +1906,37 @@ def RequirePermissionIfAuthEnabled(*permissions: str | Permission): return Depends(require_permission_if_auth_enabled(*permissions)) +def RequirePrinterPermissionIfAuthEnabled(permission: str | Permission): + """Require a permission plus any API-key ``printer_ids`` restriction.""" + + return Depends(require_printer_permission_if_auth_enabled(permission)) + + +def probe_permissions_if_auth_enabled(*permissions: str | Permission): + """Return permission availability while preserving authentication errors. + + This is for endpoints that can return a useful permission-independent + subset. Missing permissions become ``False``; invalid or absent credentials + still retain the normal 401 response from the shared permission checker. + """ + + permission_checker = require_permission_if_auth_enabled(*permissions) + + async def checker( + credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(security)] = None, + x_api_key: Annotated[str | None, Header(alias="X-API-Key")] = None, + ) -> bool: + try: + await permission_checker(credentials, x_api_key) + except HTTPException as exc: + if exc.status_code == status.HTTP_403_FORBIDDEN: + return False + raise + return True + + return checker + + def require_any_permission_if_auth_enabled(*permissions: str | Permission): """Dependency factory that requires AT LEAST ONE of the given permissions when auth is enabled.""" perm_strings = [p.value if isinstance(p, Permission) else p for p in permissions] diff --git a/backend/app/main.py b/backend/app/main.py index 551c22607..876a2555b 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -8091,6 +8091,16 @@ async def lifespan(app: FastAPI): await init_db() + # Browser download tokens expire after five minutes. Remove abandoned + # prepared ZIPs at startup as well as before each new preparation so a + # quiet appliance cannot retain an unusable bundle indefinitely. + try: + from backend.app.services.printer_media import prune_stale_printer_file_bundles + + await prune_stale_printer_file_bundles() + except Exception as exc: + logging.warning("Failed to prune stale printer download bundles: %s", exc) + # After migrations, so the is_env_managed column exists. Never raises -- # a bad BAMBUDDY_OIDC_* value is logged and skipped rather than blocking # startup (see apply_env_oidc_provider). @@ -8507,6 +8517,10 @@ async def lifespan(app: FastAPI): # L-2: Start periodic auth cleanup (stale TOTP + expired revoked JTIs) start_auth_cleanup() + from backend.app.services.printer_media import start_printer_download_cleanup + + start_printer_download_cleanup() + # Event-loop stall watchdog: dumps all thread stacks to stderr if the loop # freezes (#1486 — silent "container hangs after adding a printer" reports). from backend.app.services.loop_watchdog import start_loop_watchdog @@ -8555,6 +8569,9 @@ async def lifespan(app: FastAPI): logging.warning("Failed to shut down camera broadcasters: %s", e) stop_expected_prints_cleanup() stop_auth_cleanup() + from backend.app.services.printer_media import stop_printer_download_cleanup + + await stop_printer_download_cleanup() printer_manager.disconnect_all() await close_spoolman_client() diff --git a/backend/app/schemas/printer.py b/backend/app/schemas/printer.py index 8062dce4b..a24265681 100644 --- a/backend/app/schemas/printer.py +++ b/backend/app/schemas/printer.py @@ -1,6 +1,6 @@ from datetime import datetime -from pydantic import BaseModel, Field, field_validator +from pydantic import BaseModel, Field, field_validator, model_validator from backend.app.utils.printer_models import supports_nozzle_flow_type @@ -445,3 +445,27 @@ class DiagnosticRequest(BaseModel): ip_address: str serial_number: str | None = None access_code: str | None = None + + +class PrinterFilesDownloadRequest(BaseModel): + """Printer paths selected for a bulk download.""" + + paths: list[str] = Field(..., max_length=1000) + sizes: dict[str, int] = Field(default_factory=dict, max_length=1000) + + @model_validator(mode="after") + def _validate_sizes(self): + """Validate optional FTP-reported sizes used for early rejection.""" + + if self.sizes and set(self.sizes) != set(self.paths): + raise ValueError("A size is required for every selected printer path") + if any(size < 0 for size in self.sizes.values()): + raise ValueError("Printer file sizes must not be negative") + return self + + +class PrinterFilesJobRequest(PrinterFilesDownloadRequest): + """Browser preparation request, including native download presentation.""" + + filename: str = Field(default="printer-files.zip", min_length=1, max_length=255) + as_zip: bool = True diff --git a/backend/app/services/bambu_ftp.py b/backend/app/services/bambu_ftp.py index 4855f8793..2c1c7517e 100644 --- a/backend/app/services/bambu_ftp.py +++ b/backend/app/services/bambu_ftp.py @@ -2,6 +2,7 @@ import asyncio import ftplib # nosec B402 import logging import os +import shutil import socket import ssl import threading @@ -73,6 +74,26 @@ class UploadCancelled(Exception): """ +class DownloadCancelled(Exception): + """Raised in an FTP callback to stop a disk-backed download cooperatively.""" + + +class DownloadLimitExceeded(Exception): + """Raised before an FTP callback writes beyond its caller-supplied limit.""" + + +class DownloadInsufficientSpace(Exception): + """Raised before an FTP callback consumes the application's disk reserve.""" + + +@dataclass(frozen=True) +class FileListResult: + """A directory listing that distinguishes empty from unreachable.""" + + files: list[dict] + available: bool + + class DeleteResult(Enum): """Outcome of an FTP delete attempt. @@ -607,7 +628,7 @@ class BambuFTPClient: self._abandon_connection() self._ftp = None - def list_files(self, path: str = "/") -> list[dict]: + def list_files(self, path: str = "/", *, raise_on_error: bool = False) -> list[dict]: """List files in a directory.""" if not self._ftp: return [] @@ -663,6 +684,8 @@ class BambuFTPClient: logger.debug("Listed %s files in %s", len(files), path) except (OSError, ftplib.Error) as e: logger.info("FTP list_files failed for %s: %s", path, e) + if raise_on_error: + raise return files @@ -703,16 +726,60 @@ class BambuFTPClient: return None return data - def download_to_file(self, remote_path: str, local_path: Path) -> bool: - """Download a file from the printer to local filesystem.""" + def download_to_file( + self, + remote_path: str, + local_path: Path, + *, + expected_size: int | None = None, + max_bytes: int | None = None, + cancel_event: threading.Event | None = None, + min_free_bytes: int | None = None, + ) -> bool: + """Download a file with cooperative cancellation and byte bounds.""" if not self._ftp: logger.warning("download_to_file called but FTP not connected") return False try: local_path.parent.mkdir(parents=True, exist_ok=True) + # SIZE is the printer's own current view of the file and is more + # trustworthy than a browser round-tripped listing hint. Some + # firmware does not implement SIZE, so retain expected_size as a + # compatibility fallback when the command is unavailable. + try: + server_size = self._ftp.size(remote_path) + except (OSError, ftplib.Error): + server_size = None + authoritative_size = server_size if server_size is not None and server_size >= 0 else expected_size + if max_bytes is not None and authoritative_size is not None and authoritative_size > max_bytes: + raise DownloadLimitExceeded(remote_path) + if min_free_bytes is not None and authoritative_size is not None: + if shutil.disk_usage(local_path.parent).free < min_free_bytes + authoritative_size: + raise DownloadInsufficientSpace(remote_path) with open(local_path, "wb") as f: - self._ftp.retrbinary(f"RETR {remote_path}", f.write) + written = 0 + # retrbinary hands over 8 KiB at a time, so checking the volume + # on every callback is ~30k statvfs calls per 250 MB chunk for a + # reserve measured in hundreds of megabytes. Sampling every few + # MB cannot overshoot it by more than one interval. + free_check_interval = 8 * 1024 * 1024 + next_free_check = 0 + + def _write(chunk: bytes) -> None: + nonlocal written, next_free_check + if cancel_event is not None and cancel_event.is_set(): + raise DownloadCancelled(remote_path) + if max_bytes is not None and written + len(chunk) > max_bytes: + raise DownloadLimitExceeded(remote_path) + if min_free_bytes is not None and written >= next_free_check: + next_free_check = written + free_check_interval + if shutil.disk_usage(local_path.parent).free < min_free_bytes + free_check_interval: + raise DownloadInsufficientSpace(remote_path) + f.write(chunk) + written += len(chunk) + + self._ftp.retrbinary(f"RETR {remote_path}", _write) f.flush() os.fsync(f.fileno()) file_size = local_path.stat().st_size if local_path.exists() else 0 @@ -721,9 +788,18 @@ class BambuFTPClient: if local_path.exists(): local_path.unlink() return False + if authoritative_size is not None and file_size != authoritative_size: + logger.warning( + "FTP download of %s is short: got %s bytes, listing reported %s — treating as failed", + remote_path, + file_size, + authoritative_size, + ) + local_path.unlink(missing_ok=True) + return False logger.info("Successfully downloaded %s to %s (%s bytes)", remote_path, local_path, file_size) return True - except (OSError, ftplib.Error) as e: + except (OSError, ftplib.Error, DownloadCancelled, DownloadLimitExceeded, DownloadInsufficientSpace) as e: # Clean up partial file if it exists if local_path.exists(): try: @@ -734,6 +810,8 @@ class BambuFTPClient: # with_ftp_retry can abandon this path immediately and the caller # can advance to the next candidate instead of retrying 11× at # 30s intervals (the pattern that cost #972's reporter ~48min). + if isinstance(e, (DownloadCancelled, DownloadLimitExceeded, DownloadInsufficientSpace)): + raise if isinstance(e, ftplib.error_perm) and str(e).startswith("550"): logger.info("FTP download failed for %s: %s (not on printer)", remote_path, e) raise FileNotOnPrinterError(f"{remote_path}: {e}") from e @@ -1310,12 +1388,23 @@ async def download_file_async( timeout: float = 60.0, socket_timeout: float | None = None, printer_model: str | None = None, + expected_size: int | None = None, + max_bytes: int | None = None, + cancel_event: threading.Event | None = None, + min_free_bytes: int | None = None, ) -> bool: """Async wrapper for downloading a file with timeout. For A1/A1 Mini printers, automatically tries prot_p first, then falls back to prot_c if the download fails. The working mode is cached for future operations. + ``timeout`` bounds the wait for a *result*, not the call: when it expires + this waits for the FTP worker thread to unwind before returning, because + the thread owns ``local_path`` until it does and a caller that came back + early would delete a file still being written. That wait is bounded by the + socket timeout, so pass ``socket_timeout`` on any path that must not block + indefinitely -- every caller here does. + Args: ip_address: Printer IP address access_code: Printer access code @@ -1338,9 +1427,24 @@ async def download_file_async( # The event is set in `_download`'s finally block so the post-timeout # path can wait for genuine thread completion instead of a fixed sleep. - def _download(force_prot_c: bool, completion: dict, done: threading.Event) -> bool: + class _CombinedCancelEvent: + def __init__(self, attempt_event: threading.Event): + self._attempt_event = attempt_event + + def is_set(self) -> bool: + return self._attempt_event.is_set() or (cancel_event is not None and cancel_event.is_set()) + + def _download( + force_prot_c: bool, + completion: dict, + done: threading.Event, + attempt_cancel: threading.Event, + ) -> bool: mode_str = "prot_c" if force_prot_c else "prot_p" try: + combined_cancel = _CombinedCancelEvent(attempt_cancel) + if combined_cancel.is_set(): + raise DownloadCancelled(remote_path) client = BambuFTPClient( ip_address, access_code, @@ -1350,7 +1454,14 @@ async def download_file_async( ) if client.connect(): try: - result = client.download_to_file(remote_path, local_path) + result = client.download_to_file( + remote_path, + local_path, + expected_size=expected_size, + max_bytes=max_bytes, + cancel_event=combined_cancel, + min_free_bytes=min_free_bytes, + ) if result: BambuFTPClient.cache_mode(ip_address, mode_str) completion["success"] = True @@ -1364,10 +1475,20 @@ async def download_file_async( async def _run(force_prot_c: bool) -> bool: completion = {"success": False} done = threading.Event() + attempt_cancel = threading.Event() + worker = loop.run_in_executor(_ftp_executor, _download, force_prot_c, completion, done, attempt_cancel) try: - return await asyncio.wait_for( - loop.run_in_executor(_ftp_executor, _download, force_prot_c, completion, done), timeout=timeout - ) + return await asyncio.wait_for(asyncio.shield(worker), timeout=timeout) + except asyncio.CancelledError: + # Cancelling an asyncio Future cannot stop its executor thread. Set + # the callback-visible flag and do not let the caller unlink the + # staging file until the worker has genuinely unwound. + attempt_cancel.set() + try: + await asyncio.shield(worker) + except (DownloadCancelled, OSError, ftplib.Error): + pass + raise except TimeoutError: # Slow WiFi links commonly overshoot ftp_timeout by 10–30 s without # actually being stuck, so starting attempt 2 now would just contend @@ -1385,7 +1506,16 @@ async def download_file_async( # wait for is how you build a deadlock — with enough concurrent # timeouts the waiters would occupy every slot and the downloads they # are waiting for could never be scheduled. + attempt_cancel.set() await loop.run_in_executor(None, done.wait, grace) + # Wait for the thread either way. If the grace period was enough it + # returns at once; if it was not, the blocking socket still has to + # reach its own timeout, and returning before it does would let the + # caller unlink a file the executor is still writing. + try: + await asyncio.shield(worker) + except (DownloadCancelled, OSError, ftplib.Error): + pass if completion["success"] and local_path.exists() and local_path.stat().st_size > 0: logger.info( "FTP download wait_for timed out after %ss for %s, but thread completed within %ss grace (%s bytes) — salvaging", @@ -1705,6 +1835,36 @@ async def list_files_async( return [] +async def list_files_result_async( + ip_address: str, + access_code: str, + path: str = "/", + timeout: float = 30.0, + socket_timeout: float | None = None, + printer_model: str | None = None, +) -> FileListResult: + """List a directory without collapsing transport failure into empty.""" + + loop = asyncio.get_event_loop() + + def _list() -> FileListResult: + client = BambuFTPClient(ip_address, access_code, timeout=socket_timeout, printer_model=printer_model) + if not client.connect(): + return FileListResult(files=[], available=False) + try: + return FileListResult(files=client.list_files(path, raise_on_error=True), available=True) + except (OSError, ftplib.Error): + return FileListResult(files=[], available=False) + finally: + client.disconnect() + + try: + return await asyncio.wait_for(loop.run_in_executor(_ftp_executor, _list), timeout=timeout) + except TimeoutError: + logger.warning("FTP list_files timed out after %ss for %s", timeout, path) + return FileListResult(files=[], available=False) + + async def find_remote_file_async( ip_address: str, access_code: str, diff --git a/backend/app/services/printer_media.py b/backend/app/services/printer_media.py new file mode 100644 index 000000000..c52df2f98 --- /dev/null +++ b/backend/app/services/printer_media.py @@ -0,0 +1,719 @@ +"""Helpers for matching and downloading printer-side video files.""" + +from __future__ import annotations + +import asyncio +import json +import logging +import re +import secrets +import shutil +import tempfile +import time +import zipfile +from collections.abc import Awaitable, Callable +from dataclasses import dataclass, replace +from datetime import datetime, timedelta, timezone +from pathlib import Path, PurePosixPath + +from backend.app.core.config import settings +from backend.app.core.tasks import spawn_background_task +from backend.app.services.bambu_ftp import ( + DownloadCancelled, + DownloadInsufficientSpace, + DownloadLimitExceeded, + download_file_async, +) + +logger = logging.getLogger(__name__) + +VIDEO_SUFFIXES = (".mp4", ".avi", ".mkv") +MAX_PRINTER_ZIP_BYTES = 10 * 1024**3 +PRINTER_ZIP_FREE_SPACE_RESERVE = 256 * 1024**2 +_STALE_BUNDLE_SECONDS = 60 * 60 +MAX_PRINTER_ZIP_PREPARE_SECONDS = 30 * 60 +MAX_OPEN_ARCHIVE_IPCAM_SECONDS = 24 * 60 * 60 +_BUNDLE_KEY_RE = re.compile(r"^[A-Za-z0-9_-]{1,200}$") +_JOB_KEY_RE = re.compile(r"^[A-Za-z0-9_-]{20,200}$") +_LOCAL_JOB_TASKS: dict[str, asyncio.Task] = {} +_cleanup_task: asyncio.Task | None = None +_CLEANUP_INTERVAL_SECONDS = 15 * 60 + + +class PrinterFilesZipTooLargeError(ValueError): + """The selected printer files exceed the bounded ZIP staging limit.""" + + +class PrinterFilesZipInsufficientSpaceError(OSError): + """The app data volume cannot safely stage the selected files.""" + + +@dataclass(frozen=True) +class PrinterFilesZipResult: + """Result of staging one printer ZIP.""" + + path: Path + requested: int + successful: int + failed_paths: tuple[str, ...] + total_bytes: int + + +@dataclass(frozen=True) +class PrinterFilesJobStatus: + """Serializable state for an asynchronous browser preparation job.""" + + job_id: str + printer_id: int + state: str + requested: int + successful: int = 0 + failed: int = 0 + token: str | None = None + filename: str | None = None + message: str | None = None + + +class _FileCancelSignal: + """Cross-worker cancellation signal checked by the FTP callback thread.""" + + def __init__(self, path: Path): + self.path = path + self._last_check = 0.0 + self._cached = False + + def is_set(self) -> bool: + if self._cached: + return True + now = time.monotonic() + if now - self._last_check >= 0.25: + self._last_check = now + self._cached = self.path.exists() + return self._cached + + +def _job_status_path(job_id: str) -> Path: + if not _JOB_KEY_RE.fullmatch(job_id): + raise ValueError("Invalid printer download job id") + return _printer_zip_root() / f"job-{job_id}.json" + + +def _job_cancel_path(job_id: str) -> Path: + if not _JOB_KEY_RE.fullmatch(job_id): + raise ValueError("Invalid printer download job id") + return _printer_zip_root() / f"job-{job_id}.cancel" + + +def _write_job_status(status: PrinterFilesJobStatus) -> None: + """Atomically publish job state for polling from any app worker.""" + + path = _job_status_path(status.job_id) + temp_path = path.with_suffix(".tmp") + temp_path.write_text(json.dumps(status.__dict__, separators=(",", ":")), encoding="utf-8") + temp_path.replace(path) + + +def _read_job_status(job_id: str) -> PrinterFilesJobStatus | None: + try: + data = json.loads(_job_status_path(job_id).read_text(encoding="utf-8")) + return PrinterFilesJobStatus(**data) + except (FileNotFoundError, OSError, ValueError, TypeError, json.JSONDecodeError): + return None + + +def _naive_utc(value: datetime | None) -> datetime | None: + if value is None: + return None + if value.tzinfo is not None: + return value.astimezone(timezone.utc).replace(tzinfo=None) + return value + + +def match_ipcam_chunks( + files: list[dict], + started_at: datetime | None, + completed_at: datetime | None, + *, + now: datetime | None = None, +) -> list[dict]: + """Return `/ipcam` chunks whose completion time overlaps a print. + + Bambu's `ipcam-record.*.mp4` files are fixed-size chunks. On the tested X1C + and H2D firmware, their FTP mtime is the chunk completion time in the same + UTC-naive basis used by archive timestamps. Some firmware reports FTP LIST + mtimes in printer-local time instead; LIST carries no timezone with which + to correct those values reliably. A ten-minute tail includes the final + chunk, whose mtime lands after the print-complete event. + """ + + start = _naive_utc(started_at) + if start is None: + return [] + live_end = _naive_utc(now) or datetime.now(timezone.utc).replace(tzinfo=None) + # A crash can leave an archive in ``printing`` indefinitely. Do not turn + # that stale row into a window covering every chunk created since then. + end = _naive_utc(completed_at) or min(live_end, start + timedelta(seconds=MAX_OPEN_ARCHIVE_IPCAM_SECONDS)) + lower = start - timedelta(minutes=1) + upper = max(start, end) + timedelta(minutes=10) + + matches: list[dict] = [] + for file in files: + name = str(file.get("name") or "") + mtime = file.get("mtime") + if file.get("is_directory") or not name.lower().startswith("ipcam-record."): + continue + if not name.lower().endswith(VIDEO_SUFFIXES) or not isinstance(mtime, datetime): + continue + timestamp = _naive_utc(mtime) + if timestamp is not None and lower <= timestamp <= upper: + matches.append(file) + + matches.sort(key=lambda item: _naive_utc(item.get("mtime")) or datetime.min) + return matches + + +def _zip_arcname(remote_path: str, used: set[str]) -> str: + """Return a safe, unique relative archive name for a printer path.""" + + parts = [part for part in PurePosixPath(remote_path).parts if part not in ("/", "", ".", "..")] + candidate = "/".join(parts) or "printer-file" + stem = candidate + suffix = "" + if "." in PurePosixPath(candidate).name: + suffix = "".join(PurePosixPath(candidate).suffixes) + stem = candidate[: -len(suffix)] if suffix else candidate + counter = 2 + while candidate in used: + candidate = f"{stem}-{counter}{suffix}" + counter += 1 + used.add(candidate) + return candidate + + +def _printer_zip_root() -> Path: + """Return the dedicated staging root without doing event-loop I/O.""" + + return settings.archive_dir / "temp" / "printer-file-downloads" + + +def _ensure_printer_zip_root() -> Path: + """Create and return the staging root on the persistent data volume.""" + + root = _printer_zip_root() + root.mkdir(parents=True, exist_ok=True) + return root + + +def _prune_stale_bundles(root: Path) -> None: + """Remove abandoned bundles after token expiry, without touching archives.""" + + cutoff = time.time() - _STALE_BUNDLE_SECONDS + if not root.exists(): + return + for child in root.iterdir(): + try: + if child.is_dir() and child.stat().st_mtime < cutoff: + shutil.rmtree(child, ignore_errors=True) + elif child.is_file() and child.name.startswith("job-") and child.stat().st_mtime < cutoff: + child.unlink(missing_ok=True) + except OSError: + continue + + +async def prune_stale_printer_file_bundles() -> None: + """Prune abandoned printer ZIPs without blocking the event loop.""" + + root = await asyncio.to_thread(_ensure_printer_zip_root) + await asyncio.to_thread(_prune_stale_bundles, root) + + +async def _printer_download_cleanup_loop() -> None: + while True: + try: + await asyncio.sleep(_CLEANUP_INTERVAL_SECONDS) + await prune_stale_printer_file_bundles() + except asyncio.CancelledError: + break + except Exception: + logger.exception("Periodic printer-download cleanup failed") + + +def start_printer_download_cleanup() -> None: + global _cleanup_task + if _cleanup_task is None: + _cleanup_task = spawn_background_task(_printer_download_cleanup_loop(), name="printer-download-cleanup") + + +async def stop_printer_download_cleanup() -> None: + """Stop cleanup and cancel every in-process preparation before shutdown.""" + + global _cleanup_task + tasks: list[asyncio.Task] = [] + cleanup_task = _cleanup_task + _cleanup_task = None + if cleanup_task is not None: + cleanup_task.cancel() + tasks.append(cleanup_task) + + # Jobs can be inside an FTP worker thread. Publish the same cooperative + # cancellation marker used by the DELETE endpoint before cancelling the + # asyncio wrapper, then await every wrapper so no executor work is left + # behind when the application event loop closes. + for job_id, task in list(_LOCAL_JOB_TASKS.items()): + if not task.done(): + await asyncio.to_thread(_job_cancel_path(job_id).touch) + task.cancel() + tasks.append(task) + if tasks: + await asyncio.gather(*tasks, return_exceptions=True) + _LOCAL_JOB_TASKS.clear() + + +def printer_files_zip_path(printer_id: int, token: str) -> Path | None: + """Resolve the staged ZIP for a resource-bound browser token.""" + + bundle_key = f"{printer_id}-{token}" + if not _BUNDLE_KEY_RE.fullmatch(bundle_key): + return None + return _printer_zip_root() / bundle_key / "printer-files.zip" + + +def bind_printer_files_zip_to_token( + result: PrinterFilesZipResult, + printer_id: int, + token: str, +) -> PrinterFilesZipResult: + """Move a prepared bundle to the path derived from its persisted token.""" + + target = printer_files_zip_path(printer_id, token) + if target is None: + raise ValueError("Invalid printer ZIP token") + result.path.parent.rename(target.parent) + return replace(result, path=target) + + +def _check_initial_space(root: Path, sizes: dict[str, int]) -> None: + # These sizes are client-reported hints used only for an early rejection, + # so this is a courtesy, not the bound. The real one is enforced per write + # and per FTP callback below, against actual bytes and the live free space, + # which is the only thing that can hold when several preparations run at + # once -- and they do: nothing serializes them. Two concurrent jobs that + # both pass here stop independently at the reserve, and the one that gets + # there second fails with a message saying so. + expected_total = sum(sizes.values()) + if expected_total > MAX_PRINTER_ZIP_BYTES: + raise PrinterFilesZipTooLargeError( + f"Selected files total {expected_total} bytes; the limit is {MAX_PRINTER_ZIP_BYTES} bytes" + ) + + largest_file = max(sizes.values(), default=0) + # In the worst case the ZIP is as large as the inputs while the largest + # source is still staged beside it. Keep a reserve for the database/logs. + required = expected_total + largest_file + PRINTER_ZIP_FREE_SPACE_RESERVE + free = shutil.disk_usage(root).free + if free < required: + raise PrinterFilesZipInsufficientSpaceError( + f"The app data volume needs {required} bytes free to stage this selection; {free} bytes are available" + ) + + +async def build_printer_files_zip( + printer, + paths: list[str], + sizes: dict[str, int], + *, + bundle_key: str | None = None, + preserve_paths: bool = True, + allow_empty: bool = False, + cancel_signal: _FileCancelSignal | None = None, + progress_callback: Callable[[int, int], Awaitable[None]] | None = None, +) -> PrinterFilesZipResult: + """Download printer files one at a time into a disk-backed ZIP. + + The previous implementation held every source file and the final ZIP in + memory. Continuous `/ipcam` chunks are commonly ~250 MB each, so selecting + only a few could exhaust both server and browser memory. + """ + + root = await asyncio.to_thread(_ensure_printer_zip_root) + await asyncio.to_thread(_prune_stale_bundles, root) + await asyncio.to_thread(_check_initial_space, root, sizes) + bundle_dir: Path | None = None + try: + if bundle_key is None: + bundle_dir = Path(await asyncio.to_thread(tempfile.mkdtemp, prefix="bundle-", dir=root)) + else: + if not _BUNDLE_KEY_RE.fullmatch(bundle_key): + raise ValueError("Invalid printer ZIP bundle key") + bundle_dir = root / bundle_key + await asyncio.to_thread(bundle_dir.mkdir, mode=0o700) + zip_path = bundle_dir / "printer-files.zip" + successful = 0 + total_bytes = 0 + failed_paths: list[str] = [] + used_names: set[str] = set() + + archive = await asyncio.to_thread(zipfile.ZipFile, zip_path, "w", allowZip64=True) + try: + for index, remote_path in enumerate(paths): + if cancel_signal is not None and cancel_signal.is_set(): + raise asyncio.CancelledError + if not isinstance(remote_path, str) or not remote_path.startswith("/") or "\x00" in remote_path: + logger.warning("Skipping invalid printer file path: %r", remote_path) + failed_paths.append(remote_path) + continue + staged_path = bundle_dir / f"download-{index}" + try: + expected_size = sizes.get(remote_path) + if expected_size is not None: + free = (await asyncio.to_thread(shutil.disk_usage, root)).free + if free < expected_size + PRINTER_ZIP_FREE_SPACE_RESERVE: + raise PrinterFilesZipInsufficientSpaceError( + "The app data volume lacks space for the next selected file" + ) + downloaded = await download_file_async( + printer.ip_address, + printer.access_code, + remote_path, + staged_path, + timeout=600, + socket_timeout=60, + printer_model=printer.model, + expected_size=expected_size, + max_bytes=MAX_PRINTER_ZIP_BYTES - total_bytes, + cancel_event=cancel_signal, + min_free_bytes=PRINTER_ZIP_FREE_SPACE_RESERVE, + ) + if not downloaded: + failed_paths.append(remote_path) + continue + # Deliberately no second size comparison here. The transfer + # was already checked against the printer's own SIZE, which + # download_to_file treats as the authority precisely because + # it beats a hint the browser round-tripped; re-judging the + # result against that hint would overrule the better number + # with the worse one. The hint goes stale in exactly the case + # this feature exists for -- an /ipcam chunk or a timelapse + # still being written when the listing was taken -- and a + # complete file would then be dropped as "truncated". + file_size = (await asyncio.to_thread(staged_path.stat)).st_size + if total_bytes + file_size > MAX_PRINTER_ZIP_BYTES: + raise PrinterFilesZipTooLargeError( + f"Downloaded files exceed the {MAX_PRINTER_ZIP_BYTES}-byte limit" + ) + free = (await asyncio.to_thread(shutil.disk_usage, root)).free + if free < file_size + PRINTER_ZIP_FREE_SPACE_RESERVE: + raise PrinterFilesZipInsufficientSpaceError( + "The app data volume ran out of safe staging space while building the ZIP" + ) + compression = ( + zipfile.ZIP_STORED if remote_path.lower().endswith(VIDEO_SUFFIXES) else zipfile.ZIP_DEFLATED + ) + arc_source = remote_path if preserve_paths else PurePosixPath(remote_path).name + await asyncio.to_thread( + archive.write, + staged_path, + _zip_arcname(arc_source, used_names), + compress_type=compression, + ) + successful += 1 + total_bytes += file_size + except DownloadLimitExceeded as exc: + raise PrinterFilesZipTooLargeError( + f"Downloaded files exceed the {MAX_PRINTER_ZIP_BYTES}-byte limit" + ) from exc + except DownloadInsufficientSpace as exc: + raise PrinterFilesZipInsufficientSpaceError( + "The app data volume ran out of safe staging space during transfer" + ) from exc + except DownloadCancelled as exc: + raise asyncio.CancelledError from exc + except (PrinterFilesZipTooLargeError, PrinterFilesZipInsufficientSpaceError): + raise + except Exception as exc: + logger.warning("Failed to add %s to printer ZIP: %s", remote_path, exc) + failed_paths.append(remote_path) + finally: + await asyncio.to_thread(staged_path.unlink, missing_ok=True) + if progress_callback is not None: + await progress_callback(successful, len(failed_paths)) + finally: + await asyncio.shield(asyncio.to_thread(archive.close)) + except BaseException: + if bundle_dir is not None: + await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True)) + raise + + if successful == 0 and not allow_empty: + await asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True) + raise FileNotFoundError("No files could be downloaded") + return PrinterFilesZipResult( + path=zip_path, + requested=len(paths), + successful=successful, + failed_paths=tuple(failed_paths), + total_bytes=total_bytes, + ) + + +def printer_file_path(printer_id: int, token: str) -> Path | None: + """Resolve a prepared native single-file download.""" + + bundle_key = f"{printer_id}-{token}" + if not _BUNDLE_KEY_RE.fullmatch(bundle_key): + return None + return _printer_zip_root() / bundle_key / "printer-file" + + +def bind_printer_file_to_token(result: PrinterFilesZipResult, printer_id: int, token: str) -> PrinterFilesZipResult: + target = printer_file_path(printer_id, token) + if target is None: + raise ValueError("Invalid printer file token") + result.path.parent.rename(target.parent) + return replace(result, path=target) + + +async def build_printer_file( + printer, + remote_path: str, + expected_size: int | None, + *, + bundle_key: str, + cancel_signal: _FileCancelSignal | None = None, +) -> PrinterFilesZipResult: + """Stage one printer file on disk for a browser-native download. + + Also the read path for the 3MF preview in the file browser, which is why + nothing here waits on a shared lock: a preview must not queue behind + somebody else's ten-gigabyte selection for as long as that takes. + """ + + if not remote_path.startswith("/") or "\x00" in remote_path: + raise FileNotFoundError("Invalid printer file path") + root = await asyncio.to_thread(_ensure_printer_zip_root) + size_hints = {remote_path: expected_size} if expected_size is not None else {} + await asyncio.to_thread(_check_initial_space, root, size_hints) + bundle_dir = root / bundle_key + try: + await asyncio.to_thread(bundle_dir.mkdir, mode=0o700) + local_path = bundle_dir / "printer-file" + downloaded = await download_file_async( + printer.ip_address, + printer.access_code, + remote_path, + local_path, + timeout=600, + socket_timeout=60, + printer_model=printer.model, + expected_size=expected_size, + max_bytes=MAX_PRINTER_ZIP_BYTES, + cancel_event=cancel_signal, + min_free_bytes=PRINTER_ZIP_FREE_SPACE_RESERVE, + ) + if not downloaded: + raise FileNotFoundError("The selected printer file could not be downloaded") + file_size = (await asyncio.to_thread(local_path.stat)).st_size + return PrinterFilesZipResult( + path=local_path, + requested=1, + successful=1, + failed_paths=(), + total_bytes=file_size, + ) + except DownloadLimitExceeded as exc: + await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True)) + raise PrinterFilesZipTooLargeError(f"Downloaded file exceeds the {MAX_PRINTER_ZIP_BYTES}-byte limit") from exc + except DownloadInsufficientSpace as exc: + await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True)) + raise PrinterFilesZipInsufficientSpaceError( + "The app data volume ran out of safe staging space during transfer" + ) from exc + except DownloadCancelled as exc: + await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True)) + raise asyncio.CancelledError from exc + except BaseException: + await asyncio.shield(asyncio.to_thread(shutil.rmtree, bundle_dir, ignore_errors=True)) + raise + + +async def _run_printer_files_job( + printer, + job_id: str, + paths: list[str], + sizes: dict[str, int], + filename: str, + as_zip: bool, +) -> None: + from backend.app.core.auth import create_slicer_download_token + + cancel_signal = _FileCancelSignal(_job_cancel_path(job_id)) + status = PrinterFilesJobStatus(job_id, printer.id, "preparing", len(paths), filename=filename) + await asyncio.to_thread(_write_job_status, status) + + async def report_progress(successful: int, failed: int) -> None: + await asyncio.to_thread( + _write_job_status, + PrinterFilesJobStatus( + job_id, + printer.id, + "preparing", + len(paths), + successful=successful, + failed=failed, + filename=filename, + ), + ) + + try: + async with asyncio.timeout(MAX_PRINTER_ZIP_PREPARE_SECONDS): + if as_zip: + result = await build_printer_files_zip( + printer, + paths, + sizes, + bundle_key=f"job-{job_id}", + cancel_signal=cancel_signal, + progress_callback=report_progress, + ) + else: + result = await build_printer_file( + printer, + paths[0], + sizes.get(paths[0]), + bundle_key=f"job-{job_id}", + cancel_signal=cancel_signal, + ) + if cancel_signal.is_set(): + await asyncio.to_thread(remove_printer_files_zip, result.path) + raise asyncio.CancelledError + token = await create_slicer_download_token("printer-files", printer.id) + if as_zip: + result = await asyncio.to_thread(bind_printer_files_zip_to_token, result, printer.id, token) + else: + result = await asyncio.to_thread(bind_printer_file_to_token, result, printer.id, token) + await asyncio.to_thread( + _write_job_status, + PrinterFilesJobStatus( + job_id, + printer.id, + "ready", + len(paths), + successful=result.successful, + failed=len(result.failed_paths), + token=token, + filename=filename, + ), + ) + except asyncio.CancelledError: + await asyncio.shield( + asyncio.to_thread( + _write_job_status, + PrinterFilesJobStatus(job_id, printer.id, "cancelled", len(paths), filename=filename), + ) + ) + except PrinterFilesZipTooLargeError as exc: + await asyncio.to_thread( + _write_job_status, + PrinterFilesJobStatus(job_id, printer.id, "failed", len(paths), filename=filename, message=str(exc)), + ) + except PrinterFilesZipInsufficientSpaceError as exc: + await asyncio.to_thread( + _write_job_status, + PrinterFilesJobStatus(job_id, printer.id, "failed", len(paths), filename=filename, message=str(exc)), + ) + except TimeoutError: + await asyncio.to_thread( + _write_job_status, + PrinterFilesJobStatus( + job_id, + printer.id, + "failed", + len(paths), + filename=filename, + message="Printer download preparation exceeded the 30-minute limit", + ), + ) + except FileNotFoundError as exc: + await asyncio.to_thread( + _write_job_status, + PrinterFilesJobStatus(job_id, printer.id, "failed", len(paths), filename=filename, message=str(exc)), + ) + except Exception: + logger.exception("Printer download job %s failed", job_id) + await asyncio.to_thread( + _write_job_status, + PrinterFilesJobStatus( + job_id, + printer.id, + "failed", + len(paths), + filename=filename, + message="Printer download preparation failed", + ), + ) + finally: + await asyncio.to_thread(_job_cancel_path(job_id).unlink, missing_ok=True) + + +async def start_printer_files_job( + printer, + paths: list[str], + sizes: dict[str, int], + filename: str, + *, + as_zip: bool, +) -> PrinterFilesJobStatus: + """Start a bounded background preparation and return immediately.""" + + if not paths: + raise ValueError("No files specified") + root = await asyncio.to_thread(_ensure_printer_zip_root) + await asyncio.to_thread(_prune_stale_bundles, root) + await asyncio.to_thread(_check_initial_space, root, sizes) + job_id = secrets.token_urlsafe(24) + status = PrinterFilesJobStatus(job_id, printer.id, "queued", len(paths), filename=filename) + await asyncio.to_thread(_write_job_status, status) + task = spawn_background_task( + _run_printer_files_job(printer, job_id, paths, sizes, filename, as_zip), + name=f"printer-download-{printer.id}-{job_id}", + ) + _LOCAL_JOB_TASKS[job_id] = task + task.add_done_callback(lambda _task: _LOCAL_JOB_TASKS.pop(job_id, None)) + return status + + +async def get_printer_files_job(job_id: str, printer_id: int) -> PrinterFilesJobStatus | None: + status = await asyncio.to_thread(_read_job_status, job_id) + if status is None or status.printer_id != printer_id: + return None + return status + + +async def cancel_printer_files_job(job_id: str, printer_id: int) -> bool: + status = await get_printer_files_job(job_id, printer_id) + if status is None: + return False + await asyncio.to_thread(_job_cancel_path(job_id).touch) + task = _LOCAL_JOB_TASKS.get(job_id) + if task is not None and not task.done(): + task.cancel() + if status.state == "ready" and status.token: + zip_path = printer_files_zip_path(printer_id, status.token) + prepared = ( + zip_path + if zip_path is not None and await asyncio.to_thread(zip_path.is_file) + else printer_file_path(printer_id, status.token) + ) + if prepared is not None: + await asyncio.to_thread(remove_printer_files_zip, prepared) + await asyncio.to_thread( + _write_job_status, + replace(status, state="cancelled", token=None), + ) + return True + + +def remove_printer_files_zip(zip_path: Path) -> None: + """Remove a completed download bundle after FileResponse finishes.""" + + shutil.rmtree(zip_path.parent, ignore_errors=True) diff --git a/backend/app/utils/http.py b/backend/app/utils/http.py index 8aef07222..78ab7a028 100644 --- a/backend/app/utils/http.py +++ b/backend/app/utils/http.py @@ -1,7 +1,43 @@ """HTTP response helpers.""" +from pathlib import Path from urllib.parse import quote +from starlette.responses import PlainTextResponse + + +def download_error_response(status_code: int, message: str) -> PlainTextResponse: + """Answer a browser-native download with a file that says what went wrong. + + These URLs are reached by an ```` click, and a browser saves + whatever comes back under the name it was going to use. A JSON error body + therefore lands on the user's disk as a .zip that will not open, with + nothing on screen to explain it -- the download simply appears to have + produced a broken file. A short text file, named for the failure rather + than for the download, is at least legible when opened. + """ + + return PlainTextResponse( + f"{message}\n", + status_code=status_code, + headers={"Content-Disposition": build_content_disposition("download-failed.txt")}, + ) + + +def safe_download_filename(filename: str, fallback: str = "download", max_chars: int = 200) -> str: + """Return a basename safe for a bounded download response header.""" + + basename = Path(filename.replace("\\", "/")).name + cleaned = "".join("_" if ord(char) < 32 or ord(char) == 127 else char for char in basename).strip(" .") + if not cleaned: + return fallback + if len(cleaned) <= max_chars: + return cleaned + suffixes = "".join(Path(cleaned).suffixes) + suffix = suffixes if len(suffixes) <= 32 else "" + stem_chars = max(1, max_chars - len(suffix)) + return f"{cleaned[:stem_chars]}{suffix}" + def build_content_disposition(filename: str, disposition: str = "attachment") -> str: """Build an RFC 6266-compliant Content-Disposition header value. diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py index 311a7ca51..4a351a1b1 100644 --- a/backend/tests/conftest.py +++ b/backend/tests/conftest.py @@ -169,7 +169,7 @@ def reset_auth_enabled_cache(): @pytest.fixture(autouse=True) def disconnect_printers_registered_during_a_test(): - """Hand the ``printer_manager`` singleton back the way the test found it. + """Give every test an empty ``printer_manager`` singleton. ``POST /api/v1/printers`` really calls ``connect_printer``, so a test that creates a printer through the API parks a live client in the singleton -- @@ -179,16 +179,18 @@ def disconnect_printers_registered_during_a_test(): ``test_scheduled_drying_routes`` saw exactly that: an "online" printer with no firmware version, so scheduling a dry came back 400 instead of 200. - Only ids this test added are dropped, so a client registered by a wider - fixture stays registered. ``disconnect_printer`` is what clears the model - and printer-info caches too, and it stops the paho thread the leaked client - would otherwise keep retrying on for the rest of the run. + Snapshotting the ids at test entry was insufficient: a client leaked by a + previous module became part of that snapshot and therefore survived every + later cleanup on the same xdist worker. Clear both before and after each + test. ``disconnect_printer`` also clears model/printer-info caches and stops + any paho thread owned by the leaked client. """ from backend.app.services.printer_manager import printer_manager - before = set(printer_manager._clients) + for printer_id in list(printer_manager._clients): + printer_manager.disconnect_printer(printer_id) yield - for printer_id in set(printer_manager._clients) - before: + for printer_id in list(printer_manager._clients): printer_manager.disconnect_printer(printer_id) diff --git a/backend/tests/integration/test_archives_api.py b/backend/tests/integration/test_archives_api.py index b6ad4d5dd..78b046f77 100644 --- a/backend/tests/integration/test_archives_api.py +++ b/backend/tests/integration/test_archives_api.py @@ -3,12 +3,16 @@ Tests the full request/response cycle for /api/v1/archives/ endpoints. """ +from datetime import datetime from pathlib import Path from unittest.mock import AsyncMock, patch import pytest from httpx import AsyncClient +from backend.app.core.config import settings +from backend.app.services.bambu_ftp import FileListResult + class TestArchivesAPI: """Integration tests for /api/v1/archives/ endpoints.""" @@ -251,6 +255,460 @@ class TestArchivesAPI: assert response.status_code == 404 + @pytest.mark.asyncio + @pytest.mark.integration + async def test_get_archive_printer_media_matches_timelapse_and_ipcam_chunks( + self, + async_client: AsyncClient, + archive_factory, + printer_factory, + db_session, + ): + printer = await printer_factory() + archive = await archive_factory( + printer.id, + started_at=datetime(2026, 8, 12, 10, 0), + completed_at=datetime(2026, 8, 12, 11, 0), + timelapse_path=None, + ) + + list_timeouts = [] + + async def fake_list(_ip, _code, path, **kwargs): + list_timeouts.append(kwargs.get("timeout")) + if path == "/timelapse": + return FileListResult( + files=[ + { + "name": "video_2026-08-12_18-00-00.mp4", + "path": "/timelapse/video_2026-08-12_18-00-00.mp4", + "size": 123, + "mtime": datetime(2026, 8, 12, 11, 1), + "is_directory": False, + } + ], + available=True, + ) + if path == "/ipcam": + return FileListResult( + files=[ + { + "name": "ipcam-record.1.mp4", + "path": "/ipcam/ipcam-record.1.mp4", + "size": 250_000_000, + "mtime": datetime(2026, 8, 12, 10, 5), + "is_directory": False, + }, + { + "name": "ipcam-record.after.mp4", + "path": "/ipcam/ipcam-record.after.mp4", + "size": 250_000_000, + "mtime": datetime(2026, 8, 12, 11, 30), + "is_directory": False, + }, + ], + available=True, + ) + return FileListResult(files=[], available=False) + + with ( + patch("backend.app.api.routes.archives.list_files_result_async", new=AsyncMock(side_effect=fake_list)), + patch("backend.app.api.routes.archives.ftps_handshake_blocked", return_value=False), + ): + response = await async_client.get(f"/api/v1/archives/{archive.id}/printer-media") + + assert response.status_code == 200 + data = response.json() + assert data["local_timelapse"] is None + assert [(file["kind"], file["name"]) for file in data["remote_files"]] == [ + ("timelapse", "video_2026-08-12_18-00-00.mp4"), + ("ipcam", "ipcam-record.1.mp4"), + ] + assert list_timeouts == [8.0, 8.0] + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_archive_printer_media_skips_ftp_during_handshake_cooloff( + self, + async_client: AsyncClient, + archive_factory, + printer_factory, + ): + printer = await printer_factory() + archive = await archive_factory( + printer.id, + started_at=datetime(2026, 8, 12, 10, 0), + completed_at=datetime(2026, 8, 12, 11, 0), + timelapse_path=None, + ) + list_files = AsyncMock() + + with ( + patch("backend.app.api.routes.archives.ftps_handshake_blocked", return_value=True), + patch("backend.app.api.routes.archives.list_files_result_async", new=list_files), + ): + response = await async_client.get(f"/api/v1/archives/{archive.id}/printer-media") + + assert response.status_code == 200 + assert response.json()["remote_files"] == [] + assert response.json()["warnings"] == ["timelapse_unavailable", "ipcam_unavailable"] + list_files.assert_not_awaited() + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_archive_printer_media_checks_alternate_timelapse_directories_after_empty_listing( + self, + async_client: AsyncClient, + archive_factory, + printer_factory, + ): + printer = await printer_factory() + archive = await archive_factory( + printer.id, + started_at=datetime(2026, 8, 12, 10, 0), + completed_at=datetime(2026, 8, 12, 11, 0), + timelapse_path=None, + ) + paths: list[str] = [] + + async def fake_list(_ip, _code, path, **_kwargs): + paths.append(path) + if path == "/timelapse/video": + return FileListResult( + files=[ + { + "name": "video_2026-08-12_11-01-00.mp4", + "path": "/timelapse/video/video_2026-08-12_11-01-00.mp4", + "size": 321, + "mtime": datetime(2026, 8, 12, 11, 1), + "is_directory": False, + } + ], + available=True, + ) + return FileListResult(files=[], available=True) + + with ( + patch("backend.app.api.routes.archives.list_files_result_async", new=AsyncMock(side_effect=fake_list)), + patch("backend.app.api.routes.archives.ftps_handshake_blocked", return_value=False), + ): + response = await async_client.get(f"/api/v1/archives/{archive.id}/printer-media") + + assert response.status_code == 200 + assert response.json()["remote_files"][0]["path"].startswith("/timelapse/video/") + assert paths == ["/timelapse", "/timelapse/video", "/ipcam"] + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_archive_printer_media_releases_db_session_before_ftp( + self, + async_client: AsyncClient, + archive_factory, + printer_factory, + monkeypatch, + ): + from backend.app.api.routes import archives as archives_routes + + printer = await printer_factory() + archive = await archive_factory( + printer.id, + started_at=datetime(2026, 8, 12, 10, 0), + timelapse_path=None, + ) + real_factory = archives_routes.database.async_session + session_closed = False + + class TrackingSession: + async def __aenter__(self): + self.context = real_factory() + return await self.context.__aenter__() + + async def __aexit__(self, *args): + nonlocal session_closed + result = await self.context.__aexit__(*args) + session_closed = True + return result + + async def fake_list(*_args, **_kwargs): + assert session_closed + return FileListResult(files=[], available=True) + + monkeypatch.setattr(archives_routes.database, "async_session", TrackingSession) + with ( + patch("backend.app.api.routes.archives.list_files_result_async", new=AsyncMock(side_effect=fake_list)), + patch("backend.app.api.routes.archives.ftps_handshake_blocked", return_value=False), + ): + response = await async_client.get(f"/api/v1/archives/{archive.id}/printer-media") + + assert response.status_code == 200 + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_archive_printer_media_baseline_excludes_old_timestamp_match( + self, + async_client: AsyncClient, + archive_factory, + printer_factory, + ): + printer = await printer_factory() + archive = await archive_factory( + printer.id, + started_at=datetime(2026, 8, 12, 10, 0), + completed_at=datetime(2026, 8, 12, 11, 0), + timelapse_path=None, + timelapse_baseline=["old.mp4"], + ) + + async def fake_list(_ip, _code, path, **_kwargs): + if path == "/timelapse": + return FileListResult( + files=[ + { + "name": "old.mp4", + "path": "/timelapse/old.mp4", + "size": 10, + "mtime": datetime(2026, 8, 12, 11, 0), + "is_directory": False, + }, + { + "name": "new.mp4", + "path": "/timelapse/new.mp4", + "size": 20, + "mtime": datetime(2020, 1, 1), + "is_directory": False, + }, + ], + available=True, + ) + return FileListResult(files=[], available=True) + + with ( + patch("backend.app.api.routes.archives.list_files_result_async", new=AsyncMock(side_effect=fake_list)), + patch("backend.app.api.routes.archives.ftps_handshake_blocked", return_value=False), + ): + response = await async_client.get(f"/api/v1/archives/{archive.id}/printer-media") + + assert response.status_code == 200 + timelapses = [item for item in response.json()["remote_files"] if item["kind"] == "timelapse"] + assert [item["name"] for item in timelapses] == ["new.mp4"] + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_archive_printer_media_requires_printer_files_permission( + self, + async_client: AsyncClient, + archive_factory, + printer_factory, + tmp_path, + monkeypatch, + ): + printer = await printer_factory() + monkeypatch.setattr(settings, "base_dir", tmp_path) + timelapse = tmp_path / "timelapses" / "attached.mp4" + timelapse.parent.mkdir() + timelapse.write_bytes(b"attached video") + archive = await archive_factory( + printer.id, + started_at=datetime(2026, 8, 12, 10, 0), + timelapse_path="timelapses/attached.mp4", + ) + setup = await async_client.post( + "/api/v1/auth/setup", + json={ + "auth_enabled": True, + "admin_username": "mediaadmin", + "admin_password": "AdminPass1!", + }, + ) + assert setup.status_code == 200, setup.text + admin_login = await async_client.post( + "/api/v1/auth/login", + json={"username": "mediaadmin", "password": "AdminPass1!"}, + ) + admin_headers = {"Authorization": f"Bearer {admin_login.json()['access_token']}"} + group = await async_client.post( + "/api/v1/groups/", + headers=admin_headers, + json={"name": "archive-only-media", "permissions": ["archives:read_all"]}, + ) + assert group.status_code == 201, group.text + user = await async_client.post( + "/api/v1/users/", + headers=admin_headers, + json={ + "username": "archiveonlymedia", + "password": "ArchivePass1!", + "group_ids": [group.json()["id"]], + }, + ) + assert user.status_code == 201, user.text + login = await async_client.post( + "/api/v1/auth/login", + json={"username": "archiveonlymedia", "password": "ArchivePass1!"}, + ) + + list_files = AsyncMock() + with patch("backend.app.api.routes.archives.list_files_result_async", new=list_files): + response = await async_client.get( + f"/api/v1/archives/{archive.id}/printer-media", + headers={"Authorization": f"Bearer {login.json()['access_token']}"}, + ) + + assert response.status_code == 200 + assert response.json()["local_timelapse"] == {"name": "attached.mp4", "size": 14} + assert response.json()["remote_files"] == [] + assert response.json()["warnings"] == ["printer_files_forbidden"] + list_files.assert_not_awaited() + + token_response = await async_client.post( + f"/api/v1/archives/{archive.id}/media-download-token", + headers={"Authorization": f"Bearer {login.json()['access_token']}"}, + ) + assert token_response.status_code == 200 + download = await async_client.get( + f"/api/v1/archives/{archive.id}/media/dl/{token_response.json()['token']}/attached.mp4" + ) + assert download.status_code == 200 + assert download.content == b"attached video" + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_archive_media_token_is_archive_bound_single_use( + self, + async_client: AsyncClient, + archive_factory, + printer_factory, + tmp_path, + monkeypatch, + ): + printer = await printer_factory() + monkeypatch.setattr(settings, "base_dir", tmp_path) + media = tmp_path / "timelapses" / "bound.mp4" + media.parent.mkdir() + media.write_bytes(b"bound media") + archive_a = await archive_factory(printer.id, timelapse_path="timelapses/bound.mp4") + archive_b = await archive_factory(printer.id, timelapse_path="timelapses/bound.mp4") + + minted = await async_client.post(f"/api/v1/archives/{archive_a.id}/media-download-token") + assert minted.status_code == 200 + token = minted.json()["token"] + wrong = await async_client.get(f"/api/v1/archives/{archive_b.id}/media/dl/{token}/bound.mp4") + assert wrong.status_code == 403 + correct = await async_client.get(f"/api/v1/archives/{archive_a.id}/media/dl/{token}/bound.mp4") + assert correct.status_code == 200 + replay = await async_client.get(f"/api/v1/archives/{archive_a.id}/media/dl/{token}/bound.mp4") + assert replay.status_code == 403 + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_archive_printer_media_enforces_api_key_printer_scope( + self, + async_client: AsyncClient, + archive_factory, + printer_factory, + db_session, + ): + from backend.app.core.auth import generate_api_key + from backend.app.models.api_key import APIKey + + printer_a = await printer_factory(name="Media Scope A", serial_number="MEDIASCOPEA00001") + printer_b = await printer_factory(name="Media Scope B", serial_number="MEDIASCOPEB00001") + archive = await archive_factory( + printer_b.id, + started_at=datetime(2026, 8, 12, 10, 0), + timelapse_path=None, + ) + setup = await async_client.post( + "/api/v1/auth/setup", + json={ + "auth_enabled": True, + "admin_username": "mediascopeadmin", + "admin_password": "AdminPass1!", + }, + ) + assert setup.status_code == 200, setup.text + full_key, key_hash, key_prefix = generate_api_key() + db_session.add( + APIKey( + name="media-printer-scope", + key_hash=key_hash, + key_prefix=key_prefix, + can_read_status=True, + can_control_printer=True, + printer_ids=[printer_a.id], + enabled=True, + ) + ) + await db_session.commit() + + listing = AsyncMock() + with patch("backend.app.api.routes.archives.list_files_result_async", new=listing): + response = await async_client.get( + f"/api/v1/archives/{archive.id}/printer-media", + headers={"X-API-Key": full_key}, + ) + + assert response.status_code == 403 + listing.assert_not_awaited() + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_camera_only_user_cannot_mint_archive_media_token( + self, + async_client: AsyncClient, + archive_factory, + printer_factory, + tmp_path, + monkeypatch, + ): + printer = await printer_factory() + monkeypatch.setattr(settings, "base_dir", tmp_path) + media = tmp_path / "timelapses" / "private.mp4" + media.parent.mkdir() + media.write_bytes(b"private") + archive = await archive_factory(printer.id, timelapse_path="timelapses/private.mp4") + setup = await async_client.post( + "/api/v1/auth/setup", + json={ + "auth_enabled": True, + "admin_username": "cameraadmin", + "admin_password": "AdminPass1!", + }, + ) + assert setup.status_code == 200, setup.text + admin_login = await async_client.post( + "/api/v1/auth/login", + json={"username": "cameraadmin", "password": "AdminPass1!"}, + ) + admin_headers = {"Authorization": f"Bearer {admin_login.json()['access_token']}"} + group = await async_client.post( + "/api/v1/groups/", + headers=admin_headers, + json={"name": "camera-only-media", "permissions": ["camera:view"]}, + ) + assert group.status_code == 201, group.text + user = await async_client.post( + "/api/v1/users/", + headers=admin_headers, + json={ + "username": "cameraonlymedia", + "password": "CameraPass1!", + "group_ids": [group.json()["id"]], + }, + ) + assert user.status_code == 201, user.text + login = await async_client.post( + "/api/v1/auth/login", + json={"username": "cameraonlymedia", "password": "CameraPass1!"}, + ) + + response = await async_client.post( + f"/api/v1/archives/{archive.id}/media-download-token", + headers={"Authorization": f"Bearer {login.json()['access_token']}"}, + ) + + assert response.status_code == 403 + # ======================================================================== # Update endpoints # ======================================================================== diff --git a/backend/tests/integration/test_printers_api.py b/backend/tests/integration/test_printers_api.py index 87e541160..60b7b0832 100644 --- a/backend/tests/integration/test_printers_api.py +++ b/backend/tests/integration/test_printers_api.py @@ -10,6 +10,9 @@ import pytest from httpx import AsyncClient from sqlalchemy import select +from backend.app.core.config import settings +from backend.app.services.printer_media import PrinterFilesJobStatus, PrinterFilesZipResult + @pytest.fixture(autouse=True) def _mock_printer_test_connection(): @@ -335,14 +338,26 @@ class TestPrintersAPI: filename: str, ascii_fallback: str, db_session, + tmp_path, ): """Non-ASCII filenames must not crash header encoding (issue #1245).""" printer = await printer_factory() file_bytes = b"fake 3mf content" + staged = tmp_path / "single" / "printer-file" + staged.parent.mkdir() + staged.write_bytes(file_bytes) with patch( - "backend.app.api.routes.printers.download_file_bytes_async", - new=AsyncMock(return_value=file_bytes), + "backend.app.api.routes.printers.build_printer_file", + new=AsyncMock( + return_value=PrinterFilesZipResult( + path=staged, + requested=1, + successful=1, + failed_paths=(), + total_bytes=len(file_bytes), + ) + ), ): response = await async_client.get( f"/api/v1/printers/{printer.id}/files/download", @@ -358,6 +373,221 @@ class TestPrintersAPI: encoded_name = content_disposition.split("filename*=UTF-8''", 1)[1] assert unquote(encoded_name) == filename + @pytest.mark.asyncio + @pytest.mark.integration + async def test_download_job_returns_immediately_and_prepared_token_streams_file_response( + self, + async_client: AsyncClient, + printer_factory, + tmp_path, + monkeypatch, + ): + """The browser polls a short job request, then uses a native GET.""" + from backend.app.core.auth import create_slicer_download_token + + printer = await printer_factory() + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + token = await create_slicer_download_token("printer-files", printer.id) + bundle_dir = settings.archive_dir / "temp" / "printer-file-downloads" / f"{printer.id}-{token}" + bundle_dir.mkdir(parents=True) + zip_path = bundle_dir / "printer-files.zip" + zip_path.write_bytes(b"disk-backed zip") + + with patch( + "backend.app.api.routes.printers.start_printer_files_job", + new=AsyncMock( + return_value=PrinterFilesJobStatus( + job_id="job-id", + printer_id=printer.id, + state="queued", + requested=2, + filename="Test Printer videos.zip", + ) + ), + ): + job_response = await async_client.post( + f"/api/v1/printers/{printer.id}/files/download-job", + json={ + "paths": ["/ipcam/one.mp4", "/ipcam/two.mp4"], + "sizes": {"/ipcam/one.mp4": 7, "/ipcam/two.mp4": 8}, + "filename": "Test Printer videos.zip", + "as_zip": True, + }, + ) + assert job_response.status_code == 200 + assert job_response.json() == { + "job_id": "job-id", + "printer_id": printer.id, + "state": "queued", + "requested": 2, + "successful": 0, + "failed": 0, + "token": None, + "filename": "Test Printer videos.zip", + "message": None, + } + + response = await async_client.get( + f"/api/v1/printers/{printer.id}/files/dl/{token}/Test%20Printer%20videos.zip", + ) + + assert response.status_code == 200 + assert response.content == b"disk-backed zip" + assert 'filename="Test Printer videos.zip"' in response.headers["content-disposition"] + + # Tokens are single-use, including after a successful large download. + replay = await async_client.get( + f"/api/v1/printers/{printer.id}/files/dl/{token}/Test%20Printer%20videos.zip", + ) + assert replay.status_code == 403 + # The browser reaches this URL through an click and saves + # whatever comes back under the name it was going to use, so a refusal + # has to arrive as a legible file rather than as a JSON body landing on + # the user's disk named .zip. + assert replay.headers["content-type"].startswith("text/plain") + assert 'filename="download-failed.txt"' in replay.headers["content-disposition"] + assert b"expired" in replay.content + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_bulk_download_token_rejects_another_printer_without_consuming_it( + self, + async_client: AsyncClient, + printer_factory, + tmp_path, + monkeypatch, + ): + """A printer-A token cannot download through printer B and survives that attempt.""" + printer_a = await printer_factory(name="Printer A", serial_number="TOKENBINDINGA01") + printer_b = await printer_factory(name="Printer B", serial_number="TOKENBINDINGB01") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + from backend.app.core.auth import create_slicer_download_token + + token = await create_slicer_download_token("printer-files", printer_a.id) + bundle_dir = settings.archive_dir / "temp" / "printer-file-downloads" / f"{printer_a.id}-{token}" + bundle_dir.mkdir(parents=True) + zip_path = bundle_dir / "printer-files.zip" + zip_path.write_bytes(b"bound zip") + + wrong_printer = await async_client.get( + f"/api/v1/printers/{printer_b.id}/files/dl/{token}/printer-files.zip", + ) + assert wrong_printer.status_code == 403 + + correct_printer = await async_client.get( + f"/api/v1/printers/{printer_a.id}/files/dl/{token}/printer-files.zip", + ) + assert correct_printer.status_code == 200 + assert correct_printer.content == b"bound zip" + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_legacy_bulk_download_accepts_paths_without_sizes( + self, + async_client: AsyncClient, + printer_factory, + tmp_path, + ): + """Existing API clients may omit the newer preflight size hints.""" + + printer = await printer_factory() + bundle_dir = tmp_path / "legacy-bundle" + bundle_dir.mkdir() + zip_path = bundle_dir / "printer-files.zip" + zip_path.write_bytes(b"legacy zip") + build_zip = AsyncMock( + return_value=PrinterFilesZipResult( + path=zip_path, + requested=2, + successful=2, + failed_paths=(), + total_bytes=10, + ) + ) + + with patch("backend.app.api.routes.printers.build_printer_files_zip", new=build_zip): + response = await async_client.post( + f"/api/v1/printers/{printer.id}/files/download-zip", + json={"paths": ["model.gcode", "model.gcode"]}, + ) + + assert response.status_code == 200 + assert response.content == b"legacy zip" + assert build_zip.await_args.args[1:] == (["/model.gcode", "/model.gcode"], {}) + assert build_zip.await_args.kwargs == {"preserve_paths": False, "allow_empty": True} + + @pytest.mark.asyncio + @pytest.mark.integration + async def test_legacy_bulk_download_empty_selection_keeps_400_contract( + self, + async_client: AsyncClient, + printer_factory, + ): + printer = await printer_factory() + + response = await async_client.post( + f"/api/v1/printers/{printer.id}/files/download-zip", + json={"paths": []}, + ) + + assert response.status_code == 400 + + @pytest.mark.asyncio + @pytest.mark.integration + @pytest.mark.parametrize("transport", ["header", "bearer"]) + async def test_printer_file_routes_enforce_api_key_printer_scope( + self, + async_client: AsyncClient, + printer_factory, + db_session, + transport: str, + ): + """A key restricted to printer A must not list printer B's storage.""" + from backend.app.core.auth import generate_api_key + from backend.app.models.api_key import APIKey + from backend.app.services.bambu_ftp import FileListResult + + printer_a = await printer_factory(name="Scoped A", serial_number="SCOPEA000000001") + printer_b = await printer_factory(name="Scoped B", serial_number="SCOPEB000000001") + setup = await async_client.post( + "/api/v1/auth/setup", + json={ + "auth_enabled": True, + "admin_username": "scopeadmin", + "admin_password": "AdminPass1!", + }, + ) + assert setup.status_code == 200, setup.text + + full_key, key_hash, key_prefix = generate_api_key() + db_session.add( + APIKey( + name=f"printer-scope-{transport}", + key_hash=key_hash, + key_prefix=key_prefix, + can_control_printer=True, + printer_ids=[printer_a.id], + enabled=True, + ) + ) + await db_session.commit() + headers = {"X-API-Key": full_key} if transport == "header" else {"Authorization": f"Bearer {full_key}"} + + listing = AsyncMock(return_value=FileListResult(files=[], available=True)) + with patch("backend.app.api.routes.printers.list_files_result_async", new=listing): + denied = await async_client.get( + f"/api/v1/printers/{printer_b.id}/files", + headers=headers, + ) + allowed = await async_client.get( + f"/api/v1/printers/{printer_a.id}/files", + headers=headers, + ) + + assert denied.status_code == 403 + assert allowed.status_code == 200 + listing.assert_awaited_once() + # ======================================================================== # Status endpoint # ======================================================================== diff --git a/backend/tests/unit/services/test_bambu_ftp.py b/backend/tests/unit/services/test_bambu_ftp.py index 4e59cec6b..ad0cf6e57 100644 --- a/backend/tests/unit/services/test_bambu_ftp.py +++ b/backend/tests/unit/services/test_bambu_ftp.py @@ -276,6 +276,66 @@ class TestDownload: assert not local.exists() client.disconnect() + def test_download_to_file_prefers_fresh_server_size_over_stale_client_hint( + self, ftp_client_factory, ftp_server, tmp_path + ): + """The immediate printer SIZE result overrides a stale browser hint.""" + ftp_server.add_file("cache/short.bin", b"short") + local = tmp_path / "short.bin" + client = ftp_client_factory() + client.connect() + try: + assert client.download_to_file("/cache/short.bin", local, expected_size=100) is True + assert local.read_bytes() == b"short" + finally: + client.disconnect() + + def test_download_to_file_enforces_actual_byte_limit(self, ftp_client_factory, ftp_server, tmp_path): + """Untrusted size hints cannot let a transfer exceed the server-side cap.""" + ftp_server.add_file("cache/oversize.bin", b"too large") + local = tmp_path / "oversize.bin" + client = ftp_client_factory() + client.connect() + try: + with pytest.raises(bambu_ftp.DownloadLimitExceeded): + client.download_to_file("/cache/oversize.bin", local, max_bytes=3) + assert not local.exists() + finally: + client.disconnect() + + def test_download_to_file_uses_server_size_when_client_hint_is_omitted(self, tmp_path): + """A clean short RETR is rejected using SIZE, without trusting a caller hint.""" + local = tmp_path / "server-sized.bin" + client = BambuFTPClient("127.0.0.1", "12345678") + + class FakeFTP: + def size(self, _remote_path): + return 100 + + def retrbinary(self, _command, callback): + callback(b"short") + + client._ftp = FakeFTP() + + assert client.download_to_file("/cache/server-sized.bin", local) is False + assert not local.exists() + + def test_download_to_file_falls_back_to_client_hint_when_size_is_unsupported(self, tmp_path): + local = tmp_path / "hint-sized.bin" + client = BambuFTPClient("127.0.0.1", "12345678") + + class FakeFTP: + def size(self, _remote_path): + raise bambu_ftp.ftplib.error_perm("502 SIZE unsupported") + + def retrbinary(self, _command, callback): + callback(b"short") + + client._ftp = FakeFTP() + + assert client.download_to_file("/cache/hint-sized.bin", local, expected_size=100) is False + assert not local.exists() + def test_download_to_file_missing_raises_not_on_printer(self, ftp_client_factory, tmp_path): """Missing file raises FileNotOnPrinterError so callers can short-circuit the retry loop — 550 means the file isn't there and retrying won't help.""" @@ -884,7 +944,7 @@ class TestAsyncWrappers: def connect(self): return True - def download_to_file(self, remote_path, local_path): + def download_to_file(self, remote_path, local_path, **_kwargs): time.sleep(0.4) # longer than wait_for timeout=0.1 local_path.write_bytes(expected_content) return True @@ -933,12 +993,14 @@ class TestAsyncWrappers: def connect(self): return True - def download_to_file(self, remote_path, local_path): + def download_to_file(self, remote_path, local_path, **kwargs): # Simulate an in-progress partial write that never completes - # within the salvage grace period. + # until the async timeout asks the worker to unwind. local_path.write_bytes(b"partial...") - time.sleep(2.0) - return True # would complete eventually, but too late + while not kwargs["cancel_event"].is_set(): + time.sleep(0.01) + local_path.unlink(missing_ok=True) + raise bambu_ftp.DownloadCancelled(remote_path) def disconnect(self): pass @@ -990,7 +1052,7 @@ class TestAsyncWrappers: def connect(self): return True - def download_to_file(self, remote_path, local_path): + def download_to_file(self, remote_path, local_path, **_kwargs): time.sleep(1.5) # wait_for times out at 1.0 s; zombie finishes 0.5 s later local_path.write_bytes(expected_content) return True @@ -1014,6 +1076,61 @@ class TestAsyncWrappers: assert result is True assert local.read_bytes() == expected_content + @pytest.mark.asyncio + async def test_download_file_async_cancellation_waits_for_worker_cleanup(self, tmp_path, monkeypatch): + """Task cancellation returns only after the FTP worker has unwound.""" + from backend.app.services import bambu_ftp + + bambu_ftp.BambuFTPClient._mode_cache.pop("127.0.0.1", None) + local = tmp_path / "cancelled.bin" + started = threading.Event() + finished = threading.Event() + + class FakeClient: + def __init__(self, *args, **kwargs): + pass + + def connect(self): + return True + + def download_to_file(self, remote_path, local_path, **kwargs): + local_path.write_bytes(b"partial") + started.set() + try: + while not kwargs["cancel_event"].is_set(): + time.sleep(0.01) + local_path.unlink(missing_ok=True) + raise bambu_ftp.DownloadCancelled(remote_path) + finally: + finished.set() + + def disconnect(self): + pass + + monkeypatch.setattr(bambu_ftp, "BambuFTPClient", FakeClient) + monkeypatch.setattr(FakeClient, "_mode_cache", {}, raising=False) + monkeypatch.setattr(FakeClient, "A1_MODELS", set(), raising=False) + monkeypatch.setattr(FakeClient, "cache_mode", staticmethod(lambda ip, mode: None), raising=False) + + task = asyncio.create_task( + download_file_async( + "127.0.0.1", + "12345678", + "/cache/cancelled.bin", + local, + timeout=30.0, + printer_model="X1C", + ) + ) + assert await asyncio.to_thread(started.wait, 1.0) + task.cancel() + + with pytest.raises(asyncio.CancelledError): + await task + + assert finished.is_set() + assert not local.exists() + @pytest.mark.asyncio async def test_download_file_try_paths_first_succeeds(self, patch_ftp_port, tmp_path): """download_file_try_paths_async succeeds on first path.""" diff --git a/backend/tests/unit/test_http_utils.py b/backend/tests/unit/test_http_utils.py index 3692a843a..8c220bed9 100644 --- a/backend/tests/unit/test_http_utils.py +++ b/backend/tests/unit/test_http_utils.py @@ -4,7 +4,7 @@ from urllib.parse import unquote import pytest -from backend.app.utils.http import build_content_disposition +from backend.app.utils.http import build_content_disposition, safe_download_filename @pytest.mark.parametrize( @@ -69,3 +69,19 @@ def test_disposition_param_is_respected() -> None: def test_quotes_and_backslashes_stripped_from_ascii_fallback() -> None: header = build_content_disposition('a"b\\c.pdf') assert 'filename="abc.pdf"' in header + + +def test_safe_download_filename_bounds_unicode_and_preserves_normal_suffixes() -> None: + filename = f"{'界' * 300}.gcode.3mf" + result = safe_download_filename(filename) + + assert len(result) == 200 + assert result.endswith(".gcode.3mf") + + +def test_safe_download_filename_drops_path_control_chars_and_pathological_suffix() -> None: + result = safe_download_filename(f"../folder/bad\x00name.{'x' * 300}") + + assert "/" not in result + assert "\x00" not in result + assert len(result) == 200 diff --git a/backend/tests/unit/test_printer_media.py b/backend/tests/unit/test_printer_media.py new file mode 100644 index 000000000..fa84ce698 --- /dev/null +++ b/backend/tests/unit/test_printer_media.py @@ -0,0 +1,411 @@ +import ast +import asyncio +import os +import shutil +import threading +import time +import zipfile +from datetime import datetime +from pathlib import Path +from types import SimpleNamespace +from unittest.mock import AsyncMock, patch + +import pytest + +from backend.app.core.config import settings +from backend.app.services import printer_media +from backend.app.services.printer_media import ( + MAX_PRINTER_ZIP_BYTES, + PrinterFilesZipInsufficientSpaceError, + PrinterFilesZipTooLargeError, + build_printer_files_zip, + match_ipcam_chunks, + prune_stale_printer_file_bundles, + remove_printer_files_zip, +) + + +def test_module_imports_on_every_supported_platform(): + """No POSIX-only import may sit at the top of this module. + + Bambuddy ships a signed Windows installer, and printers.py imports this + module at startup, so a top-level ``import fcntl`` here is not a degraded + feature on Windows -- it is an application that does not boot at all. + network_utils.py is the house pattern: import inside the branch that needs + it, after checking ``sys.platform``. + """ + tree = ast.parse(Path(printer_media.__file__).read_text(encoding="utf-8")) + top_level = { + alias.name.split(".")[0] for node in tree.body if isinstance(node, ast.Import) for alias in node.names + } | {node.module.split(".")[0] for node in tree.body if isinstance(node, ast.ImportFrom) and node.module} + + assert not top_level & {"fcntl", "termios", "pwd", "grp", "resource", "syslog"} + + +def test_match_ipcam_chunks_uses_archive_window_and_ignores_non_video_entries(): + files = [ + {"name": "index", "mtime": datetime(2026, 8, 12, 10, 5), "is_directory": False}, + {"name": "ipcam-record.before.mp4", "mtime": datetime(2026, 8, 12, 9, 50), "is_directory": False}, + {"name": "ipcam-record.first.mp4", "mtime": datetime(2026, 8, 12, 10, 4), "is_directory": False}, + {"name": "ipcam-record.last.mp4", "mtime": datetime(2026, 8, 12, 11, 8), "is_directory": False}, + {"name": "ipcam-record.after.mp4", "mtime": datetime(2026, 8, 12, 11, 11), "is_directory": False}, + ] + + matched = match_ipcam_chunks( + files, + datetime(2026, 8, 12, 10, 0), + datetime(2026, 8, 12, 11, 0), + ) + + assert [file["name"] for file in matched] == ["ipcam-record.first.mp4", "ipcam-record.last.mp4"] + + +@pytest.mark.asyncio +async def test_build_printer_files_zip_stages_on_data_volume_and_compresses_by_type(tmp_path, monkeypatch): + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + + payloads = { + "/ipcam/chunk.mp4": (b"video-") * 512, + "/cache/model.gcode": (b"G1 X1 Y1\n") * 512, + } + + async def fake_download(_ip, _code, remote_path, local_path: Path, **_kwargs): + local_path.write_bytes(payloads[remote_path]) + return True + + with patch( + "backend.app.services.printer_media.download_file_async", + new=AsyncMock(side_effect=fake_download), + ): + result = await build_printer_files_zip( + printer, + ["/ipcam/chunk.mp4", "/cache/model.gcode"], + {path: len(payload) for path, payload in payloads.items()}, + ) + zip_path = result.path + + try: + assert result.successful == 2 + assert zip_path.is_relative_to(settings.archive_dir / "temp" / "printer-file-downloads") + with zipfile.ZipFile(zip_path) as archive: + assert archive.namelist() == ["ipcam/chunk.mp4", "cache/model.gcode"] + assert archive.getinfo("ipcam/chunk.mp4").compress_type == zipfile.ZIP_STORED + assert archive.getinfo("cache/model.gcode").compress_type == zipfile.ZIP_DEFLATED + assert not list(zip_path.parent.glob("download-*")) + finally: + remove_printer_files_zip(zip_path) + + assert not zip_path.parent.exists() + + +@pytest.mark.asyncio +async def test_build_printer_files_zip_offloads_blocking_zip_and_filesystem_work(tmp_path, monkeypatch): + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + event_loop_thread = threading.get_ident() + offloaded_threads: list[int] = [] + real_prune = printer_media._prune_stale_bundles + real_space_check = printer_media._check_initial_space + + def tracking_prune(root): + offloaded_threads.append(threading.get_ident()) + return real_prune(root) + + def tracking_space_check(root, sizes): + offloaded_threads.append(threading.get_ident()) + return real_space_check(root, sizes) + + async def fake_download(_ip, _code, _remote_path, local_path: Path, **_kwargs): + local_path.write_bytes(b"G1 X1 Y1\n" * 512) + return True + + monkeypatch.setattr(printer_media, "_prune_stale_bundles", tracking_prune) + monkeypatch.setattr(printer_media, "_check_initial_space", tracking_space_check) + with patch("backend.app.services.printer_media.download_file_async", new=AsyncMock(side_effect=fake_download)): + result = await build_printer_files_zip(printer, ["/model.gcode"], {"/model.gcode": 4608}) + + try: + assert offloaded_threads + assert all(thread_id != event_loop_thread for thread_id in offloaded_threads) + finally: + remove_printer_files_zip(result.path) + + +@pytest.mark.asyncio +async def test_prune_stale_printer_file_bundles_removes_hour_old_abandoned_bundle(tmp_path, monkeypatch): + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + root = settings.archive_dir / "temp" / "printer-file-downloads" + stale = root / "stale" + fresh = root / "fresh" + stale.mkdir(parents=True) + fresh.mkdir() + (stale / "printer-files.zip").write_bytes(b"stale") + (fresh / "printer-files.zip").write_bytes(b"fresh") + old = time.time() - 60 * 60 - 1 + os.utime(stale, (old, old)) + + await prune_stale_printer_file_bundles() + + assert not stale.exists() + assert fresh.exists() + + +@pytest.mark.asyncio +async def test_build_printer_files_zip_skips_relative_and_nul_paths(tmp_path, monkeypatch): + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + + async def fake_download(_ip, _code, remote_path, local_path: Path, **_kwargs): + local_path.write_bytes(b"valid") + return True + + download = AsyncMock(side_effect=fake_download) + with patch("backend.app.services.printer_media.download_file_async", new=download): + result = await build_printer_files_zip( + printer, + ["relative.gcode", "/bad\x00.gcode", "/valid.gcode"], + {"relative.gcode": 1, "/bad\x00.gcode": 1, "/valid.gcode": 5}, + ) + + try: + assert result.requested == 3 + assert result.successful == 1 + assert result.failed_paths == ("relative.gcode", "/bad\x00.gcode") + download.assert_awaited_once() + assert download.await_args.args[2] == "/valid.gcode" + finally: + remove_printer_files_zip(result.path) + + +@pytest.mark.asyncio +async def test_build_printer_files_zip_rejects_oversized_selection_before_download(tmp_path, monkeypatch): + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + download = AsyncMock() + + with ( + patch("backend.app.services.printer_media.download_file_async", new=download), + pytest.raises(PrinterFilesZipTooLargeError), + ): + await build_printer_files_zip( + printer, + ["/huge.mp4"], + {"/huge.mp4": MAX_PRINTER_ZIP_BYTES + 1}, + ) + + download.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_build_printer_files_zip_rejects_insufficient_data_volume_space(tmp_path, monkeypatch): + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + monkeypatch.setattr("backend.app.services.printer_media.shutil.disk_usage", lambda _path: SimpleNamespace(free=1)) + + with pytest.raises(PrinterFilesZipInsufficientSpaceError): + await build_printer_files_zip(printer, ["/small.gcode"], {"/small.gcode": 5}) + + +@pytest.mark.asyncio +async def test_build_printer_files_zip_keeps_a_file_whose_listing_size_went_stale(tmp_path, monkeypatch): + """A verified transfer is not re-judged against the browser's size hint. + + download_to_file compares what it wrote against the printer's own SIZE and + treats that as the authority, precisely because it beats a hint the browser + round-tripped. The hint goes stale in the case this feature exists for -- an + /ipcam chunk still being written when the modal listed it -- and the file + then arrives longer than advertised. Dropping it as "truncated" would fail + the one selection the user came for; a genuinely short RETR is already + rejected a layer down (test_bambu_ftp.py). + """ + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + + async def fake_download(_ip, _code, _remote_path, local_path: Path, **_kwargs): + # The chunk grew by 20 bytes between the listing and the transfer. + local_path.write_bytes(b"A" * 120) + return True + + with patch("backend.app.services.printer_media.download_file_async", new=AsyncMock(side_effect=fake_download)): + result = await build_printer_files_zip(printer, ["/ipcam/chunk.mp4"], {"/ipcam/chunk.mp4": 100}) + + try: + assert (result.successful, result.failed_paths) == (1, ()) + with zipfile.ZipFile(result.path) as archive: + assert archive.read("ipcam/chunk.mp4") == b"A" * 120 + finally: + remove_printer_files_zip(result.path) + + +def test_match_ipcam_chunks_caps_an_unfinished_archive_window(): + files = [ + { + "name": "ipcam-record.next-week.mp4", + "mtime": datetime(2026, 8, 20, 10, 0), + "is_directory": False, + } + ] + + assert ( + match_ipcam_chunks( + files, + datetime(2026, 8, 12, 10, 0), + None, + now=datetime(2026, 8, 21, 10, 0), + ) + == [] + ) + + +@pytest.mark.asyncio +async def test_build_printer_files_zip_cleans_bundle_on_cancellation(tmp_path, monkeypatch): + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + + async def cancel_download(*_args, **_kwargs): + raise asyncio.CancelledError + + with ( + patch("backend.app.services.printer_media.download_file_async", new=AsyncMock(side_effect=cancel_download)), + pytest.raises(asyncio.CancelledError), + ): + await build_printer_files_zip(printer, ["/video.mp4"], {"/video.mp4": 100}) + + root = settings.archive_dir / "temp" / "printer-file-downloads" + assert not list(root.glob("bundle-*")) + + +@pytest.mark.asyncio +async def test_build_printer_files_zip_reports_per_file_progress(tmp_path, monkeypatch): + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + progress: list[tuple[int, int]] = [] + + async def fake_download(_ip, _code, remote_path, local_path: Path, **_kwargs): + if remote_path.endswith("missing.gcode"): + return False + local_path.write_bytes(b"ok") + return True + + async def report(successful: int, failed: int) -> None: + progress.append((successful, failed)) + + with patch( + "backend.app.services.printer_media.download_file_async", + new=AsyncMock(side_effect=fake_download), + ): + result = await build_printer_files_zip( + printer, + ["/ok.gcode", "/missing.gcode"], + {"/ok.gcode": 2, "/missing.gcode": 2}, + progress_callback=report, + ) + + try: + assert progress == [(1, 0), (1, 1)] + finally: + remove_printer_files_zip(result.path) + + +@pytest.mark.asyncio +async def test_two_preparations_run_at_the_same_time(tmp_path, monkeypatch): + """Nothing queues one preparation behind another. + + An exclusive staging lock held for the length of a transfer would make one + ten-gigabyte selection block every other download on the instance -- and the + same code path serves the file browser's 3MF preview, so it would block that + too, for as long as the selection takes. + """ + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + active = 0 + max_active = 0 + + async def fake_download(_ip, _code, _remote_path, local_path: Path, **_kwargs): + nonlocal active, max_active + active += 1 + max_active = max(max_active, active) + try: + await asyncio.sleep(0.05) + local_path.write_bytes(b"ok") + return True + finally: + active -= 1 + + with patch( + "backend.app.services.printer_media.download_file_async", + new=AsyncMock(side_effect=fake_download), + ): + first, second = await asyncio.gather( + build_printer_files_zip(printer, ["/first.gcode"], {"/first.gcode": 2}), + build_printer_files_zip(printer, ["/second.gcode"], {"/second.gcode": 2}), + ) + + try: + assert max_active == 2 + finally: + remove_printer_files_zip(first.path) + remove_printer_files_zip(second.path) + + +@pytest.mark.asyncio +async def test_concurrent_preparations_both_stop_at_the_disk_reserve(tmp_path, monkeypatch): + """With preparations running together, the reserve is what has to hold. + + The preflight only sees client-reported hints, and two jobs read the same + free space before either has spent any of it, so neither can be the bound. + The per-file check against actual bytes is, and it stops both of them + without leaving a staged bundle behind. + """ + printer = SimpleNamespace(ip_address="printer", access_code="code", model="X1C") + archive_dir = tmp_path / "archive" + monkeypatch.setattr(settings, "archive_dir", archive_dir) + # Enough for the preflight, which is told 2 bytes; nowhere near enough for + # the 10 MiB that actually arrives. + monkeypatch.setattr( + "backend.app.services.printer_media.shutil.disk_usage", + lambda _path: SimpleNamespace(free=printer_media.PRINTER_ZIP_FREE_SPACE_RESERVE + 1024 * 1024), + ) + + async def fake_download(_ip, _code, _remote_path, local_path: Path, **_kwargs): + await asyncio.sleep(0.01) + local_path.write_bytes(b"A" * (10 * 1024 * 1024)) + return True + + with patch( + "backend.app.services.printer_media.download_file_async", + new=AsyncMock(side_effect=fake_download), + ): + outcomes = await asyncio.gather( + build_printer_files_zip(printer, ["/first.gcode"], {"/first.gcode": 2}), + build_printer_files_zip(printer, ["/second.gcode"], {"/second.gcode": 2}), + return_exceptions=True, + ) + + assert all(isinstance(outcome, PrinterFilesZipInsufficientSpaceError) for outcome in outcomes), outcomes + root = archive_dir / "temp" / "printer-file-downloads" + assert [child for child in root.iterdir() if child.is_dir()] == [] + + +@pytest.mark.asyncio +async def test_shutdown_awaits_download_jobs_and_publishes_cancellation(tmp_path, monkeypatch): + monkeypatch.setattr(settings, "archive_dir", tmp_path / "archive") + job_id = "shutdown-job-abcdefghijklmnop" + printer_media._ensure_printer_zip_root() + started = asyncio.Event() + + async def wait_forever(): + started.set() + await asyncio.Event().wait() + + task = asyncio.create_task(wait_forever()) + printer_media._LOCAL_JOB_TASKS[job_id] = task + await started.wait() + + await printer_media.stop_printer_download_cleanup() + + assert task.done() + assert task.cancelled() + assert printer_media._LOCAL_JOB_TASKS == {} + assert printer_media._job_cancel_path(job_id).exists() diff --git a/backend/tests/unit/test_route_auth_coverage.py b/backend/tests/unit/test_route_auth_coverage.py index 5da459e01..934cbca46 100644 --- a/backend/tests/unit/test_route_auth_coverage.py +++ b/backend/tests/unit/test_route_auth_coverage.py @@ -81,6 +81,12 @@ _PUBLIC_ROUTES: frozenset[tuple[str, str]] = frozenset( ("GET", "/api/v1/archives/{archive_id}/dl/{token}/{filename}"), ("GET", "/api/v1/archives/{archive_id}/source-dl/{token}/{filename}"), ("GET", "/api/v1/library/files/{file_id}/dl/{token}/{filename}"), + # Printer download target — validates a short-lived, single-use token + # bound to the printer ID before streaming its prepared bundle. + ("GET", "/api/v1/printers/{printer_id}/files/dl/{token}/{filename}"), + # Attached archive media target — validates a token bound to the + # archive ID before returning the local timelapse. + ("GET", "/api/v1/archives/{archive_id}/media/dl/{token}/{filename}"), # Obico cached frame — one-time nonce embedded in tags. ("GET", "/api/v1/obico/cached-frame/{nonce}"), # MakerWorld thumbnail proxy — fetches external URL; no Bambuddy data exposed. diff --git a/frontend/src/__tests__/components/ArchiveMediaDownloadModal.test.tsx b/frontend/src/__tests__/components/ArchiveMediaDownloadModal.test.tsx new file mode 100644 index 000000000..57ae825db --- /dev/null +++ b/frontend/src/__tests__/components/ArchiveMediaDownloadModal.test.tsx @@ -0,0 +1,199 @@ +import { act, fireEvent, render, screen, waitFor } from '@testing-library/react'; +import { QueryClient, QueryClientProvider } from '@tanstack/react-query'; +import { beforeEach, describe, expect, it, vi } from 'vitest'; +import { ArchiveMediaDownloadModal } from '../../components/ArchiveMediaDownloadModal'; +import { api } from '../../api/client'; + +const showToast = vi.fn(); + +vi.mock('../../contexts/ToastContext', () => ({ + useToast: () => ({ showToast }), +})); + +vi.mock('../../api/client', () => ({ + api: { + getArchivePrinterMedia: vi.fn(), + downloadArchiveTimelapse: vi.fn(), + downloadPrinterFilesAsZip: vi.fn(), + }, +})); + +const media = { + archive_id: 1, + printer_id: 1, + local_timelapse: null, + remote_files: [{ + name: 'video.mp4', + path: '/timelapse/video.mp4', + size: 1024, + mtime: '2026-08-18T10:00:00Z', + kind: 'timelapse' as const, + }], + warnings: [], +}; + +describe('ArchiveMediaDownloadModal', () => { + beforeEach(() => { + vi.clearAllMocks(); + vi.mocked(api.getArchivePrinterMedia).mockResolvedValue(media); + }); + + it('does not reselect a manually deselected single file when query data refreshes', async () => { + const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } }); + render( + + + , + ); + + const filename = await screen.findByText('video.mp4'); + const downloadButton = screen.getByRole('button', { name: /Download selected \(1\)/i }); + expect(downloadButton).toBeEnabled(); + + fireEvent.click(filename.closest('button')!); + expect(screen.getByRole('button', { name: /Download selected \(0\)/i })).toBeDisabled(); + + await act(async () => { + queryClient.setQueryData(['archive-printer-media', 1], { + ...media, + remote_files: [...media.remote_files], + }); + }); + + await waitFor(() => { + expect(screen.getByRole('button', { name: /Download selected \(0\)/i })).toBeDisabled(); + }); + }); + + it('prunes a selected path that disappears during refetch', async () => { + const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } }); + render( + + + , + ); + + expect(await screen.findByRole('button', { name: /Download selected \(1\)/i })).toBeEnabled(); + await act(async () => { + queryClient.setQueryData(['archive-printer-media', 1], { ...media, remote_files: [] }); + }); + + await waitFor(() => expect(screen.queryByRole('button', { name: /Download selected/i })).not.toBeInTheDocument()); + }); + + it('shows unavailable warnings even when no media was found', async () => { + vi.mocked(api.getArchivePrinterMedia).mockResolvedValue({ + ...media, + remote_files: [], + warnings: ['timelapse_unavailable', 'ipcam_unavailable'], + }); + const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } }); + render( + + + , + ); + + expect(await screen.findByText(/No timelapse or IP camera chunks were found/)).toBeInTheDocument(); + expect(screen.getByText('The timelapse directory could not be read')).toBeInTheDocument(); + expect(screen.getByText('The IP camera directory could not be read')).toBeInTheDocument(); + }); + + it('shows how far the preparation has got', async () => { + // The file browser has shown per-file progress from this same call all + // along; without it the archive side is a spinner for as long as the + // transfer takes, which for a few /ipcam chunks is minutes. + vi.mocked(api.downloadPrinterFilesAsZip).mockImplementation( + (_printerId, _paths, _sizes, _filename, _asZip, _signal, onProgress) => { + onProgress?.(1, 2); + return new Promise(() => {}); + }, + ); + const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } }); + render( + + + , + ); + + fireEvent.click(await screen.findByRole('button', { name: /Download selected \(1\)/i })); + + expect(await screen.findByText('1/2')).toBeInTheDocument(); + }); + + it('cancels an in-flight printer preparation when the modal unmounts', async () => { + let observedSignal: AbortSignal | undefined; + vi.mocked(api.downloadPrinterFilesAsZip).mockImplementation( + (_printerId, _paths, _sizes, _filename, _asZip, signal) => { + observedSignal = signal; + return new Promise((_resolve, reject) => { + signal?.addEventListener('abort', () => reject(new DOMException('cancelled', 'AbortError'))); + }); + }, + ); + const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } }); + const { unmount } = render( + + + , + ); + + fireEvent.click(await screen.findByRole('button', { name: /Download selected \(1\)/i })); + await waitFor(() => expect(api.downloadPrinterFilesAsZip).toHaveBeenCalledOnce()); + unmount(); + + expect(observedSignal?.aborted).toBe(true); + }); + + it('reports a local timelapse token failure', async () => { + vi.mocked(api.getArchivePrinterMedia).mockResolvedValue({ + ...media, + local_timelapse: { name: 'attached.mp4', size: 42 }, + remote_files: [], + }); + vi.mocked(api.downloadArchiveTimelapse).mockRejectedValue(new Error('token expired')); + const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } }); + render( + + + , + ); + + fireEvent.click(await screen.findByRole('button', { name: /^Download$/i })); + + await waitFor(() => expect(showToast).toHaveBeenCalledWith( + 'Download failed: token expired', + 'error', + )); + }); +}); diff --git a/frontend/src/__tests__/components/FileManagerModal.test.tsx b/frontend/src/__tests__/components/FileManagerModal.test.tsx index 0f15e032f..a4835b076 100644 --- a/frontend/src/__tests__/components/FileManagerModal.test.tsx +++ b/frontend/src/__tests__/components/FileManagerModal.test.tsx @@ -219,6 +219,64 @@ describe('FileManagerModal', () => { } }); + it('selects the visible range between a click and a shift-click', async () => { + server.use( + http.get('/api/v1/printers/:id/files', () => HttpResponse.json({ + files: [ + ...mockFiles.filter(file => file.is_directory), + { name: 'alpha.gcode', path: '/alpha.gcode', size: 1, is_directory: false, mtime: null }, + { name: 'bravo.gcode', path: '/bravo.gcode', size: 2, is_directory: false, mtime: null }, + { name: 'charlie.gcode', path: '/charlie.gcode', size: 3, is_directory: false, mtime: null }, + { name: 'delta.gcode', path: '/delta.gcode', size: 4, is_directory: false, mtime: null }, + ], + })), + ); + + render( + + ); + + fireEvent.click(await screen.findByRole('button', { name: 'Select alpha.gcode' })); + fireEvent.click(screen.getByRole('button', { name: 'Select charlie.gcode' }), { shiftKey: true }); + + expect(await screen.findByText('3 selected')).toBeInTheDocument(); + expect(screen.getByRole('button', { name: 'Deselect alpha.gcode' })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: 'Deselect bravo.gcode' })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: 'Deselect charlie.gcode' })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: 'Select delta.gcode' })).toBeInTheDocument(); + }); + + it('always selects a shift-clicked range even when the target is already selected', async () => { + server.use( + http.get('/api/v1/printers/:id/files', () => HttpResponse.json({ + files: [ + { name: 'alpha.gcode', path: '/alpha.gcode', size: 1, is_directory: false, mtime: null }, + { name: 'bravo.gcode', path: '/bravo.gcode', size: 2, is_directory: false, mtime: null }, + { name: 'charlie.gcode', path: '/charlie.gcode', size: 3, is_directory: false, mtime: null }, + ], + })), + ); + + render( + + ); + + fireEvent.click(await screen.findByRole('button', { name: 'Select alpha.gcode' })); + fireEvent.click(screen.getByRole('button', { name: 'Select charlie.gcode' })); + fireEvent.click(screen.getByRole('button', { name: 'Deselect alpha.gcode' }), { shiftKey: true }); + + expect(await screen.findByText('3 selected')).toBeInTheDocument(); + expect(screen.getByRole('button', { name: 'Deselect bravo.gcode' })).toBeInTheDocument(); + }); + it('enables download button when files are selected', async () => { render( { expect(screen.getByText('Select All')).toBeInTheDocument(); }); }); + + it('starts a preparation job, uses a native download link, and reports partial results', async () => { + let preparation: { + paths: string[]; + sizes: Record; + filename: string; + as_zip: boolean; + } | null = null; + server.use( + http.post('/api/v1/printers/:id/files/download-job', async ({ request }) => { + preparation = await request.json() as typeof preparation; + return HttpResponse.json({ + job_id: 'job-id', + state: 'ready', + token: 'download-token', + requested: 2, + successful: 1, + failed: 1, + message: null, + }); + }), + ); + const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => undefined); + + render( + + ); + + await waitFor(() => expect(screen.getByText('Select All')).toBeInTheDocument()); + fireEvent.click(screen.getByText('Select All')); + fireEvent.click(screen.getByRole('button', { name: /Download \(2\)/i })); + + await waitFor(() => expect(clickSpy).toHaveBeenCalledOnce()); + expect(preparation).toEqual({ + paths: ['/benchy.3mf', '/print_job.gcode'], + sizes: { + '/benchy.3mf': 1048575, + '/print_job.gcode': 2048000, + }, + filename: 'X1_Carbon-files.zip', + as_zip: true, + }); + expect(document.querySelector('a')).toBeNull(); + expect(await screen.findByText( + 'ZIP download started with 1 of 2 files; the rest could not be retrieved', + )).toBeInTheDocument(); + clickSpy.mockRestore(); + }); }); describe('search and filter', () => { @@ -286,6 +396,59 @@ describe('FileManagerModal', () => { expect(screen.queryByText('print_job.gcode')).not.toBeInTheDocument(); }); }); + + it('selects all files from the shared visible-file filter', async () => { + render( + + ); + + await waitFor(() => expect(screen.getByText('benchy.3mf')).toBeInTheDocument()); + fireEvent.change(screen.getByPlaceholderText('Filter files...'), { target: { value: 'benchy' } }); + fireEvent.click(screen.getByText('Select All')); + + expect(screen.getByText('1 selected')).toBeInTheDocument(); + expect(screen.getByRole('button', { name: 'Download' })).toBeEnabled(); + }); + + it('keeps the selection when a refresh cannot reach the printer', async () => { + render( + + ); + + fireEvent.click(await screen.findByRole('button', { name: 'Select benchy.3mf' })); + expect(screen.getByText('1 selected')).toBeInTheDocument(); + + // An unreachable printer answers with an empty list plus a warning. That + // is not the same statement as "those files are gone", and it must not + // throw away a selection the user made moments ago. + server.use( + http.get('/api/v1/printers/:id/files', () => + HttpResponse.json({ files: [], warnings: ['printer_unavailable'] }) + ) + ); + fireEvent.click(screen.getByRole('button', { name: 'Refresh' })); + + expect(await screen.findByText( + 'The printer file service is unavailable. Try again when the printer is reachable.', + )).toBeInTheDocument(); + expect(screen.getByText('1 selected')).toBeInTheDocument(); + }); + + it('drops hidden selections when the filter changes', async () => { + render( + + ); + + fireEvent.click(await screen.findByRole('button', { name: 'Select benchy.3mf' })); + expect(screen.getByText('1 selected')).toBeInTheDocument(); + fireEvent.change(screen.getByPlaceholderText('Filter files...'), { target: { value: 'gcode' } }); + + await waitFor(() => expect(screen.getByRole('button', { name: 'Download' })).toBeDisabled()); + }); }); describe('sorting', () => { @@ -386,9 +549,30 @@ describe('FileManagerModal', () => { ); await waitFor(() => { - expect(screen.getByText('No files in this directory')).toBeInTheDocument(); + expect(screen.getByText('No files on printer')).toBeInTheDocument(); }); }); + + it('distinguishes an unreachable printer from an empty directory', async () => { + server.use( + http.get('/api/v1/printers/:id/files', () => { + return HttpResponse.json({ files: [], warnings: ['printer_unavailable'] }); + }) + ); + + render( + + ); + + expect(await screen.findByText( + 'The printer file service is unavailable. Try again when the printer is reachable.', + )).toBeInTheDocument(); + expect(screen.queryByText('No files on printer')).not.toBeInTheDocument(); + }); }); describe('loading state', () => { diff --git a/frontend/src/__tests__/pages/ArchivesPage.test.tsx b/frontend/src/__tests__/pages/ArchivesPage.test.tsx index 1099a614d..70ea1a41d 100644 --- a/frontend/src/__tests__/pages/ArchivesPage.test.tsx +++ b/frontend/src/__tests__/pages/ArchivesPage.test.tsx @@ -2,12 +2,13 @@ * Tests for the ArchivesPage component. */ -import { describe, it, expect, beforeEach } from 'vitest'; +import { describe, it, expect, beforeEach, afterEach } from 'vitest'; import { screen, waitFor, fireEvent } from '@testing-library/react'; import { render } from '../utils'; import { ArchivesPage } from '../../pages/ArchivesPage'; import { http, HttpResponse } from 'msw'; import { server } from '../mocks/server'; +import { setAuthToken } from '../../api/client'; const mockArchives = [ { @@ -68,6 +69,7 @@ const mockArchiveStats = { describe('ArchivesPage', () => { beforeEach(() => { + setAuthToken(null); server.use( http.get('/api/v1/archives/', () => { return HttpResponse.json(mockArchives); @@ -102,6 +104,10 @@ describe('ArchivesPage', () => { ); }); + afterEach(() => { + setAuthToken(null); + }); + describe('rendering', () => { it('renders the page title', async () => { render(); @@ -340,6 +346,109 @@ describe('ArchivesPage', () => { }); describe('timelapse management', () => { + it('keeps an attached timelapse available without printer-file permission', async () => { + setAuthToken('archive-only-token', 'session'); + server.use( + http.get('*/api/v1/auth/status', () => HttpResponse.json({ + auth_enabled: true, + requires_setup: false, + })), + http.get('/api/v1/auth/me', () => HttpResponse.json({ + id: 7, + username: 'archive-viewer', + is_active: true, + is_admin: false, + groups: [], + permissions: ['archives:read_all'], + created_at: '2026-08-18T00:00:00Z', + })), + http.get('/api/v1/archives/', () => HttpResponse.json([ + { ...mockArchives[0], timelapse_path: 'timelapses/attached.mp4' }, + { ...mockArchives[1], timelapse_path: null }, + ])), + http.get('/api/v1/archives/:id/printer-media', ({ params }) => HttpResponse.json({ + archive_id: Number(params.id), + printer_id: 1, + local_timelapse: { name: 'attached.mp4', size: 1024 }, + remote_files: [], + warnings: ['printer_files_forbidden'], + })), + ); + + render(); + + const mediaButton = (await screen.findAllByTitle('Download print videos'))[0]; + expect(mediaButton).toBeEnabled(); + const deniedButtons = screen.getAllByTitle('You do not have permission to access printer files'); + expect(deniedButtons.every(button => button.hasAttribute('disabled'))).toBe(true); + + fireEvent.click(mediaButton); + expect(await screen.findByText('attached.mp4')).toBeInTheDocument(); + expect(screen.getByText('You do not have permission to access printer files')).toBeInTheDocument(); + }); + + it('opens print video downloads and shows matching IP camera chunks', async () => { + server.use( + http.get('/api/v1/archives/:id/printer-media', ({ params }) => { + return HttpResponse.json({ + archive_id: Number(params.id), + printer_id: 1, + local_timelapse: null, + remote_files: [ + { + name: 'ipcam-record.2024-01-01_10-05-00.1.mp4', + path: '/ipcam/ipcam-record.2024-01-01_10-05-00.1.mp4', + size: 250_000_000, + mtime: '2024-01-01T10:10:00Z', + kind: 'ipcam', + }, + ], + warnings: [], + }); + }), + ); + + render(); + const mediaButtons = await screen.findAllByTitle('Download print videos'); + fireEvent.click(mediaButtons[0]); + + expect(await screen.findByText('Print videos')).toBeInTheDocument(); + expect(await screen.findByText('ipcam-record.2024-01-01_10-05-00.1.mp4')).toBeInTheDocument(); + }); + + it('shows a toast when printer video ZIP preparation fails', async () => { + server.use( + http.get('/api/v1/archives/:id/printer-media', ({ params }) => HttpResponse.json({ + archive_id: Number(params.id), + printer_id: 1, + local_timelapse: null, + remote_files: [{ + name: 'ipcam-record.1.mp4', + path: '/ipcam/ipcam-record.1.mp4', + size: 250_000_000, + mtime: '2024-01-01T10:10:00Z', + kind: 'ipcam', + }], + warnings: [], + })), + http.post('/api/v1/printers/:id/files/download-job', () => HttpResponse.json({ + job_id: 'failed-job', + state: 'failed', + requested: 1, + successful: 0, + failed: 0, + token: null, + message: 'Not enough app data volume space', + })), + ); + + render(); + fireEvent.click((await screen.findAllByTitle('Download print videos'))[0]); + fireEvent.click(await screen.findByRole('button', { name: /Download selected \(1\)/i })); + + expect(await screen.findByText('Download failed: Not enough app data volume space')).toBeInTheDocument(); + }); + it('shows upload timelapse menu item when no timelapse attached', async () => { const archivesWithoutTimelapse = mockArchives.map(a => ({ ...a, timelapse_path: null })); server.use( diff --git a/frontend/src/__tests__/pages/PrintersPage.test.tsx b/frontend/src/__tests__/pages/PrintersPage.test.tsx index af5ae0603..cbe1b75e0 100644 --- a/frontend/src/__tests__/pages/PrintersPage.test.tsx +++ b/frontend/src/__tests__/pages/PrintersPage.test.tsx @@ -150,6 +150,22 @@ describe('PrintersPage', () => { expect(screen.getByText('X1 Carbon')).toBeInTheDocument(); }); }); + + it('offers FTP file browsing when MQTT status is offline', async () => { + server.use( + http.get('/api/v1/printers/:id/status', () => { + return HttpResponse.json({ ...mockPrinterStatus, connected: false }); + }), + ); + + render(); + + const browseButtons = await screen.findAllByRole('button', { name: /browse printer files/i }); + expect(browseButtons).toHaveLength(mockPrinters.length); + await userEvent.click(browseButtons[0]); + + expect(await screen.findByText('File Manager')).toBeInTheDocument(); + }); }); describe('printer info', () => { diff --git a/frontend/src/__tests__/pages/PrintersPageDropOnBusy.test.tsx b/frontend/src/__tests__/pages/PrintersPageDropOnBusy.test.tsx index e1e090973..a93b96b69 100644 --- a/frontend/src/__tests__/pages/PrintersPageDropOnBusy.test.tsx +++ b/frontend/src/__tests__/pages/PrintersPageDropOnBusy.test.tsx @@ -58,9 +58,12 @@ function renderWith(statusOver: Record) { http.get('/api/v1/printers/', () => HttpResponse.json([mockPrinter])), http.get('/api/v1/printers/:id/status', () => HttpResponse.json(makeStatus(statusOver))), http.get('/api/v1/queue/', () => HttpResponse.json([])), - http.post('/api/v1/library/files', async ({ request }) => { - const form = await request.formData(); - uploads.push((form.get('file') as File).name); + http.post('/api/v1/library/files', () => { + // Parsing multipart bodies in MSW depends on the Node.js FormData + // implementation and is unrelated to this regression. Recording the + // matched request proves the page attempted the upload without making + // the test sensitive to that runtime detail. + uploads.push('request'); return HttpResponse.json({ id: 7, filename: 'part.gcode', metadata: {} }); }), ); diff --git a/frontend/src/api/client.ts b/frontend/src/api/client.ts index a427cc14f..4ae676701 100644 --- a/frontend/src/api/client.ts +++ b/frontend/src/api/client.ts @@ -696,6 +696,22 @@ export interface ArchiveDuplicate { match_type: 'exact' | 'similar'; // 'exact' = hash match, 'similar' = name match } +export interface ArchivePrinterMediaFile { + name: string; + path: string; + size: number; + mtime: string | null; + kind: 'timelapse' | 'ipcam'; +} + +export interface ArchivePrinterMedia { + archive_id: number; + printer_id: number | null; + local_timelapse: { name: string; size: number } | null; + remote_files: ArchivePrinterMediaFile[]; + warnings: Array<'printer_missing' | 'timelapse_unavailable' | 'ipcam_unavailable' | 'printer_files_forbidden'>; +} + export interface Archive { id: number; printer_id: number | null; @@ -4671,6 +4687,7 @@ export const api = { path: string; mtime?: string; }>; + warnings: Array<'printer_unavailable'>; }>(`/printers/${printerId}/files?path=${encodeURIComponent(path)}`), getPrinterFileDownloadUrl: (printerId: number, path: string) => `${API_BASE}/printers/${printerId}/files/download?path=${encodeURIComponent(path)}`, @@ -4701,46 +4718,81 @@ export const api = { }>(`/printers/${printerId}/files/plates?path=${encodeURIComponent(path)}`), getPrinterFilePlateThumbnail: (printerId: number, plateIndex: number, path: string) => withStreamToken(`${API_BASE}/printers/${printerId}/files/plate-thumbnail/${plateIndex}?path=${encodeURIComponent(path)}`), - downloadPrinterFile: async (printerId: number, path: string): Promise => { - const headers: Record = {}; - if (authToken) { - headers['Authorization'] = `Bearer ${authToken}`; + downloadPrinterFilesAsZip: async ( + printerId: number, + paths: string[], + sizes: Record, + filename = 'printer-files.zip', + asZip = true, + signal?: AbortSignal, + onProgress?: (completed: number, total: number) => void, + ): Promise<{ requested: number; successful: number; failed: number }> => { + type JobStatus = { + job_id: string; + state: 'queued' | 'preparing' | 'ready' | 'failed' | 'cancelled'; + requested: number; + successful: number; + failed: number; + token: string | null; + message: string | null; + }; + let jobId: string | null = null; + try { + if (signal?.aborted) throw new DOMException('Download cancelled', 'AbortError'); + let status = await request(`/printers/${printerId}/files/download-job`, { + method: 'POST', + body: JSON.stringify({ paths, sizes, filename, as_zip: asZip }), + signal, + }); + jobId = status.job_id; + let polls = 0; + while (status.state === 'queued' || status.state === 'preparing') { + onProgress?.(status.successful + status.failed, status.requested); + // Small selections finish in the first seconds, so poll quickly there. + // A large one runs for up to half an hour, where half-second polling is + // thousands of requests that each re-check the caller's credentials. + const delay = polls < 10 ? 500 : 2000; + polls += 1; + await new Promise((resolve, reject) => { + if (signal?.aborted) { + reject(new DOMException('Download cancelled', 'AbortError')); + return; + } + const onAbort = () => { + window.clearTimeout(timer); + reject(new DOMException('Download cancelled', 'AbortError')); + }; + const timer = window.setTimeout(() => { + signal?.removeEventListener('abort', onAbort); + resolve(); + }, delay); + signal?.addEventListener('abort', onAbort, { once: true }); + }); + status = await request(`/printers/${printerId}/files/download-jobs/${jobId}`, { signal }); + } + onProgress?.(status.successful + status.failed, status.requested); + if (status.state !== 'ready' || !status.token) { + throw new Error(status.message || (status.state === 'cancelled' + ? 'Download cancelled' + : 'Printer download preparation failed')); + } + const link = document.createElement('a'); + link.href = `${API_BASE}/printers/${printerId}/files/dl/${encodeURIComponent(status.token)}/${encodeURIComponent(filename)}`; + link.download = filename; + document.body.appendChild(link); + link.click(); + link.remove(); + return { + requested: status.requested, + successful: status.successful, + failed: status.failed, + }; + } catch (error) { + if (jobId) { + await request(`/printers/${printerId}/files/download-jobs/${jobId}`, { method: 'DELETE' }).catch(() => undefined); + } + throw error; } - const response = await fetch( - `${API_BASE}/printers/${printerId}/files/download?path=${encodeURIComponent(path)}`, - { headers } - ); - if (!response.ok) { - const error = await response.json().catch(() => ({})); - throw new Error(error.detail || `HTTP ${response.status}`); - } - const disposition = response.headers.get('Content-Disposition'); - const filename = parseContentDispositionFilename(disposition) || path.split('/').pop() || 'download'; - const blob = await response.blob(); - const url = window.URL.createObjectURL(blob); - const a = document.createElement('a'); - a.href = url; - a.download = filename; - document.body.appendChild(a); - a.click(); - document.body.removeChild(a); - window.URL.revokeObjectURL(url); - }, - downloadPrinterFilesAsZip: async (printerId: number, paths: string[]): Promise => { - const headers: Record = { 'Content-Type': 'application/json' }; - if (authToken) { - headers['Authorization'] = `Bearer ${authToken}`; - } - const response = await fetch(`${API_BASE}/printers/${printerId}/files/download-zip`, { - method: 'POST', - headers, - body: JSON.stringify({ paths }), - }); - if (!response.ok) { - const error = await response.json().catch(() => ({})); - throw new Error(error.detail || `HTTP ${response.status}`); - } - return response.blob(); }, deletePrinterFile: (printerId: number, path: string) => request<{ status: string; path: string }>(`/printers/${printerId}/files?path=${encodeURIComponent(path)}`, { @@ -4994,6 +5046,20 @@ export const api = { getArchiveGcode: (id: number) => `${API_BASE}/archives/${id}/gcode`, getArchivePlatePreview: (id: number) => withStreamToken(`${API_BASE}/archives/${id}/plate-preview`), getArchiveTimelapse: (id: number) => withStreamToken(`${API_BASE}/archives/${id}/timelapse?v=${Date.now()}`), + downloadArchiveTimelapse: async (id: number, filename: string): Promise => { + const prepared = await request<{ token: string; filename: string }>( + `/archives/${id}/media-download-token`, + { method: 'POST' }, + ); + const link = document.createElement('a'); + link.href = `${API_BASE}/archives/${id}/media/dl/${encodeURIComponent(prepared.token)}/${encodeURIComponent(filename)}`; + link.download = filename; + document.body.appendChild(link); + link.click(); + link.remove(); + }, + getArchivePrinterMedia: (id: number) => + request(`/archives/${id}/printer-media`), scanArchiveTimelapse: (id: number) => request<{ status: string; diff --git a/frontend/src/components/ArchiveMediaDownloadModal.tsx b/frontend/src/components/ArchiveMediaDownloadModal.tsx new file mode 100644 index 000000000..0521e75b1 --- /dev/null +++ b/frontend/src/components/ArchiveMediaDownloadModal.tsx @@ -0,0 +1,256 @@ +import { useEffect, useMemo, useRef, useState } from 'react'; +import { useQuery } from '@tanstack/react-query'; +import { CheckSquare, Download, Film, Loader2, Square, Video, X } from 'lucide-react'; +import { useTranslation } from 'react-i18next'; +import { api } from '../api/client'; +import { useToast } from '../contexts/ToastContext'; +import { formatFileSize } from '../utils/file'; +import { Button } from './Button'; + +interface ArchiveMediaDownloadModalProps { + archiveId: number; + archiveName: string; + printerName: string; + onClose: () => void; +} + +export function ArchiveMediaDownloadModal({ + archiveId, + archiveName, + printerName, + onClose, +}: ArchiveMediaDownloadModalProps) { + const { t } = useTranslation(); + const { showToast } = useToast(); + const [selectedPaths, setSelectedPaths] = useState>(new Set()); + const [downloadStarting, setDownloadStarting] = useState(false); + const [downloadProgress, setDownloadProgress] = useState<{ current: number; total: number } | null>(null); + const initializedSelectionArchiveRef = useRef(null); + const downloadAbortRef = useRef(null); + const mediaQuery = useQuery({ + queryKey: ['archive-printer-media', archiveId], + queryFn: () => api.getArchivePrinterMedia(archiveId), + staleTime: 60_000, + }); + + const remoteFiles = useMemo(() => mediaQuery.data?.remote_files ?? [], [mediaQuery.data]); + + useEffect(() => { + if (!mediaQuery.data || initializedSelectionArchiveRef.current === archiveId) return; + initializedSelectionArchiveRef.current = archiveId; + if (remoteFiles.length === 1) { + setSelectedPaths(new Set([remoteFiles[0].path])); + } + }, [archiveId, mediaQuery.data, remoteFiles]); + + useEffect(() => { + const availablePaths = new Set(remoteFiles.map(file => file.path)); + setSelectedPaths(current => new Set([...current].filter(path => availablePaths.has(path)))); + }, [remoteFiles]); + + useEffect(() => () => downloadAbortRef.current?.abort(), []); + + useEffect(() => { + const handleKeyDown = (event: KeyboardEvent) => { + if (event.key === 'Escape') onClose(); + }; + window.addEventListener('keydown', handleKeyDown); + return () => window.removeEventListener('keydown', handleKeyDown); + }, [onClose]); + + const togglePath = (path: string) => { + setSelectedPaths((current) => { + const next = new Set(current); + if (next.has(path)) next.delete(path); + else next.add(path); + return next; + }); + }; + + const downloadLocalTimelapse = async () => { + const sourceName = mediaQuery.data?.local_timelapse?.name ?? ''; + const extension = sourceName.includes('.') ? `.${sourceName.split('.').pop()}` : ''; + try { + await api.downloadArchiveTimelapse(archiveId, `${archiveName}_timelapse${extension}`); + } catch (error) { + showToast(t('printerFiles.downloadFailed', { + error: error instanceof Error ? error.message : t('printerFiles.unknownError'), + }), 'error'); + } + }; + + const downloadSelected = async () => { + if (!mediaQuery.data?.printer_id || selectedPaths.size === 0) return; + const selectedFiles = remoteFiles.filter(file => selectedPaths.has(file.path)); + if (selectedFiles.length === 0) return; + const controller = new AbortController(); + downloadAbortRef.current = controller; + setDownloadStarting(true); + try { + const result = await api.downloadPrinterFilesAsZip( + mediaQuery.data.printer_id, + selectedFiles.map(file => file.path), + Object.fromEntries(selectedFiles.map(file => [file.path, file.size])), + `${archiveName.replace(/[^a-zA-Z0-9]/g, '_')}-printer-videos.zip`, + true, + controller.signal, + (completed, total) => setDownloadProgress({ current: completed, total }), + ); + if (result.failed > 0) { + showToast(t('printerFiles.zipPartial', { + successful: result.successful, + total: result.requested, + }), 'warning'); + } else { + showToast(t('printerFiles.zipStarted', { count: result.successful })); + } + } catch (error) { + showToast(t('printerFiles.downloadFailed', { + error: error instanceof Error ? error.message : t('printerFiles.unknownError'), + }), 'error'); + } finally { + if (downloadAbortRef.current === controller) downloadAbortRef.current = null; + setDownloadProgress(null); + setDownloadStarting(false); + } + }; + + const hasMedia = !!mediaQuery.data?.local_timelapse || remoteFiles.length > 0; + + const warningText = (warning: string) => { + if (warning === 'printer_files_forbidden') return t('printers.permission.noFiles'); + if (warning === 'printer_missing') return t('archives.media.printerMissing'); + if (warning === 'timelapse_unavailable') return t('archives.media.timelapseUnavailable'); + return t('archives.media.ipcamUnavailable'); + }; + + const warnings = (mediaQuery.data?.warnings ?? []).map((warning) => ( +

+ {warningText(warning)} +

+ )); + + return ( +
+
event.stopPropagation()} + > +
+
+

+

+

{archiveName} · {printerName}

+
+ +
+ +
+ {mediaQuery.isLoading ? ( +
+ + {t('archives.media.searching')} +
+ ) : mediaQuery.isError ? ( +

+ {t('archives.media.searchFailed')} +

+ ) : !hasMedia ? ( +
+

{t('archives.media.none')}

+ {warnings} +
+ ) : ( +
+ {mediaQuery.data?.local_timelapse && ( +
+ +
+

+ {mediaQuery.data.local_timelapse.name} +

+

+ {t('archives.media.attachedTimelapse')} · {formatFileSize(mediaQuery.data.local_timelapse.size)} +

+
+ +
+ )} + + {remoteFiles.length > 0 && ( +
+
+

+ {t('archives.media.printerFiles')} ({remoteFiles.length}) +

+ +
+
+ {remoteFiles.map((file) => { + const selected = selectedPaths.has(file.path); + return ( + + ); + })} +
+
+ )} + + {warnings} +
+ )} +
+ + {remoteFiles.length > 0 && ( +
+ +
+ )} +
+
+ ); +} diff --git a/frontend/src/components/FileManagerModal.tsx b/frontend/src/components/FileManagerModal.tsx index 51496ce5d..80c10146c 100644 --- a/frontend/src/components/FileManagerModal.tsx +++ b/frontend/src/components/FileManagerModal.tsx @@ -1,4 +1,4 @@ -import { useState, useEffect } from 'react'; +import { useEffect, useMemo, useRef, useState } from 'react'; import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'; import { useTranslation } from 'react-i18next'; import { @@ -290,6 +290,8 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage const [sortBy, setSortBy] = useState('name-asc'); const [downloadProgress, setDownloadProgress] = useState<{ current: number; total: number } | null>(null); const [viewerFile, setViewerFile] = useState<{ path: string; name: string } | null>(null); + const selectionAnchorRef = useRef(null); + const downloadAbortRef = useRef(null); // Close on Escape key useEffect(() => { @@ -317,6 +319,52 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage staleTime: 30000, // Cache for 30 seconds }); + const visibleFiles = useMemo(() => [...(data?.files ?? [])] + .filter((file) => !searchQuery || file.name.toLowerCase().includes(searchQuery.toLowerCase())) + .sort((a, b) => { + if (a.is_directory && !b.is_directory) return -1; + if (!a.is_directory && b.is_directory) return 1; + + switch (sortBy) { + case 'name-asc': + return a.name.localeCompare(b.name); + case 'name-desc': + return b.name.localeCompare(a.name); + case 'size-asc': + return a.size - b.size; + case 'size-desc': + return b.size - a.size; + case 'date-asc': { + const aTime = a.mtime ? parseUTCDate(a.mtime)?.getTime() ?? 0 : 0; + const bTime = b.mtime ? parseUTCDate(b.mtime)?.getTime() ?? 0 : 0; + return aTime - bTime; + } + case 'date-desc': { + const aTime = a.mtime ? parseUTCDate(a.mtime)?.getTime() ?? 0 : 0; + const bTime = b.mtime ? parseUTCDate(b.mtime)?.getTime() ?? 0 : 0; + return bTime - aTime; + } + default: + return a.name.localeCompare(b.name); + } + }), [data?.files, searchQuery, sortBy]); + + // Drop selections the user can no longer see -- but only when the listing is + // real. An unreachable printer answers with an empty file list and a warning, + // and treating that as "those files are gone" would throw away a selection + // the user made moments ago because one poll happened to fail. + const listingIsReal = !!data && !data.warnings?.includes('printer_unavailable'); + useEffect(() => { + if (!listingIsReal) return; + const visiblePaths = new Set(visibleFiles.filter(file => !file.is_directory).map(file => file.path)); + setSelectedFiles(current => new Set([...current].filter(path => visiblePaths.has(path)))); + if (selectionAnchorRef.current && !visiblePaths.has(selectionAnchorRef.current)) { + selectionAnchorRef.current = null; + } + }, [visibleFiles, listingIsReal]); + + useEffect(() => () => downloadAbortRef.current?.abort(), []); + const deleteMutation = useMutation({ mutationFn: async (paths: string[]) => { // Delete files one by one @@ -328,6 +376,7 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage showToast(t('printerFiles.toast.filesDeleted', { count: filesToDelete.length })); queryClient.invalidateQueries({ queryKey: ['printerFiles', printerId] }); setSelectedFiles(new Set()); + selectionAnchorRef.current = null; setFilesToDelete([]); }, onError: (error: Error) => { @@ -338,6 +387,7 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage const navigateToFolder = (path: string) => { setCurrentPath(path); setSelectedFiles(new Set()); + selectionAnchorRef.current = null; }; const navigateUp = () => { @@ -346,13 +396,30 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage parts.pop(); setCurrentPath(parts.length ? '/' + parts.join('/') : '/'); setSelectedFiles(new Set()); + selectionAnchorRef.current = null; }; const toggleFileSelection = (path: string, e: React.MouseEvent) => { e.stopPropagation(); + const selectablePaths = visibleFiles.filter(file => !file.is_directory).map(file => file.path); + const anchorIndex = selectionAnchorRef.current + ? selectablePaths.indexOf(selectionAnchorRef.current) + : -1; + const targetIndex = selectablePaths.indexOf(path); + const extendsRange = e.shiftKey && anchorIndex !== -1 && targetIndex !== -1; + + // Moved out of the state updater deliberately: React may run an updater + // more than once, and a ref assignment is not the kind of thing that + // survives being replayed by accident. + if (!extendsRange) selectionAnchorRef.current = path; + setSelectedFiles(prev => { const next = new Set(prev); - if (next.has(path)) { + if (extendsRange) { + const start = Math.min(anchorIndex, targetIndex); + const end = Math.max(anchorIndex, targetIndex); + selectablePaths.slice(start, end + 1).forEach(rangePath => next.add(rangePath)); + } else if (next.has(path)) { next.delete(path); } else { next.add(path); @@ -362,55 +429,66 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage }; const selectAllFiles = () => { - if (!data?.files) return; - const filePaths = data.files - .filter(f => !f.is_directory && (!searchQuery || f.name.toLowerCase().includes(searchQuery.toLowerCase()))) - .map(f => f.path); + const filePaths = visibleFiles.filter(file => !file.is_directory).map(file => file.path); setSelectedFiles(new Set(filePaths)); + selectionAnchorRef.current = null; }; const deselectAllFiles = () => { setSelectedFiles(new Set()); + selectionAnchorRef.current = null; }; const handleDownload = async () => { if (selectedFiles.size === 0) return; - const paths = Array.from(selectedFiles); + const paths = visibleFiles.filter(file => !file.is_directory && selectedFiles.has(file.path)).map(file => file.path); + if (paths.length === 0) return; + const controller = new AbortController(); + downloadAbortRef.current = controller; - if (paths.length === 1) { - // Single file - direct download with auth - api.downloadPrinterFile(printerId, paths[0]).catch((err) => { - console.error('Printer file download failed:', err); - }); - setSelectedFiles(new Set()); - return; - } - - // Multiple files - download as ZIP setDownloadProgress({ current: 0, total: paths.length }); try { - const blob = await api.downloadPrinterFilesAsZip(printerId, paths); - const url = URL.createObjectURL(blob); - const a = document.createElement('a'); - a.href = url; - a.download = `${printerName.replace(/[^a-zA-Z0-9]/g, '_')}-files.zip`; - document.body.appendChild(a); - a.click(); - document.body.removeChild(a); - URL.revokeObjectURL(url); - showToast(`Downloaded ${paths.length} files as ZIP`); + const sizes = Object.fromEntries(paths.map(path => [ + path, + data?.files.find(file => file.path === path)?.size ?? 0, + ])); + const result = await api.downloadPrinterFilesAsZip( + printerId, + paths, + sizes, + paths.length === 1 + ? data?.files.find(file => file.path === paths[0])?.name ?? 'printer-file' + : `${printerName.replace(/[^a-zA-Z0-9]/g, '_')}-files.zip`, + paths.length > 1, + controller.signal, + (completed, total) => setDownloadProgress({ current: completed, total }), + ); + if (result.failed > 0) { + showToast(t('printerFiles.zipPartial', { + successful: result.successful, + total: result.requested, + }), 'warning'); + } else { + showToast(t('printerFiles.zipStarted', { count: result.successful })); + } setSelectedFiles(new Set()); + selectionAnchorRef.current = null; } catch (error) { - showToast(`Download failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 'error'); + showToast(t('printerFiles.downloadFailed', { + error: error instanceof Error ? error.message : t('printerFiles.unknownError'), + }), 'error'); } finally { + if (downloadAbortRef.current === controller) downloadAbortRef.current = null; setDownloadProgress(null); } }; const handleDelete = () => { if (selectedFiles.size === 0) return; - setFilesToDelete(Array.from(selectedFiles)); + setFilesToDelete( + visibleFiles.filter(file => !file.is_directory && selectedFiles.has(file.path)).map(file => file.path), + ); }; // Quick navigation buttons for common directories @@ -515,6 +593,8 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage size="sm" onClick={() => refetch()} disabled={isLoading} + aria-label={t('common.refresh')} + title={t('common.refresh')} > @@ -540,47 +620,17 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage
+ ) : data?.warnings?.includes('printer_unavailable') ? ( +
+ {t('printerFiles.printerUnavailable')} +
) : !data?.files?.length ? (
- No files in this directory + {t('printerFiles.noFiles')}
) : (
- {/* Filter and sort: directories first, then files with selected sort */} - {[...data.files] - .filter((file) => - !searchQuery || file.name.toLowerCase().includes(searchQuery.toLowerCase()) - ) - .sort((a, b) => { - // Directories always first - if (a.is_directory && !b.is_directory) return -1; - if (!a.is_directory && b.is_directory) return 1; - - // Apply selected sort within same type - switch (sortBy) { - case 'name-asc': - return a.name.localeCompare(b.name); - case 'name-desc': - return b.name.localeCompare(a.name); - case 'size-asc': - return a.size - b.size; - case 'size-desc': - return b.size - a.size; - case 'date-asc': { - const aTime = a.mtime ? parseUTCDate(a.mtime)?.getTime() ?? 0 : 0; - const bTime = b.mtime ? parseUTCDate(b.mtime)?.getTime() ?? 0 : 0; - return aTime - bTime; - } - case 'date-desc': { - const aTime = a.mtime ? parseUTCDate(a.mtime)?.getTime() ?? 0 : 0; - const bTime = b.mtime ? parseUTCDate(b.mtime)?.getTime() ?? 0 : 0; - return bTime - aTime; - } - default: - return a.name.localeCompare(b.name); - } - }) - .map((file) => { + {visibleFiles.map((file) => { const FileIcon = getFileIcon(file.name, file.is_directory); const isSelected = selectedFiles.has(file.path); @@ -592,9 +642,11 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage ? 'bg-bambu-green/20 border border-bambu-green/50' : 'hover:bg-bambu-dark-tertiary' }`} - onClick={() => { + onClick={(event) => { if (file.is_directory) { navigateToFolder(file.path); + } else { + toggleFileSelection(file.path, event); } }} > @@ -603,6 +655,10 @@ export function FileManagerModal({ printerId, printerName, onClose }: FileManage + )} +