491 lines
18 KiB
Python
491 lines
18 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
VPS Monitor Backend — serveur central.
|
|
Agrège les données de tous les agents et expose une API REST pour le frontend.
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import os
|
|
import secrets
|
|
import sqlite3
|
|
from collections import deque
|
|
from contextlib import contextmanager
|
|
from datetime import datetime, timedelta, timezone
|
|
from pathlib import Path
|
|
from typing import Annotated
|
|
|
|
import bcrypt as _bcrypt
|
|
import aiohttp
|
|
from fastapi import Depends, FastAPI, HTTPException
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
|
|
from jose import JWTError, jwt
|
|
from pydantic import BaseModel
|
|
|
|
# ─── Config ───────────────────────────────────────────────────────────────────
|
|
|
|
DB_FILE = Path(os.getenv("DB_FILE", "data/monitor.db"))
|
|
|
|
# ─── Ring buffer de stats (en mémoire) ───────────────────────────────────────
|
|
_STATS_MAX_POINTS = 120 # 10 min à 5 s d'intervalle
|
|
_stats_history: dict[str, deque] = {}
|
|
SECRET_FILE = Path(os.getenv("SECRET_FILE", "data/.jwt_secret"))
|
|
AGENT_TIMEOUT = int(os.getenv("AGENT_TIMEOUT", "5"))
|
|
JWT_ALGORITHM = "HS256"
|
|
JWT_EXPIRE_MIN = int(os.getenv("JWT_EXPIRE_MINUTES", "1440")) # 24 h
|
|
|
|
DB_FILE.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Clé JWT : env var > fichier persisté > génération + sauvegarde
|
|
def _load_jwt_secret() -> str:
|
|
env = os.getenv("JWT_SECRET")
|
|
if env:
|
|
return env
|
|
if SECRET_FILE.exists():
|
|
return SECRET_FILE.read_text().strip()
|
|
secret = secrets.token_hex(32)
|
|
SECRET_FILE.write_text(secret)
|
|
SECRET_FILE.chmod(0o600)
|
|
return secret
|
|
|
|
JWT_SECRET = _load_jwt_secret()
|
|
|
|
bearer_scheme = HTTPBearer()
|
|
|
|
# ─── Modèles ──────────────────────────────────────────────────────────────────
|
|
|
|
class VpsConfig(BaseModel):
|
|
id: str
|
|
name: str
|
|
host: str
|
|
port: int = 8001
|
|
api_key: str
|
|
description: str = ""
|
|
tags: list[str] = []
|
|
|
|
|
|
class ActionRequest(BaseModel):
|
|
action: str # start | stop | restart
|
|
|
|
|
|
class VpsUpdateRequest(BaseModel):
|
|
name: str
|
|
host: str
|
|
port: int = 8001
|
|
api_key: str = "" # vide = conserver la clé existante
|
|
description: str = ""
|
|
tags: list[str] = []
|
|
|
|
|
|
class ComposeUpdateRequest(BaseModel):
|
|
project: str
|
|
|
|
|
|
class RegisterRequest(BaseModel):
|
|
username: str
|
|
password: str
|
|
|
|
|
|
class LoginRequest(BaseModel):
|
|
username: str
|
|
password: str
|
|
|
|
|
|
# ─── SQLite ───────────────────────────────────────────────────────────────────
|
|
|
|
@contextmanager
|
|
def get_db():
|
|
conn = sqlite3.connect(DB_FILE, check_same_thread=False)
|
|
conn.row_factory = sqlite3.Row
|
|
try:
|
|
yield conn
|
|
conn.commit()
|
|
except Exception:
|
|
conn.rollback()
|
|
raise
|
|
finally:
|
|
conn.close()
|
|
|
|
|
|
def init_db() -> None:
|
|
with get_db() as conn:
|
|
conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
username TEXT PRIMARY KEY,
|
|
password TEXT NOT NULL,
|
|
role TEXT NOT NULL DEFAULT 'admin'
|
|
)
|
|
""")
|
|
conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS vps (
|
|
id TEXT PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
host TEXT NOT NULL,
|
|
port INTEGER NOT NULL DEFAULT 8001,
|
|
api_key TEXT NOT NULL,
|
|
description TEXT NOT NULL DEFAULT '',
|
|
tags TEXT NOT NULL DEFAULT '[]'
|
|
)
|
|
""")
|
|
# Migration : ajoute la colonne tags si elle n'existe pas encore
|
|
try:
|
|
conn.execute("ALTER TABLE vps ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'")
|
|
except Exception:
|
|
pass # colonne déjà présente
|
|
|
|
|
|
init_db()
|
|
|
|
|
|
# ─── Persistance ──────────────────────────────────────────────────────────────
|
|
|
|
def load_users() -> list[dict]:
|
|
with get_db() as conn:
|
|
return [dict(r) for r in conn.execute("SELECT * FROM users").fetchall()]
|
|
|
|
|
|
def add_user(user: dict) -> None:
|
|
with get_db() as conn:
|
|
conn.execute(
|
|
"INSERT INTO users (username, password, role) VALUES (?, ?, ?)",
|
|
(user["username"], user["password"], user["role"]),
|
|
)
|
|
|
|
|
|
def load_vps() -> list[dict]:
|
|
with get_db() as conn:
|
|
rows = [dict(r) for r in conn.execute("SELECT * FROM vps").fetchall()]
|
|
for row in rows:
|
|
try:
|
|
row["tags"] = json.loads(row.get("tags") or "[]")
|
|
except Exception:
|
|
row["tags"] = []
|
|
return rows
|
|
|
|
|
|
def insert_vps(vps: dict) -> None:
|
|
with get_db() as conn:
|
|
conn.execute(
|
|
"INSERT INTO vps (id, name, host, port, api_key, description, tags) VALUES (?, ?, ?, ?, ?, ?, ?)",
|
|
(vps["id"], vps["name"], vps["host"], vps["port"], vps["api_key"],
|
|
vps.get("description", ""), json.dumps(vps.get("tags", []))),
|
|
)
|
|
|
|
|
|
def remove_vps(vps_id: str) -> bool:
|
|
with get_db() as conn:
|
|
cur = conn.execute("DELETE FROM vps WHERE id = ?", (vps_id,))
|
|
return cur.rowcount > 0
|
|
|
|
|
|
def update_vps(vps_id: str, data: dict) -> bool:
|
|
with get_db() as conn:
|
|
cur = conn.execute(
|
|
"UPDATE vps SET name=?, host=?, port=?, api_key=?, description=?, tags=? WHERE id=?",
|
|
(data["name"], data["host"], data["port"], data["api_key"],
|
|
data["description"], json.dumps(data.get("tags", [])), vps_id),
|
|
)
|
|
return cur.rowcount > 0
|
|
|
|
|
|
# ─── Auth helpers ─────────────────────────────────────────────────────────────
|
|
|
|
def create_token(username: str, role: str) -> str:
|
|
payload = {
|
|
"sub": username,
|
|
"role": role,
|
|
"exp": datetime.now(timezone.utc) + timedelta(minutes=JWT_EXPIRE_MIN),
|
|
}
|
|
return jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)
|
|
|
|
|
|
def get_current_user(
|
|
credentials: Annotated[HTTPAuthorizationCredentials, Depends(bearer_scheme)]
|
|
) -> dict:
|
|
try:
|
|
payload = jwt.decode(credentials.credentials, JWT_SECRET, algorithms=[JWT_ALGORITHM])
|
|
username = payload.get("sub")
|
|
if not username:
|
|
raise HTTPException(status_code=401, detail="Token invalide")
|
|
except JWTError:
|
|
raise HTTPException(status_code=401, detail="Token invalide ou expiré")
|
|
user = next((u for u in load_users() if u["username"] == username), None)
|
|
if not user:
|
|
raise HTTPException(status_code=401, detail="Utilisateur introuvable")
|
|
return user
|
|
|
|
|
|
# ─── App ──────────────────────────────────────────────────────────────────────
|
|
|
|
app = FastAPI(title="VPS Monitor Backend", version="1.0.0")
|
|
|
|
app.add_middleware(
|
|
CORSMiddleware,
|
|
allow_origins=os.getenv("CORS_ORIGINS", "*").split(","),
|
|
allow_methods=["*"],
|
|
allow_headers=["*"],
|
|
)
|
|
|
|
# ─── Helpers HTTP ─────────────────────────────────────────────────────────────
|
|
|
|
async def agent_get(vps: dict, path: str):
|
|
url = f"http://{vps['host']}:{vps['port']}{path}"
|
|
headers = {"X-API-Key": vps["api_key"]}
|
|
timeout = aiohttp.ClientTimeout(total=AGENT_TIMEOUT)
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.get(url, headers=headers, timeout=timeout) as r:
|
|
r.raise_for_status()
|
|
return await r.json()
|
|
|
|
|
|
async def agent_post(vps: dict, path: str, payload: dict | None = None):
|
|
url = f"http://{vps['host']}:{vps['port']}{path}"
|
|
headers = {"X-API-Key": vps["api_key"]}
|
|
timeout = aiohttp.ClientTimeout(total=AGENT_TIMEOUT)
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post(url, headers=headers, json=payload, timeout=timeout) as r:
|
|
r.raise_for_status()
|
|
return await r.json()
|
|
|
|
|
|
async def fetch_vps_status(vps: dict) -> dict:
|
|
"""Interroge un agent et retourne son état complet."""
|
|
try:
|
|
containers_res, system_res = await asyncio.gather(
|
|
agent_get(vps, "/containers"),
|
|
agent_get(vps, "/system"),
|
|
return_exceptions=True,
|
|
)
|
|
if isinstance(containers_res, Exception):
|
|
raise containers_res
|
|
system = system_res if not isinstance(system_res, Exception) else None
|
|
return {
|
|
"id": vps["id"],
|
|
"name": vps["name"],
|
|
"host": vps["host"],
|
|
"description": vps.get("description", ""),
|
|
"online": True,
|
|
"containers": containers_res,
|
|
"system": system,
|
|
"tags": vps.get("tags", []),
|
|
}
|
|
except Exception as e:
|
|
return {
|
|
"id": vps["id"],
|
|
"name": vps["name"],
|
|
"host": vps["host"],
|
|
"description": vps.get("description", ""),
|
|
"online": False,
|
|
"error": str(e),
|
|
"containers": [],
|
|
"system": None,
|
|
"tags": vps.get("tags", []),
|
|
}
|
|
|
|
|
|
# ─── Collecteur de stats (tâche de fond) ─────────────────────────────────────
|
|
|
|
async def _fetch_system_stat(vps: dict) -> None:
|
|
"""Collecte un point de stats système pour un VPS et l'insère dans le ring buffer."""
|
|
try:
|
|
data = await agent_get(vps, "/system")
|
|
buf = _stats_history.setdefault(vps["id"], deque(maxlen=_STATS_MAX_POINTS))
|
|
buf.append({
|
|
"ts": datetime.now(timezone.utc).isoformat(),
|
|
"cpu": data["cpu_percent"],
|
|
"ram_percent": data["ram_percent"],
|
|
"ram_used": data["ram_used"],
|
|
"ram_total": data["ram_total"],
|
|
"net_sent_per_sec": data["net_sent_per_sec"],
|
|
"net_recv_per_sec": data["net_recv_per_sec"],
|
|
"net_bytes_sent": data.get("net_bytes_sent", 0),
|
|
"net_bytes_recv": data.get("net_bytes_recv", 0),
|
|
})
|
|
except Exception:
|
|
pass # VPS hors ligne ou agent non mis à jour — ignoré silencieusement
|
|
|
|
|
|
async def _stats_collector() -> None:
|
|
"""Tâche de fond : collecte les stats de tous les VPS toutes les 5 secondes."""
|
|
await asyncio.sleep(3) # laisse l'app finir de démarrer
|
|
while True:
|
|
vps_list = load_vps()
|
|
await asyncio.gather(
|
|
*[_fetch_system_stat(v) for v in vps_list],
|
|
return_exceptions=True,
|
|
)
|
|
await asyncio.sleep(5)
|
|
|
|
|
|
@app.on_event("startup")
|
|
async def startup_event() -> None:
|
|
asyncio.create_task(_stats_collector())
|
|
|
|
|
|
# ─── Routes Auth ──────────────────────────────────────────────────────────────
|
|
|
|
@app.get("/api/auth/status")
|
|
def auth_status():
|
|
"""Indique si des utilisateurs existent déjà (pour le frontend)."""
|
|
return {"has_users": len(load_users()) > 0}
|
|
|
|
|
|
@app.post("/api/auth/register", status_code=201)
|
|
def register(body: RegisterRequest):
|
|
"""Enregistre le premier utilisateur (admin). Fermé ensuite."""
|
|
if len(load_users()) > 0:
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="L'enregistrement public est désactivé. Seul l'admin peut créer des comptes."
|
|
)
|
|
if not body.username.strip() or len(body.password) < 6:
|
|
raise HTTPException(status_code=422, detail="Mot de passe trop court (6 caractères min.)")
|
|
user = {
|
|
"username": body.username.strip(),
|
|
"password": _bcrypt.hashpw(body.password.encode(), _bcrypt.gensalt()).decode(),
|
|
"role": "admin",
|
|
}
|
|
add_user(user)
|
|
token = create_token(user["username"], user["role"])
|
|
return {"access_token": token, "token_type": "bearer", "role": user["role"]}
|
|
|
|
|
|
@app.post("/api/auth/login")
|
|
def login(body: LoginRequest):
|
|
"""Authentifie un utilisateur et retourne un JWT."""
|
|
users = load_users()
|
|
user = next((u for u in users if u["username"] == body.username), None)
|
|
if not user or not _bcrypt.checkpw(body.password.encode(), user["password"].encode()):
|
|
raise HTTPException(status_code=401, detail="Identifiants incorrects")
|
|
token = create_token(user["username"], user["role"])
|
|
return {"access_token": token, "token_type": "bearer", "role": user["role"]}
|
|
|
|
|
|
@app.get("/api/auth/me")
|
|
def me(current_user: Annotated[dict, Depends(get_current_user)]):
|
|
return {"username": current_user["username"], "role": current_user["role"]}
|
|
|
|
|
|
# ─── Routes VPS ───────────────────────────────────────────────────────────────
|
|
|
|
@app.get("/api/vps")
|
|
def list_vps(_: Annotated[dict, Depends(get_current_user)]):
|
|
"""Liste les VPS configurés (sans les clés API)."""
|
|
return [
|
|
{"id": v["id"], "name": v["name"], "host": v["host"],
|
|
"description": v.get("description", ""), "tags": v.get("tags", [])}
|
|
for v in load_vps()
|
|
]
|
|
|
|
|
|
@app.post("/api/vps", status_code=201)
|
|
def add_vps(vps: VpsConfig, _: Annotated[dict, Depends(get_current_user)]):
|
|
"""Ajoute un nouveau VPS."""
|
|
if any(v["id"] == vps.id for v in load_vps()):
|
|
raise HTTPException(status_code=409, detail="Un VPS avec cet ID existe déjà")
|
|
insert_vps(vps.model_dump())
|
|
return {"status": "ok", "id": vps.id}
|
|
|
|
|
|
@app.delete("/api/vps/{vps_id}")
|
|
def delete_vps(vps_id: str, _: Annotated[dict, Depends(get_current_user)]):
|
|
"""Supprime un VPS de la configuration."""
|
|
if not remove_vps(vps_id):
|
|
raise HTTPException(status_code=404, detail="VPS introuvable")
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.put("/api/vps/{vps_id}")
|
|
def edit_vps(vps_id: str, body: VpsUpdateRequest, _: Annotated[dict, Depends(get_current_user)]):
|
|
"""Met à jour les paramètres d'un VPS (name, host, port, api_key, description)."""
|
|
existing = next((v for v in load_vps() if v["id"] == vps_id), None)
|
|
if not existing:
|
|
raise HTTPException(status_code=404, detail="VPS introuvable")
|
|
data = {
|
|
"name": body.name,
|
|
"host": body.host,
|
|
"port": body.port,
|
|
"api_key": body.api_key.strip() or existing["api_key"],
|
|
"description": body.description,
|
|
"tags": body.tags,
|
|
}
|
|
update_vps(vps_id, data)
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.get("/api/vps/{vps_id}/stats")
|
|
def get_vps_stats(vps_id: str, _: Annotated[dict, Depends(get_current_user)]):
|
|
"""Retourne l'historique des stats système d'un VPS (ring buffer en mémoire)."""
|
|
if not any(v["id"] == vps_id for v in load_vps()):
|
|
raise HTTPException(status_code=404, detail="VPS introuvable")
|
|
return list(_stats_history.get(vps_id, deque()))
|
|
|
|
|
|
@app.get("/api/status")
|
|
async def all_status(_: Annotated[dict, Depends(get_current_user)]):
|
|
"""Retourne l'état de tous les VPS en parallèle."""
|
|
vps_list = load_vps()
|
|
results = await asyncio.gather(*[fetch_vps_status(v) for v in vps_list])
|
|
return list(results)
|
|
|
|
|
|
@app.get("/api/vps/{vps_id}/status")
|
|
async def vps_status(vps_id: str, _: Annotated[dict, Depends(get_current_user)]):
|
|
"""Retourne l'état d'un VPS spécifique."""
|
|
vps = next((v for v in load_vps() if v["id"] == vps_id), None)
|
|
if not vps:
|
|
raise HTTPException(status_code=404, detail="VPS introuvable")
|
|
return await fetch_vps_status(vps)
|
|
|
|
|
|
@app.get("/api/vps/{vps_id}/containers/{container_id}/logs")
|
|
async def container_logs(
|
|
vps_id: str, container_id: str, lines: int = 100,
|
|
_: Annotated[dict, Depends(get_current_user)] = None
|
|
):
|
|
"""Récupère les logs d'un conteneur via l'agent."""
|
|
vps = next((v for v in load_vps() if v["id"] == vps_id), None)
|
|
if not vps:
|
|
raise HTTPException(status_code=404, detail="VPS introuvable")
|
|
try:
|
|
return await agent_get(vps, f"/containers/{container_id}/logs?lines={lines}")
|
|
except Exception as e:
|
|
raise HTTPException(status_code=502, detail=str(e))
|
|
|
|
|
|
@app.post("/api/vps/{vps_id}/containers/{container_id}/action")
|
|
async def container_action(
|
|
vps_id: str, container_id: str, body: ActionRequest,
|
|
_: Annotated[dict, Depends(get_current_user)] = None
|
|
):
|
|
"""Effectue une action sur un conteneur via l'agent."""
|
|
vps = next((v for v in load_vps() if v["id"] == vps_id), None)
|
|
if not vps:
|
|
raise HTTPException(status_code=404, detail="VPS introuvable")
|
|
try:
|
|
return await agent_post(vps, f"/containers/{container_id}/action?action={body.action}")
|
|
except Exception as e:
|
|
raise HTTPException(status_code=502, detail=str(e))
|
|
|
|
|
|
@app.post("/api/vps/{vps_id}/compose/update")
|
|
async def compose_update(
|
|
vps_id: str, body: ComposeUpdateRequest,
|
|
_: Annotated[dict, Depends(get_current_user)] = None
|
|
):
|
|
"""Lance docker compose pull + up sur un projet via l'agent."""
|
|
vps = next((v for v in load_vps() if v["id"] == vps_id), None)
|
|
if not vps:
|
|
raise HTTPException(status_code=404, detail="VPS introuvable")
|
|
try:
|
|
url = f"http://{vps['host']}:{vps['port']}/compose/update?project={body.project}"
|
|
headers = {"X-API-Key": vps["api_key"]}
|
|
timeout = aiohttp.ClientTimeout(total=600)
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post(url, headers=headers, timeout=timeout) as r:
|
|
r.raise_for_status()
|
|
return await r.json()
|
|
except Exception as e:
|
|
raise HTTPException(status_code=502, detail=str(e))
|