Seafile is a self-hosted file synchronization and sharing platform — a privacy-first alternative to Dropbox and Google Drive — that lets organizations store, sync, and collaborate on files without sending data to third-party cloud providers. Teams use Seafile for shared document libraries, cross-device file sync, and secure file sharing with external partners. When Seafile goes down, file synchronization halts across every connected desktop and mobile client, shared library links stop working, and any business process that depends on shared files becomes a bottleneck. Unlike consumer cloud storage, self-hosted Seafile outages are invisible to the vendor — you are entirely responsible for detecting and resolving failures. Vigilmon gives you external visibility into Seafile's ping endpoint, web UI, file access API, and SSL certificate so failures are caught within 60 seconds.
What You'll Build
- A monitor on Seafile's
/api2/ping/health endpoint - An HTTP monitor for the Seafile web UI
- An HTTP monitor for the file access API liveness check (
/api2/account/info/returning 403 confirms the API is alive) - SSL certificate monitoring for your Seafile domain
- An alerting setup that catches application, database, and SSL failures before users report sync errors
Prerequisites
- A running Seafile instance with a public or network-reachable domain
- HTTPS configured (e.g.,
https://seafile.example.com) - A free account at vigilmon.online
Step 1: Verify Seafile's Ping Endpoint
Seafile exposes a lightweight ping endpoint at /api2/ping/ that returns a simple string response confirming the API server is alive:
curl https://seafile.example.com/api2/ping/
A healthy instance returns HTTP 200 with this body:
"pong"
This endpoint requires no authentication and is the fastest way to confirm the Seahub web application (Python/Django) and the Seafile daemon are serving requests. A 200 with pong confirms the application layer is up. A non-200 or a connection timeout indicates Seahub has crashed, the Seafile daemon is not running, or a database connectivity failure has taken the application offline.
Step 2: Create a Vigilmon HTTP Monitor for the Ping Endpoint
- Log in to Vigilmon → Add Monitor → HTTP.
- URL:
https://seafile.example.com/api2/ping/. - Check interval: 60 seconds.
- Response timeout: 10 seconds.
- Expected status:
200. - Keyword:
pong. - Label:
Seafile Ping. - Click Save.
This monitor catches:
- Seahub (the Django web frontend) process crashes
- Seafile server daemon failures that make file operations unavailable
- MySQL/MariaDB connectivity failures — Seafile stores user accounts, library metadata, sharing permissions, file histories, and audit logs in MySQL; a database failure prevents all file operations and user authentication
- Memcached session failures that lock users out of the web interface
- Container or system-level crashes that take the entire stack offline
The pong keyword check ensures the response is genuine — not a 200 from nginx serving a cached error page or an upstream-unavailable fallback.
MySQL dependency: Seafile uses MySQL (or MariaDB) as its primary metadata store for every library, file version record, share link, group membership, and user account. The Seafile daemon maintains its own separate SQLite databases for block metadata, but all web-accessible functionality — sharing, user management, web browsing of files — depends on MySQL. A MySQL failure makes Seafile's web UI and API fully non-functional even if the daemon and file storage are intact.
Step 3: Monitor the Seafile Web UI
The Seafile web UI (Seahub) is where users browse files, manage shared libraries, upload documents, and generate sharing links. Monitor it independently from the API ping to catch reverse proxy failures and Django rendering issues:
- Add Monitor → HTTP.
- URL:
https://seafile.example.com. - Check interval: 60 seconds.
- Expected status:
200. - Keyword:
Seafile. - Label:
Seafile Web UI. - Click Save.
This monitor catches nginx or Apache reverse proxy failures, Django static file serving errors, and Seahub rendering failures that prevent users from accessing the web interface — even when the underlying Seafile daemon is running and file storage is intact. A broken web UI means no browser-based file access, no sharing link generation, and no web-based uploads or downloads.
Step 4: Monitor the File Access API Liveness
Seafile's REST API at /api2/account/info/ returns user account information for authenticated users. Without a valid authorization token, it returns 403 Forbidden — confirming the API is alive, parsing requests, and applying access controls correctly:
curl -i https://seafile.example.com/api2/account/info/
# Expected: HTTP 403 (API is alive, authentication is enforced)
- Add Monitor → HTTP.
- URL:
https://seafile.example.com/api2/account/info/. - Check interval: 60 seconds.
- Expected status:
403. - Label:
Seafile File Access API. - Click Save.
A 403 is the correct liveness signal: it proves the Seahub Django server accepted the connection, processed the request through the authentication middleware, determined the request lacks valid credentials, and returned a proper HTTP response. A 502 means the proxy is running but Django is not responding. A 500 typically indicates a database error or application exception. A timeout means the application layer has failed entirely.
Sync clients and the API: Seafile's desktop and mobile sync clients communicate with the server primarily through the Seafile daemon protocol, but many operations — authentication, library list retrieval, sharing — use the HTTP API. If the API becomes unresponsive, sync clients may lose their session, stop syncing, and require manual re-authentication when the service recovers. Early API failure detection minimizes the number of clients that enter a disconnected state.
Step 5: Monitor SSL Certificates
Seafile desktop and mobile sync clients enforce strict TLS certificate validation. An expired SSL certificate:
- Immediately breaks file synchronization on every connected device across your organization
- Locks all users out of the Seahub web interface
- Invalidates all existing share links, preventing external file access
- May cause the Seafile daemon to reject TLS connections depending on your deployment configuration
- Breaks any external integration (WebDAV, third-party apps) using HTTPS to access Seafile
- Add Monitor → SSL Certificate.
- Domain:
seafile.example.com. - Alert when expiry is within: 30 days.
- Alert again: 14 days, 7 days, 3 days, 1 day.
- Click Save.
TLS and sync clients: Seafile sync clients are particularly unforgiving about certificate errors — unlike browsers, they do not offer a "proceed anyway" option. An expired certificate immediately disconnects every sync client in your organization. A 30-day SSL alert gives you ample time to renew before any disruption.
Step 6: Configure Alerting
In Vigilmon under Settings → Notifications, configure your alert channels:
| Monitor | Trigger | Action |
|---|---|---|
| /api2/ping/ | Non-200 or pong missing | Check Seahub and Seafile daemon; inspect MySQL connectivity; review Seahub logs |
| Web UI | Non-200 or keyword missing | Check nginx/reverse proxy; verify Seahub is serving; inspect Django logs |
| File Access API | Non-403 response | Check Seahub Django process; inspect MySQL; verify authentication middleware |
| SSL certificate | < 30 days to expiry | Renew certificate; verify Let's Encrypt auto-renewal is functioning |
Alert after: 2 consecutive failures for HTTP monitors. Route alerts to both your infrastructure team and a communication channel visible to users — a Seafile outage affects all connected sync clients immediately, and users should be notified proactively rather than discovering broken sync on their own.
Common Seafile Failure Modes and What Vigilmon Catches
| Scenario | Vigilmon monitor | |---|---| | Seahub Django process crash | Ping endpoint fails; alert within 60 s | | Seafile daemon crash | File operations fail; daemon status should be monitored separately at the system level | | MySQL down or disk full | Ping may pass but API returns 500; all web and API operations fail | | Memcached session store failure | Users get logged out on each request; session-dependent operations fail | | Reverse proxy misconfiguration after upgrade | Web UI monitor fires; ping endpoint may still respond | | Seafile storage volume unmounted | Files unreadable; ping and API may pass while file operations fail | | SSL certificate expires | All sync clients disconnect; web and API access blocked for all users | | Django static files not collected after upgrade | Web UI loads partially; keyword check may still pass | | DNS misconfiguration | All monitors fire simultaneously; sync clients lose connectivity | | MySQL connection pool exhaustion under heavy sync load | API returns 500; web UI throws database errors | | Seahub memory leak causing slow response | Health check starts timing out; performance degrades before full failure |
Self-hosted file storage gives you data sovereignty and cost control — but it also means downtime is entirely yours to detect and resolve. Vigilmon watches Seafile's ping endpoint, web UI, file access API, and SSL certificate so you're alerted within 60 seconds of any failure, before your team discovers broken sync on their laptops or share links stop working for external partners.
Start monitoring Seafile in under 5 minutes — register free at vigilmon.online.