259 lines
9.1 KiB
Python
259 lines
9.1 KiB
Python
#!/usr/bin/env python3
|
|
"""Проверка сервисов Buryans Hub на соответствие единому стандарту.
|
|
|
|
Стандарт (5 требований):
|
|
S1 ИДЕНТИЧНОСТЬ — сервис закрыт Authentik (oauth2-proxy рядом или нативный OIDC)
|
|
S2 ДАННЫЕ — есть бэкап данных сервиса
|
|
S3 ЗДОРОВЬЕ — сервис отвечает по HTTP (< 500)
|
|
S4 ДОКУМЕНТАЦИЯ — есть deploy/ctNNN (compose) или запись в реестре
|
|
S5 УНИКАЛЬНОСТЬ — роль не дублируется
|
|
|
|
Запуск: python3 service-standard-check.py
|
|
Вывод: таблица + сводка + файл /tmp/standard-report.csv
|
|
"""
|
|
import csv
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import urllib.error
|
|
import urllib.request
|
|
|
|
INFRA = {"beszel-agent", "promtail", "nats", "swarm-redis"}
|
|
DBISH = ("postgres", "mariadb", "redis", "valkey")
|
|
|
|
BACKUP_DIR = "/mnt/backups/pre-night-20261107"
|
|
BACKUP_HINTS = {
|
|
"nextcloud": ["nextcloud-data", "nextcloud_db", "nextcloud-db"],
|
|
"paperless": ["paperless-105", "paperless_main"],
|
|
"gitea": ["gitea", "gitea_db"],
|
|
"authentik": ["authentik-db", "authentik"],
|
|
"vaultwarden": ["vaultwarden"],
|
|
"homeassistant": ["homeassistant-config"],
|
|
"jellyfin": [],
|
|
"immich": ["immich_db"],
|
|
"matrix-synapse": ["matrix-data", "matrix_db"],
|
|
"calibre-web": ["books"],
|
|
"kavita": ["kavita"],
|
|
"audiobookshelf": ["audiobookshelf"],
|
|
"firefly": ["firefly_db", "lifestyle-apps"],
|
|
"mealie": ["mealie_db", "lifestyle-apps"],
|
|
"monica": ["monica", "lifestyle-apps"],
|
|
"grocy": ["lifestyle-apps"],
|
|
"vikunja": ["lifestyle-apps"],
|
|
"homebox": ["lifestyle-apps"],
|
|
"memos": ["lifestyle-apps"],
|
|
"docmost": ["lifestyle-apps"],
|
|
"n8n": ["n8n"],
|
|
"frigate": ["frigate"],
|
|
"combine": ["combine"],
|
|
}
|
|
|
|
# нативные OIDC (проверено в спринте)
|
|
NATIVE_SSO = {"nextcloud", "gitea", "jellyfin", "paperless", "vaultwarden"}
|
|
|
|
|
|
def sh(cmd, timeout=25):
|
|
try:
|
|
r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
|
|
return (r.stdout or "").strip()
|
|
except Exception:
|
|
return ""
|
|
|
|
|
|
def load_services():
|
|
rows = []
|
|
p = "/tmp/services.csv"
|
|
if not os.path.exists(p):
|
|
sh("sh /tmp/audit_services.sh > /tmp/services.csv")
|
|
for line in open(p, encoding="utf-8", errors="ignore"):
|
|
parts = line.rstrip("\n").split("|")
|
|
if len(parts) < 7 or parts[1] == "SERVICE":
|
|
continue
|
|
rows.append(dict(ct=parts[0], name=parts[1], img=parts[2], port=parts[3],
|
|
restart=parts[4], data=parts[5], status=parts[6]))
|
|
return rows
|
|
|
|
|
|
def is_app(r):
|
|
if r["name"] in INFRA or r["name"].startswith("oauth2-proxy"):
|
|
return False
|
|
if any(k in r["img"] for k in DBISH):
|
|
return False
|
|
return True
|
|
|
|
|
|
def probe(ct, port):
|
|
if not port:
|
|
return None
|
|
p = port.split()[0] if port.split() else ""
|
|
if not p.isdigit():
|
|
return None
|
|
paths = ("/", "/health", "/healthz", "/api/health", "/status", "/ping", "/api/config")
|
|
best = None
|
|
for host in ("127.0.0.1", "192.168.1.%s" % ct):
|
|
for path in paths:
|
|
try:
|
|
req = urllib.request.Request("http://%s:%s%s" % (host, p, path), method="GET")
|
|
with urllib.request.urlopen(req, timeout=4) as r:
|
|
code = r.status
|
|
except urllib.error.HTTPError as e:
|
|
code = e.code
|
|
except Exception:
|
|
continue
|
|
if code < 500:
|
|
return code
|
|
best = best or code
|
|
return best
|
|
|
|
|
|
def tcp_probe(ct, port):
|
|
"""Проверка порта по TCP (для сервисов без HTTP)."""
|
|
import socket
|
|
if not port:
|
|
return None
|
|
p = port.split()[0] if port.split() else ""
|
|
if not p.isdigit():
|
|
return None
|
|
for host in ("192.168.1.%s" % ct, "127.0.0.1"):
|
|
try:
|
|
sk = socket.create_connection((host, int(p)), timeout=3)
|
|
sk.close()
|
|
return 1
|
|
except Exception:
|
|
continue
|
|
return None
|
|
|
|
|
|
def has_backup(name, ct=None):
|
|
# новый ночной бэкап данных сервисов
|
|
import glob
|
|
if ct:
|
|
if glob.glob("/mnt/backups/services/*/ct%s-data.tar.gz" % ct):
|
|
return True
|
|
keys = BACKUP_HINTS.get(name, [name])
|
|
for root in (BACKUP_DIR + "/files", BACKUP_DIR + "/db"):
|
|
if not os.path.isdir(root):
|
|
continue
|
|
files = os.listdir(root)
|
|
for k in keys:
|
|
if any(k in f for f in files):
|
|
return True
|
|
return False
|
|
|
|
|
|
|
|
# сервис -> суффикс его oauth2-proxy (когда имена не совпадают)
|
|
PROXY_ALIAS = {
|
|
"calibre-web": "calibre",
|
|
"homeassistant": "home",
|
|
"uptime_kuma": "status",
|
|
"dozzle": "logs",
|
|
"beszel": "metrics",
|
|
"firefly": "finance",
|
|
"house3d-web": "3d",
|
|
"element-web": "element",
|
|
"node_red": "nodered",
|
|
"stirling-pdf": "stirling",
|
|
"docmost": "docmost",
|
|
"navidrome": "navidrome",
|
|
"audiobookshelf": "audiobookshelf",
|
|
"freshrss": "freshrss",
|
|
"linkding": "linkding",
|
|
"openclaw": "openclaw",
|
|
"catalog": "catalog",
|
|
"monica": "monica",
|
|
"grocy": "grocy",
|
|
"dashy": "dashy",
|
|
"podfetch": "podfetch",
|
|
"n8n": "n8n",
|
|
"sonarr": "sonarr",
|
|
"radarr": "radarr",
|
|
"prowlarr": "prowlarr",
|
|
"bazarr": "bazarr",
|
|
"prometheus": "prometheus",
|
|
"duplicati": "backup",
|
|
}
|
|
|
|
|
|
def sso_map():
|
|
"""service -> есть ли собственный oauth2-proxy (по суффиксу имени)."""
|
|
m = {}
|
|
for r in load_services():
|
|
if r["name"].startswith("oauth2-proxy") and r["status"] == "running":
|
|
suffix = r["name"].replace("oauth2-proxy-", "")
|
|
m[suffix] = True
|
|
return m
|
|
|
|
|
|
def has_docs(ct):
|
|
return os.path.isdir("/root/buryan-infra/deploy/ct%s" % ct)
|
|
|
|
|
|
def main():
|
|
rows = [r for r in load_services() if is_app(r) and r["status"] == "running"]
|
|
PROXY = sso_map()
|
|
|
|
out = []
|
|
for r in rows:
|
|
key = PROXY_ALIAS.get(r["name"], r["name"].replace("_", ""))
|
|
s1 = bool(PROXY.get(key)) or bool(PROXY.get(r["name"])) or r["name"] in NATIVE_SSO
|
|
s2 = has_backup(r["name"], r["ct"])
|
|
known_port = bool(r["port"]) and r["port"].split() and r["port"].split()[0].isdigit()
|
|
code = probe(r["ct"], r["port"]) if known_port else None
|
|
tcp = None
|
|
if known_port and code is None:
|
|
tcp = tcp_probe(r["ct"], r["port"])
|
|
s3_applicable = known_port
|
|
s3 = ((code is not None and code < 500) or tcp == 1) if known_port else None
|
|
if s3 is True and code is None and tcp == 1:
|
|
code = "tcp"
|
|
if not known_port:
|
|
code = "n/a"
|
|
s4 = has_docs(r["ct"])
|
|
checks = [s1, s2, s4] + ([s3] if s3 is not None else [])
|
|
score = sum(1 for x in checks if x)
|
|
maxs = len(checks)
|
|
out.append(dict(ct=r["ct"], service=r["name"], sso=s1, backup=s2,
|
|
health=s3, docs=s4, code=code or "-", score=score, maxs=maxs))
|
|
|
|
out.sort(key=lambda x: (x["score"], x["ct"]))
|
|
with open("/tmp/standard-report.csv", "w", newline="", encoding="utf-8") as f:
|
|
w = csv.DictWriter(f, fieldnames=["ct", "service", "sso", "backup",
|
|
"health", "docs", "code", "score", "maxs"])
|
|
w.writeheader()
|
|
w.writerows(out)
|
|
|
|
total = len(out)
|
|
print("СЕРВИСОВ ПРОВЕРЕНО: %d" % total)
|
|
print()
|
|
print("%-4s %-26s %-4s %-7s %-6s %-6s %-6s %s" %
|
|
("CT", "СЕРВИС", "SSO", "БЭКАП", "HTTP", "ДОКИ", "БАЛЛ", "СТАТУС"))
|
|
for x in out:
|
|
st = "ГОТОВ" if x["score"] == x["maxs"] else ("почти" if x["score"] >= x["maxs"] - 1 else "нужно")
|
|
h = x["code"] if x["code"] != "n/a" else "н/п"
|
|
print("%-4s %-26s %-4s %-7s %-6s %-6s %-6s %s" % (
|
|
x["ct"], x["service"][:26],
|
|
"+" if x["sso"] else "-", "+" if x["backup"] else "-",
|
|
h, "+" if x["docs"] else "-",
|
|
"%d/%d" % (x["score"], x["maxs"]), st))
|
|
|
|
print()
|
|
print("СВОДКА:")
|
|
for key, label in (("sso", "S1 идентичность"), ("backup", "S2 бэкап"),
|
|
("health", "S3 здоровье"), ("docs", "S4 документация")):
|
|
if key == "health":
|
|
appl = [x for x in out if x["health"] is not None]
|
|
n = sum(1 for x in appl if x["health"])
|
|
print(" %-18s %d / %d (%d%%) [неприменимо: %d]" % (
|
|
label, n, len(appl), round(100 * n / max(len(appl), 1)), total - len(appl)))
|
|
else:
|
|
n = sum(1 for x in out if x[key])
|
|
print(" %-18s %d / %d (%d%%)" % (label, n, total, round(100 * n / max(total, 1))))
|
|
full = sum(1 for x in out if x["score"] == x["maxs"])
|
|
print(" %-18s %d / %d (%d%%)" % ("полный стандарт", full, total,
|
|
round(100 * full / max(total, 1))))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|