"""Buryan Hub Core: шина событий и граф сущностей. Один процесс, три задачи: 1) принимать события от сервисов и складывать в общую базу; 2) хранить карточки сущностей и связи между ними; 3) публиковать значимое в Matrix (личка владельцу). Запуск: python3 core.py (HTTP на порту 9120) """ import json import os import threading import time import urllib.request from datetime import datetime, timezone from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer import psycopg2 import psycopg2.extras DSN = os.environ.get("CORE_DSN", "dbname=hub_core user=hub_core password=hub_core host=127.0.0.1") PORT = int(os.environ.get("CORE_PORT", "9120")) MATRIX_HS = os.environ.get("MATRIX_HS", "https://matrix.buryans.ru") NOTIFY_TOKEN = os.environ.get("NOTIFY_TOKEN", "") NOTIFY_ROOM = os.environ.get("NOTIFY_ROOM", "") # какие события стоит показывать человеку сразу LOUD = { "media.imported", "media.requested", "media.failed", "backup.done", "backup.failed", "service.down", "service.up", "monitor.down", "monitor.up", "camera.detection", "photo.imported", "book.added", "document.added", } def db(): con = psycopg2.connect(DSN, connect_timeout=10) con.autocommit = True return con def ensure_schema(): sql = open(os.path.join(os.path.dirname(__file__), "schema.sql"), encoding="utf-8").read() with db() as con, con.cursor() as cur: cur.execute(sql) ROUTES_FILE = "/etc/hub-core/routes.json" _ROUTES = None def load_routes(): """Куда какое событие отправлять: тип → бот.""" global _ROUTES if _ROUTES is not None: return _ROUTES try: _ROUTES = json.load(open(ROUTES_FILE, encoding="utf-8")) except Exception: _ROUTES = {} return _ROUTES def route_for(etype): """Выбрать получателя по типу события.""" routes = load_routes() for prefix in sorted(routes, key=len, reverse=True): if etype.startswith(prefix): return routes[prefix] return {"token": NOTIFY_TOKEN, "room": NOTIFY_ROOM} def publish(text, etype=""): """Короткое уведомление в личку владельцу.""" target = route_for(etype) if etype else {"token": NOTIFY_TOKEN, "room": NOTIFY_ROOM} token, room = target.get("token") or NOTIFY_TOKEN, target.get("room") or NOTIFY_ROOM if not (token and room): return txn = int(datetime.now().timestamp() * 1000) import urllib.parse rid = urllib.parse.quote(room, safe="") body = json.dumps({"msgtype": "m.text", "body": text, "format": "org.matrix.custom.html", "formatted_body": text.replace("\n", "
")}).encode() req = urllib.request.Request( f"{MATRIX_HS}/_matrix/client/v3/rooms/{rid}/send/m.room.message/{txn}", data=body, method="PUT", headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"}) try: urllib.request.urlopen(req, timeout=10) except Exception: pass def human_event(ev): e = ev.get("entity") or {} title = e.get("title") or e.get("key") or "объект" t = ev.get("type", "") icons = {"media.imported": "🎬", "media.requested": "🕓", "media.failed": "⚠️", "backup.done": "💾", "backup.failed": "⚠️", "service.down": "🔴", "service.up": "✅", "photo.imported": "📷", "book.added": "📚", "document.added": "📄"} icon = icons.get(t, "•") src = ev.get("source", "?") extra = ev.get("payload") or {} line = f"{icon} **{title}** — {t} ({src})" if extra.get("detail"): line += f"\n{extra['detail']}" return line def stem_ru(text): """Грубая основа русского слова: «Дюну» → «дюн».""" t = (text or "").lower().strip() for suf in ("ами", "ями", "ого", "его", "ому", "ему", "ыми", "ими", "ая", "яя", "ое", "ее", "ые", "ие", "ой", "ый", "ий", "ах", "ях", "ам", "ям", "ом", "ем", "ов", "ев", "ии", "у", "ю", "а", "я", "ы", "и", "е", "о", "ь"): if len(t) >= len(suf) + 3 and t.endswith(suf): return t[:-len(suf)] return t def do_search(q, limit=20): """Поиск по карточкам: название и внешние ключи.""" like = f"%{q.strip().lower()}%" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select id, kind, title, status, external_ids, updated_at from entities where search_text like %s order by updated_at desc limit %s""", (like, limit)) items = [dict(r) for r in cur.fetchall()] if not items: stem = stem_ru(q) if stem and len(stem) >= 3: cur.execute("""select id, kind, title, status from entities where search_text like %s order by length(title) limit %s""", (f"%{stem}%", limit)) items = [dict(r) for r in cur.fetchall()] con.close() return {"query": q, "count": len(items), "items": items} def do_entity(eid): """Карточка: сама сущность, её связи и история событий.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("select * from entities where id = %s", (eid,)) row = cur.fetchone() if not row: con.close() return None card = dict(row) cur.execute("""select e.id, e.kind, e.title, l.relation from entity_links l join entities e on e.id = case when l.from_id = %s then l.to_id else l.from_id end where l.from_id = %s or l.to_id = %s""", (eid, eid, eid)) links = [dict(r) for r in cur.fetchall()] cur.execute("""select at, source, type, payload from events where entity_id = %s order by id desc limit 50""", (eid,)) history = [dict(r) for r in cur.fetchall()] con.close() return {"card": card, "links": links, "history": history} DATA_DIR = os.environ.get("PROJECT_DATA", "/root/buryan-infra/data") def _ensure_doc_table(): con = db() with con.cursor() as cur: cur.execute(""" create table if not exists data_docs ( id bigserial primary key, collection text not null, key text not null, payload jsonb not null, tags text[] not null default '{}', created_at timestamptz not null default now(), updated_at timestamptz not null default now(), unique (collection, key) )""") cur.execute("create index if not exists idx_docs_collection on data_docs (collection)") con.close() def do_data_put(collection, data): """Сохранить документ: {key, payload, tags}.""" _ensure_doc_table() key = str(data.get("key") or "").strip() if not key: return None, "нужен key" payload = data.get("payload") or {} tags = data.get("tags") or [] con = db() cur = con.cursor() cur.execute("""insert into data_docs (collection, key, payload, tags) values (%s, %s, %s, %s) on conflict (collection, key) do update set payload = excluded.payload, tags = excluded.tags, updated_at = now() returning id, updated_at""", (collection, key, json.dumps(payload, ensure_ascii=False), tags)) row = cur.fetchone() con.close() return {"id": row[0], "updated_at": str(row[1])}, None def do_data_list(collection, limit=100, tag=None): _ensure_doc_table() con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) if tag: cur.execute("""select id, key, payload, tags, updated_at from data_docs where collection=%s and %s = any(tags) order by updated_at desc limit %s""", (collection, tag, limit)) else: cur.execute("""select id, key, payload, tags, updated_at from data_docs where collection=%s order by updated_at desc limit %s""", (collection, limit)) items = [dict(r) for r in cur.fetchall()] con.close() return {"collection": collection, "count": len(items), "items": items}, None def _jsonable(obj): if isinstance(obj, dict): return {k: _jsonable(v) for k, v in obj.items()} if isinstance(obj, list): return [_jsonable(v) for v in obj] return str(obj) if hasattr(obj, "isoformat") else obj def do_export(collection, fmt="json", filename=None, limit=500): """Выгрузить коллекцию в папку проекта.""" data, err = do_data_list(collection, limit=limit) if err: return None, err items = _jsonable(data["items"]) folder = os.path.join(DATA_DIR, collection) os.makedirs(folder, exist_ok=True) stamp = datetime.now().strftime("%Y-%m-%d") if fmt == "md": name = filename or f"{collection}-{stamp}.md" lines = [f"# {collection}", "", f"записей: {len(items)}", ""] for it in items: lines.append(f"## {it.get('key')}") lines.append(f"обновлено: {it.get('updated_at')}") payload = it.get("payload") or {} for k, v in payload.items(): lines.append(f"* **{k}**: {v}") lines.append("") open(os.path.join(folder, name), "w", encoding="utf-8").write("\n".join(lines)) else: name = filename or f"{collection}-{stamp}.json" with open(os.path.join(folder, name), "w", encoding="utf-8") as f: json.dump({"collection": collection, "exported_at": str(datetime.now()), "count": len(items), "items": items}, f, ensure_ascii=False, indent=1, default=str) path = os.path.join(folder, name) return {"path": path, "count": len(items), "format": fmt}, None def do_services(): """Источники событий: сколько, когда последнее.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select source, count(*) as total, max(at) as last_at, count(*) filter (where at > now() - interval '24 hours') as last24 from events group by source order by total desc""") rows = [dict(r) for r in cur.fetchall()] con.close() return {"count": len(rows), "items": rows} def do_service_history(source, limit=50): """История по одному сервису.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select e.id, e.at, e.type, e.entity->>'title' as title, e.payload from events e where e.source = %s order by e.id desc limit %s""", (source, limit)) rows = [dict(r) for r in cur.fetchall()] con.close() return {"source": source, "count": len(rows), "items": rows} def do_metrics(): """Метрики в формате Prometheus.""" lines = [] con = db() cur = con.cursor() cur.execute("select source, count(*) from events group by source") lines.append("# HELP hub_events_total События по источникам") lines.append("# TYPE hub_events_total counter") for src, n in cur.fetchall(): lines.append(f'hub_events_total{{source="{src}"}} {n}') cur.execute("select count(*) from events where at > now() - interval '24 hours'") lines.append("# HELP hub_events_24h События за сутки") lines.append("# TYPE hub_events_24h gauge") lines.append(f"hub_events_24h {cur.fetchone()[0]}") cur.execute("select kind, count(*) from entities group by kind") lines.append("# HELP hub_entities Карточки по видам") lines.append("# TYPE hub_entities gauge") for kind, n in cur.fetchall(): safe = (kind or "unknown").replace('"', "") lines.append(f'hub_entities{{kind="{safe}"}} {n}') cur.execute("select count(*) from problems where resolved_at is null") lines.append("# HELP hub_problems_open Открытые проблемы") lines.append("# TYPE hub_problems_open gauge") lines.append(f"hub_problems_open {cur.fetchone()[0]}") cur.execute("select kind, status, count(*) from actions group by kind, status") lines.append("# HELP hub_actions Действия автоматики") lines.append("# TYPE hub_actions counter") for kind, status, n in cur.fetchall(): lines.append(f'hub_actions{{kind="{kind}",status="{status}"}} {n}') cur.execute("select count(*) from entity_links") lines.append("# HELP hub_links Связи между карточками") lines.append("# TYPE hub_links gauge") lines.append(f"hub_links {cur.fetchone()[0]}") con.close() # хранилища try: import subprocess out = subprocess.run(["pvesm", "status"], capture_output=True, text=True, timeout=15) lines.append("# HELP hub_storage_percent Заполненность хранилищ") lines.append("# TYPE hub_storage_percent gauge") for line in out.stdout.splitlines()[1:]: parts = line.split() if len(parts) >= 7 and parts[6].endswith("%"): try: lines.append(f'hub_storage_percent{{name="{parts[0]}",type="{parts[1]}"}} ' f'{float(parts[6].rstrip("%"))}') except ValueError: pass except Exception: pass # возраст бэкапов try: import time lines.append("# HELP hub_backup_age_hours Возраст последнего бэкапа") lines.append("# TYPE hub_backup_age_hours gauge") checks = { "postgresql": "/var/log/hub-pg-verify.log", "matrix": "/var/log/hub-matrix-backup.log", "bots": "/var/log/hub-bots-verify.log", "offsite": "/var/log/hub-offsite-verify.log", "core": "/mnt/backups/hub-core", } for name, path in checks.items(): try: if os.path.isdir(path): files = [os.path.join(path, f) for f in os.listdir(path)] mtime = max(os.path.getmtime(f) for f in files) if files else 0 else: mtime = os.path.getmtime(path) lines.append(f'hub_backup_age_hours{{name="{name}"}} ' f'{round((time.time() - mtime) / 3600, 1)}') except OSError: pass except Exception: pass return "\n".join(lines) + "\n" JOBS = { "коннекторы": ("/var/log/hub-connectors.log", 1), "сверка": ("/var/log/hub-reconcile.log", 30), "связка карточек": ("/var/log/hub-linker.log", 30), "дайджест": ("/var/log/hub-digest.log", 30), "инвентаризация": ("/var/log/hub-inventory.log", 30), "каталог": ("/var/log/hub-catalog.log", 30), "экспорт": ("/var/log/hub-export.log", 30), "бэкап базы": ("/var/log/hub-backup.log", 30), "проверка бэкапа PG": ("/var/log/hub-pg-verify.log", 30), "проверка бэкапа ботов": ("/var/log/hub-bots-verify.log", 30), "бэкап Matrix": ("/var/log/hub-matrix-backup.log", 30), "офсайт": ("/var/log/hub-offsite-verify.log", 24 * 8), "просмотр": ("/var/log/hub-resume.log", 30), "недельный отчёт": ("/var/log/hub-weekly-core.log", 24 * 8), "аудит доступов": ("/var/log/hub-identity.log", 24 * 8), "восстановление CT": ("/var/log/hub-lxc-verify.log", 24 * 8), } def jobs_status(): """Состояние задач: когда последний раз отработали.""" now = time.time() rows = [] for name, (path, limit_h) in JOBS.items(): try: age_h = (now - os.path.getmtime(path)) / 3600 state = "ок" if age_h <= limit_h else "просрочено" except OSError: age_h, state = None, "не запускалась" rows.append((name, age_h, limit_h, state)) return rows def do_links(limit=200): """Связи контента: список и сводка по типам.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("select relation, count(*) as n from entity_links group by relation order by n desc") summary = {r["relation"]: r["n"] for r in cur.fetchall()} cur.execute("""select a.title as from_title, a.kind as from_kind, b.title as to_title, b.kind as to_kind, l.relation from entity_links l join entities a on a.id = l.from_id join entities b on b.id = l.to_id order by l.relation, a.title limit %s""", (limit,)) items = [dict(r) for r in cur.fetchall()] con.close() return {"total": sum(summary.values()), "by_relation": summary, "items": items} def do_entities(kind=None, limit=200, q=None): con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) sql = "select id, kind, title, status, updated_at from entities where 1=1" args = [] if kind: sql += " and kind = %s" args.append(kind) if q: sql += " and search_text like %s" args.append(f"%{q.lower()}%") sql += " order by updated_at desc limit %s" args.append(limit) cur.execute(sql, args) items = [dict(r) for r in cur.fetchall()] con.close() return {"count": len(items), "items": items} def do_similar(eid, limit=10): """Похожие карточки: общие темы, жанры и прямые связи «похож».""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("select id, kind, title from entities where id = %s", (eid,)) root = cur.fetchone() if not root: con.close() return None # два шага: фильм → темы/жанры → другие фильмы с теми же темами cur.execute(""" with mine as ( select l.to_id as node from entity_links l where l.from_id = %s and l.relation in ('тема', 'жанр') union select l.from_id as node from entity_links l where l.to_id = %s and l.relation in ('тема', 'жанр') ), hits as ( select l.from_id as film_id, count(*) as shared from entity_links l where l.to_id in (select node from mine) and l.relation in ('тема', 'жанр') and l.from_id <> %s group by l.from_id ) select e.id, e.kind, e.title, h.shared from hits h join entities e on e.id = h.film_id where e.kind in ('фильм', 'книга') order by h.shared desc, e.title limit %s """, (eid, eid, eid, limit)) items = [dict(r) for r in cur.fetchall()] # прямые связи «похож» cur.execute(""" select e.id, e.kind, e.title from entity_links l join entities e on e.id = case when l.from_id = %s then l.to_id else l.from_id end where (l.from_id = %s or l.to_id = %s) and l.relation = 'похож' """, (eid, eid, eid)) direct = [dict(r) for r in cur.fetchall()] con.close() return {"root": dict(root), "similar": items, "direct": direct} def do_person(query, limit=20): """Персона и её фильмы.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select id, kind, title from entities where kind in ('актёр','режиссёр','композитор') and search_text like %s order by length(title) limit 1""", (f"%{query.lower()}%",)) person = cur.fetchone() if not person: con.close() return None cur.execute(""" select e.title, e.kind, l.relation from entity_links l join entities e on e.id = case when l.from_id = %s then l.to_id else l.from_id end where (l.from_id = %s or l.to_id = %s) order by e.title """, (person["id"], person["id"], person["id"])) films = [dict(r) for r in cur.fetchall()] con.close() return {"person": dict(person), "films": films, "count": len(films)} def do_pick2(genre=None, theme=None, decade=None, kind="фильм", person=None, rating=None, limit=10): """Подбор из медиатеки с любыми фильтрами графа.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) conds = ["e.kind = %s"] args = [kind] def add_relation(rel, value): conds.append("""exists ( select 1 from entity_links li join entities ni on ni.id = li.to_id where li.from_id = e.id and li.relation = %s and ni.search_text like %s)""") args.extend([rel, f"%{value.lower()}%"]) if genre: add_relation("жанр", genre) if theme: add_relation("тема", theme) if decade: add_relation("снят в", decade) if rating: add_relation("оценка", rating) if person: conds.append("""exists ( select 1 from entity_links lp join entities np on np.id = lp.to_id where lp.from_id = e.id and np.kind in ('актёр','режиссёр','композитор') and np.search_text like %s)""") args.append(f"%{person.lower()}%") sql = ("select e.id, e.title, e.kind, e.status from entities e where " + " and ".join(conds) + " order by e.title limit %s") args.append(limit) cur.execute(sql, args) items = [dict(r) for r in cur.fetchall()] for it in items: cur.execute("""select n.title from entity_links l join entities n on n.id = l.to_id where l.from_id = %s and l.relation = 'оценка' limit 1""", (it["id"],)) row = cur.fetchone() it["rating"] = row["title"] if row else None cur.execute("""select string_agg(n.title, ', ') from entity_links l join entities n on n.id = l.to_id where l.from_id = %s and l.relation = 'жанр'""", (it["id"],)) it["genres"] = cur.fetchone()["string_agg"] con.close() return {"count": len(items), "items": items} def do_compare(book_query, film_query): """Сравнение книги и фильма: что общего.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) def find(kind, q): cur.execute("""select id, kind, title from entities where kind = %s and search_text like %s order by length(title) limit 1""", (kind, f"%{q.lower()}%")) return cur.fetchone() book = find("книга", book_query) film = find("фильм", film_query) if not book or not film: con.close() return None def related(eid, rel): cur.execute("""select n.title from entity_links l join entities n on n.id = l.to_id where l.from_id = %s and l.relation = %s""", (eid, rel)) return {r["title"] for r in cur.fetchall()} b_genres, b_themes = related(book["id"], "жанр"), related(book["id"], "тема") f_genres, f_themes = related(film["id"], "жанр"), related(film["id"], "тема") b_authors = related(book["id"], "написал") cur.execute("""select 1 from entity_links l where l.from_id = %s and l.to_id = %s and l.relation = 'экранизация'""", (book["id"], film["id"])) linked = cur.fetchone() is not None con.close() return { "book": dict(book), "film": dict(film), "linked": linked, "common_genres": sorted(b_genres & f_genres), "only_book_genres": sorted(b_genres - f_genres), "only_film_genres": sorted(f_genres - b_genres), "common_themes": sorted(b_themes & f_themes), "authors": sorted(b_authors), } def do_timeline(node_query, kind="тема"): """Тема или жанр по десятилетиям.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select id, title from entities where kind = %s and search_text like %s order by length(title) limit 1""", (kind, f"%{node_query.lower()}%")) node = cur.fetchone() if not node: con.close() return None cur.execute(""" with items as ( select case when l.from_id = %s then l.to_id else l.from_id end as item_id from entity_links l where (l.from_id = %s or l.to_id = %s) and l.relation = %s ) select d.title as decade, count(*) as n, string_agg(e.title, ',' order by e.title) as items from items i join entity_links l on (l.from_id = i.item_id and l.relation = 'снят в') join entities d on d.id = l.to_id join entities e on e.id = i.item_id group by d.title order by d.title """, (node["id"], node["id"], node["id"], kind)) rows = [dict(r) for r in cur.fetchall()] con.close() return {"node": dict(node), "decades": rows} def do_cross(limit=50): """Книги с экранизацией и авторы, чьи книги экранизированы.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute(""" select b.title as book, f.title as film from entity_links l join entities b on b.id = l.from_id and b.kind = 'книга' join entities f on f.id = l.to_id and f.kind = 'фильм' where l.relation = 'экранизация' order by b.title limit %s """, (limit,)) books_with_film = [dict(r) for r in cur.fetchall()] cur.execute(""" select a.title as author, f.title as film from entity_links l join entities a on a.id = l.from_id and a.kind = 'автор' join entities f on f.id = l.to_id and f.kind = 'фильм' where l.relation = 'экранирован' order by a.title limit %s """, (limit,)) authors_screened = [dict(r) for r in cur.fetchall()] con.close() return {"books_with_film": books_with_film, "authors_screened": authors_screened} def do_top_persons(kind="актёр", limit=10): """Персоны с наибольшим числом фильмов.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute(""" select e.id, e.title, count(*) as films from entity_links l join entities e on e.id = case when l.from_id = e.id then e.id else l.to_id end where e.kind = %s and l.relation in ('снялся','снял','музыка') group by e.id, e.title order by films desc, e.title limit %s """, (kind, limit)) items = [dict(r) for r in cur.fetchall()] con.close() return {"kind": kind, "items": items} def do_graph_stats(): con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("select kind, count(*) as n from entities group by kind order by n desc") cards = [dict(r) for r in cur.fetchall()] cur.execute("select relation, count(*) as n from entity_links group by relation order by n desc") relations = [dict(r) for r in cur.fetchall()] con.close() return {"cards": cards, "relations": relations, "total_cards": sum(c["n"] for c in cards), "total_links": sum(r["n"] for r in relations)} def do_graph_json(limit=150): """Узлы и рёбра для визуализации.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute(""" select e.id, e.kind, e.title, count(l.id) as degree from entities e left join entity_links l on l.from_id = e.id or l.to_id = e.id group by e.id, e.kind, e.title order by degree desc limit %s """, (limit,)) nodes = [dict(r) for r in cur.fetchall()] ids = [n["id"] for n in nodes] edges = [] if ids: cur.execute(""" select l.from_id as source, l.to_id as target, l.relation from entity_links l where l.from_id = any(%s) and l.to_id = any(%s) limit 500 """, (ids, ids)) edges = [dict(r) for r in cur.fetchall()] con.close() return {"nodes": nodes, "edges": edges} MOODS = { "мрачн": ["dystopia", "noir", "dark", "survival", "horror", "thriller", "drama"], "мрач": ["dystopia", "noir", "dark", "survival", "horror", "thriller", "drama"], "тяжёл": ["drama", "war", "thriller", "mystery"], "лёгк": ["comedy", "family", "adventure", "romance"], "легк": ["comedy", "family", "adventure", "romance"], "добр": ["family", "friendship", "adventure", "comedy"], "умн": ["artificial intelligence", "based on novel", "mystery", "science fiction"], "эпичн": ["epic", "space opera", "adventure", "science fiction", "war"], "страшн": ["horror", "monster", "thriller", "mystery"], "смешн": ["comedy"], "романтич": ["romance", "drama"], "детектив": ["detective", "mystery", "crime", "thriller"], } def do_mood(mood, limit=10): """Подбор по настроению: темы и жанры из словаря MOODS.""" low = (mood or "").lower() hints = [] for key, words in MOODS.items(): if key in low: hints = words break if not hints: return {"mood": mood, "count": 0, "items": [], "hints": []} con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) like = ["%" + h.lower() + "%" for h in hints] cur.execute(""" select e.id, e.title, count(distinct n.id) as score from entities e join entity_links l on l.from_id = e.id join entities n on n.id = l.to_id where e.kind = 'фильм' and n.search_text like any(%s) and l.relation in ('тема', 'жанр') group by e.id, e.title order by score desc, e.title limit %s """, (like, limit)) items = [dict(r) for r in cur.fetchall()] for it in items: cur.execute("""select n.title from entity_links l join entities n on n.id = l.to_id where l.from_id = %s and l.relation = 'оценка' limit 1""", (it["id"],)) row = cur.fetchone() it["rating"] = row["title"] if row else None con.close() return {"mood": mood, "count": len(items), "items": items, "hints": hints} def do_candidates(limit=20): """Кандидаты из рекомендаций: чего нет в медиатеке.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select e.id, e.title, e.key, e.status, count(l.id) as votes from entities e left join entity_links l on l.to_id = e.id and l.relation = 'рекомендует' where e.kind = 'кандидат' group by e.id, e.title, e.key, e.status order by votes desc, e.title limit %s""", (limit,)) items = [dict(r) for r in cur.fetchall()] for it in items: it["tmdb"] = (it.get("key") or "").replace("candidate:", "") con.close() return {"count": len(items), "items": items} def do_coworkers(query, limit=12): """С кем вместе снимался: партнёры по фильмам.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select id, title from entities where kind in ('актёр','режиссёр','композитор') and search_text like %s order by length(title) limit 1""", (f"%{query.lower()}%",)) person = cur.fetchone() if not person: con.close() return None cur.execute(""" with films as ( select case when l.from_id = %s then l.to_id else l.from_id end as fid from entity_links l where (l.from_id = %s or l.to_id = %s) ) select p.id, p.title, p.kind, count(*) as together, string_agg(f.title, ', ' order by f.title) as films from films x join entity_links l on (l.from_id = x.fid) join entities p on p.id = l.to_id and p.kind in ('актёр','режиссёр','композитор') join entities f on f.id = x.fid where l.relation in ('снялся','снял','музыка') and p.id <> %s group by p.id, p.title, p.kind order by together desc, p.title limit %s """, (person["id"], person["id"], person["id"], person["id"], limit)) partners = [dict(r) for r in cur.fetchall()] con.close() return {"person": dict(person), "partners": partners} def do_suggest(q, limit=8): """Подсказки по началу названия: для автодополнения.""" if not q or len(q.strip()) < 2: return {"query": q, "items": []} con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select id, kind, title from entities where search_text like %s order by length(title) limit %s""", (f"%{q.strip().lower()}%", limit)) items = [dict(r) for r in cur.fetchall()] con.close() return {"query": q, "items": items} def snapshot_graph(day=None): """Снимок размеров графа за день.""" from datetime import date day = day or date.today().isoformat() con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""create table if not exists graph_history ( day date primary key, cards integer, links integer, persons integer)""") cur.execute("select count(*) as n from entities") cards = cur.fetchone()["n"] cur.execute("select count(*) as n from entity_links") links = cur.fetchone()["n"] cur.execute("select count(*) as n from entities where kind in ('актёр','режиссёр','композитор')") persons = cur.fetchone()["n"] cur.execute("""insert into graph_history (day, cards, links, persons) values (%s, %s, %s, %s) on conflict (day) do update set cards = %s, links = %s, persons = %s""", (day, cards, links, persons, cards, links, persons)) con.commit() con.close() return {"day": str(day), "cards": cards, "links": links, "persons": persons} def do_history(days=30): con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select day, cards, links, persons from graph_history order by day desc limit %s""", (days,)) rows = [dict(r) for r in cur.fetchall()] con.close() rows.reverse() growth = None if len(rows) >= 2: growth = {"cards": rows[-1]["cards"] - rows[0]["cards"], "links": rows[-1]["links"] - rows[0]["links"]} return {"items": rows, "growth": growth} def do_seasons(query): """Сериал и его сезоны с числом эпизодов.""" con = db() cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) cur.execute("""select id, title from entities where kind = 'сериал' and search_text like %s order by length(title) limit 1""", (f"%{query.lower()}%",)) series = cur.fetchone() if not series: con.close() return None cur.execute("""select b.title, b.status, l.relation from entity_links l join entities b on b.id = l.to_id where l.from_id = %s and b.kind = 'сезон' order by b.title""", (series["id"],)) seasons = [dict(r) for r in cur.fetchall()] con.close() return {"series": dict(series), "seasons": seasons, "count": len(seasons)} def render_panel(): """HTML-страница: состояние системы в одном месте.""" try: con = db() cur = con.cursor() cur.execute("select count(*) from entities") entities = cur.fetchone()[0] cur.execute("select count(*) from events") events = cur.fetchone()[0] cur.execute("select count(*) from events where at > now() - interval '24 hours'") events24 = cur.fetchone()[0] cur.execute("select count(*) from problems where resolved_at is null") open_problems = cur.fetchone()[0] cur.execute("""select check_name, detail, at from problems where resolved_at is null order by at desc limit 10""") problems = cur.fetchall() cur.execute("""select at, source, type, entity->>'title' from events order by id desc limit 25""") recent = cur.fetchall() cur.execute("""select source, count(*) as total, count(*) filter (where at > now() - interval '24 hours') as last24, max(at) as last_at from events group by source order by total desc""") by_source = cur.fetchall() try: cur.execute("""select payload from data_docs where collection='inventory' order by updated_at desc limit 1""") invrow = cur.fetchone() inventory = invrow[0] if invrow else None except Exception: inventory = None try: cur.execute("""select payload from data_docs where collection='identity' order by updated_at desc limit 1""") idrow = cur.fetchone() identity = idrow[0] if idrow else None except Exception: identity = None jobs = jobs_status() try: gstats = do_graph_stats() except Exception: gstats = {"cards": [], "relations": [], "total_cards": 0, "total_links": 0} try: tl = do_timeline("science fiction", "жанр") except Exception: tl = None try: hist = do_history(30) growth = hist.get("growth") except Exception: growth = None try: cross = do_cross(limit=10) except Exception: cross = {"books_with_film": [], "authors_screened": []} try: top_genres = do_pick(limit=100) if False else [] except Exception: top_genres = [] cur.execute("select count(*) from entity_links") links = cur.fetchone()[0] cur.execute("""select at, kind, target, detail, status from actions order by id desc limit 10""") actions = cur.fetchall() con.close() err = None except Exception as e: entities = events = events24 = open_problems = 0 problems, recent, by_source, actions, links, inventory, identity = [], [], [], [], 0, None, None jobs = [] gstats = {"cards": [], "relations": [], "total_cards": 0, "total_links": 0} cross = {"books_with_film": [], "authors_screened": []} err = str(e)[:200] def esc(x): return (str(x) if x is not None else "—").replace("&", "&").replace("<", "<") rows = "".join( f"{esc(at.strftime('%d.%m %H:%M'))}{esc(src)}" f"{esc(typ)}{esc(title)}" for at, src, typ, title in recent) or "событий пока нет" media_kinds = {"фильм", "книга", "жанр", "тема", "актёр", "режиссёр", "композитор", "студия", "коллекция", "серия книг", "автор", "эпоха", "кандидат", "оценка", "язык", "рейтинг"} g_cards = sum(c["n"] for c in gstats.get("cards") or [] if c["kind"] in media_kinds) g_links = gstats.get("total_links") or 0 max_rel = max([r["n"] for r in gstats.get("relations") or []] or [1]) g_rel_rows = "".join( f"{esc(r['relation'])}{r['n']}" f"
" for r in (gstats.get("relations") or [])[:12]) or "пусто" cross_rows = [] for b in (cross.get("books_with_film") or [])[:6]: cross_rows.append(f"📖 {esc(b['book'])}↔🎬 {esc(b['film'])}") for a in (cross.get("authors_screened") or [])[:6]: cross_rows.append(f"✍️ {esc(a['author'])}→🎬 {esc(a['film'])}") g_timeline = "
нет данных
" if tl and tl.get("decades"): mx = max(d["n"] for d in tl["decades"]) or 1 bars = [] for d in tl["decades"]: w = int(220 * d["n"] / mx) bars.append( f"
" f"{esc(d['decade'])}" f"
" f"{d['n']}
") g_timeline = "".join(bars) g_growth = "" if growth: g_growth = (" · рост за период: карточек " + str(growth.get("cards")) + ", связей " + str(growth.get("links"))) g_cross_rows = "".join(cross_rows) or "пока нет совпадений" job_rows = "".join( f"{esc(n)}{(str(round(a, 1)) + ' ч') if a is not None else '—'}" f"{lim} ч{esc(st)}" for n, a, lim, st in jobs) or "нет данных" identity_text = "аудит ещё не запускался" if isinstance(identity, dict) and identity.get("table"): identity_text = identity["table"] inv_rows = "" if isinstance(inventory, dict): jf = inventory.get("jellyfin") or {} nv = inventory.get("navidrome") or {} cb = inventory.get("calibre") or {} im = inventory.get("immich") or {} pl = inventory.get("paperless") or {} fr = inventory.get("frigate") or {} inv_rows = ( f"Jellyfin{jf.get('Movie')} фильмов, {jf.get('Series')} сериалов, " f"{jf.get('Episode')} серий" f"Navidrome{nv.get('albums')} альбомов, {nv.get('tracks')} треков" f"Calibre{cb.get('books')} книг" f"Immich{im.get('assets')} снимков, {im.get('albums')} альбомов" f"Paperless{pl.get('documents')} документов" f"Frigate{fr.get('cameras')} камер") if not inv_rows: inv_rows = 'инвентаризация ещё не собиралась' arows = "".join( f"{esc(at.strftime('%d.%m %H:%M'))}{esc(kind)}" f"{esc(target)}{esc(detail)}" f"{esc(st)}" for at, kind, target, detail, st in actions) or "действий не было" prow = "".join( f"{esc(name)}{esc(detail)}" for name, detail, _ in problems) or "открытых проблем нет" src_rows = "".join( f"{esc(src)}{total}{last24}{esc(str(last_at)[:16])}" for src, total, last24, last_at in by_source) or "событий пока нет" return f""" Buryan Hub

