Create app.py

app.py

@@ -0,0 +1,290 @@
+import os, json, sqlite3, asyncio, time
+from datetime import datetime, timedelta, timezone
+from threading import Lock
+
+import httpx
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.staticfiles import StaticFiles
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from pydantic import BaseModel, HttpUrl
+
+# --------------------------
+# Config & Paths
+# --------------------------
+PORT = int(os.getenv("PORT", "7860"))
+DATA_DIR = "/data" if os.path.isdir("/data") else "."
+DB_PATH = os.path.join(DATA_DIR, "uptime.db")
+DEFAULT_SITES = [
+    {"url": "https://huggingface.co", "name": "Hugging Face"},
+    {"url": "https://www.google.com", "name": "Google"},
+    {"url": "https://www.bbc.com", "name": "BBC"},
+]
+CHECK_INTERVAL_SECONDS = 300  # 5 minutes
+HTTP_TIMEOUT_SECONDS = 10
+
+# --------------------------
+# DB setup
+# --------------------------
+os.makedirs(DATA_DIR, exist_ok=True)
+conn = sqlite3.connect(DB_PATH, check_same_thread=False)
+conn.row_factory = sqlite3.Row
+db_lock = Lock()
+
+def init_db():
+    with db_lock:
+        c = conn.cursor()
+        c.execute("""
+            CREATE TABLE IF NOT EXISTS sites (
+              url TEXT PRIMARY KEY,
+              name TEXT NOT NULL,
+              method TEXT DEFAULT 'GET',
+              expected_min INT DEFAULT 200,
+              expected_max INT DEFAULT 399,
+              created_at TEXT DEFAULT (datetime('now'))
+            );
+        """)
+        c.execute("""
+            CREATE TABLE IF NOT EXISTS checks (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              ts TEXT NOT NULL,
+              url TEXT NOT NULL,
+              ok INT NOT NULL,
+              status_code INT,
+              ms REAL,
+              FOREIGN KEY (url) REFERENCES sites(url)
+            );
+        """)
+        c.execute("""
+            CREATE TABLE IF NOT EXISTS incidents (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              url TEXT NOT NULL,
+              start_ts TEXT NOT NULL,
+              end_ts TEXT,
+              FOREIGN KEY (url) REFERENCES sites(url)
+            );
+        """)
+        conn.commit()
+
+        # Seed a few demo sites if empty
+        existing = c.execute("SELECT COUNT(*) AS n FROM sites").fetchone()["n"]
+        if existing == 0:
+            for s in DEFAULT_SITES:
+                try:
+                    c.execute("INSERT OR IGNORE INTO sites(url, name) VALUES (?, ?)", (s["url"], s["name"]))
+                except sqlite3.Error:
+                    pass
+            conn.commit()
+
+def list_sites():
+    with db_lock:
+        rows = conn.execute("SELECT url, name, method, expected_min, expected_max FROM sites ORDER BY url").fetchall()
+    return [dict(r) for r in rows]
+
+def get_last_check(url: str):
+    with db_lock:
+        r = conn.execute(
+            "SELECT ts, ok, status_code, ms FROM checks WHERE url=? ORDER BY id DESC LIMIT 1", (url,)
+        ).fetchone()
+    return dict(r) if r else None
+
+def get_prev_check(url: str):
+    with db_lock:
+        r = conn.execute(
+            "SELECT ts, ok, status_code, ms FROM checks WHERE url=? ORDER BY id DESC LIMIT 1 OFFSET 1", (url,)
+        ).fetchone()
+    return dict(r) if r else None
+
+def record_check(url: str, ok: int, status_code: int | None, ms: float | None, ts_iso: str):
+    with db_lock:
+        conn.execute("INSERT INTO checks(ts, url, ok, status_code, ms) VALUES (?,?,?,?,?)",
+                     (ts_iso, url, ok, status_code, ms))
+        conn.commit()
+
+def open_incident_if_needed(url: str, now_iso: str, prev_ok: int | None, current_ok: int):
+    with db_lock:
+        # If transitioning from UP->DOWN, open a new incident
+        if (prev_ok == 1 or prev_ok is None) and current_ok == 0:
+            conn.execute("INSERT INTO incidents(url, start_ts) VALUES (?,?)", (url, now_iso))
+            conn.commit()
+        # If transitioning from DOWN->UP, close the latest open incident
+        elif prev_ok == 0 and current_ok == 1:
+            conn.execute(
+                "UPDATE incidents SET end_ts=? WHERE url=? AND end_ts IS NULL",
+                (now_iso, url)
+            )
+            conn.commit()
+
+def incidents_for(url: str, limit: int = 50):
+    with db_lock:
+        rows = conn.execute(
+            "SELECT id, url, start_ts, end_ts FROM incidents WHERE url=? ORDER BY id DESC LIMIT ?",
+            (url, limit)
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+def uptime_ratio(url: str, since: datetime):
+    with db_lock:
+        rows = conn.execute(
+            "SELECT ok FROM checks WHERE url=? AND ts >= ?",
+            (url, since.replace(tzinfo=timezone.utc).isoformat())
+        ).fetchall()
+    if not rows:
+        return None
+    total = len(rows)
+    ups = sum(1 for r in rows if r["ok"] == 1)
+    return round(100.0 * ups / total, 2)
+
+# --------------------------
+# HTTP checker
+# --------------------------
+async def check_one(client: httpx.AsyncClient, site: dict):
+    url = site["url"]
+    expected_min = int(site.get("expected_min", 200))
+    expected_max = int(site.get("expected_max", 399))
+
+    t0 = time.perf_counter()
+    code = None
+    ok = 0
+    try:
+        # Use GET with follow_redirects to treat 3xx as success if within range
+        resp = await client.get(url, follow_redirects=True, timeout=HTTP_TIMEOUT_SECONDS)
+        code = resp.status_code
+        ok = 1 if (expected_min <= code <= expected_max) else 0
+    except Exception:
+        ok = 0
+    ms = round((time.perf_counter() - t0) * 1000.0, 2)
+    now_iso = datetime.now(timezone.utc).isoformat()
+
+    prev = get_last_check(url)
+    prev_ok = prev["ok"] if prev else None
+
+    record_check(url, ok, code, ms, now_iso)
+    open_incident_if_needed(url, now_iso, prev_ok, ok)
+
+    return {
+        "url": url,
+        "ok": ok,
+        "status_code": code,
+        "ms": ms,
+        "ts": now_iso
+    }
+
+async def run_checks():
+    sites = list_sites()
+    if not sites:
+        return []
+    limits = httpx.Limits(max_connections=20, max_keepalive_connections=10)
+    async with httpx.AsyncClient(limits=limits) as client:
+        tasks = [check_one(client, s) for s in sites]
+        return await asyncio.gather(*tasks)
+
+# --------------------------
+# API & Scheduler
+# --------------------------
+app = FastAPI(title="HF Uptime Monitor", version="1.0.0")
+
+# Simple CORS for same-origin front-end
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_methods=["*"], allow_headers=["*"]
+)
+
+class SiteIn(BaseModel):
+    url: HttpUrl
+    name: str
+
+@app.on_event("startup")
+async def on_startup():
+    init_db()
+    # Kick an immediate check on boot (don't await, run in background)
+    asyncio.create_task(run_checks())
+
+    # Start APScheduler
+    scheduler = AsyncIOScheduler()
+    scheduler.add_job(run_checks, "interval", seconds=CHECK_INTERVAL_SECONDS, next_run_time=datetime.now(timezone.utc))
+    scheduler.start()
+    app.state.scheduler = scheduler
+
+@app.on_event("shutdown")
+async def on_shutdown():
+    sched = getattr(app.state, "scheduler", None)
+    if sched:
+        sched.shutdown(wait=False)
+
+# Static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+@app.get("/")
+def root():
+    return FileResponse("static/index.html")
+
+@app.get("/api/sites")
+def api_sites():
+    return JSONResponse(list_sites())
+
+@app.post("/api/sites")
+def api_add_site(site: SiteIn):
+    with db_lock:
+        try:
+            conn.execute(
+                "INSERT OR IGNORE INTO sites(url, name) VALUES (?, ?)",
+                (site.url, site.name.strip() or site.url)
+            )
+            conn.commit()
+        except sqlite3.Error as e:
+            raise HTTPException(400, f"DB error: {e}")
+    return {"ok": True}
+
+@app.delete("/api/sites")
+def api_delete_site(url: str):
+    with db_lock:
+        conn.execute("DELETE FROM sites WHERE url=?", (url,))
+        conn.execute("DELETE FROM checks WHERE url=?", (url,))
+        conn.execute("DELETE FROM incidents WHERE url=?", (url,))
+        conn.commit()
+    return {"ok": True}
+
+@app.post("/api/check-now")
+async def api_check_now():
+    results = await run_checks()
+    return results
+
+@app.get("/api/status")
+def api_status():
+    sites = list_sites()
+    now = datetime.now(timezone.utc)
+    since_24h = now - timedelta(hours=24)
+    since_7d = now - timedelta(days=7)
+
+    out = []
+    for s in sites:
+        last = get_last_check(s["url"])
+        u24 = uptime_ratio(s["url"], since_24h)
+        u7 = uptime_ratio(s["url"], since_7d)
+        open_incident = False
+        with db_lock:
+            open_inc = conn.execute(
+                "SELECT 1 FROM incidents WHERE url=? AND end_ts IS NULL LIMIT 1",
+                (s["url"],)
+            ).fetchone()
+            open_incident = bool(open_inc)
+
+        out.append({
+            "url": s["url"],
+            "name": s["name"],
+            "last": last,            # {ts, ok, status_code, ms} or None
+            "uptime24h": u24,        # float or None
+            "uptime7d": u7,          # float or None
+            "open_incident": open_incident
+        })
+    return out
+
+@app.get("/api/incidents")
+def api_incidents(url: str):
+    return incidents_for(url, limit=100)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=PORT)