381 lines
13 KiB
Python
381 lines
13 KiB
Python
"""Кэш иерархии Grafana (инстанс → org → папки → правила) через API + БД."""
|
||
|
||
from __future__ import annotations
|
||
|
||
import html
|
||
import json
|
||
import logging
|
||
from dataclasses import dataclass
|
||
|
||
import asyncpg
|
||
from fastapi import APIRouter, Depends, HTTPException, Request
|
||
from fastapi.responses import HTMLResponse
|
||
from pydantic import BaseModel, Field
|
||
|
||
from onguard24.config import get_settings
|
||
from onguard24.deps import get_pool
|
||
from onguard24.domain.events import EventBus
|
||
from onguard24.grafana_sources import iter_grafana_sources
|
||
from onguard24.integrations import grafana_topology as gt
|
||
from onguard24.modules.ui_support import wrap_module_html_page
|
||
|
||
log = logging.getLogger(__name__)
|
||
|
||
router = APIRouter(tags=["module-grafana-catalog"])
|
||
ui_router = APIRouter(tags=["web-grafana-catalog"], include_in_schema=False)
|
||
|
||
|
||
def register_events(_bus: EventBus, _pool: asyncpg.Pool | None = None) -> None:
|
||
pass
|
||
|
||
|
||
class SyncBody(BaseModel):
|
||
instance_slug: str | None = Field(
|
||
default=None,
|
||
description="Slug из GRAFANA_SOURCES_JSON; пусто — все источники с api_token",
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class PullOutcome:
|
||
org_id: int
|
||
org_name: str
|
||
folder_rows: list[tuple[str, str, str | None]]
|
||
rules: list[gt.ParsedRuleRow]
|
||
warnings: list[str]
|
||
|
||
|
||
async def pull_topology(api_url: str, token: str) -> tuple[PullOutcome | None, str | None]:
|
||
org, oerr = await gt.fetch_org(api_url, token)
|
||
if oerr or not org:
|
||
return None, oerr or "no org"
|
||
oid = org.get("id")
|
||
if oid is None:
|
||
return None, "org response without id"
|
||
oname = str(org.get("name") or "")
|
||
|
||
warnings: list[str] = []
|
||
folders_raw, ferr = await gt.fetch_all_folders(api_url, token)
|
||
if ferr:
|
||
warnings.append(ferr)
|
||
|
||
ruler_raw, rerr = await gt.fetch_ruler_rules_raw(api_url, token)
|
||
if rerr:
|
||
warnings.append(rerr)
|
||
rules: list[gt.ParsedRuleRow] = []
|
||
namespaces: set[str] = set()
|
||
else:
|
||
rules = gt.parse_ruler_rules(ruler_raw or {})
|
||
namespaces = {r.namespace_uid for r in rules}
|
||
|
||
merged = gt.merge_folder_rows(folders_raw, namespaces)
|
||
return (
|
||
PullOutcome(
|
||
org_id=int(oid),
|
||
org_name=oname,
|
||
folder_rows=merged,
|
||
rules=rules,
|
||
warnings=warnings,
|
||
),
|
||
None,
|
||
)
|
||
|
||
|
||
async def persist_topology(
|
||
conn: asyncpg.Connection,
|
||
instance_slug: str,
|
||
outcome: PullOutcome,
|
||
) -> None:
|
||
oid = outcome.org_id
|
||
await conn.execute(
|
||
"""
|
||
DELETE FROM grafana_catalog_rules
|
||
WHERE instance_slug = $1 AND grafana_org_id = $2
|
||
""",
|
||
instance_slug,
|
||
oid,
|
||
)
|
||
await conn.execute(
|
||
"""
|
||
DELETE FROM grafana_catalog_folders
|
||
WHERE instance_slug = $1 AND grafana_org_id = $2
|
||
""",
|
||
instance_slug,
|
||
oid,
|
||
)
|
||
|
||
for uid, title, parent in outcome.folder_rows:
|
||
await conn.execute(
|
||
"""
|
||
INSERT INTO grafana_catalog_folders
|
||
(instance_slug, grafana_org_id, folder_uid, title, parent_uid)
|
||
VALUES ($1, $2, $3, $4, $5)
|
||
""",
|
||
instance_slug,
|
||
oid,
|
||
uid,
|
||
title,
|
||
parent,
|
||
)
|
||
|
||
for r in outcome.rules:
|
||
await conn.execute(
|
||
"""
|
||
INSERT INTO grafana_catalog_rules (
|
||
instance_slug, grafana_org_id, namespace_uid, rule_group_name,
|
||
rule_uid, title, rule_group_interval, labels
|
||
)
|
||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb)
|
||
""",
|
||
instance_slug,
|
||
oid,
|
||
r.namespace_uid,
|
||
r.rule_group_name,
|
||
r.rule_uid,
|
||
r.title,
|
||
r.rule_group_interval,
|
||
json.dumps(r.labels),
|
||
)
|
||
|
||
fc = len(outcome.folder_rows)
|
||
rc = len(outcome.rules)
|
||
warn_txt = "; ".join(outcome.warnings) if outcome.warnings else None
|
||
if warn_txt and len(warn_txt) > 1900:
|
||
warn_txt = warn_txt[:1900] + "…"
|
||
await conn.execute(
|
||
"""
|
||
INSERT INTO grafana_catalog_meta (
|
||
instance_slug, grafana_org_id, org_name, synced_at,
|
||
folder_count, rule_count, error_text
|
||
)
|
||
VALUES ($1, $2, $3, now(), $4, $5, $6)
|
||
ON CONFLICT (instance_slug, grafana_org_id) DO UPDATE SET
|
||
org_name = EXCLUDED.org_name,
|
||
synced_at = EXCLUDED.synced_at,
|
||
folder_count = EXCLUDED.folder_count,
|
||
rule_count = EXCLUDED.rule_count,
|
||
error_text = EXCLUDED.error_text
|
||
""",
|
||
instance_slug,
|
||
oid,
|
||
outcome.org_name,
|
||
fc,
|
||
rc,
|
||
warn_txt,
|
||
)
|
||
|
||
|
||
@router.post("/sync", status_code=200)
|
||
async def sync_catalog_api(
|
||
body: SyncBody,
|
||
pool: asyncpg.Pool | None = Depends(get_pool),
|
||
):
|
||
if pool is None:
|
||
raise HTTPException(status_code=503, detail="database disabled")
|
||
sources = iter_grafana_sources(get_settings())
|
||
if body.instance_slug:
|
||
sl = body.instance_slug.strip().lower()
|
||
sources = [s for s in sources if s.slug == sl]
|
||
if not sources:
|
||
raise HTTPException(status_code=404, detail="unknown instance slug")
|
||
to_run = [s for s in sources if s.api_token.strip()]
|
||
if not to_run:
|
||
raise HTTPException(
|
||
status_code=400,
|
||
detail="нет источников с api_token; задайте GRAFANA_SOURCES_JSON или GRAFANA_SERVICE_ACCOUNT_TOKEN",
|
||
)
|
||
|
||
results: list[dict] = []
|
||
for src in to_run:
|
||
outcome, err = await pull_topology(src.api_url, src.api_token)
|
||
if err or outcome is None:
|
||
results.append({"slug": src.slug, "ok": False, "error": err})
|
||
log.warning("grafana_catalog sync failed %s: %s", src.slug, err)
|
||
continue
|
||
async with pool.acquire() as conn:
|
||
async with conn.transaction():
|
||
await persist_topology(conn, src.slug, outcome)
|
||
results.append(
|
||
{
|
||
"slug": src.slug,
|
||
"ok": True,
|
||
"org_id": outcome.org_id,
|
||
"org_name": outcome.org_name,
|
||
"folders": len(outcome.folder_rows),
|
||
"rules": len(outcome.rules),
|
||
"warnings": outcome.warnings,
|
||
}
|
||
)
|
||
return {"results": results}
|
||
|
||
|
||
@router.get("/meta")
|
||
async def list_meta_api(pool: asyncpg.Pool | None = Depends(get_pool)):
|
||
if pool is None:
|
||
return {"items": [], "database": "disabled"}
|
||
async with pool.acquire() as conn:
|
||
rows = await conn.fetch(
|
||
"""
|
||
SELECT instance_slug, grafana_org_id, org_name, synced_at,
|
||
folder_count, rule_count, error_text
|
||
FROM grafana_catalog_meta
|
||
ORDER BY instance_slug, grafana_org_id
|
||
"""
|
||
)
|
||
items = []
|
||
for r in rows:
|
||
items.append(
|
||
{
|
||
"instance_slug": r["instance_slug"],
|
||
"grafana_org_id": r["grafana_org_id"],
|
||
"org_name": r["org_name"],
|
||
"synced_at": r["synced_at"].isoformat() if r["synced_at"] else None,
|
||
"folder_count": r["folder_count"],
|
||
"rule_count": r["rule_count"],
|
||
"error_text": r["error_text"],
|
||
}
|
||
)
|
||
return {"items": items}
|
||
|
||
|
||
@router.get("/tree")
|
||
async def tree_api(
|
||
instance_slug: str,
|
||
pool: asyncpg.Pool | None = Depends(get_pool),
|
||
):
|
||
if pool is None:
|
||
raise HTTPException(status_code=503, detail="database disabled")
|
||
slug = instance_slug.strip().lower()
|
||
async with pool.acquire() as conn:
|
||
meta = await conn.fetchrow(
|
||
"""
|
||
SELECT * FROM grafana_catalog_meta
|
||
WHERE instance_slug = $1 AND grafana_org_id > 0
|
||
ORDER BY synced_at DESC LIMIT 1
|
||
""",
|
||
slug,
|
||
)
|
||
if not meta:
|
||
raise HTTPException(status_code=404, detail="no catalog for this slug; run POST /sync first")
|
||
oid = meta["grafana_org_id"]
|
||
folders = await conn.fetch(
|
||
"""
|
||
SELECT folder_uid, title, parent_uid
|
||
FROM grafana_catalog_folders
|
||
WHERE instance_slug = $1 AND grafana_org_id = $2
|
||
ORDER BY title
|
||
""",
|
||
slug,
|
||
oid,
|
||
)
|
||
rules = await conn.fetch(
|
||
"""
|
||
SELECT namespace_uid, rule_group_name, rule_uid, title,
|
||
rule_group_interval, labels
|
||
FROM grafana_catalog_rules
|
||
WHERE instance_slug = $1 AND grafana_org_id = $2
|
||
ORDER BY namespace_uid, rule_group_name, title
|
||
""",
|
||
slug,
|
||
oid,
|
||
)
|
||
|
||
by_ns: dict[str, list[dict]] = {}
|
||
for r in rules:
|
||
ns = r["namespace_uid"]
|
||
by_ns.setdefault(ns, []).append(
|
||
{
|
||
"rule_uid": r["rule_uid"],
|
||
"title": r["title"],
|
||
"rule_group": r["rule_group_name"],
|
||
"interval": r["rule_group_interval"],
|
||
"labels": r["labels"] if isinstance(r["labels"], dict) else {},
|
||
}
|
||
)
|
||
|
||
folder_nodes = []
|
||
for f in folders:
|
||
uid = f["folder_uid"]
|
||
folder_nodes.append(
|
||
{
|
||
"folder_uid": uid,
|
||
"title": f["title"],
|
||
"parent_uid": f["parent_uid"],
|
||
"rules": by_ns.get(uid, []),
|
||
}
|
||
)
|
||
|
||
return {
|
||
"instance_slug": slug,
|
||
"grafana_org_id": oid,
|
||
"org_name": meta["org_name"],
|
||
"synced_at": meta["synced_at"].isoformat() if meta["synced_at"] else None,
|
||
"folders": folder_nodes,
|
||
"orphan_rule_namespaces": sorted(set(by_ns.keys()) - {f["folder_uid"] for f in folders}),
|
||
}
|
||
|
||
|
||
@ui_router.get("/", response_class=HTMLResponse)
|
||
async def grafana_catalog_ui(request: Request):
|
||
pool = get_pool(request)
|
||
inner = ""
|
||
if pool is None:
|
||
inner = "<p>База не настроена.</p>"
|
||
else:
|
||
try:
|
||
async with pool.acquire() as conn:
|
||
rows = await conn.fetch(
|
||
"""
|
||
SELECT instance_slug, org_name, synced_at, folder_count, rule_count, error_text
|
||
FROM grafana_catalog_meta
|
||
ORDER BY instance_slug
|
||
"""
|
||
)
|
||
if not rows:
|
||
inner = "<p>Каталог пуст. Вызовите <code>POST /api/v1/modules/grafana-catalog/sync</code>.</p>"
|
||
else:
|
||
inner = "<table class='irm-table'><thead><tr><th>Slug</th><th>Org</th><th>Синхр.</th><th>Папок</th><th>Правил</th><th>Ошибка</th></tr></thead><tbody>"
|
||
for r in rows:
|
||
err = html.escape(str(r["error_text"] or "—"))[:120]
|
||
st = r["synced_at"].isoformat() if r["synced_at"] else "—"
|
||
inner += (
|
||
f"<tr><td>{html.escape(r['instance_slug'])}</td>"
|
||
f"<td>{html.escape(str(r['org_name']))}</td>"
|
||
f"<td>{html.escape(st)}</td>"
|
||
f"<td>{r['folder_count']}</td><td>{r['rule_count']}</td>"
|
||
f"<td>{err}</td></tr>"
|
||
)
|
||
inner += "</tbody></table>"
|
||
except Exception as e:
|
||
inner = f"<p class='module-err'>{html.escape(str(e))}</p>"
|
||
page = f"""<h1>Каталог Grafana</h1>
|
||
<p>Иерархия: инстанс (slug) → организация → папки → правила. Синхронизация по HTTP API.</p>
|
||
{inner}
|
||
<p><small>API: <code>POST …/grafana-catalog/sync</code>, <code>GET …/grafana-catalog/tree?instance_slug=…</code></small></p>"""
|
||
return HTMLResponse(
|
||
wrap_module_html_page(
|
||
document_title="Каталог Grafana — onGuard24",
|
||
current_slug="grafana-catalog",
|
||
main_inner_html=page,
|
||
)
|
||
)
|
||
|
||
|
||
async def render_home_fragment(request: Request) -> str:
|
||
pool = get_pool(request)
|
||
if pool is None:
|
||
return '<p class="module-note">Нужна БД для каталога Grafana.</p>'
|
||
try:
|
||
async with pool.acquire() as conn:
|
||
n = await conn.fetchval("SELECT count(*)::int FROM grafana_catalog_meta WHERE grafana_org_id >= 0")
|
||
last = await conn.fetchrow(
|
||
"SELECT max(synced_at) AS m FROM grafana_catalog_meta WHERE grafana_org_id >= 0"
|
||
)
|
||
except Exception:
|
||
return '<p class="module-note">Таблицы каталога недоступны (миграции?).</p>'
|
||
ts = last["m"].isoformat() if last and last["m"] else "никогда"
|
||
return (
|
||
f'<div class="module-fragment"><p>Источников с синхронизацией: <strong>{int(n)}</strong>. '
|
||
f"Последняя синхр.: <strong>{html.escape(ts)}</strong></p></div>"
|
||
)
|