151 lines
4.8 KiB
Python
151 lines
4.8 KiB
Python
import os
|
|
import json
|
|
import subprocess
|
|
from datetime import datetime
|
|
from flask import Flask, jsonify, render_template
|
|
|
|
app = Flask(__name__)
|
|
|
|
POLL_SECONDS = int(os.getenv("POLL_SECONDS", "10"))
|
|
APP_DOMAIN = os.getenv("APP_DOMAIN", "peterstockings.com")
|
|
DOCKER = os.getenv("DOCKER_BIN", "/usr/bin/docker")
|
|
SHOW_INFRA = os.getenv("SHOW_INFRA", "1") == "1"
|
|
|
|
# Optional JSON map: {"gitea":"https://gitea.peterstockings.com", "bloodpressure":"https://bp.peterstockings.com"}
|
|
APP_URL_OVERRIDES = {}
|
|
try:
|
|
APP_URL_OVERRIDES = json.loads(os.getenv("APP_URL_OVERRIDES", "{}"))
|
|
except Exception:
|
|
APP_URL_OVERRIDES = {}
|
|
|
|
def sh(cmd: list[str]) -> str:
|
|
return subprocess.check_output(cmd, stderr=subprocess.STDOUT, text=True).strip()
|
|
|
|
def docker_ps_all() -> list[dict]:
|
|
# Name + Image + Status + Ports
|
|
fmt = "{{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}"
|
|
out = sh([DOCKER, "ps", "--format", fmt])
|
|
rows = []
|
|
for line in out.splitlines():
|
|
name, image, status, ports = line.split("\t")
|
|
rows.append({"name": name, "image": image, "status": status, "ports": ports})
|
|
return rows
|
|
|
|
def docker_stats() -> dict:
|
|
# Name + CPU + MemUsage + MemPerc
|
|
fmt = "{{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}"
|
|
out = sh([DOCKER, "stats", "--no-stream", "--format", fmt])
|
|
stats = {}
|
|
for line in out.splitlines():
|
|
name, cpu, mem_usage, mem_pct = line.split("\t")
|
|
# mem_usage like: "58.84MiB / 384MiB"
|
|
mem_used, mem_limit = [s.strip() for s in mem_usage.split("/", 1)]
|
|
stats[name] = {
|
|
"cpu": cpu,
|
|
"mem_used": mem_used,
|
|
"mem_limit": mem_limit,
|
|
"mem_pct": mem_pct,
|
|
}
|
|
return stats
|
|
|
|
def docker_inspect_restart_count(container_name: str) -> int:
|
|
# RestartCount is useful when stuff is flapping / OOMing
|
|
try:
|
|
out = sh([DOCKER, "inspect", "-f", "{{.RestartCount}}", container_name])
|
|
return int(out.strip())
|
|
except Exception:
|
|
return 0
|
|
|
|
def is_app_web_container(name: str) -> bool:
|
|
# Dokku apps typically have containers like "<app>.web.1"
|
|
return name.endswith(".web.1") and not name.startswith("dokku.")
|
|
|
|
def infer_app_name(container_name: str) -> str:
|
|
# "<app>.web.1" -> "<app>"
|
|
return container_name.rsplit(".web.1", 1)[0]
|
|
|
|
def infer_url(app_name: str) -> str:
|
|
if app_name in APP_URL_OVERRIDES:
|
|
return APP_URL_OVERRIDES[app_name]
|
|
# default
|
|
return f"https://{app_name}.{APP_DOMAIN}"
|
|
|
|
def classify_infra(container_name: str) -> bool:
|
|
return (
|
|
container_name.startswith("dokku.postgres.")
|
|
or container_name.startswith("dokku.redis.")
|
|
or container_name.startswith("dokku.mysql.")
|
|
or container_name.startswith("dokku.mongodb.")
|
|
or container_name == "dokku.minio.storage"
|
|
or container_name == "logspout"
|
|
)
|
|
|
|
def collect():
|
|
ps_rows = docker_ps_all()
|
|
stats = docker_stats()
|
|
|
|
apps = []
|
|
infra = []
|
|
|
|
for r in ps_rows:
|
|
name = r["name"]
|
|
s = stats.get(name, {})
|
|
row = {
|
|
"container": name,
|
|
"image": r["image"],
|
|
"status": r["status"],
|
|
"ports": r["ports"],
|
|
"cpu": s.get("cpu", ""),
|
|
"mem_used": s.get("mem_used", ""),
|
|
"mem_limit": s.get("mem_limit", ""),
|
|
"mem_pct": s.get("mem_pct", ""),
|
|
"restarts": docker_inspect_restart_count(name),
|
|
}
|
|
|
|
if is_app_web_container(name):
|
|
app_name = infer_app_name(name)
|
|
row["app"] = app_name
|
|
row["url"] = infer_url(app_name)
|
|
apps.append(row)
|
|
elif SHOW_INFRA and classify_infra(name):
|
|
infra.append(row)
|
|
|
|
# Sort stable
|
|
apps.sort(key=lambda x: x["app"])
|
|
infra.sort(key=lambda x: x["container"])
|
|
|
|
# Simple top-line summary
|
|
warnings = []
|
|
for a in apps:
|
|
# mem_pct is like "15.32%"
|
|
try:
|
|
pct = float(a["mem_pct"].replace("%", "")) if a["mem_pct"] else 0.0
|
|
except Exception:
|
|
pct = 0.0
|
|
if pct >= 85:
|
|
warnings.append(f"{a['app']} RAM high ({a['mem_pct']})")
|
|
if a["restarts"] >= 3:
|
|
warnings.append(f"{a['app']} restarting (restarts={a['restarts']})")
|
|
|
|
return {
|
|
"generated_at": datetime.utcnow().isoformat() + "Z",
|
|
"poll_seconds": POLL_SECONDS,
|
|
"domain": APP_DOMAIN,
|
|
"apps": apps,
|
|
"infra": infra,
|
|
"warnings": warnings,
|
|
}
|
|
|
|
@app.get("/")
|
|
def index():
|
|
return render_template("index.html", poll_seconds=POLL_SECONDS)
|
|
|
|
@app.get("/partial/apps")
|
|
def partial_apps():
|
|
data = collect()
|
|
return render_template("apps_table.html", data=data)
|
|
|
|
@app.get("/api/status")
|
|
def api_status():
|
|
return jsonify(collect())
|