767 lines
30 KiB
Python
767 lines
30 KiB
Python
"""Overview stats and SSE activity stream."""
|
|
|
|
import asyncio
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import sqlite3
|
|
from datetime import date, datetime, timezone
|
|
from fastapi import APIRouter
|
|
from sse_starlette.sse import EventSourceResponse
|
|
import httpx
|
|
|
|
import sys
|
|
from pathlib import Path
|
|
sys.path.insert(0, str(Path(__file__).parent.parent))
|
|
|
|
from lib_bridge import (
|
|
portainer_list_containers, ENDPOINTS, ollama_available,
|
|
GMAIL_DB, DVISH_DB, PROTON_DB, RESTART_DB, LOG_DIR, OLLAMA_URL,
|
|
prom_query,
|
|
)
|
|
from log_parser import get_recent_events, tail_logs, get_new_lines
|
|
|
|
router = APIRouter(tags=["overview"])
|
|
|
|
|
|
def _count_today_emails(db_path: Path) -> int:
|
|
"""Count emails processed today from a processed.db file."""
|
|
if not db_path.exists():
|
|
return 0
|
|
try:
|
|
today = date.today().isoformat()
|
|
conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
|
|
cur = conn.execute(
|
|
"SELECT COUNT(*) FROM processed WHERE processed_at LIKE ?",
|
|
(f"{today}%",),
|
|
)
|
|
count = cur.fetchone()[0]
|
|
conn.close()
|
|
return count
|
|
except Exception:
|
|
return 0
|
|
|
|
|
|
def _count_unhealthy(db_path: Path) -> int:
|
|
"""Count unhealthy containers from stack-restart.db."""
|
|
if not db_path.exists():
|
|
return 0
|
|
try:
|
|
conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
|
|
cur = conn.execute("SELECT COUNT(*) FROM unhealthy_tracking")
|
|
count = cur.fetchone()[0]
|
|
conn.close()
|
|
return count
|
|
except Exception:
|
|
return 0
|
|
|
|
|
|
def _gpu_info() -> dict:
|
|
"""Get GPU info from olares via SSH."""
|
|
try:
|
|
result = subprocess.run(
|
|
["ssh", "-o", "ConnectTimeout=3", "olares",
|
|
"nvidia-smi --query-gpu=temperature.gpu,power.draw,power.limit,"
|
|
"memory.used,memory.total,utilization.gpu --format=csv,noheader,nounits"],
|
|
capture_output=True, text=True, timeout=10,
|
|
)
|
|
if result.returncode != 0:
|
|
return {"available": False}
|
|
parts = [p.strip() for p in result.stdout.strip().split(",")]
|
|
|
|
def _f(v):
|
|
try:
|
|
return float(v)
|
|
except (ValueError, TypeError):
|
|
return None
|
|
|
|
if len(parts) >= 6:
|
|
return {
|
|
"available": True,
|
|
"temp_c": _f(parts[0]),
|
|
"power_draw_w": _f(parts[1]),
|
|
"power_limit_w": _f(parts[2]),
|
|
"memory_used_mb": _f(parts[3]),
|
|
"memory_total_mb": _f(parts[4]),
|
|
"utilization_pct": _f(parts[5]),
|
|
}
|
|
except Exception:
|
|
pass
|
|
return {"available": False}
|
|
|
|
|
|
@router.get("/stats/overview")
|
|
def stats_overview():
|
|
"""Aggregate overview stats."""
|
|
# Container counts
|
|
container_counts = {}
|
|
total = 0
|
|
for ep_name in ENDPOINTS:
|
|
try:
|
|
containers = portainer_list_containers(ep_name)
|
|
running = sum(1 for c in containers if c.get("State") == "running")
|
|
container_counts[ep_name] = {"total": len(containers), "running": running}
|
|
total += len(containers)
|
|
except Exception:
|
|
container_counts[ep_name] = {"total": 0, "running": 0, "error": True}
|
|
|
|
# GPU
|
|
gpu = _gpu_info()
|
|
|
|
# Email counts
|
|
email_today = {
|
|
"gmail": _count_today_emails(GMAIL_DB),
|
|
"dvish": _count_today_emails(DVISH_DB),
|
|
"proton": _count_today_emails(PROTON_DB),
|
|
}
|
|
email_today["total"] = sum(email_today.values())
|
|
|
|
# Unhealthy
|
|
unhealthy = _count_unhealthy(RESTART_DB)
|
|
|
|
# Ollama
|
|
ollama_up = ollama_available(OLLAMA_URL)
|
|
|
|
return {
|
|
"containers": {"total": total, "by_endpoint": container_counts},
|
|
"gpu": gpu,
|
|
"email_today": email_today,
|
|
"unhealthy_count": unhealthy,
|
|
"ollama_available": ollama_up,
|
|
}
|
|
|
|
|
|
@router.get("/activity")
|
|
async def activity_stream():
|
|
"""SSE stream of today's automation events."""
|
|
|
|
async def event_generator():
|
|
# Send initial batch
|
|
events = get_recent_events(LOG_DIR)
|
|
yield {"event": "init", "data": json.dumps(events)}
|
|
|
|
# Poll for new events
|
|
positions = tail_logs(LOG_DIR)
|
|
while True:
|
|
await asyncio.sleep(5)
|
|
new_events, positions = get_new_lines(LOG_DIR, positions)
|
|
if new_events:
|
|
yield {"event": "update", "data": json.dumps(new_events)}
|
|
|
|
return EventSourceResponse(event_generator())
|
|
|
|
|
|
@router.post("/actions/pause-organizers")
|
|
def pause_organizers():
|
|
"""Pause all email organizer cron jobs."""
|
|
result = subprocess.run(
|
|
["/home/homelab/organized/repos/homelab/scripts/gmail-organizer-ctl.sh", "stop"],
|
|
capture_output=True, text=True, timeout=10,
|
|
)
|
|
return {"success": result.returncode == 0, "output": result.stdout.strip()}
|
|
|
|
|
|
@router.post("/actions/resume-organizers")
|
|
def resume_organizers():
|
|
"""Resume all email organizer cron jobs."""
|
|
result = subprocess.run(
|
|
["/home/homelab/organized/repos/homelab/scripts/gmail-organizer-ctl.sh", "start"],
|
|
capture_output=True, text=True, timeout=10,
|
|
)
|
|
return {"success": result.returncode == 0, "output": result.stdout.strip()}
|
|
|
|
|
|
@router.get("/actions/organizer-status")
|
|
def organizer_status():
|
|
"""Check if organizers are running or paused."""
|
|
result = subprocess.run(
|
|
["/home/homelab/organized/repos/homelab/scripts/gmail-organizer-ctl.sh", "status"],
|
|
capture_output=True, text=True, timeout=10,
|
|
)
|
|
return {"output": result.stdout.strip()}
|
|
|
|
|
|
@router.get("/calendar")
|
|
def get_calendar_events():
|
|
"""Fetch upcoming events from Baikal CalDAV."""
|
|
import re
|
|
from datetime import datetime, timezone
|
|
|
|
BAIKAL_URL = "http://192.168.0.200:12852/dav.php/calendars/vish/default/"
|
|
BAIKAL_USER = "vish"
|
|
BAIKAL_PASS = "REDACTED_PASSWORD"
|
|
|
|
today = datetime.now(timezone.utc).strftime("%Y%m%dT000000Z")
|
|
body = f'''<?xml version="1.0" encoding="UTF-8"?>
|
|
<c:calendar-query xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav">
|
|
<d:prop><d:getetag/><c:calendar-data/></d:prop>
|
|
<c:filter>
|
|
<c:comp-filter name="VCALENDAR">
|
|
<c:comp-filter name="VEVENT">
|
|
<c:time-range start="{today}"/>
|
|
</c:comp-filter>
|
|
</c:comp-filter>
|
|
</c:filter>
|
|
</c:calendar-query>'''
|
|
|
|
try:
|
|
auth = httpx.DigestAuth(BAIKAL_USER, BAIKAL_PASS)
|
|
with httpx.Client(timeout=10) as client:
|
|
r = client.request("REPORT", BAIKAL_URL, content=body,
|
|
headers={"Content-Type": "application/xml", "Depth": "1"}, auth=auth)
|
|
r.raise_for_status()
|
|
|
|
# Parse iCal events
|
|
summaries = re.findall(r'SUMMARY:(.*?)(?:\r?\n)', r.text)
|
|
starts = re.findall(r'DTSTART[^:]*:(.*?)(?:\r?\n)', r.text)
|
|
locations = re.findall(r'LOCATION:(.*?)(?:\r?\n)', r.text)
|
|
|
|
events = []
|
|
now = datetime.now(timezone.utc)
|
|
for i, (start, summary) in enumerate(zip(starts, summaries)):
|
|
# Parse date — handle both date and datetime formats
|
|
try:
|
|
if len(start) == 8:
|
|
dt = datetime.strptime(start, "%Y%m%d").replace(tzinfo=timezone.utc)
|
|
else:
|
|
clean = start.replace("Z", "")
|
|
dt = datetime.strptime(clean[:15], "%Y%m%dT%H%M%S").replace(tzinfo=timezone.utc)
|
|
except ValueError:
|
|
continue
|
|
|
|
# Only future events
|
|
if dt < now:
|
|
continue
|
|
|
|
# Clean up summary (unescape iCal)
|
|
clean_summary = summary.replace("\\,", ",").replace("\\;", ";").replace("&", "&")
|
|
|
|
events.append({
|
|
"summary": clean_summary,
|
|
"start": dt.isoformat(),
|
|
"date": dt.strftime("%b %d"),
|
|
"time": dt.strftime("%I:%M %p") if len(start) > 8 else "All day",
|
|
"location": locations[i].replace("\\,", ",").replace("\\n", ", ") if i < len(locations) else None,
|
|
})
|
|
|
|
# Sort by date, limit to next 8
|
|
events.sort(key=lambda e: e["start"])
|
|
return {"events": events[:8], "total": len(events)}
|
|
except Exception as e:
|
|
return {"events": [], "error": str(e)}
|
|
|
|
|
|
def _search_repo_docs(query: str, max_chars: int = 2000) -> str:
|
|
"""Search repo docs/scripts for relevant snippets. Lightweight keyword match."""
|
|
import re
|
|
repo = Path("/app/scripts").parent if Path("/app/scripts").exists() else Path(__file__).parent.parent.parent.parent
|
|
search_dirs = [repo / "docs" / "services" / "individual", repo / "scripts", repo / "docs"]
|
|
|
|
keywords = [w.lower() for w in re.findall(r'\w{3,}', query) if w.lower() not in {
|
|
"the", "how", "what", "does", "can", "are", "this", "that", "have",
|
|
"many", "much", "about", "from", "with", "your", "there", "which",
|
|
}]
|
|
if not keywords:
|
|
return ""
|
|
# Add aliases so related terms find each other
|
|
aliases = {"tailscale": "headscale", "headscale": "tailscale", "gpu": "nvidia",
|
|
"jellyfin": "olares", "containers": "portainer", "dns": "adguard"}
|
|
extra = [aliases[k] for k in keywords if k in aliases]
|
|
keywords = list(set(keywords + extra))
|
|
|
|
scored = []
|
|
for search_dir in search_dirs:
|
|
if not search_dir.exists():
|
|
continue
|
|
for f in search_dir.rglob("*.md"):
|
|
try:
|
|
text = f.read_text(errors="ignore")[:8000]
|
|
score = sum(text.lower().count(kw) for kw in keywords)
|
|
if score > 0:
|
|
scored.append((score, f, text))
|
|
except Exception:
|
|
continue
|
|
for f in search_dir.rglob("*.py"):
|
|
if f.name.startswith("__"):
|
|
continue
|
|
try:
|
|
# Only read the docstring/header, not full scripts
|
|
text = f.read_text(errors="ignore")[:1000]
|
|
score = sum(text.lower().count(kw) for kw in keywords)
|
|
if score > 0:
|
|
scored.append((score, f, text))
|
|
except Exception:
|
|
continue
|
|
|
|
if not scored:
|
|
return ""
|
|
|
|
scored.sort(key=lambda x: -x[0])
|
|
snippets = []
|
|
total = 0
|
|
for _, path, text in scored[:2]: # max 2 files
|
|
# Trim to relevant section — find paragraphs with keywords
|
|
lines = text.split("\n")
|
|
relevant = []
|
|
for i, line in enumerate(lines):
|
|
if any(kw in line.lower() for kw in keywords):
|
|
start = max(0, i - 2)
|
|
end = min(len(lines), i + 5)
|
|
relevant.extend(lines[start:end])
|
|
snippet = "\n".join(dict.fromkeys(relevant))[:1000] # dedup, cap at 1K
|
|
if not snippet.strip():
|
|
snippet = text[:500]
|
|
snippets.append(f"[{path.name}]\n{snippet}")
|
|
total += len(snippet)
|
|
if total >= max_chars:
|
|
break
|
|
|
|
return "\n\n".join(snippets)
|
|
|
|
|
|
@router.post("/chat")
|
|
def chat_with_ollama(body: dict):
|
|
"""Chat with Ollama using live homelab context + repo docs."""
|
|
message = body.get("message", "")
|
|
if not message:
|
|
return {"error": "No message provided"}
|
|
|
|
# Gather live context from multiple sources
|
|
context_parts = []
|
|
try:
|
|
overview = stats_overview()
|
|
containers = overview.get("containers", {})
|
|
gpu = overview.get("gpu", {})
|
|
context_parts.append(
|
|
f"Containers: {containers.get('total', '?')} total across endpoints: "
|
|
+ ", ".join(f"{k} ({v.get('total','?')} containers, {v.get('running','?')} running)"
|
|
for k, v in containers.get("by_endpoint", {}).items())
|
|
)
|
|
if gpu.get("available"):
|
|
context_parts.append(
|
|
f"GPU: {gpu.get('name','RTX 5090')}, {gpu.get('temp_c','?')}°C, "
|
|
f"{gpu.get('memory_used_mb','?')}/{gpu.get('memory_total_mb','?')} MB VRAM, "
|
|
f"{gpu.get('utilization_pct','?')}% util"
|
|
)
|
|
email_data = overview.get("email_today", {})
|
|
if isinstance(email_data, dict):
|
|
context_parts.append(f"Emails today: {email_data.get('total', 0)} (dvish: {email_data.get('dvish', 0)}, proton: {email_data.get('proton', 0)})")
|
|
context_parts.append(f"Ollama: {'online' if overview.get('ollama_available') else 'offline'}")
|
|
context_parts.append(f"Unhealthy containers: {overview.get('unhealthy_count', 0)}")
|
|
except Exception:
|
|
context_parts.append("(could not fetch live stats)")
|
|
|
|
# Fetch Headscale nodes if question mentions network/tailscale/headscale/nodes
|
|
msg_lower = message.lower()
|
|
if any(kw in msg_lower for kw in ["tailscale", "headscale", "node", "mesh", "vpn", "network"]):
|
|
try:
|
|
import json as _json
|
|
hs_result = subprocess.run(
|
|
["ssh", "-o", "ConnectTimeout=3", "calypso",
|
|
"/usr/local/bin/docker exec headscale headscale nodes list -o json"],
|
|
capture_output=True, text=True, timeout=10,
|
|
)
|
|
if hs_result.returncode == 0:
|
|
nodes = _json.loads(hs_result.stdout)
|
|
online = [n for n in nodes if n.get("online")]
|
|
node_names = ", ".join(n.get("givenName") or n.get("name", "?") for n in nodes)
|
|
context_parts.append(f"Headscale/Tailscale: {len(nodes)} nodes ({len(online)} online): {node_names}")
|
|
else:
|
|
context_parts.append("Headscale: 26 nodes (could not fetch live list, but documented as 26)")
|
|
except Exception:
|
|
context_parts.append("Headscale: 26 nodes (documented, could not fetch live)")
|
|
|
|
# Fetch Jellyfin status if question mentions media/jellyfin/streaming
|
|
if any(kw in msg_lower for kw in ["jellyfin", "media", "stream", "movie", "tv", "playing"]):
|
|
try:
|
|
from routers.media import jellyfin_status
|
|
jf = jellyfin_status()
|
|
libs = ", ".join(f"{l['name']} ({l['type']})" for l in jf.get("libraries", []))
|
|
active = jf.get("active_sessions", [])
|
|
playing = ", ".join(f"{s['title']} by {s['user']}" for s in active) if active else "nothing"
|
|
context_parts.append(f"Jellyfin v{jf.get('version','?')}: libraries={libs}. Now playing: {playing}")
|
|
except Exception:
|
|
pass
|
|
|
|
# Fetch AdGuard stats if question mentions dns/adguard/blocked
|
|
if any(kw in msg_lower for kw in ["dns", "adguard", "blocked", "queries", "domain"]):
|
|
try:
|
|
from routers.network import adguard_stats
|
|
ag = adguard_stats()
|
|
context_parts.append(f"AdGuard DNS: {ag.get('total_queries', '?')} total queries, {ag.get('blocked', '?')} blocked, {ag.get('avg_time', '?')}s avg response")
|
|
except Exception:
|
|
pass
|
|
|
|
system_context = (
|
|
"You are a homelab assistant. You have direct access to the following live infrastructure data:\n\n"
|
|
+ "\n".join(f"- {p}" for p in context_parts)
|
|
+ "\n\n"
|
|
"Homelab hosts: Atlantis (Synology NAS, media/arr stack), Calypso (Synology, AdGuard DNS, Headscale, Authentik SSO), "
|
|
"Olares (K3s, RTX 5090, Jellyfin, Ollama), NUC (lightweight services), RPi5 (Uptime Kuma), "
|
|
"homelab-vm (Prometheus, Grafana, dashboard), Guava (TrueNAS), Seattle (remote VM), matrix-ubuntu (NPM, CrowdSec).\n\n"
|
|
"Services: Sonarr, Radarr, SABnzbd, Deluge, Prowlarr, Bazarr, Lidarr, Tdarr, Audiobookshelf, LazyLibrarian on Atlantis. "
|
|
"Jellyfin + Ollama on Olares with GPU transcoding. 3 email auto-organizers (Gmail x2 + Proton). "
|
|
"11 Ollama-powered automation scripts. Gitea CI with AI PR reviewer.\n\n"
|
|
"IMPORTANT: Answer using the LIVE DATA above, not general knowledge. The container counts are REAL numbers from Portainer right now. "
|
|
"When asked 'how many containers on atlantis' answer with the exact number from the live data (e.g. 59). Be concise."
|
|
)
|
|
|
|
# Search repo docs for relevant context (max 2K chars)
|
|
doc_context = _search_repo_docs(message, max_chars=2000)
|
|
if doc_context:
|
|
system_context += f"\n\nRelevant documentation:\n{doc_context}"
|
|
|
|
prompt = f"{system_context}\n\nUser: {message}\nAssistant:"
|
|
|
|
try:
|
|
from lib_bridge import ollama_available as _ollama_check
|
|
if not _ollama_check():
|
|
return {"response": "Ollama is currently offline. Try again later."}
|
|
import sys as _sys
|
|
scripts_dir = str(Path("/app/scripts") if Path("/app/scripts").exists() else Path(__file__).parent.parent.parent / "scripts")
|
|
if scripts_dir not in _sys.path:
|
|
_sys.path.insert(0, scripts_dir)
|
|
from lib.ollama import ollama_generate
|
|
response = ollama_generate(prompt, num_predict=800, timeout=90)
|
|
return {"response": response}
|
|
except Exception as e:
|
|
return {"error": str(e)}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Health score
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@router.get("/health-score")
|
|
def health_score():
|
|
"""Calculate aggregate system health score 0-100."""
|
|
score = 100
|
|
details = []
|
|
|
|
try:
|
|
overview = stats_overview()
|
|
containers = overview.get("containers", {})
|
|
by_ep = containers.get("by_endpoint", {})
|
|
|
|
# Container health (40 points) — only penalize crashed containers, not cleanly stopped ones
|
|
crashed = 0
|
|
cleanly_stopped = 0
|
|
for ep_name in by_ep:
|
|
try:
|
|
ep_containers = portainer_list_containers(ep_name)
|
|
for c in ep_containers:
|
|
state = c.get("State", "")
|
|
status = c.get("Status", "")
|
|
if state != "running":
|
|
if "Exited (0)" in status:
|
|
cleanly_stopped += 1
|
|
else:
|
|
crashed += 1
|
|
except Exception:
|
|
pass
|
|
if crashed > 0:
|
|
penalty = min(40, crashed * 8)
|
|
score -= penalty
|
|
details.append(f"-{penalty}: {crashed} containers crashed/unhealthy")
|
|
else:
|
|
details.append("+40: all containers healthy")
|
|
if cleanly_stopped > 0:
|
|
details.append(f"(info: {cleanly_stopped} intentionally stopped, not penalized)")
|
|
|
|
# Unhealthy containers (20 points)
|
|
unhealthy = overview.get("unhealthy_count", 0)
|
|
if unhealthy > 0:
|
|
penalty = min(20, unhealthy * 10)
|
|
score -= penalty
|
|
details.append(f"-{penalty}: {unhealthy} unhealthy containers")
|
|
else:
|
|
details.append("+20: no unhealthy containers")
|
|
|
|
# GPU available (10 points)
|
|
gpu = overview.get("gpu", {})
|
|
if not gpu.get("available"):
|
|
score -= 10
|
|
details.append("-10: GPU unavailable")
|
|
else:
|
|
details.append("+10: GPU online")
|
|
|
|
# Ollama available (10 points)
|
|
if not overview.get("ollama_available"):
|
|
score -= 10
|
|
details.append("-10: Ollama offline")
|
|
else:
|
|
details.append("+10: Ollama online")
|
|
|
|
# Backup status (10 points)
|
|
backup_log = Path("/app/logs" if Path("/app/logs").exists() else "/tmp") / "gmail-backup-daily.log"
|
|
if backup_log.exists():
|
|
with open(backup_log) as f:
|
|
content = f.read()
|
|
if "ERROR" in content[-2000:]:
|
|
score -= 10
|
|
details.append("-10: backup has errors")
|
|
else:
|
|
details.append("+10: backup OK")
|
|
else:
|
|
score -= 5
|
|
details.append("-5: no backup log found")
|
|
|
|
# Config drift (10 points)
|
|
drift_log = Path("/app/logs" if Path("/app/logs").exists() else "/tmp") / "config-drift.log"
|
|
if drift_log.exists():
|
|
with open(drift_log) as f:
|
|
lines = f.readlines()
|
|
last_lines = "".join(lines[-20:])
|
|
if "drifts" in last_lines.lower() and "no drifts" not in last_lines.lower():
|
|
score -= 10
|
|
details.append("-10: config drift detected")
|
|
else:
|
|
details.append("+10: no drift")
|
|
else:
|
|
details.append("+10: no drift (no log)")
|
|
except Exception as e:
|
|
details.append(f"Error calculating: {e}")
|
|
|
|
return {
|
|
"score": max(0, min(100, score)),
|
|
"grade": "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "D" if score >= 60 else "F",
|
|
"details": details,
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Quick actions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@router.post("/actions/restart-jellyfin")
|
|
def restart_jellyfin():
|
|
"""Restart Jellyfin on Olares."""
|
|
result = subprocess.run(
|
|
["ssh", "-o", "ConnectTimeout=3", "olares",
|
|
"kubectl rollout restart deployment/jellyfin -n jellyfin-vishinator"],
|
|
capture_output=True, text=True, timeout=15)
|
|
return {"success": result.returncode == 0, "output": result.stdout.strip() or result.stderr.strip()}
|
|
|
|
|
|
@router.post("/actions/restart-ollama")
|
|
def restart_ollama():
|
|
"""Restart Ollama on Olares."""
|
|
result = subprocess.run(
|
|
["ssh", "-o", "ConnectTimeout=3", "olares",
|
|
"kubectl rollout restart deployment/ollama -n ollamaserver-shared"],
|
|
capture_output=True, text=True, timeout=15)
|
|
return {"success": result.returncode == 0, "output": result.stdout.strip() or result.stderr.strip()}
|
|
|
|
|
|
@router.post("/actions/run-backup")
|
|
def run_backup():
|
|
"""Trigger daily Gmail backup."""
|
|
result = subprocess.run(
|
|
["/home/homelab/organized/repos/homelab/scripts/gmail-backup-daily.sh"],
|
|
capture_output=True, text=True, timeout=300)
|
|
return {"success": result.returncode == 0, "output": result.stdout.strip()[-500:]}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Automation timeline
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@router.get("/automation-timeline")
|
|
def automation_timeline():
|
|
"""When each automation last ran."""
|
|
log_dir = Path("/app/logs") if Path("/app/logs").exists() else Path("/tmp")
|
|
|
|
automations = {
|
|
"Email (lz)": "gmail-organizer.log",
|
|
"Email (dvish)": "gmail-organizer-dvish.log",
|
|
"Email (proton)": "proton-organizer.log",
|
|
"Stack Restart": "stack-restart.log",
|
|
"Backup": "gmail-backup-daily.log",
|
|
"Backup Validator": "backup-validator.log",
|
|
"Disk Predictor": "disk-predictor.log",
|
|
"Config Drift": "config-drift.log",
|
|
"Receipt Tracker": "receipt-tracker.log",
|
|
"Changelog": "changelog-generator.log",
|
|
"Email Digest": "email-digest.log",
|
|
}
|
|
|
|
timeline = []
|
|
for name, filename in automations.items():
|
|
path = log_dir / filename
|
|
if path.exists():
|
|
mtime = os.path.getmtime(path)
|
|
last_modified = datetime.fromtimestamp(mtime, tz=timezone.utc).isoformat()
|
|
# Get last line with a timestamp
|
|
with open(path) as f:
|
|
lines = f.readlines()
|
|
last_run = None
|
|
for line in reversed(lines[-50:]):
|
|
if line[:4].isdigit():
|
|
last_run = line[:19]
|
|
break
|
|
# Fall back to file modification time if no timestamp found in content
|
|
if not last_run:
|
|
last_run = last_modified[:19]
|
|
timeline.append({"name": name, "last_run": last_run, "last_modified": last_modified, "exists": True})
|
|
else:
|
|
timeline.append({"name": name, "exists": False})
|
|
|
|
return timeline
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Disk usage (via Prometheus)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@router.get("/disk-usage")
|
|
def disk_usage():
|
|
"""Disk usage from Prometheus.
|
|
|
|
Filters out network mounts (nfs/cifs) so remote capacity isn't double-counted,
|
|
deduplicates Synology btrfs subvolumes, and aggregates ZFS datasets into
|
|
pool-level usage (individual ZFS datasets misleadingly show pool free space).
|
|
"""
|
|
_fs_exclude = "tmpfs|devtmpfs|overlay|nfs|nfs4|cifs"
|
|
_mp_exclude = "/boot.*"
|
|
_synology_hosts = {"atlantis", "calypso", "setillo"}
|
|
try:
|
|
avail = prom_query(f'node_filesystem_avail_bytes{{fstype!~"{_fs_exclude}",mountpoint!~"{_mp_exclude}"}}')
|
|
total = prom_query(f'node_filesystem_size_bytes{{fstype!~"{_fs_exclude}",mountpoint!~"{_mp_exclude}"}}')
|
|
|
|
total_map = {}
|
|
for t in total:
|
|
key = f"{t['metric'].get('instance', '?')}:{t['metric'].get('mountpoint', '?')}"
|
|
total_map[key] = float(t['value'][1])
|
|
|
|
disks = {}
|
|
# Collect ZFS datasets separately for pool-level aggregation
|
|
# Key: (host, pool_avail_rounded) -> {used, avail, label}
|
|
zfs_pools: dict[tuple, dict] = {}
|
|
|
|
for a in avail:
|
|
key = f"{a['metric'].get('instance', '?')}:{a['metric'].get('mountpoint', '?')}"
|
|
mount = a['metric'].get('mountpoint', '?')
|
|
fstype = a['metric'].get('fstype', '')
|
|
avail_bytes = float(a['value'][1])
|
|
total_bytes = total_map.get(key, 0)
|
|
if total_bytes < 1e9:
|
|
continue
|
|
host = a['metric'].get('instance', '?').split(':')[0]
|
|
|
|
# ZFS: aggregate all datasets per pool instead of showing individually
|
|
if fstype == "zfs":
|
|
used_bytes = total_bytes - avail_bytes
|
|
pool_key = (host, round(avail_bytes / 1e9))
|
|
if pool_key not in zfs_pools:
|
|
zfs_pools[pool_key] = {"used": 0, "avail": avail_bytes, "label": mount, "host": host}
|
|
zfs_pools[pool_key]["used"] += used_bytes
|
|
# Keep shortest mountpoint as label
|
|
if len(mount) < len(zfs_pools[pool_key]["label"]):
|
|
zfs_pools[pool_key]["label"] = mount
|
|
continue
|
|
|
|
# Skip Synology REDACTED_APP_PASSWORD bind-mounts (subvolumes of the same btrfs pool)
|
|
if "/@appdata/" in mount or "/@docker" in mount:
|
|
continue
|
|
# Synology NAS hosts: only show /volumeN data partitions, skip OS root
|
|
if host in _synology_hosts and not mount.startswith("/volume"):
|
|
continue
|
|
dedup_key = f"{host}:{mount}"
|
|
used_pct = ((total_bytes - avail_bytes) / total_bytes * 100) if total_bytes > 0 else 0
|
|
disks[dedup_key] = {
|
|
"host": host,
|
|
"mount": mount,
|
|
"total_gb": round(total_bytes / 1e9, 1),
|
|
"avail_gb": round(avail_bytes / 1e9, 1),
|
|
"used_pct": round(used_pct, 1),
|
|
}
|
|
|
|
# Convert aggregated ZFS pools into disk entries (skip tiny pools < 10GB)
|
|
for pool_key, p in zfs_pools.items():
|
|
total_bytes = p["used"] + p["avail"]
|
|
if total_bytes < 10e9:
|
|
continue
|
|
used_pct = (p["used"] / total_bytes * 100) if total_bytes > 0 else 0
|
|
dedup_key = f"{p['host']}:zfs:{pool_key[1]}"
|
|
disks[dedup_key] = {
|
|
"host": p["host"],
|
|
"mount": p["label"],
|
|
"total_gb": round(total_bytes / 1e9, 1),
|
|
"avail_gb": round(p["avail"] / 1e9, 1),
|
|
"used_pct": round(used_pct, 1),
|
|
}
|
|
|
|
result = sorted(disks.values(), key=lambda d: -d["used_pct"])
|
|
return result[:20]
|
|
except Exception as e:
|
|
return {"error": str(e)}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Host temperatures (via Prometheus)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@router.get("/temperatures")
|
|
def temperatures():
|
|
"""Host temperatures from Prometheus node_hwmon_temp_celsius.
|
|
|
|
Returns one entry per host with CPU/SoC temp (highest relevant sensor)
|
|
plus any hot NVMe drives flagged separately.
|
|
"""
|
|
# Chips/labels that indicate CPU/SoC temperature
|
|
_cpu_chips = {"coretemp", "k10temp", "pci0000:00_0000:00:18_3", "thermal_zone"}
|
|
try:
|
|
results = prom_query("node_hwmon_temp_celsius")
|
|
from collections import defaultdict
|
|
hosts: dict[str, dict] = defaultdict(lambda: {
|
|
"cpu_temp": None, "sensors": [],
|
|
})
|
|
|
|
for r in results:
|
|
m = r["metric"]
|
|
host = m.get("instance", "?").split(":")[0]
|
|
chip = m.get("chip", "")
|
|
label = m.get("label", m.get("sensor", ""))
|
|
temp = float(r["value"][1])
|
|
if temp <= 0:
|
|
continue
|
|
|
|
is_cpu = any(k in chip for k in _cpu_chips)
|
|
is_nvme = "nvme" in chip
|
|
entry = hosts[host]
|
|
|
|
if is_cpu:
|
|
if entry["cpu_temp"] is None or temp > entry["cpu_temp"]:
|
|
entry["cpu_temp"] = temp
|
|
elif is_nvme:
|
|
entry["sensors"].append({"label": f"NVMe ({chip.split('_')[-1]})", "temp": temp})
|
|
else:
|
|
entry["sensors"].append({"label": label or chip, "temp": temp})
|
|
|
|
out = []
|
|
for host, data in hosts.items():
|
|
# Pick the highest temp as representative if no CPU sensor found
|
|
all_temps = ([data["cpu_temp"]] if data["cpu_temp"] else []) + \
|
|
[s["temp"] for s in data["sensors"]]
|
|
cpu = data["cpu_temp"] or (max(all_temps) if all_temps else None)
|
|
if cpu is None:
|
|
continue
|
|
# Flag hottest NVMe if above 70°C
|
|
hot_nvme = None
|
|
nvme_sensors = [s for s in data["sensors"] if "NVMe" in s["label"]]
|
|
if nvme_sensors:
|
|
hottest = max(nvme_sensors, key=lambda s: s["temp"])
|
|
if hottest["temp"] >= 70:
|
|
hot_nvme = {"label": hottest["label"], "temp": round(hottest["temp"], 1)}
|
|
out.append({
|
|
"host": host,
|
|
"cpu_temp": round(cpu, 1),
|
|
"hot_nvme": hot_nvme,
|
|
})
|
|
|
|
out.sort(key=lambda d: -d["cpu_temp"])
|
|
return out
|
|
except Exception as e:
|
|
return {"error": str(e)}
|