2025-12-11 18:32:55 -07:00
|
|
|
"""
|
|
|
|
|
WROLPi Controller - FastAPI Application
|
|
|
|
|
|
|
|
|
|
The Controller provides:
|
|
|
|
|
- System status monitoring (CPU, memory, drives, network)
|
|
|
|
|
- Service management (start/stop/restart systemd services)
|
|
|
|
|
- Disk mounting and management
|
|
|
|
|
- Admin operations (hotspot, throttle, shutdown, reboot)
|
|
|
|
|
- Simple emergency UI when main app is down
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
import asyncio
|
2026-03-14 10:03:11 -06:00
|
|
|
import logging
|
2025-12-11 18:32:55 -07:00
|
|
|
from contextlib import asynccontextmanager
|
|
|
|
|
from pathlib import Path
|
|
|
|
|
|
2026-03-14 10:03:11 -06:00
|
|
|
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(name)s %(levelname)s %(message)s')
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
2025-12-11 18:32:55 -07:00
|
|
|
from fastapi import FastAPI, Request
|
2026-04-07 20:01:49 -06:00
|
|
|
from fastapi.responses import FileResponse, HTMLResponse
|
2025-12-11 18:32:55 -07:00
|
|
|
from fastapi.templating import Jinja2Templates
|
|
|
|
|
|
|
|
|
|
from controller import __version__
|
2026-03-08 16:05:56 -06:00
|
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
|
|
|
|
2025-12-11 18:32:55 -07:00
|
|
|
from controller.api.admin import router as admin_router
|
Hotspot captive portal: welcome page with the WROLPi's address (#709)
* Hotspot captive portal: welcome page with the WROLPi's address
Devices that join the hotspot probe a fixed plain-HTTP URL to check for
Internet access. NetworkManager's shared-mode dnsmasq now resolves those
probe hostnames (and `wrolpi`) to the hotspot address via an include the
Controller writes when the hotspot starts, the probes land on the Controller
(port 80), and are redirected to /portal: "This is your WROLPi, its address is
10.42.0.1, open WROLPi / open the Controller".
Only the probe hostnames are hijacked so the hotspot keeps forwarding
everything else when the WROLPi has an uplink. The include is corrected and
the connection re-activated once if NetworkManager picked a non-default
subnet. Writing the include is best-effort; the hotspot starts regardless.
`hotspot.captive_portal` (controller.yaml, default true) toggles the probe
redirects and the include; like the other hotspot settings it applies on the
next hotspot start, so saving while the hotspot is up reports
restart_required and both Controller UIs say so. The status endpoint gains
the hotspot address and portal URL, shown in both UIs. repair.sh only
creates the include directory so a disabled setting survives upgrades.
Native only: Docker has no hotspot.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: address review
* React: re-read the hotspot address whenever the HotspotToggle starts or
stops the hotspot, matching the fallback UI's refresh-on-status.
* A WPA3 start that reverts to WPA2 leaves the hotspot up, so it now gets
the captive portal address correction too.
* The corrective `nmcli connection up` logs a warning on a non-zero exit;
dnsmasq would otherwise keep the old address silently.
* HotspotStatusResponse.captive_portal defaults to true like everywhere else.
* Trim design narrative from the module docstring and React comments.
* The include-before-activate test now observes the include at the moment
of the `nmcli ... hotspot` call instead of inferring from call order.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: never forward any record type for probe hosts
`address=` only synthesizes A/AAAA answers. iOS also asks for the HTTPS
record type; dnsmasq forwarded that upstream, Apple's answer aliased to
captive.g.aaplimg.com, and the phone fetched the genuine "Success" from
Apple instead of the portal. Each probe host now also gets `local=`, so
dnsmasq answers every type itself, and the CDN alias is a probe host too.
Observed with dnsmasq query logging on a hotspot with an eth0 uplink.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: let acknowledged clients finish so the OS offers "Done"
A phone's sign-in sheet only shows "Done" once the OS re-probes and gets
the genuine success reply. The Controller now remembers each client (by
hotspot IP) that has loaded the portal page and answers its later probes
with the reply each OS expects (Apple "Success" HTML, Android 204, Windows
"Microsoft Connect Test", ...). The set is cleared when the hotspot
starts so a new session shows the page again.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: acknowledge on Continue, not on view
iOS fetches the portal page in the background before opening the sheet,
then re-probes after the sheet's own navigation. Acknowledging on view
made that re-probe return "Success" as the sheet's content. Phones only
re-check the network (and offer "Done") after a full-page navigation, so
the welcome page now has a Continue button leading to /portal/continue,
which is the only place a client is acknowledged. The Continue page says
to tap Done and links to WROLPi and the Controller.
Also hijack clients3.google.com (older Android probe host).
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* help: bump wrolpi-help to the captive portal and Speed Test docs
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: comments describe the Continue design; clear acks on stop
Three comments still described acknowledging on view, which c72a7f7b
removed. Acknowledged clients are now also cleared when the hotspot
stops, so a lease reused in a later session sees the portal page.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-13 20:09:48 -06:00
|
|
|
from controller.api.captive_portal import router as captive_portal_router
|
2025-12-11 18:32:55 -07:00
|
|
|
from controller.api.disks import router as disks_router
|
2026-03-14 14:56:32 -06:00
|
|
|
from controller.api.onboarding import router as onboarding_router
|
2026-03-08 16:05:56 -06:00
|
|
|
from controller.api.ready import router as ready_router
|
2025-12-11 18:32:55 -07:00
|
|
|
from controller.api.schemas import HealthResponse
|
2026-02-25 15:32:43 -07:00
|
|
|
from controller.api.scripts import router as scripts_router
|
2025-12-11 18:32:55 -07:00
|
|
|
from controller.api.services import router as services_router
|
|
|
|
|
from controller.api.status import router as status_router
|
The Controller can make a secondary a copy of its primary with rsync (#992)
* The Controller can make a secondary a copy of its primary with rsync
The second part of replacing the sync. The Controller runs it, because the secondary's API is stopped while its
library is replaced: checks, a database snapshot on the primary, stop the API, rsync every file from the primary's
daemon (ignored directories included), fetch the snapshot and put it in the database's place, start the API, purge.
- Files the primary deleted or changed are moved to a dated folder in .sync-trash, and removed after
delete_after_days (a new sync.yaml setting, 30 by default; none never deletes), or sooner when the drive is nearly
full.
- A primary of another version or database migration, or with its media unmounted, is refused before anything is
touched. The database is replaced last, so a sync that stops earlier leaves one that works.
- On a Raspberry Pi and Debian rsync runs as the wrolpi user; in Docker in a helper container made from the api
container. A Controller that starts after an interrupted sync starts the API.
- When a secondary's API starts it takes the library settings of the primary's wrolpi.yaml, which the sync left.
Reached only through the Controller's /api/sync/run for now; the existing sync and its schedule are unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* The sync copies no link that leaves the library, and root follows none in the media directory
Security review of the Controller's sync:
- An exclusion that ends in a slash matches only a directory. A file or link named config/ssl, tags or
config/backup on the primary would have replaced this machine's directory of that name. The exclusions now match
whatever has the name.
- Links were copied as they are. One that points outside the primary's library would, on the secondary, point at
the secondary's own files, which the web server then serves. Only links that stay inside the library are copied,
and no device files.
- The Controller is root, in a media directory that belongs to another user. It no longer writes, reads, replaces
or purges through a symbolic link there.
Found on the way: the directory the Controller made for the incoming database belonged to root, so rsync, which
runs as the library's owner, could not have written into it. It now belongs to the media directory's owner.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* A sync ends when its primary stops answering, and makes room before it copies
Review found:
- rsync waits forever by default. A primary that lost power or its link during a copy left the secondary's API
stopped until someone cancelled. rsync now gives up after 30 seconds without a connection and 5 minutes without
data, which ends the run and starts the API.
- The trash was only purged after a run that succeeded. The trash is what fills the drive, and a full drive fails
every run, so it never got its turn. It is now also purged before the copy.
- A value in sync.yaml that could not be used raised after the run lock was taken and before the handlers that
release it, leaving "A sync is already running" until the Controller restarted.
- The playlists directory left out of the copy was this machine's, not the primary's, whose hard links would have
arrived as full copies. The primary's wrolpi.yaml is now fetched before the copy, and both are left out.
- A primary whose media directory is elsewhere is refused: its database names every file by its full path.
- In Docker rsync is its own container, which outlives a Controller that stops. A Controller that starts after an
interrupted sync now removes it before it starts the API.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-18 20:12:20 -07:00
|
|
|
from controller.api.sync import router as sync_router
|
2025-12-11 18:32:55 -07:00
|
|
|
from controller.lib.config import (
|
2026-07-18 13:40:23 -06:00
|
|
|
get_ca_certificate_path,
|
2026-04-07 20:01:49 -06:00
|
|
|
get_config_value,
|
2026-07-18 13:40:23 -06:00
|
|
|
is_ca_certificate_available,
|
2025-12-11 18:32:55 -07:00
|
|
|
is_docker_mode,
|
|
|
|
|
is_primary_drive_mounted,
|
|
|
|
|
reload_config_from_drive,
|
2026-04-07 20:01:49 -06:00
|
|
|
save_config,
|
|
|
|
|
update_config,
|
2025-12-11 18:32:55 -07:00
|
|
|
)
|
A WROLPi serves its library over rsync, and makes a database snapshot on request (#988)
* A WROLPi serves its library over rsync, and makes a database snapshot on request
The first part of replacing the sync: a secondary will copy its primary's whole media directory with rsync and
replace its database with the primary's, instead of downloading the files of FileGroups over HTTP (which never
copies an ignored directory, such as the map's).
- An rsync daemon serves the media directory read-only on port 8873, on every WROLPi. It never serves the TLS keys,
the cookies, or the database in use. On a Raspberry Pi and Debian it is the wrolpi-rsyncd unit; in Docker the
Controller runs it in a helper container made from the api container (its image, user and volumes), so the media
directory is still configured in one place. All three read controller/rsyncd.conf.
- POST /api/sync/snapshot asks for a snapshot of the database, which the daemon serves from config/.sync. An
unchanged database is not written again.
- /api/sync/info also says the database's migration and whether the media directory is mounted.
Nothing uses these yet; the existing sync is unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* The rsync daemon follows no links, and no snapshot is made in WROL Mode
- A client that asked the daemon to follow symbolic links could read what a link in the library points at. A
relative link to config/ssl was read this way although that directory is left out of the module. The daemon now
refuses the three options that follow links; a link is sent as a link.
- A database snapshot is a new file on the primary's drive, so WROL Mode refuses it, as it does a backup. A snapshot
made earlier is still served.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* No rsync helper from an image without rsync, and the helper follows the api container
Review found:
- A helper made from an api image built before rsync was added exits at once, and Docker restarted it forever while
the Controller reported it created. The image is now looked at first; no helper is made from one without rsync,
an older helper is left serving, and the reason is logged once.
- The helper was only checked when the Controller started, so a recreated or rebuilt api container left it stale.
It is now checked every minute.
- A snapshot cut off by its process being killed stayed marked as running and held back every later request.
- The snapshot's half-written temporary file was served by the daemon.
- The comment on the daemon's refused options claimed more than they give: a link that is part of the requested
path is still followed.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-18 16:47:02 -07:00
|
|
|
from controller.lib.rsyncd import rsync_daemon_loop
|
2026-07-18 13:40:23 -06:00
|
|
|
from controller.lib.scripts import get_script_status
|
2025-12-11 18:32:55 -07:00
|
|
|
from controller.lib.docker_services import (
|
|
|
|
|
can_manage_containers,
|
|
|
|
|
get_all_containers_status,
|
|
|
|
|
)
|
|
|
|
|
from controller.lib.status import (
|
|
|
|
|
get_cpu_status,
|
2025-12-24 15:45:53 -07:00
|
|
|
get_iostat_status,
|
2025-12-11 18:32:55 -07:00
|
|
|
get_load_status,
|
|
|
|
|
get_memory_status,
|
|
|
|
|
get_primary_drive_status,
|
2025-12-26 10:05:13 -07:00
|
|
|
get_uptime_status,
|
2025-12-11 18:32:55 -07:00
|
|
|
)
|
|
|
|
|
from controller.lib.status_worker import status_worker_loop
|
The Controller can make a secondary a copy of its primary with rsync (#992)
* The Controller can make a secondary a copy of its primary with rsync
The second part of replacing the sync. The Controller runs it, because the secondary's API is stopped while its
library is replaced: checks, a database snapshot on the primary, stop the API, rsync every file from the primary's
daemon (ignored directories included), fetch the snapshot and put it in the database's place, start the API, purge.
- Files the primary deleted or changed are moved to a dated folder in .sync-trash, and removed after
delete_after_days (a new sync.yaml setting, 30 by default; none never deletes), or sooner when the drive is nearly
full.
- A primary of another version or database migration, or with its media unmounted, is refused before anything is
touched. The database is replaced last, so a sync that stops earlier leaves one that works.
- On a Raspberry Pi and Debian rsync runs as the wrolpi user; in Docker in a helper container made from the api
container. A Controller that starts after an interrupted sync starts the API.
- When a secondary's API starts it takes the library settings of the primary's wrolpi.yaml, which the sync left.
Reached only through the Controller's /api/sync/run for now; the existing sync and its schedule are unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* The sync copies no link that leaves the library, and root follows none in the media directory
Security review of the Controller's sync:
- An exclusion that ends in a slash matches only a directory. A file or link named config/ssl, tags or
config/backup on the primary would have replaced this machine's directory of that name. The exclusions now match
whatever has the name.
- Links were copied as they are. One that points outside the primary's library would, on the secondary, point at
the secondary's own files, which the web server then serves. Only links that stay inside the library are copied,
and no device files.
- The Controller is root, in a media directory that belongs to another user. It no longer writes, reads, replaces
or purges through a symbolic link there.
Found on the way: the directory the Controller made for the incoming database belonged to root, so rsync, which
runs as the library's owner, could not have written into it. It now belongs to the media directory's owner.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* A sync ends when its primary stops answering, and makes room before it copies
Review found:
- rsync waits forever by default. A primary that lost power or its link during a copy left the secondary's API
stopped until someone cancelled. rsync now gives up after 30 seconds without a connection and 5 minutes without
data, which ends the run and starts the API.
- The trash was only purged after a run that succeeded. The trash is what fills the drive, and a full drive fails
every run, so it never got its turn. It is now also purged before the copy.
- A value in sync.yaml that could not be used raised after the run lock was taken and before the handlers that
release it, leaving "A sync is already running" until the Controller restarted.
- The playlists directory left out of the copy was this machine's, not the primary's, whose hard links would have
arrived as full copies. The primary's wrolpi.yaml is now fetched before the copy, and both are left out.
- A primary whose media directory is elsewhere is refused: its database names every file by its full path.
- In Docker rsync is its own container, which outlives a Controller that stops. A Controller that starts after an
interrupted sync now removes it before it starts the API.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-18 20:12:20 -07:00
|
|
|
from controller.lib.sync import recover_interrupted_sync
|
2025-12-11 18:32:55 -07:00
|
|
|
from controller.lib.systemd import get_all_services_status
|
|
|
|
|
|
|
|
|
|
# Templates directory
|
|
|
|
|
TEMPLATES_DIR = Path(__file__).parent / "templates"
|
|
|
|
|
templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@asynccontextmanager
|
|
|
|
|
async def lifespan(app: FastAPI):
|
|
|
|
|
"""
|
|
|
|
|
Application lifespan handler.
|
|
|
|
|
Runs on startup and shutdown.
|
|
|
|
|
"""
|
|
|
|
|
# Startup
|
2026-03-14 10:03:11 -06:00
|
|
|
logger.info("WROLPi Controller v%s starting...", __version__)
|
|
|
|
|
logger.info("Docker mode: %s", is_docker_mode())
|
2025-12-11 18:32:55 -07:00
|
|
|
|
2026-05-30 15:59:14 -06:00
|
|
|
# When running under Docker dev, status.py will have already remapped
|
|
|
|
|
# psutil.PROCFS_PATH to /host/proc (and the sysfs paths) so we report
|
|
|
|
|
# real host metrics instead of the container's tiny namespace.
|
|
|
|
|
if is_docker_mode():
|
|
|
|
|
import psutil
|
|
|
|
|
procfs_path = getattr(psutil, "PROCFS_PATH", "N/A (not supported on this platform)")
|
|
|
|
|
logger.info("Using host procfs for stats: %s", procfs_path)
|
|
|
|
|
|
2025-12-11 18:32:55 -07:00
|
|
|
# Try to load config from drive if mounted
|
|
|
|
|
if is_primary_drive_mounted():
|
|
|
|
|
if reload_config_from_drive():
|
2026-03-14 10:03:11 -06:00
|
|
|
logger.info("Loaded configuration from drive")
|
2025-12-11 18:32:55 -07:00
|
|
|
else:
|
2026-03-14 10:03:11 -06:00
|
|
|
logger.info("Using default configuration (no controller.yaml found)")
|
2026-03-13 15:56:21 -06:00
|
|
|
|
|
|
|
|
# Apply timezone from wrolpi.yaml to the system.
|
2026-07-04 08:22:24 -06:00
|
|
|
from controller.lib.admin import apply_timezone_from_config, migrate_hotspot_settings_from_wrolpi_config
|
2026-03-13 15:56:21 -06:00
|
|
|
apply_timezone_from_config()
|
2026-03-28 16:28:47 -06:00
|
|
|
|
2026-07-04 08:22:24 -06:00
|
|
|
# Copy legacy hotspot settings from wrolpi.yaml into controller.yaml.
|
|
|
|
|
migrate_hotspot_settings_from_wrolpi_config()
|
|
|
|
|
|
2026-03-28 16:28:47 -06:00
|
|
|
# Apply Samba config if enabled.
|
|
|
|
|
from controller.lib.samba import apply_samba_from_config
|
|
|
|
|
apply_samba_from_config()
|
2025-12-11 18:32:55 -07:00
|
|
|
else:
|
2026-03-28 10:09:58 -06:00
|
|
|
# Drive may be mounted but controller.yaml may not exist yet (e.g., the system
|
|
|
|
|
# was set up before the Controller was introduced). Create the marker file.
|
|
|
|
|
from controller.lib.config import get_media_directory, save_config
|
|
|
|
|
media_dir = get_media_directory()
|
|
|
|
|
if media_dir.is_mount():
|
|
|
|
|
logger.info("Primary drive is mounted at %s but controller.yaml is missing, creating it", media_dir)
|
|
|
|
|
config_dir = media_dir / "config"
|
|
|
|
|
config_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
|
try:
|
|
|
|
|
save_config()
|
|
|
|
|
reload_config_from_drive()
|
|
|
|
|
except RuntimeError as e:
|
|
|
|
|
logger.warning("Failed to create controller.yaml: %s", e)
|
|
|
|
|
|
2026-07-04 08:22:24 -06:00
|
|
|
from controller.lib.admin import apply_timezone_from_config, migrate_hotspot_settings_from_wrolpi_config
|
2026-03-28 10:09:58 -06:00
|
|
|
apply_timezone_from_config()
|
2026-07-04 08:22:24 -06:00
|
|
|
migrate_hotspot_settings_from_wrolpi_config()
|
2026-03-28 16:28:47 -06:00
|
|
|
|
|
|
|
|
from controller.lib.samba import apply_samba_from_config
|
|
|
|
|
apply_samba_from_config()
|
2026-03-28 10:09:58 -06:00
|
|
|
else:
|
|
|
|
|
logger.info("Primary drive not mounted - using default configuration")
|
2025-12-11 18:32:55 -07:00
|
|
|
|
The Controller can make a secondary a copy of its primary with rsync (#992)
* The Controller can make a secondary a copy of its primary with rsync
The second part of replacing the sync. The Controller runs it, because the secondary's API is stopped while its
library is replaced: checks, a database snapshot on the primary, stop the API, rsync every file from the primary's
daemon (ignored directories included), fetch the snapshot and put it in the database's place, start the API, purge.
- Files the primary deleted or changed are moved to a dated folder in .sync-trash, and removed after
delete_after_days (a new sync.yaml setting, 30 by default; none never deletes), or sooner when the drive is nearly
full.
- A primary of another version or database migration, or with its media unmounted, is refused before anything is
touched. The database is replaced last, so a sync that stops earlier leaves one that works.
- On a Raspberry Pi and Debian rsync runs as the wrolpi user; in Docker in a helper container made from the api
container. A Controller that starts after an interrupted sync starts the API.
- When a secondary's API starts it takes the library settings of the primary's wrolpi.yaml, which the sync left.
Reached only through the Controller's /api/sync/run for now; the existing sync and its schedule are unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* The sync copies no link that leaves the library, and root follows none in the media directory
Security review of the Controller's sync:
- An exclusion that ends in a slash matches only a directory. A file or link named config/ssl, tags or
config/backup on the primary would have replaced this machine's directory of that name. The exclusions now match
whatever has the name.
- Links were copied as they are. One that points outside the primary's library would, on the secondary, point at
the secondary's own files, which the web server then serves. Only links that stay inside the library are copied,
and no device files.
- The Controller is root, in a media directory that belongs to another user. It no longer writes, reads, replaces
or purges through a symbolic link there.
Found on the way: the directory the Controller made for the incoming database belonged to root, so rsync, which
runs as the library's owner, could not have written into it. It now belongs to the media directory's owner.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* A sync ends when its primary stops answering, and makes room before it copies
Review found:
- rsync waits forever by default. A primary that lost power or its link during a copy left the secondary's API
stopped until someone cancelled. rsync now gives up after 30 seconds without a connection and 5 minutes without
data, which ends the run and starts the API.
- The trash was only purged after a run that succeeded. The trash is what fills the drive, and a full drive fails
every run, so it never got its turn. It is now also purged before the copy.
- A value in sync.yaml that could not be used raised after the run lock was taken and before the handlers that
release it, leaving "A sync is already running" until the Controller restarted.
- The playlists directory left out of the copy was this machine's, not the primary's, whose hard links would have
arrived as full copies. The primary's wrolpi.yaml is now fetched before the copy, and both are left out.
- A primary whose media directory is elsewhere is refused: its database names every file by its full path.
- In Docker rsync is its own container, which outlives a Controller that stops. A Controller that starts after an
interrupted sync now removes it before it starts the API.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-18 20:12:20 -07:00
|
|
|
# A sync that was running when the Controller stopped left the API stopped.
|
|
|
|
|
app.state.sync_recovery_task = asyncio.create_task(asyncio.to_thread(recover_interrupted_sync))
|
|
|
|
|
|
A WROLPi serves its library over rsync, and makes a database snapshot on request (#988)
* A WROLPi serves its library over rsync, and makes a database snapshot on request
The first part of replacing the sync: a secondary will copy its primary's whole media directory with rsync and
replace its database with the primary's, instead of downloading the files of FileGroups over HTTP (which never
copies an ignored directory, such as the map's).
- An rsync daemon serves the media directory read-only on port 8873, on every WROLPi. It never serves the TLS keys,
the cookies, or the database in use. On a Raspberry Pi and Debian it is the wrolpi-rsyncd unit; in Docker the
Controller runs it in a helper container made from the api container (its image, user and volumes), so the media
directory is still configured in one place. All three read controller/rsyncd.conf.
- POST /api/sync/snapshot asks for a snapshot of the database, which the daemon serves from config/.sync. An
unchanged database is not written again.
- /api/sync/info also says the database's migration and whether the media directory is mounted.
Nothing uses these yet; the existing sync is unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* The rsync daemon follows no links, and no snapshot is made in WROL Mode
- A client that asked the daemon to follow symbolic links could read what a link in the library points at. A
relative link to config/ssl was read this way although that directory is left out of the module. The daemon now
refuses the three options that follow links; a link is sent as a link.
- A database snapshot is a new file on the primary's drive, so WROL Mode refuses it, as it does a backup. A snapshot
made earlier is still served.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* No rsync helper from an image without rsync, and the helper follows the api container
Review found:
- A helper made from an api image built before rsync was added exits at once, and Docker restarted it forever while
the Controller reported it created. The image is now looked at first; no helper is made from one without rsync,
an older helper is left serving, and the reason is logged once.
- The helper was only checked when the Controller started, so a recreated or rebuilt api container left it stale.
It is now checked every minute.
- A snapshot cut off by its process being killed stayed marked as running and held back every later request.
- The snapshot's half-written temporary file was served by the daemon.
- The comment on the daemon's refused options claimed more than they give: a link that is part of the requested
path is still followed.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-18 16:47:02 -07:00
|
|
|
# Docker: the library is served to secondary WROLPis from a helper container, kept matching the api container.
|
|
|
|
|
if is_docker_mode():
|
|
|
|
|
app.state.rsync_daemon_task = asyncio.create_task(rsync_daemon_loop())
|
|
|
|
|
|
2026-10-13 19:29:15 -06:00
|
|
|
# After the config (and any migrated hotspot settings) are loaded. Starting can take a while; do not block.
|
|
|
|
|
from controller.lib.admin import start_hotspot_on_boot
|
|
|
|
|
app.state.hotspot_on_boot_task = asyncio.create_task(asyncio.to_thread(start_hotspot_on_boot))
|
|
|
|
|
|
2025-12-11 18:32:55 -07:00
|
|
|
# Initialize cached status
|
|
|
|
|
app.state.cached_status = {}
|
|
|
|
|
|
|
|
|
|
# Start status worker background task
|
|
|
|
|
status_task = asyncio.create_task(status_worker_loop(app))
|
|
|
|
|
|
|
|
|
|
yield
|
|
|
|
|
|
|
|
|
|
# Shutdown
|
2026-03-14 10:03:11 -06:00
|
|
|
logger.info("WROLPi Controller shutting down...")
|
2025-12-11 18:32:55 -07:00
|
|
|
status_task.cancel()
|
|
|
|
|
try:
|
|
|
|
|
await status_task
|
|
|
|
|
except asyncio.CancelledError:
|
|
|
|
|
pass
|
A WROLPi serves its library over rsync, and makes a database snapshot on request (#988)
* A WROLPi serves its library over rsync, and makes a database snapshot on request
The first part of replacing the sync: a secondary will copy its primary's whole media directory with rsync and
replace its database with the primary's, instead of downloading the files of FileGroups over HTTP (which never
copies an ignored directory, such as the map's).
- An rsync daemon serves the media directory read-only on port 8873, on every WROLPi. It never serves the TLS keys,
the cookies, or the database in use. On a Raspberry Pi and Debian it is the wrolpi-rsyncd unit; in Docker the
Controller runs it in a helper container made from the api container (its image, user and volumes), so the media
directory is still configured in one place. All three read controller/rsyncd.conf.
- POST /api/sync/snapshot asks for a snapshot of the database, which the daemon serves from config/.sync. An
unchanged database is not written again.
- /api/sync/info also says the database's migration and whether the media directory is mounted.
Nothing uses these yet; the existing sync is unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* The rsync daemon follows no links, and no snapshot is made in WROL Mode
- A client that asked the daemon to follow symbolic links could read what a link in the library points at. A
relative link to config/ssl was read this way although that directory is left out of the module. The daemon now
refuses the three options that follow links; a link is sent as a link.
- A database snapshot is a new file on the primary's drive, so WROL Mode refuses it, as it does a backup. A snapshot
made earlier is still served.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* No rsync helper from an image without rsync, and the helper follows the api container
Review found:
- A helper made from an api image built before rsync was added exits at once, and Docker restarted it forever while
the Controller reported it created. The image is now looked at first; no helper is made from one without rsync,
an older helper is left serving, and the reason is logged once.
- The helper was only checked when the Controller started, so a recreated or rebuilt api container left it stale.
It is now checked every minute.
- A snapshot cut off by its process being killed stayed marked as running and held back every later request.
- The snapshot's half-written temporary file was served by the daemon.
- The comment on the daemon's refused options claimed more than they give: a link that is part of the requested
path is still followed.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-18 16:47:02 -07:00
|
|
|
if rsync_daemon_task := getattr(app.state, "rsync_daemon_task", None):
|
|
|
|
|
rsync_daemon_task.cancel()
|
2025-12-11 18:32:55 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
# Create FastAPI app
|
|
|
|
|
app = FastAPI(
|
|
|
|
|
title="WROLPi Controller",
|
|
|
|
|
description="System management service for WROLPi",
|
|
|
|
|
version=__version__,
|
|
|
|
|
lifespan=lifespan,
|
|
|
|
|
)
|
|
|
|
|
|
2026-03-08 16:05:56 -06:00
|
|
|
# CORS middleware - matches Caddy's permissive policy for offline/local use.
|
|
|
|
|
app.add_middleware(
|
|
|
|
|
CORSMiddleware,
|
|
|
|
|
allow_origins=["*"],
|
|
|
|
|
allow_methods=["*"],
|
|
|
|
|
allow_headers=["*"],
|
|
|
|
|
)
|
|
|
|
|
|
2025-12-11 18:32:55 -07:00
|
|
|
# Include routers
|
|
|
|
|
app.include_router(admin_router)
|
Hotspot captive portal: welcome page with the WROLPi's address (#709)
* Hotspot captive portal: welcome page with the WROLPi's address
Devices that join the hotspot probe a fixed plain-HTTP URL to check for
Internet access. NetworkManager's shared-mode dnsmasq now resolves those
probe hostnames (and `wrolpi`) to the hotspot address via an include the
Controller writes when the hotspot starts, the probes land on the Controller
(port 80), and are redirected to /portal: "This is your WROLPi, its address is
10.42.0.1, open WROLPi / open the Controller".
Only the probe hostnames are hijacked so the hotspot keeps forwarding
everything else when the WROLPi has an uplink. The include is corrected and
the connection re-activated once if NetworkManager picked a non-default
subnet. Writing the include is best-effort; the hotspot starts regardless.
`hotspot.captive_portal` (controller.yaml, default true) toggles the probe
redirects and the include; like the other hotspot settings it applies on the
next hotspot start, so saving while the hotspot is up reports
restart_required and both Controller UIs say so. The status endpoint gains
the hotspot address and portal URL, shown in both UIs. repair.sh only
creates the include directory so a disabled setting survives upgrades.
Native only: Docker has no hotspot.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: address review
* React: re-read the hotspot address whenever the HotspotToggle starts or
stops the hotspot, matching the fallback UI's refresh-on-status.
* A WPA3 start that reverts to WPA2 leaves the hotspot up, so it now gets
the captive portal address correction too.
* The corrective `nmcli connection up` logs a warning on a non-zero exit;
dnsmasq would otherwise keep the old address silently.
* HotspotStatusResponse.captive_portal defaults to true like everywhere else.
* Trim design narrative from the module docstring and React comments.
* The include-before-activate test now observes the include at the moment
of the `nmcli ... hotspot` call instead of inferring from call order.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: never forward any record type for probe hosts
`address=` only synthesizes A/AAAA answers. iOS also asks for the HTTPS
record type; dnsmasq forwarded that upstream, Apple's answer aliased to
captive.g.aaplimg.com, and the phone fetched the genuine "Success" from
Apple instead of the portal. Each probe host now also gets `local=`, so
dnsmasq answers every type itself, and the CDN alias is a probe host too.
Observed with dnsmasq query logging on a hotspot with an eth0 uplink.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: let acknowledged clients finish so the OS offers "Done"
A phone's sign-in sheet only shows "Done" once the OS re-probes and gets
the genuine success reply. The Controller now remembers each client (by
hotspot IP) that has loaded the portal page and answers its later probes
with the reply each OS expects (Apple "Success" HTML, Android 204, Windows
"Microsoft Connect Test", ...). The set is cleared when the hotspot
starts so a new session shows the page again.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: acknowledge on Continue, not on view
iOS fetches the portal page in the background before opening the sheet,
then re-probes after the sheet's own navigation. Acknowledging on view
made that re-probe return "Success" as the sheet's content. Phones only
re-check the network (and offer "Done") after a full-page navigation, so
the welcome page now has a Continue button leading to /portal/continue,
which is the only place a client is acknowledged. The Continue page says
to tap Done and links to WROLPi and the Controller.
Also hijack clients3.google.com (older Android probe host).
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* help: bump wrolpi-help to the captive portal and Speed Test docs
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* captive portal: comments describe the Continue design; clear acks on stop
Three comments still described acknowledging on view, which c72a7f7b
removed. Acknowledged clients are now also cleared when the hotspot
stops, so a lease reused in a later session sees the portal page.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-13 20:09:48 -06:00
|
|
|
app.include_router(captive_portal_router)
|
2025-12-11 18:32:55 -07:00
|
|
|
app.include_router(disks_router)
|
2026-03-14 14:56:32 -06:00
|
|
|
app.include_router(onboarding_router)
|
2026-03-08 16:05:56 -06:00
|
|
|
app.include_router(ready_router)
|
2026-02-25 15:32:43 -07:00
|
|
|
app.include_router(scripts_router)
|
2025-12-11 18:32:55 -07:00
|
|
|
app.include_router(services_router)
|
|
|
|
|
app.include_router(status_router)
|
The Controller can make a secondary a copy of its primary with rsync (#992)
* The Controller can make a secondary a copy of its primary with rsync
The second part of replacing the sync. The Controller runs it, because the secondary's API is stopped while its
library is replaced: checks, a database snapshot on the primary, stop the API, rsync every file from the primary's
daemon (ignored directories included), fetch the snapshot and put it in the database's place, start the API, purge.
- Files the primary deleted or changed are moved to a dated folder in .sync-trash, and removed after
delete_after_days (a new sync.yaml setting, 30 by default; none never deletes), or sooner when the drive is nearly
full.
- A primary of another version or database migration, or with its media unmounted, is refused before anything is
touched. The database is replaced last, so a sync that stops earlier leaves one that works.
- On a Raspberry Pi and Debian rsync runs as the wrolpi user; in Docker in a helper container made from the api
container. A Controller that starts after an interrupted sync starts the API.
- When a secondary's API starts it takes the library settings of the primary's wrolpi.yaml, which the sync left.
Reached only through the Controller's /api/sync/run for now; the existing sync and its schedule are unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* The sync copies no link that leaves the library, and root follows none in the media directory
Security review of the Controller's sync:
- An exclusion that ends in a slash matches only a directory. A file or link named config/ssl, tags or
config/backup on the primary would have replaced this machine's directory of that name. The exclusions now match
whatever has the name.
- Links were copied as they are. One that points outside the primary's library would, on the secondary, point at
the secondary's own files, which the web server then serves. Only links that stay inside the library are copied,
and no device files.
- The Controller is root, in a media directory that belongs to another user. It no longer writes, reads, replaces
or purges through a symbolic link there.
Found on the way: the directory the Controller made for the incoming database belonged to root, so rsync, which
runs as the library's owner, could not have written into it. It now belongs to the media directory's owner.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* A sync ends when its primary stops answering, and makes room before it copies
Review found:
- rsync waits forever by default. A primary that lost power or its link during a copy left the secondary's API
stopped until someone cancelled. rsync now gives up after 30 seconds without a connection and 5 minutes without
data, which ends the run and starts the API.
- The trash was only purged after a run that succeeded. The trash is what fills the drive, and a full drive fails
every run, so it never got its turn. It is now also purged before the copy.
- A value in sync.yaml that could not be used raised after the run lock was taken and before the handlers that
release it, leaving "A sync is already running" until the Controller restarted.
- The playlists directory left out of the copy was this machine's, not the primary's, whose hard links would have
arrived as full copies. The primary's wrolpi.yaml is now fetched before the copy, and both are left out.
- A primary whose media directory is elsewhere is refused: its database names every file by its full path.
- In Docker rsync is its own container, which outlives a Controller that stops. A Controller that starts after an
interrupted sync now removes it before it starts the API.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-18 20:12:20 -07:00
|
|
|
app.include_router(sync_router)
|
2025-12-11 18:32:55 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
def get_host(request: Request) -> str:
|
|
|
|
|
"""Get the host for links (use request host, fallback to localhost)."""
|
|
|
|
|
host = request.headers.get("host", "localhost")
|
|
|
|
|
# Strip port if present
|
|
|
|
|
if ":" in host:
|
|
|
|
|
host = host.split(":")[0]
|
|
|
|
|
return host
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@app.get("/", response_class=HTMLResponse)
|
|
|
|
|
async def dashboard(request: Request):
|
|
|
|
|
"""Render the main dashboard UI with real status data."""
|
|
|
|
|
# Try to use cached status first
|
|
|
|
|
cached = getattr(request.app.state, "cached_status", {})
|
|
|
|
|
|
|
|
|
|
if cached:
|
|
|
|
|
cpu = cached.get("cpu_stats") or {}
|
|
|
|
|
memory = cached.get("memory_stats") or {}
|
|
|
|
|
load = cached.get("load_stats") or {}
|
2025-12-24 15:45:53 -07:00
|
|
|
iostat = cached.get("iostat_stats") or {}
|
2025-12-26 10:05:13 -07:00
|
|
|
uptime = cached.get("uptime_stats") or {}
|
2025-12-11 18:32:55 -07:00
|
|
|
drives = cached.get("drives_stats") or []
|
|
|
|
|
primary_drive = None
|
|
|
|
|
for drive in drives:
|
|
|
|
|
if drive.get("mount") == "/media/wrolpi":
|
|
|
|
|
primary_drive = drive
|
|
|
|
|
break
|
|
|
|
|
else:
|
|
|
|
|
# Fallback to direct calls if cache not yet populated
|
|
|
|
|
cpu = get_cpu_status()
|
|
|
|
|
memory = get_memory_status()
|
|
|
|
|
load = get_load_status()
|
2025-12-24 15:45:53 -07:00
|
|
|
iostat = get_iostat_status()
|
2025-12-26 10:05:13 -07:00
|
|
|
uptime = get_uptime_status()
|
2025-12-11 18:32:55 -07:00
|
|
|
primary_drive = get_primary_drive_status()
|
|
|
|
|
|
|
|
|
|
# Format storage data
|
|
|
|
|
storage = {}
|
|
|
|
|
if primary_drive:
|
|
|
|
|
free_bytes = primary_drive["size"] - primary_drive["used"]
|
|
|
|
|
storage = {
|
|
|
|
|
"percent": primary_drive["percent"],
|
|
|
|
|
"free_gb": round(free_bytes / (1024 ** 3), 1),
|
|
|
|
|
}
|
|
|
|
|
|
2025-12-26 10:05:13 -07:00
|
|
|
# Format uptime
|
|
|
|
|
uptime_seconds = uptime.get("uptime_seconds", 0)
|
|
|
|
|
if uptime_seconds:
|
|
|
|
|
days = uptime_seconds // 86400
|
|
|
|
|
hours = (uptime_seconds % 86400) // 3600
|
|
|
|
|
uptime_formatted = f"{days}d {hours}h" if days > 0 else f"{hours}h {(uptime_seconds % 3600) // 60}m"
|
|
|
|
|
else:
|
|
|
|
|
uptime_formatted = "--"
|
|
|
|
|
|
2025-12-11 18:32:55 -07:00
|
|
|
# Get service status
|
|
|
|
|
if is_docker_mode():
|
|
|
|
|
if can_manage_containers():
|
|
|
|
|
services = get_all_containers_status()
|
|
|
|
|
else:
|
|
|
|
|
services = []
|
|
|
|
|
else:
|
|
|
|
|
services = get_all_services_status()
|
|
|
|
|
|
controller: group services into Core vs Optional & Maintenance
The Controller listed every wrolpi-* service in one flat table, which was
confusing for new users who couldn't tell always-on infrastructure from
one-off/dev/maintenance units.
Services are now split into two groups computed once in the backend and
exposed as `service.group`:
* Core Services - persistent services enabled at boot (api, app, caddy,
kiwix, ...), the normal running system.
* Optional & Maintenance - one-off/dev/maintenance tasks (bootstrap, repair,
upgrade, *-dev, discovered wrolpi-*), plus persistent
services the user has disabled at boot (e.g. Samba with
no shares configured).
Rule: core iff kind == "persistent" and enabled; otherwise optional. Group
membership only changes when the user toggles Boot, never on start/stop or
polling, so rows stay put. Within each group, failed/stopped services sort
first so problems stay visible.
Feature parity across all three render paths: the React ControllerPage, the
server-side Jinja template, and the client-side poll refresh. Docker
containers have no group field and fall back to a single ungrouped list.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-22 19:41:17 -06:00
|
|
|
# Sort services so problems surface first, then alphabetically. The
|
|
|
|
|
# template partitions on each service's "group" (core vs optional).
|
|
|
|
|
_status_order = {"failed": 0, "unknown": 1, "stopped": 2, "running": 3}
|
|
|
|
|
services = sorted(
|
|
|
|
|
services,
|
|
|
|
|
key=lambda s: (_status_order.get(s.get("status"), 1), s["name"]),
|
|
|
|
|
)
|
2025-12-24 16:43:37 -07:00
|
|
|
|
2026-07-18 13:40:23 -06:00
|
|
|
# Root CA download is only useful after the media drive is mounted (so an
|
|
|
|
|
# existing CA on the drive is visible) and repair has finished generating
|
|
|
|
|
# or refreshing certificates. While repair is running the CA may not exist
|
|
|
|
|
# yet or the leaf/Caddyfile may still be mid-update.
|
|
|
|
|
script_status = get_script_status()
|
|
|
|
|
repair_running = (
|
|
|
|
|
script_status.get("running") and script_status.get("script_name") == "repair"
|
|
|
|
|
)
|
|
|
|
|
cert_download_ready = is_ca_certificate_available() and not repair_running
|
|
|
|
|
|
2025-12-11 18:32:55 -07:00
|
|
|
context = {
|
|
|
|
|
"version": __version__,
|
|
|
|
|
"docker_mode": is_docker_mode(),
|
|
|
|
|
"drive_mounted": is_primary_drive_mounted(),
|
2026-04-07 20:01:49 -06:00
|
|
|
"hide_cert_banner": get_config_value("hide_cert_banner", False),
|
2026-07-18 13:40:23 -06:00
|
|
|
"cert_download_ready": cert_download_ready,
|
2025-12-11 18:32:55 -07:00
|
|
|
"host": get_host(request),
|
|
|
|
|
|
|
|
|
|
# Real status data
|
|
|
|
|
"cpu": {
|
|
|
|
|
"percent": cpu["percent"],
|
|
|
|
|
"temperature_c": cpu["temperature"], # Field renamed
|
2026-07-23 19:42:52 -06:00
|
|
|
"fan_rpm": cpu.get("fan_rpm"),
|
2025-12-11 18:32:55 -07:00
|
|
|
},
|
|
|
|
|
"memory": {
|
|
|
|
|
"percent": round((memory["used"] / memory["total"]) * 100, 1) if memory["total"] > 0 else 0,
|
|
|
|
|
"used_gb": round(memory["used"] / (1024 ** 3), 1),
|
|
|
|
|
},
|
|
|
|
|
"load": {
|
|
|
|
|
"load_1min": load["minute_1"], # Field renamed
|
|
|
|
|
},
|
|
|
|
|
"storage": storage,
|
2025-12-24 15:45:53 -07:00
|
|
|
"iostat": {
|
|
|
|
|
"percent_iowait": iostat.get("percent_iowait"),
|
|
|
|
|
},
|
2025-12-26 10:05:13 -07:00
|
|
|
"uptime": {
|
|
|
|
|
"formatted": uptime_formatted,
|
|
|
|
|
"seconds": uptime_seconds,
|
|
|
|
|
},
|
2025-12-11 18:32:55 -07:00
|
|
|
|
|
|
|
|
# Real service status
|
|
|
|
|
"services": services,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return templates.TemplateResponse(request, "index.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@app.get("/api/health", response_model=HealthResponse)
|
|
|
|
|
async def health_check() -> HealthResponse:
|
|
|
|
|
"""
|
|
|
|
|
Health check endpoint.
|
|
|
|
|
Returns basic status for monitoring and load balancer checks.
|
|
|
|
|
"""
|
|
|
|
|
return HealthResponse(
|
|
|
|
|
status="healthy",
|
|
|
|
|
version=__version__,
|
|
|
|
|
docker_mode=is_docker_mode(),
|
|
|
|
|
drive_mounted=is_primary_drive_mounted(),
|
|
|
|
|
)
|
2026-04-07 20:01:49 -06:00
|
|
|
|
|
|
|
|
|
|
|
|
|
@app.get("/ca.crt")
|
|
|
|
|
async def download_ca_certificate():
|
2026-07-18 13:40:23 -06:00
|
|
|
"""Serve the WROLPi Root CA certificate for browser trust setup.
|
|
|
|
|
|
|
|
|
|
Only available after the media drive is mounted so an existing CA on the
|
|
|
|
|
drive can be served (and never a transient pre-onboarding path).
|
|
|
|
|
"""
|
|
|
|
|
from fastapi.responses import JSONResponse
|
|
|
|
|
|
|
|
|
|
if not is_docker_mode() and not is_primary_drive_mounted():
|
|
|
|
|
return JSONResponse(
|
|
|
|
|
status_code=404,
|
|
|
|
|
content={"error": "CA certificate not available until the media drive is mounted"},
|
|
|
|
|
)
|
|
|
|
|
ca_path = get_ca_certificate_path()
|
2026-04-07 20:01:49 -06:00
|
|
|
if not ca_path.is_file():
|
|
|
|
|
return JSONResponse(status_code=404, content={"error": "CA certificate not found"})
|
|
|
|
|
return FileResponse(
|
|
|
|
|
path=ca_path,
|
|
|
|
|
media_type="application/x-x509-ca-cert",
|
|
|
|
|
filename="wrolpi-ca.crt",
|
|
|
|
|
headers={"Content-Disposition": 'attachment; filename="wrolpi-ca.crt"'},
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@app.post("/api/hide-cert-banner")
|
|
|
|
|
async def hide_cert_banner():
|
|
|
|
|
"""Permanently hide the HTTPS certificate setup banner."""
|
|
|
|
|
update_config("hide_cert_banner", True)
|
|
|
|
|
save_config()
|
|
|
|
|
return {"ok": True}
|