Buryan Hub

ядро событий и карточек · обновлено сейчас
{'

Ошибка базы: ' + esc(err) + '

' if err else ''}
{entities}карточек
{events}событий всего
{events24}за 24 часа
{open_problems}проблем
{links}связей

Задачи

{job_rows}
задачапоследний запускпределсостояние

Проблемы

{prow}
проверкачто не так

Графики

Дашборд: Grafana — Buryan Hub · метрики Prometheus

Медиа: граф контента

интерактивный граф · спросить агента
карточек {g_cards} · связей {g_links}{g_growth}
{g_rel_rows}
связьсколько

Фантастика по десятилетиям

{g_timeline}

Книги и экранизации

{g_cross_rows}

Доступы по сервисам

аудит по понедельникам, команда !users у бота Инфраструктура
{identity_text}

Что есть в сервисах

{inv_rows}
сервисчто есть

Действия сверки и автоисправлений

{arows}
когдачтоцельрезультатстатус

Последние события

{rows}
когдаисточниктипобъект

Источники событий

{src_rows}
источниквсегоза суткипоследнее
""" JELLYFIN_URL = os.environ.get("JELLYFIN_URL", "http://192.168.1.103:8096") JELLYFIN_KEY = os.environ.get("JELLYFIN_KEY", "") def _jellyfin_scan(): """Просим Jellyfin пересканировать библиотеку.""" if not JELLYFIN_KEY: return False, "нет ключа Jellyfin" req = urllib.request.Request( f"{JELLYFIN_URL}/Library/Refresh", data=b"", method="POST", headers={"Authorization": f'MediaBrowser Token="{JELLYFIN_KEY}"'}) try: with urllib.request.urlopen(req, timeout=20) as r: return r.status in (200, 204), f"HTTP {r.status}" except urllib.error.HTTPError as e: return False, f"HTTP {e.code}" except Exception as e: return False, str(e)[:100] def _journal(kind, target, detail, status="done", rollback=None): try: con = db() with con.cursor() as cur: cur.execute("""insert into actions (kind, target, detail, status, rollback) values (%s,%s,%s,%s,%s)""", (kind, target, detail, status, rollback)) con.close() except Exception: pass def auto_actions(ev, etype): """Что сделать сразу после события.""" ent = ev.get("entity") or {} title = ent.get("title") or ent.get("key") or "объект" if etype == "media.imported": ok, detail = _jellyfin_scan() _journal("scan", "jellyfin", f"после импорта «{title}»: {detail}", "done" if ok else "failed", None) return ok if etype == "media.requested": # заявку просто фиксируем: одобрение — решение человека _journal("note", "seerr", f"заявка «{title}» принята", "done", None) return True return False class Handler(BaseHTTPRequestHandler): def log_message(self, *a): pass def _json(self, code, obj): body = json.dumps(obj, ensure_ascii=False, default=str).encode() self.send_response(code) self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) def do_GET(self): if self.path == "/" or self.path.startswith("/panel"): body = render_panel().encode("utf-8") self.send_response(200) self.send_header("Content-Type", "text/html; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) return if self.path.startswith("/data/"): import urllib.parse as up parts = self.path.split("?")[0].split("/data/") coll = parts[1] if len(parts) > 1 else "" qs = up.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} tag = (qs.get("tag") or [None])[0] limit = int((qs.get("limit") or ["100"])[0]) try: res, err = do_data_list(coll, limit, tag) except Exception as e: return self._json(500, {"error": str(e)[:200]}) return self._json(200 if not err else 500, res or {"error": err}) if self.path.startswith("/health"): try: with db() as con, con.cursor() as cur: cur.execute("select count(*) from events") n = cur.fetchone()[0] return self._json(200, {"ok": True, "events": n}) except Exception as e: return self._json(500, {"ok": False, "error": str(e)[:200]}) if self.path.startswith("/metrics"): try: body = do_metrics().encode("utf-8") except Exception as e: body = f"# error: {e}".encode() self.send_response(200) self.send_header("Content-Type", "text/plain; version=0.0.4; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) return if self.path.startswith("/compare"): import urllib.parse as _uc qs = _uc.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} b = (qs.get("book") or [""])[0] f = (qs.get("film") or [""])[0] if not b or not f: return self._json(400, {"error": "нужны book и film"}) try: data = do_compare(b, f) except Exception as e: return self._json(500, {"error": str(e)[:200]}) return self._json(200 if data else 404, data or {"error": "не найдено"}) if self.path.startswith("/timeline"): import urllib.parse as _u1 qs = _u1.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} q = (qs.get("q") or [""])[0] k = (qs.get("kind") or ["тема"])[0] if not q: return self._json(400, {"error": "нужен q"}) try: data = do_timeline(q, k) except Exception as e: return self._json(500, {"error": str(e)[:200]}) return self._json(200 if data else 404, data or {"error": "не найдено"}) if self.path.startswith("/cross"): try: return self._json(200, do_cross()) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/persons"): import urllib.parse as _u2 qs = _u2.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} k = (qs.get("kind") or ["актёр"])[0] try: return self._json(200, do_top_persons(k)) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/ask.html"): try: with open("/opt/hub-core/ask.html", encoding="utf-8") as f: body = f.read().encode("utf-8") self.send_response(200) self.send_header("Content-Type", "text/html; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) return except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/ask"): import urllib.parse as _ua qs = _ua.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} q = (qs.get("q") or [""])[0] if not q: return self._json(400, {"error": "нужен q"}) try: import sys as _sys if "/opt/hub-bots" not in _sys.path: _sys.path.insert(0, "/opt/hub-bots") from hub import agent as _agent answer, plan = _agent.run(q) return self._json(200, {"answer": answer, "plan": _agent.describe(plan)}) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/graph.html"): try: with open("/opt/hub-core/graph.html", encoding="utf-8") as f: body = f.read().encode("utf-8") self.send_response(200) self.send_header("Content-Type", "text/html; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) return except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/graph"): try: if "json" in self.path: return self._json(200, do_graph_json()) return self._json(200, do_graph_stats()) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/person.html"): try: with open("/opt/hub-core/person.html", encoding="utf-8") as f: body = f.read().encode("utf-8") self.send_response(200) self.send_header("Content-Type", "text/html; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) return except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/coworkers"): import urllib.parse as _ucw qs = _ucw.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} q = (qs.get("q") or [""])[0] if not q: return self._json(400, {"error": "нужен q"}) try: data = do_coworkers(q) except Exception as e: return self._json(500, {"error": str(e)[:200]}) return self._json(200 if data else 404, data or {"error": "не найдено"}) if self.path.startswith("/history"): import urllib.parse as _uh qs = _uh.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} try: days = int((qs.get("days") or ["30"])[0]) except ValueError: days = 30 try: return self._json(200, do_history(days)) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/snapshot"): try: return self._json(200, snapshot_graph()) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/seasons"): import urllib.parse as _use qs = _use.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} q = (qs.get("q") or [""])[0] if not q: return self._json(400, {"error": "нужен q"}) try: data = do_seasons(q) except Exception as e: return self._json(500, {"error": str(e)[:200]}) return self._json(200 if data else 404, data or {"error": "не найдено"}) if self.path.startswith("/suggest"): import urllib.parse as _usg qs = _usg.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} q = (qs.get("q") or [""])[0] try: lim = int((qs.get("limit") or ["8"])[0]) except ValueError: lim = 8 try: return self._json(200, do_suggest(q, lim)) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/candidates"): import urllib.parse as _ucd qs = _ucd.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} try: lim = int((qs.get("limit") or ["20"])[0]) except ValueError: lim = 20 try: return self._json(200, do_candidates(lim)) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/mood"): import urllib.parse as _um qs = _um.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} m = (qs.get("mood") or [""])[0] if not m: return self._json(400, {"error": "нужен mood"}) try: return self._json(200, do_mood(m)) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/pick"): import urllib.parse as _upp qs = _upp.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} g = (qs.get("genre") or [None])[0] t = (qs.get("theme") or [None])[0] d = (qs.get("decade") or [None])[0] k = (qs.get("kind") or ["фильм"])[0] per = (qs.get("person") or [None])[0] rat = (qs.get("rating") or [None])[0] try: lim = int((qs.get("limit") or ["10"])[0]) except ValueError: lim = 10 try: return self._json(200, do_pick2(g, t, d, k, per, rat, lim)) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/similar"): import urllib.parse as _up2 qs = _up2.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} try: eid = int((qs.get("id") or ["0"])[0]) except ValueError: eid = 0 if not eid: return self._json(400, {"error": "нужен id"}) try: data = do_similar(eid) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if not data: return self._json(404, {"error": "карточка не найдена"}) return self._json(200, data) if self.path == "/person" or self.path.startswith("/person?"): import urllib.parse as _up3 qs = _up3.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} q = (qs.get("q") or [""])[0] if not q: return self._json(400, {"error": "нужен q"}) try: data = do_person(q) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if not data: return self._json(404, {"error": "персона не найдена"}) return self._json(200, data) if self.path.startswith("/links"): try: return self._json(200, do_links()) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path == "/services": try: return self._json(200, do_services()) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/service/"): src = self.path.split("/service/")[1].split("?")[0] if not src: return self._json(400, {"error": "нужно имя сервиса"}) try: return self._json(200, do_service_history(src)) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/search"): import urllib.parse as up q = (up.parse_qs(self.path.split("?", 1)[1]).get("q") or [""])[0] if "?" in self.path else "" if not q: return self._json(400, {"error": "нужен параметр q"}) try: return self._json(200, do_search(q)) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/entity/"): try: eid = int(self.path.split("/entity/")[1].split("?")[0]) except ValueError: return self._json(400, {"error": "нужен числовой id"}) try: data = do_entity(eid) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if data is None: return self._json(404, {"error": "карточка не найдена"}) return self._json(200, data) if self.path.startswith("/entities"): import urllib.parse as _up qs = _up.parse_qs(self.path.split("?")[1]) if "?" in self.path else {} kind = (qs.get("kind") or [None])[0] q = (qs.get("q") or [None])[0] try: limit = int((qs.get("limit") or ["200"])[0]) except ValueError: limit = 200 try: return self._json(200, do_entities(kind, limit, q)) except Exception as e: return self._json(500, {"error": str(e)[:200]}) if self.path.startswith("/events"): try: with db() as con, con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur: cur.execute("""select id, at, source, type, entity, payload from events order by id desc limit 30""") return self._json(200, {"items": [dict(r) for r in cur.fetchall()]}) except Exception as e: return self._json(500, {"error": str(e)[:200]}) return self._json(404, {"error": "нет такого пути"}) def do_POST(self): length = int(self.headers.get("Content-Length", 0)) raw = self.rfile.read(length) if length else b"{}" try: data = json.loads(raw or b"{}") except json.JSONDecodeError: return self._json(400, {"error": "не JSON"}) if self.path.startswith("/event"): return self._event(data) if self.path.startswith("/entity"): return self._entity(data) if self.path.startswith("/link"): return self._link(data) if self.path.startswith("/data/"): coll = self.path.split("/data/")[1].split("?")[0] if not coll: return self._json(400, {"error": "нужна коллекция"}) res, err = do_data_put(coll, data) return self._json(201 if not err else 500, res or {"error": err}) if self.path.startswith("/export"): coll = data.get("collection") or "" if not coll: return self._json(400, {"error": "нужна collection"}) res, err = do_export(coll, data.get("format") or "json", data.get("filename")) return self._json(200 if not err else 500, res or {"error": err}) return self._json(404, {"error": "нет такого пути"}) # ── события ── def _event(self, ev): src = (ev.get("source") or "").strip() typ = (ev.get("type") or "").strip() if not (src and typ): return self._json(400, {"error": "нужны source и type"}) now = datetime.now(timezone.utc) ent = ev.get("entity") or {} payload = ev.get("payload") or {} try: with db() as con, con.cursor() as cur: cur.execute( """insert into events (at, source, type, entity, payload, actor) values (%s, %s, %s, %s, %s, %s) returning id""", (now, src, typ, json.dumps(ent, ensure_ascii=False), json.dumps(payload, ensure_ascii=False), ev.get("actor") or "system")) eid = cur.fetchone()[0] # событие, связанное с сущностью, обновляет её статус if ent.get("kind") and ent.get("key"): cur.execute( """insert into entities (kind, key, title, status, external_ids, search_text, updated_at) values (%s, %s, %s, %s, %s, %s, %s) on conflict (kind, key) do update set status = excluded.status, title = coalesce(excluded.title, entities.title), updated_at = excluded.updated_at returning id""", (ent["kind"], ent["key"], ent.get("title") or ent["key"], typ, json.dumps({src: ent.get("key")}, ensure_ascii=False), f"{ent.get('title') or ''} {ent.get('key')}".lower(), now)) ent_id = cur.fetchone()[0] cur.execute("update events set entity_id = %s where id = %s", (ent_id, eid)) threading.Thread(target=auto_actions, args=(ev, typ), daemon=True).start() if typ in LOUD: threading.Thread(target=publish, args=(human_event(ev), typ), daemon=True).start() return self._json(201, {"ok": True, "id": eid}) except Exception as e: return self._json(500, {"error": str(e)[:200]}) # ── сущности ── def _entity(self, data): kind = (data.get("kind") or "").strip() key = (data.get("key") or "").strip() if not (kind and key): return self._json(400, {"error": "нужны kind и key"}) now = datetime.now(timezone.utc) title = data.get("title") or key aliases = " ".join(str(a) for a in (data.get("aliases") or []) if a) try: with db() as con, con.cursor() as cur: cur.execute( """insert into entities (kind, key, title, status, external_ids, search_text, updated_at) values (%s, %s, %s, %s, %s, %s, %s) on conflict (kind, key) do update set title = excluded.title, status = coalesce(excluded.status, entities.status), external_ids = entities.external_ids || excluded.external_ids, search_text = excluded.search_text, updated_at = excluded.updated_at returning id""", (kind, key, title, data.get("status"), json.dumps(data.get("external_ids") or {}, ensure_ascii=False), f"{title} {key} {aliases}".lower(), now)) rid = cur.fetchone()[0] return self._json(201, {"ok": True, "id": rid}) except Exception as e: return self._json(500, {"error": str(e)[:200]}) def _link(self, data): a, b = data.get("from"), data.get("to") rel = data.get("relation") or "related" if not (a and b): return self._json(400, {"error": "нужны from и to (id)"}) try: with db() as con, con.cursor() as cur: cur.execute( """insert into entity_links (from_id, to_id, relation) values (%s, %s, %s) on conflict do nothing returning id""", (a, b, rel)) row = cur.fetchone() return self._json(201, {"ok": True, "id": row[0] if row else None}) except Exception as e: return self._json(500, {"error": str(e)[:200]}) def main(): ensure_schema() srv = ThreadingHTTPServer(("0.0.0.0", PORT), Handler) print(f"hub-core слушает {PORT}", flush=True) srv.serve_forever() if __name__ == "__main__": main()