Коннектор отдаёт monitor.up/monitor.down вместо разового списка; ключ события включает состояние, карточка монитора остаётся одна (entity_key). Найдено и исправлено в мониторах: Calibre-web и FreshRSS смотрели на старый адрес 192.168.1.111 (сервисы на .240), пять мониторов принимали только 2xx при фактических 302 — добавлены 3xx, два мёртвых монитора выключены (Nginx Proxy Manager, Paperless-110). Итог: 50 вверх, 5 вниз (три — push-мониторы бэкапов, это норма). Копия базы до правок: kuma.db.bak-monitors.
317 lines
12 KiB
Python
317 lines
12 KiB
Python
"""Коннекторы: опрашиваем сервисы и превращаем изменения в события ядра.
|
|
|
|
Почему опрос, а не вебхуки: вебхуки надо настраивать в каждом сервисе
|
|
отдельно и они ломаются при обновлениях. Опрос работает сразу и не
|
|
требует правок в сервисах. Состояние храним в sync_state, поэтому каждое
|
|
изменение превращается ровно в одно событие.
|
|
"""
|
|
import json
|
|
import os
|
|
import sys
|
|
import urllib.error
|
|
import urllib.parse
|
|
import urllib.request
|
|
import sys as _sys
|
|
_sys.path.insert(0, '/opt/hub-core')
|
|
import kuma_source
|
|
from datetime import datetime, timezone
|
|
|
|
CORE = os.environ.get("CORE_URL", "http://127.0.0.1:9120")
|
|
SONARR = os.environ.get("SONARR_URL", "http://192.168.1.117:8989")
|
|
SONARR_KEY = os.environ.get("SONARR_KEY", "")
|
|
RADARR = os.environ.get("RADARR_URL", "http://192.168.1.118:7878")
|
|
RADARR_KEY = os.environ.get("RADARR_KEY", "")
|
|
SEERR = os.environ.get("SEERR_URL", "http://192.168.1.121:5055")
|
|
SEERR_KEY = os.environ.get("SEERR_KEY", "")
|
|
JELLYFIN = os.environ.get("JELLYFIN_URL", "http://192.168.1.103:8096")
|
|
JELLYFIN_KEY = os.environ.get("JELLYFIN_KEY", "")
|
|
KUMA = os.environ.get("KUMA_URL", "http://192.168.1.107:3001")
|
|
KUMA_KEY = os.environ.get("KUMA_KEY", "")
|
|
ALERTMANAGER = os.environ.get("ALERTMANAGER_URL", "http://192.168.1.134:9093")
|
|
FRIGATE = os.environ.get("FRIGATE_URL", "http://192.168.1.126:5000")
|
|
PAPERLESS = os.environ.get("PAPERLESS_URL", "http://192.168.1.105:8000")
|
|
PAPERLESS_TOKEN = os.environ.get("PAPERLESS_TOKEN", "")
|
|
|
|
STATE_FILE = os.environ.get("STATE_FILE", "/var/lib/hub-core/state.json")
|
|
|
|
|
|
def http(url, headers=None, timeout=20):
|
|
req = urllib.request.Request(url, headers=headers or {})
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=timeout) as r:
|
|
return json.loads(r.read() or b"{}"), None
|
|
except urllib.error.HTTPError as e:
|
|
return None, f"HTTP {e.code}"
|
|
except Exception as e:
|
|
return None, str(e)[:120]
|
|
|
|
|
|
def send_event(source, etype, kind, key, title, detail=None):
|
|
payload = {"entity": {"kind": kind, "key": key, "title": title},
|
|
"payload": {"detail": detail} if detail else {}}
|
|
body = json.dumps({"source": source, "type": etype, **payload}).encode()
|
|
req = urllib.request.Request(f"{CORE}/event", data=body, method="POST",
|
|
headers={"Content-Type": "application/json"})
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=15) as r:
|
|
return r.status in (200, 201)
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def load_state():
|
|
try:
|
|
return json.load(open(STATE_FILE, encoding="utf-8"))
|
|
except OSError:
|
|
return {}
|
|
|
|
|
|
def save_state(state):
|
|
os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True)
|
|
json.dump(state, open(STATE_FILE, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
|
|
|
|
|
|
# ─────────────────────── источники ───────────────────────
|
|
|
|
def arr_history(base, key, source, count=20):
|
|
data, err = http(f"{base}/api/v3/history?page=1&pageSize={count}&sortKey=date&sortDirection=descending",
|
|
{"X-Api-Key": key})
|
|
if err:
|
|
return [], err
|
|
out = []
|
|
for rec in (data or []).get("records", []):
|
|
if rec.get("eventType") not in ("downloadFolderImported", "grabbed"):
|
|
continue
|
|
out.append({
|
|
"id": rec.get("id"),
|
|
"title": (rec.get("sourceTitle") or rec.get("series", {}).get("title")
|
|
or rec.get("movie", {}).get("title") or "без названия"),
|
|
"when": rec.get("date"),
|
|
"type": "media.imported" if rec["eventType"] == "downloadFolderImported" else "media.grabbed",
|
|
})
|
|
return out, None
|
|
|
|
|
|
def seerr_requests():
|
|
data, err = http(f"{SEERR}/api/v1/request?take=20&filter=all&sort=added", {"X-Api-Key": SEERR_KEY})
|
|
if err:
|
|
return [], err
|
|
out = []
|
|
for r in (data or {}).get("results", []):
|
|
media = r.get("media") or {}
|
|
title = media.get("title") or media.get("name") or "заявка"
|
|
out.append({
|
|
"id": r.get("id"),
|
|
"title": title,
|
|
"status": r.get("status"),
|
|
"when": r.get("createdAt"),
|
|
"type": "media.requested",
|
|
})
|
|
return out, None
|
|
|
|
|
|
def jellyfin_recent():
|
|
data, err = http(f"{JELLYFIN}/Items?Recursive=true&IncludeItemTypes=Movie,Series&SortBy=DateCreated"
|
|
f"&SortOrder=Descending&Limit=10&Fields=DateCreated",
|
|
{"Authorization": f'MediaBrowser Token="{JELLYFIN_KEY}"'})
|
|
if err:
|
|
return [], err
|
|
out = []
|
|
for it in (data or {}).get("Items", []):
|
|
out.append({
|
|
"id": it.get("Id"),
|
|
"title": it.get("Name"),
|
|
"when": it.get("DateCreated"),
|
|
"type": "media.added",
|
|
})
|
|
return out, None
|
|
|
|
|
|
def alertmanager_alerts():
|
|
data, err = http(f"{ALERTMANAGER}/api/v2/alerts")
|
|
if err:
|
|
return [], err
|
|
out = []
|
|
for a in data or []:
|
|
labels = a.get("labels") or {}
|
|
out.append({
|
|
"id": f"{labels.get('alertname')}|{labels.get('host','')}",
|
|
"title": labels.get("alertname", "тревога"),
|
|
"status": (a.get("status") or {}).get("state"),
|
|
"when": a.get("startsAt"),
|
|
"type": "service.alert",
|
|
})
|
|
return out, None
|
|
|
|
|
|
|
|
# ─────────────────────── источники из баз ───────────────────────
|
|
import subprocess
|
|
|
|
|
|
def pct(ct, args, timeout=40):
|
|
cmd = ["pct", "exec", str(ct), "--"] + args
|
|
try:
|
|
out = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
|
|
if out.returncode != 0:
|
|
return None, (out.stderr or out.stdout).strip()[:120]
|
|
return out.stdout.strip(), None
|
|
except Exception as e:
|
|
return None, str(e)[:120]
|
|
|
|
|
|
def paperless_docs():
|
|
data, err = http(f"{PAPERLESS}/api/documents/?page_size=20&ordering=-created",
|
|
{"Authorization": f"Token {PAPERLESS_TOKEN}"})
|
|
if err:
|
|
return [], err
|
|
out = []
|
|
for d in (data or {}).get("results", []):
|
|
out.append({"id": d.get("id"), "title": d.get("title") or "документ",
|
|
"when": d.get("created"), "type": "document.added"})
|
|
return out, None
|
|
|
|
|
|
def calibre_books():
|
|
script = ("import json,sqlite3;c=sqlite3.connect('/opt/books/library/metadata.db');"
|
|
"rows=c.execute('select id,title from books order by id desc limit 15').fetchall();"
|
|
"print(json.dumps(rows, ensure_ascii=False))")
|
|
out, err = pct(111, ["python3", "-c", script])
|
|
if err:
|
|
return [], err
|
|
try:
|
|
rows = json.loads(out or "[]")
|
|
except json.JSONDecodeError:
|
|
return [], "не разобрал ответ"
|
|
return [{"id": r[0], "title": r[1] or "книга", "type": "book.added"} for r in rows], None
|
|
|
|
|
|
def navidrome_albums():
|
|
out, err = pct(125, ["docker", "exec", "navidrome", "sqlite3", "-separator", "|",
|
|
"/data/navidrome.db",
|
|
"select id, name from album order by created_at desc limit 15"])
|
|
if err:
|
|
return [], err
|
|
rows = []
|
|
for line in (out or "").splitlines():
|
|
parts = line.split("|")
|
|
if len(parts) >= 2:
|
|
rows.append({"id": parts[0], "title": parts[1], "type": "music.added"})
|
|
return rows, None
|
|
|
|
|
|
def immich_albums():
|
|
sql = ('select id, "albumName" from album order by "createdAt" desc limit 15')
|
|
out, err = pct(151, ["su", "-", "postgres", "-c",
|
|
f"psql -d immich_db -tA -F'|' -c '{sql}'"])
|
|
if err:
|
|
return [], err
|
|
rows = []
|
|
for line in (out or "").splitlines():
|
|
parts = line.split("|")
|
|
if len(parts) >= 2:
|
|
rows.append({"id": parts[0], "title": parts[1], "type": "photo.album"})
|
|
return rows, None
|
|
|
|
|
|
def kuma_monitors():
|
|
script = ("import json,sqlite3;"
|
|
"c=sqlite3.connect('/opt/network-lxc/uptime/data/kuma.db');"
|
|
"rows=c.execute('select id,name,active from monitor where active=1 limit 60').fetchall();"
|
|
"print(json.dumps(rows, ensure_ascii=False))")
|
|
out, err = pct(107, ["python3", "-c", script])
|
|
if err:
|
|
return [], err
|
|
try:
|
|
rows = json.loads(out or "[]")
|
|
except json.JSONDecodeError:
|
|
return [], "не разобрал ответ"
|
|
return [{"id": r[0], "title": r[1] or f"монитор {r[0]}", "type": "monitor.active"} for r in rows], None
|
|
|
|
|
|
|
|
def ha_entities():
|
|
"""HA без токена: читаем реестр сущностей из хранилища."""
|
|
script = ("import json;"
|
|
"d=json.load(open('/config/.storage/core.entity_registry'))['data']['entities'];"
|
|
"rows=[[e.get('entity_id'), e.get('name') or e.get('original_name') or e.get('entity_id')]"
|
|
" for e in d if not e.get('disabled_by')][:80];"
|
|
"print(json.dumps(rows, ensure_ascii=False))")
|
|
out, err = pct(106, ["docker", "exec", "homeassistant", "sh", "-c", f"python3 -c \"{script}\""])
|
|
if err:
|
|
return [], err
|
|
try:
|
|
rows = json.loads(out or "[]")
|
|
except json.JSONDecodeError:
|
|
return [], "не разобрал ответ"
|
|
return [{"id": r[0], "title": r[1], "type": "ha.entity"} for r in rows], None
|
|
|
|
|
|
|
|
def frigate_events():
|
|
"""Frigate: события детекции (когда появятся камеры)."""
|
|
data, err = http(f"{FRIGATE}/api/events?limit=20")
|
|
if err:
|
|
return [], err
|
|
out = []
|
|
for e in data or []:
|
|
label = e.get("label") or e.get("sub_label") or "объект"
|
|
cam = e.get("camera") or "камера"
|
|
out.append({"id": e.get("id"), "title": f"{label} — {cam}",
|
|
"when": e.get("start_time"), "type": "camera.detection"})
|
|
return out, None
|
|
|
|
|
|
SOURCES = [
|
|
("sonarr", lambda: arr_history(SONARR, SONARR_KEY, "sonarr"), "сериал"),
|
|
("radarr", lambda: arr_history(RADARR, RADARR_KEY, "radarr"), "фильм"),
|
|
("seerr", seerr_requests, "заявка"),
|
|
("jellyfin", jellyfin_recent, "фильм"),
|
|
("alertmanager", alertmanager_alerts, "тревога"),
|
|
("paperless", paperless_docs, "документ"),
|
|
("calibre", calibre_books, "книга"),
|
|
("navidrome", navidrome_albums, "музыка"),
|
|
("immich", immich_albums, "фотоальбом"),
|
|
("kuma", lambda: kuma_source.kuma_status(pct), "монитор"),
|
|
("frigate", frigate_events, "камера"),
|
|
("homeassistant", ha_entities, "устройство"),
|
|
]
|
|
|
|
|
|
def main():
|
|
state = load_state()
|
|
total = 0
|
|
report = []
|
|
for name, fetch, kind in SOURCES:
|
|
try:
|
|
items, err = fetch()
|
|
except Exception as e:
|
|
items, err = [], f"{type(e).__name__}: {e}"
|
|
if err:
|
|
report.append(f"{name}: ошибка {err}")
|
|
continue
|
|
seen = set(state.get(name, []))
|
|
new = 0
|
|
for it in items:
|
|
key = str(it.get("id"))
|
|
if not key or key in seen:
|
|
continue
|
|
etype = it.get("type") or f"{name}.event"
|
|
detail = f"статус {it.get('status')}" if it.get("status") else None
|
|
ent_key = it.get("entity_key") or key
|
|
if send_event(name, etype, kind, f"{name}:{ent_key}", it.get("title") or key, detail):
|
|
seen.add(key)
|
|
new += 1
|
|
# храним только последние 500 ключей, чтобы файл не рос
|
|
state[name] = list(seen)[-500:]
|
|
total += new
|
|
report.append(f"{name}: {new} новых")
|
|
save_state(state)
|
|
print(f"[{datetime.now(timezone.utc).isoformat(timespec='seconds')}] "
|
|
f"событий: {total} | " + "; ".join(report))
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|