From cf2b2fd9abc0f3fc9edf012a98e5881460832bb5 Mon Sep 17 00:00:00 2001 From: Roman Buryan Date: Thu, 15 Oct 2026 15:49:29 +0300 Subject: [PATCH] =?UTF-8?q?=D0=B5=D0=B4=D0=B8=D0=BD=D1=8B=D0=B9=20=D1=81?= =?UTF-8?q?=D0=BB=D0=BE=D0=B9=20=D1=83=D0=B2=D0=B5=D0=B4=D0=BE=D0=BC=D0=BB?= =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D0=B9:=20Matrix=20=D0=BE=D1=81=D0=BD=D0=BE?= =?UTF-8?q?=D0=B2=D0=BD=D0=BE=D0=B9=20=D0=BA=D0=B0=D0=BD=D0=B0=D0=BB,=20Te?= =?UTF-8?q?legram=20=D0=B7=D0=B5=D1=80=D0=BA=D0=B0=D0=BB=D0=BE;=20=D1=82?= =?UTF-8?q?=D1=80=D0=B8=20=D0=B0=D0=BB=D0=B5=D1=80=D1=82=D0=B0=20=D0=BF?= =?UTF-8?q?=D0=B5=D1=80=D0=B5=D0=B2=D0=B5=D0=B4=D0=B5=D0=BD=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ops/notify/README.md | 50 ++++++ ops/notify/check_certs.py | 235 +++++++++++++++++++++++++++ ops/notify/check_disk.py | 256 +++++++++++++++++++++++++++++ ops/notify/check_thin_pool.py | 298 ++++++++++++++++++++++++++++++++++ ops/notify/notify.py | 114 +++++++++++++ 5 files changed, 953 insertions(+) create mode 100644 ops/notify/README.md create mode 100755 ops/notify/check_certs.py create mode 100755 ops/notify/check_disk.py create mode 100755 ops/notify/check_thin_pool.py create mode 100644 ops/notify/notify.py diff --git a/ops/notify/README.md b/ops/notify/README.md new file mode 100644 index 0000000..fff815e --- /dev/null +++ b/ops/notify/README.md @@ -0,0 +1,50 @@ +# Единый слой уведомлений + +## Зачем + +Доступ к Telegram нестабилен, и оповещение инфраструктуры нельзя строить +на канале, который может не работать. Поэтому **Matrix — основной канал**, +Telegram — зеркало. + +Проверено 15.10.2026: тестовое уведомление доставлено в Matrix, +**в Telegram — НЕ доставлено**. Именно поэтому слой и построен. + +## Как устроено + +``` +событие (диск, сертификат, хранилище, обновление) + ↓ + notify.send(text) + ├─→ Matrix (основной) — комната «Инфраструктура: уведомления» + └─→ Telegram (зеркало) — если доступен +``` + +`send()` возвращает `True`, если доставлено **хотя бы одним** каналом, — +чтобы вызывающая сторона не слала уведомление повторно. + +## Файлы + +| Файл | Назначение | +|---|---| +| `/root/.buryan-notify.env` | адрес Matrix, токен, комната (права 600) | +| `/opt/buryan-hub/scripts/notify.py` | сам модуль | +| `ops/notify/*.py` | копия в репозитории для истории | + +## Комната + +`!xmPlMatgPxoOgHOPEA:matrix.buryans.ru` — «Инфраструктура: уведомления», +**без сквозного шифрования**: это машинные сообщения, а не переписка. +Для команд людей используется отдельная комната бота. + +## Как переведены скрипты + +Исходная функция переименована в `send_alert_telegram`, а `send_alert` +стала обёрткой над общим слоем. **Логика не изменилась** — те же имя, +аргумент и результат. Копии оригинала лежат рядом: `*.before-notify`. + +Откат одного скрипта: `cp check_disk.py.before-notify check_disk.py`. + +## Задел + +Слой позволяет добавить третий канал (или убрать Telegram) изменением +одного файла, а не сорока трёх. diff --git a/ops/notify/check_certs.py b/ops/notify/check_certs.py new file mode 100755 index 0000000..775788b --- /dev/null +++ b/ops/notify/check_certs.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +# ============================================================ +# check_certs.py — контроль сроков сертификатов (задача F6-6) +# ============================================================ +# Зачем: сертификат обратного прокси действует до 24.12.2026. Если продление +# не сработает, узнать об этом лучше за две недели, а не в день истечения. +# +# Что проверяет: настоящий сертификат, который отдаётся по каждому домену — +# то есть именно то, что получает браузер. Проверка идёт по сети, а не по +# файлам, поэтому ловит и случай, когда файл обновился, а прокси его не взял. +# +# Порог: предупреждение за 14 дней, критично за 7. +# +# Запуск по расписанию: раз в сутки. +# ============================================================ +import json +import os +import socket +import ssl +import subprocess +import sys +import time +from datetime import datetime, timezone + +WARN_DAYS = int(os.getenv("THRESH_WARN_DAYS", "14")) +CRIT_DAYS = int(os.getenv("THRESH_CRITICAL_DAYS", "7")) +STATE_FILE = os.getenv("CERT_STATE_FILE", "/var/lib/buryan-monitor/cert-state.json") +TOKENS_FILE = os.getenv("TOKENS_FILE", "/root/bots-tokens.env") +ALERT_CHAT_ID = os.getenv("ALERT_CHAT_ID", "273442500") +TG_PROXY = os.getenv("TG_PROXY", "http://192.168.1.10:10888") + +DOMAINS = os.getenv("CERT_DOMAINS", " ".join([ + "buryans.ru", + "vault.buryans.ru", + "matrix.buryans.ru", + "headscale.buryans.ru", + "authentik.buryans.ru", + "n8n.buryans.ru", + "element.buryans.ru", + "status.buryans.ru", + "git.buryans.ru", + "recipes.buryans.ru", + "finance.buryans.ru", + "sync.buryans.ru", + "music.buryans.ru", + "chat.buryans.ru", +])).split() + +PG_HOST = os.getenv("PG_HOST", "192.168.1.151") +PG_DB = os.getenv("PG_DB", "buryan_monitoring") +PG_USER = os.getenv("PG_USER", "buryan_monitor") + + +def expiry_of(host, timeout=12): + """Срок действия сертификата, который отдаёт узел. + + Сертификат запрашивается как обычная строка PEM и разбирается openssl. + Через ssl.getpeercert() не получается: при отключённой проверке + подлинности Python возвращает пустой словарь, и срок узнать неоткуда. + """ + pem = ssl.get_server_certificate((host, 443), timeout=timeout) + res = subprocess.run( + ["openssl", "x509", "-noout", "-enddate", "-subject"], + input=pem, capture_output=True, text=True, timeout=15, + ) + not_after_raw = "" + subject = "?" + for line in res.stdout.splitlines(): + if line.startswith("notAfter="): + not_after_raw = line.split("=", 1)[1].strip() + elif line.startswith("subject="): + subject = line.split("=", 1)[1].strip() + + if not not_after_raw: + return None, None + + not_after = datetime.strptime(not_after_raw, "%b %d %H:%M:%S %Y %Z") + not_after = not_after.replace(tzinfo=timezone.utc) + days = (not_after - datetime.now(timezone.utc)).days + return days, subject + + +def status_of(days): + if days < CRIT_DAYS: + return "CRITICAL" + if days < WARN_DAYS: + return "WARNING" + return "OK" + + +def read_state(): + try: + with open(STATE_FILE) as fh: + return json.load(fh) + except Exception: + return {} + + +def write_state(state): + os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True) + tmp = STATE_FILE + ".tmp" + with open(tmp, "w") as fh: + json.dump(state, fh) + os.replace(tmp, STATE_FILE) + + +def alert_token(): + try: + with open(TOKENS_FILE) as fh: + for line in fh: + if line.startswith("ALERT_TOKEN="): + return line.split("=", 1)[1].strip() + except Exception: + pass + return "" + + +def send_alert(text): + """Единый слой: Matrix основной, Telegram зеркало. + + Возвращает True, если доставлено хотя бы одним каналом, — чтобы + вызывающая сторона не повторяла уведомление. + """ + try: + import os as _os + import sys as _sys + _sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__))) + import notify + return notify.send(text) + except Exception as _exc: # noqa: BLE001 + print(f"общий слой уведомлений недоступен, шлю напрямую в Telegram: {_exc}", + file=sys.stderr) + return send_alert_telegram(text) + +def send_alert_telegram(text): + token = alert_token() + if not token: + print(f"нет токена бота алертов в {TOKENS_FILE}", file=sys.stderr) + return False + try: + res = subprocess.run( + ["curl", "-s", "-m", "25", "-o", "/dev/null", "-w", "%{http_code}", + "-x", TG_PROXY, "-X", "POST", + "--data-urlencode", f"chat_id={ALERT_CHAT_ID}", + "--data-urlencode", f"text={text}", + "--data-urlencode", "parse_mode=HTML", + f"https://api.telegram.org/bot{token}/sendMessage"], + capture_output=True, text=True, timeout=40, + ) + return res.stdout.strip() == "200" + except Exception as exc: + print(f"не удалось отправить уведомление: {exc}", file=sys.stderr) + return False + + +def save_metrics(rows): + import shutil + if not shutil.which("psql") or not rows: + return + values = ",".join( + f"('{h}',{d},'{s.replace(chr(39), chr(39) * 2)}')" for h, d, s in rows + ) + sql = ("INSERT INTO cert_metrics (domain, days_left, subject) " + f"VALUES {values}") + try: + subprocess.run(["psql", "-h", PG_HOST, "-U", PG_USER, "-d", PG_DB, "-c", sql], + capture_output=True, text=True, timeout=30) + except Exception as exc: + print(f"не удалось записать замеры: {exc}", file=sys.stderr) + + +def main(): + state = read_state() + now = time.time() + problems = [] + rows = [] + unreachable = [] + + for host in DOMAINS: + try: + days, subject = expiry_of(host) + except Exception as exc: + unreachable.append(f"{host} ({exc})") + continue + if days is None: + unreachable.append(host) + continue + + rows.append((host, days, subject or "?")) + status = status_of(days) + prev = state.get(host, {}) + prev_status = prev.get("status") + + if status == "OK": + if prev_status and prev_status != "OK": + send_alert(f"✅ Сертификат {host} продлён, осталось {days} дней") + state[host] = {"status": "OK", "days": days, "ts": now} + continue + + if status != prev_status or now - prev.get("ts", 0) > 24 * 3600: + problems.append((host, days, status, subject)) + + state[host] = {"status": status, "days": days, "ts": now} + + if problems: + # Одно сообщение на все домены — по той же причине, что и для дисков. + problems.sort(key=lambda p: p[1]) + lines = [ + f"{'🔴' if status == 'CRITICAL' else '🟠'} " + f"{host} — осталось {days} дней" + for host, days, status, _ in problems + ] + send_alert( + f"⚠️ Сроки сертификатов: истекают у {len(problems)} домен(ов)\n\n" + + "\n".join(lines) + + "\n\nПродлением занимается обратный прокси (CT 101, npm-app-1).\n" + "Проверить: pct exec 101 -- docker exec npm-app-1 " + "certbot renew --dry-run" + ) + + if unreachable: + print(f"не удалось проверить: {', '.join(unreachable)}", file=sys.stderr) + + write_state(state) + save_metrics(rows) + + if rows: + worst = min(d for _, d, _ in rows) + print(f"[{datetime.now().isoformat()}] проверено доменов: {len(rows)}, " + f"минимум дней: {worst}, тревог: {len(problems)}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/ops/notify/check_disk.py b/ops/notify/check_disk.py new file mode 100755 index 0000000..c7c525e --- /dev/null +++ b/ops/notify/check_disk.py @@ -0,0 +1,256 @@ +#!/usr/bin/env python3 +# ============================================================ +# check_disk.py — контроль заполнения дисков гостей (задача F6-6) +# ============================================================ +# Зачем: 14.10.2026 выяснилось, что контейнеры стояли на 86–89%, и никто +# об этом не знал. Пул томов контролировался, а сами диски — нет. +# +# Что проверяет: +# * корневой раздел каждого работающего контейнера; +# * корневой раздел хоста; +# * раздел с резервными копиями. +# +# Как уведомляет: переход через порог — сообщение, возврат в норму — +# сообщение, повтор в том же состоянии — молчание (не чаще раза в сутки). +# +# Запуск по расписанию: ежечасно. +# ============================================================ +import json +import os +import subprocess +import sys +import time +from datetime import datetime + +WARN = int(os.getenv("THRESH_WARN", "85")) +CRIT = int(os.getenv("THRESH_CRITICAL", "92")) +STATE_FILE = os.getenv("DISK_STATE_FILE", "/var/lib/buryan-monitor/disk-state.json") +TOKENS_FILE = os.getenv("TOKENS_FILE", "/root/bots-tokens.env") +ALERT_CHAT_ID = os.getenv("ALERT_CHAT_ID", "273442500") +TG_PROXY = os.getenv("TG_PROXY", "http://192.168.1.10:10888") +REPEAT_AFTER = 24 * 3600 # повторять напоминание не чаще раза в сутки + +PG_HOST = os.getenv("PG_HOST", "192.168.1.151") +PG_DB = os.getenv("PG_DB", "buryan_monitoring") +PG_USER = os.getenv("PG_USER", "buryan_monitor") + + +def run(cmd, timeout=40): + try: + res = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout) + return res.stdout.strip() + except Exception: + return "" + + +def guests(): + """Работающие контейнеры: номер и имя.""" + out = run(["pct", "list"]) + result = [] + for line in out.splitlines()[1:]: + parts = line.split() + if len(parts) < 3 or parts[1] != "running": + continue + cid = parts[0] + cfg = run(["pct", "config", cid]) + name = cid + for cline in cfg.splitlines(): + if cline.startswith("hostname:"): + name = cline.split(":", 1)[1].strip() + result.append((cid, name)) + return result + + +def percent(path): + """Процент заполнения точки монтирования, либо None.""" + if path == "/": + out = run(["df", "-P", "/"]) + else: + out = run(["pct", "exec", path[0], "--", "df", "-P", "/"]) + + for line in out.splitlines(): + parts = line.split() + if len(parts) >= 5 and parts[4].endswith("%"): + try: + return int(parts[4].rstrip("%")) + except ValueError: + return None + return None + + +def status_of(pct): + if pct >= CRIT: + return "CRITICAL" + if pct >= WARN: + return "WARNING" + return "OK" + + +def collect(): + """Собирает заполнение по всем наблюдаемым точкам.""" + items = [] + for cid, name in guests(): + pct = percent((cid,)) + if pct is not None: + items.append({"key": f"ct-{cid}", "title": f"CT {cid} {name}", "pct": pct}) + + host = percent("/") + if host is not None: + items.append({"key": "pve", "title": "Хост pve", "pct": host}) + + out = run(["df", "-P", "/mnt/backups"]) + for line in out.splitlines(): + parts = line.split() + if len(parts) >= 5 and parts[4].endswith("%"): + try: + items.append({"key": "backups", "title": "Раздел копий", + "pct": int(parts[4].rstrip("%"))}) + except ValueError: + pass + return items + + +def read_state(): + try: + with open(STATE_FILE) as fh: + return json.load(fh) + except Exception: + return {} + + +def write_state(state): + os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True) + tmp = STATE_FILE + ".tmp" + with open(tmp, "w") as fh: + json.dump(state, fh) + os.replace(tmp, STATE_FILE) + + +def alert_token(): + try: + with open(TOKENS_FILE) as fh: + for line in fh: + if line.startswith("ALERT_TOKEN="): + return line.split("=", 1)[1].strip() + except Exception: + pass + return "" + + +def send_alert(text): + """Единый слой: Matrix основной, Telegram зеркало. + + Возвращает True, если доставлено хотя бы одним каналом, — чтобы + вызывающая сторона не повторяла уведомление. + """ + try: + import os as _os + import sys as _sys + _sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__))) + import notify + return notify.send(text) + except Exception as _exc: # noqa: BLE001 + print(f"общий слой уведомлений недоступен, шлю напрямую в Telegram: {_exc}", + file=sys.stderr) + return send_alert_telegram(text) + +def send_alert_telegram(text): + """Отправка через curl: urllib не смог договориться с прокси по TLS.""" + token = alert_token() + if not token: + print(f"нет токена бота алертов в {TOKENS_FILE}", file=sys.stderr) + return False + try: + res = subprocess.run( + ["curl", "-s", "-m", "25", "-o", "/dev/null", "-w", "%{http_code}", + "-x", TG_PROXY, "-X", "POST", + "--data-urlencode", f"chat_id={ALERT_CHAT_ID}", + "--data-urlencode", f"text={text}", + "--data-urlencode", "parse_mode=HTML", + f"https://api.telegram.org/bot{token}/sendMessage"], + capture_output=True, text=True, timeout=40, + ) + return res.stdout.strip() == "200" + except Exception as exc: + print(f"не удалось отправить уведомление: {exc}", file=sys.stderr) + return False + + +def save_metrics(items): + """Пишет замеры в базу. Без базы работа продолжается.""" + import shutil + if not shutil.which("psql"): + return + values = ",".join( + f"('{i['key']}','{i['title'].replace(chr(39), chr(39) * 2)}',{i['pct']})" + for i in items + ) + sql = ("INSERT INTO disk_metrics (guest_key, guest_title, used_percent) " + f"VALUES {values}") + try: + subprocess.run(["psql", "-h", PG_HOST, "-U", PG_USER, "-d", PG_DB, "-c", sql], + capture_output=True, text=True, timeout=30) + except Exception as exc: + print(f"не удалось записать замеры: {exc}", file=sys.stderr) + + +def main(): + items = collect() + if not items: + print("не удалось получить данные о дисках", file=sys.stderr) + return 1 + + state = read_state() + now = time.time() + problems = [] + + for item in items: + status = status_of(item["pct"]) + item["status"] = status + prev = state.get(item["key"], {}) + prev_status = prev.get("status") + last_ts = prev.get("ts", 0) + + if status == "OK": + if prev_status and prev_status != "OK": + send_alert( + f"✅ {item['title']}: место освободилось\n" + f"Заполнение {item['pct']}%" + ) + state[item["key"]] = {"status": "OK", "pct": item["pct"], "ts": now} + continue + + if status != prev_status or now - last_ts > REPEAT_AFTER: + problems.append(item) + + state[item["key"]] = {"status": status, "pct": item["pct"], "ts": now} + + if problems: + # Одно сообщение на все точки: если порог перешли десять контейнеров, + # десять отдельных сообщений — это шум, который перестают читать. + problems.sort(key=lambda i: -i["pct"]) + lines = [ + f"{'🔴' if p['status'] == 'CRITICAL' else '🟠'} " + f"{p['title']} — {p['pct']}%" + for p in problems + ] + head = (f"⚠️ Заполнение дисков: порог превышен " + f"на {len(problems)} точк(ах)\n\n") + tail = ("\n\nЧто делать:\n" + "• убрать разросшиеся логи: " + "bash /opt/buryan-hub/scripts/fix-logs.sh\n" + "• убрать старые образы: docker system prune -a\n" + "• расширить диск: pct resize <CT> rootfs +4G") + send_alert(head + "\n".join(lines) + tail) + + write_state(state) + save_metrics(items) + + worst = max(i["pct"] for i in items) + print(f"[{datetime.now().isoformat()}] проверено точек: {len(items)}, " + f"максимум {worst}%, тревог: {len(problems)}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/ops/notify/check_thin_pool.py b/ops/notify/check_thin_pool.py new file mode 100755 index 0000000..b28aa12 --- /dev/null +++ b/ops/notify/check_thin_pool.py @@ -0,0 +1,298 @@ +#!/usr/bin/env python3 +""" +check_thin_pool.py — метрики пула тонких томов PVE и оповещение о переполнении. + +Что изменено 2026-10-14: + * добавлено ОПОВЕЩЕНИЕ. Раньше скрипт каждые 5 минут исправно записывал + в базу статус CRITICAL, но никого не уведомлял — поэтому переполнение + пула 14.10.2026 прошло незамеченным, хотя данные о нём были всё время + (последняя запись: data_percent 80.66, vg_free 1.00, status CRITICAL). + * оповещение идёт через бота алертов @Buryans_AlertBot — в соответствии + с разделением ролей в docs/BOTS.md (аварии и мониторинг). + * добавлена защита от повторов: один статус — не чаще раза в ALERT_COOLDOWN. + * добавлено сообщение о восстановлении, когда статус возвращается в норму. + * пороги можно переопределить переменными THRESH_WARNING / THRESH_CRITICAL — + это нужно для проверки оповещения без реальной аварии. + +Запуск: PGPASSWORD=... python3 check_thin_pool.py +Проверка оповещения: THRESH_CRITICAL=0 PGPASSWORD=... python3 check_thin_pool.py +""" +import json +import os +import subprocess +import sys +import time +import urllib.parse +import urllib.request +from datetime import datetime + +import psycopg2 + +PG_CONFIG = { + "host": os.environ.get("PG_HOST", "192.168.1.151"), + "port": int(os.environ.get("PG_PORT", "5432")), + "database": os.environ.get("PG_DB", "buryan_monitoring"), + "user": os.environ.get("PG_USER", "buryan_monitor"), + "password": os.environ.get("PGPASSWORD"), +} + +THRESHOLDS = { + "warning": float(os.environ.get("THRESH_WARNING", "70")), + "critical": float(os.environ.get("THRESH_CRITICAL", "80")), +} + +LVS = "/sbin/lvs" +VGS = "/sbin/vgs" + +TOKENS_FILE = os.environ.get("TOKENS_FILE", "/root/bots-tokens.env") +TG_PROXY = os.environ.get("TG_PROXY", "http://192.168.1.10:10888") +ALERT_CHAT_ID = os.environ.get("ALERT_CHAT_ID", "273442500") +ALERT_STATE = os.environ.get("ALERT_STATE", "/var/lib/buryan-monitor/last-alert.json") +ALERT_COOLDOWN = int(os.environ.get("ALERT_COOLDOWN", "3600")) + + +def run(cmd): + result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30) + if result.returncode != 0: + raise RuntimeError(f"Command failed: {cmd}\n{result.stderr}") + return result.stdout.strip() + + +def collect_metrics(): + pool_out = run( + f"{LVS} --noheadings --nosuffix --units g " + f"-o lv_name,vg_name,data_percent,metadata_percent,lv_size " + f"| grep -E '^[[:space:]]*data[[:space:]]+pve'" + ) + parts = pool_out.split() + if len(parts) < 5: + raise RuntimeError(f"Cannot parse lvs: {pool_out}") + pool_name, vg_name, data_pct, meta_pct, data_size = parts[:5] + + meta_size = run( + f"{LVS} --noheadings --nosuffix --units g -o lv_size pve/data_tmeta 2>/dev/null || echo 0" + ).strip() + vg_free = run(f"{VGS} --noheadings --nosuffix --units g -o vg_free {vg_name}").strip() + + vms_out = run( + f"{LVS} --noheadings --nosuffix --units g -o lv_name,data_percent " + f"| grep 'vm-' | sort -k2 -nr | head -5" + ) + top_vms = [] + for line in vms_out.splitlines(): + p = line.split() + if len(p) >= 2: + try: + top_vms.append({"vm": p[0], "data_pct": float(p[1])}) + except ValueError: + pass + + vm_count = int(run(f"{LVS} --noheadings | grep -c 'vm-' || echo 0")) + + data_pct_f = float(data_pct) + if data_pct_f > THRESHOLDS["critical"]: + status = "CRITICAL" + elif data_pct_f > THRESHOLDS["warning"]: + status = "WARNING" + else: + status = "OK" + + return { + "pool_name": pool_name, + "vg_name": vg_name, + "data_size_gib": float(data_size), + "data_percent": data_pct_f, + "metadata_size_gib": float(meta_size), + "metadata_percent": float(meta_pct), + "vg_free_gib": float(vg_free), + "vm_count": vm_count, + "top_vms": top_vms, + "status": status, + } + + +def save_to_db(metrics): + with psycopg2.connect(**PG_CONFIG) as conn: + with conn.cursor() as cur: + cur.execute( + """ + INSERT INTO thin_pool_metrics + (pool_name, vg_name, data_size_gib, data_percent, metadata_size_gib, + metadata_percent, vg_free_gib, vm_count, top_vms, status) + VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s) + """, + ( + metrics["pool_name"], + metrics["vg_name"], + metrics["data_size_gib"], + metrics["data_percent"], + metrics["metadata_size_gib"], + metrics["metadata_percent"], + metrics["vg_free_gib"], + metrics["vm_count"], + json.dumps(metrics["top_vms"]), + metrics["status"], + ), + ) + conn.commit() + + +# --- Оповещение ------------------------------------------------------------- +def alert_token(): + try: + with open(TOKENS_FILE, encoding="utf-8") as f: + for line in f: + key, _, value = line.strip().partition("=") + if key == "ALERT_TOKEN": + return value + except OSError: + pass + return None + + +def send_alert(text): + """Единый слой: Matrix основной, Telegram зеркало. + + Возвращает True, если доставлено хотя бы одним каналом, — чтобы + вызывающая сторона не повторяла уведомление. + """ + try: + import os as _os + import sys as _sys + _sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__))) + import notify + return notify.send(text) + except Exception as _exc: # noqa: BLE001 + print(f"общий слой уведомлений недоступен, шлю напрямую в Telegram: {_exc}", + file=sys.stderr) + return send_alert_telegram(text) + +def send_alert_telegram(text): + """Отправляет сообщение через бота алертов. + + Отправка сделана через curl, а не через urllib: при работе через + локальный прокси urllib не смог завершить рукопожатие TLS + (handshake operation timed out), тогда как curl по тому же адресу + проходит нормально. + """ + token = alert_token() + if not token: + print(f"нет токена бота алертов в {TOKENS_FILE} — уведомление не отправлено", file=sys.stderr) + return False + + url = f"https://api.telegram.org/bot{token}/sendMessage" + try: + res = subprocess.run( + [ + "curl", "-s", "-m", "25", "-o", "/dev/null", "-w", "%{http_code}", + "-x", TG_PROXY, "-X", "POST", + "--data-urlencode", f"chat_id={ALERT_CHAT_ID}", + "--data-urlencode", f"text={text}", + "--data-urlencode", "parse_mode=HTML", + url, + ], + capture_output=True, text=True, timeout=40, + ) + code = res.stdout.strip() + if code == "200": + return True + print(f"уведомление не отправлено, код ответа {code} {res.stderr.strip()}", file=sys.stderr) + return False + except Exception as exc: # noqa: BLE001 + print(f"не удалось отправить уведомление: {exc}", file=sys.stderr) + return False + + +def read_alert_state(): + try: + with open(ALERT_STATE, encoding="utf-8") as f: + return json.load(f) + except Exception: # noqa: BLE001 + return {} + + +def write_alert_state(status): + os.makedirs(os.path.dirname(ALERT_STATE), exist_ok=True) + with open(ALERT_STATE, "w", encoding="utf-8") as f: + json.dump({"status": status, "ts": time.time()}, f) + + +def should_alert(status): + state = read_alert_state() + if state.get("status") == status and time.time() - state.get("ts", 0) < ALERT_COOLDOWN: + return False + return True + + +def format_alert(metrics, recovered=False): + pct = metrics["data_percent"] + free = metrics["vg_free_gib"] + if recovered: + return ( + "✅ Пул томов PVE в норме\n\n" + f"Занято: {pct}%\nСвободно в группе томов: {free} ГБ" + ) + + lines = [ + "🔴 Пул томов PVE переполнен", + "", + f"Занято: {pct}%", + f"Свободно в группе томов: {free} ГБ", + ] + if metrics["top_vms"]: + lines.append("") + lines.append("Самые заполненные:") + for item in metrics["top_vms"][:5]: + lines.append(f"• {item['vm']} — {item['data_pct']}%") + lines += [ + "", + "При 100% данные контейнеров и виртуальных машин повреждаются.", + "Что делать: проверить /mnt/backups/dump и запустить " + "/opt/buryan-hub/scripts/vzdump-rotate.sh, затем " + "fstrim -v /mnt/backups.", + ] + return "\n".join(lines) + + +def maybe_alert(metrics): + """Уведомляет об аварии или о восстановлении. + + Состояние записывается только при успешной отправке: если Telegram + недоступен, при следующем запуске попытка повторится. + """ + status = metrics["status"] + previous = read_alert_state().get("status") + + if status == "OK": + if previous and previous != "OK": + if send_alert(format_alert(metrics, recovered=True)): + write_alert_state("OK") + else: + write_alert_state("OK") + return + + if should_alert(status) and send_alert(format_alert(metrics)): + write_alert_state(status) + + +def main(): + if not PG_CONFIG["password"]: + print("PGPASSWORD не установлен", file=sys.stderr) + sys.exit(1) + + try: + metrics = collect_metrics() + save_to_db(metrics) + maybe_alert(metrics) + print( + f"[{datetime.now().isoformat()}] Data={metrics['data_percent']}% " + f"Meta={metrics['metadata_percent']}% VG_Free={metrics['vg_free_gib']}G " + f"Status={metrics['status']}" + ) + except Exception as exc: # noqa: BLE001 + print(f"Ошибка: {exc}", file=sys.stderr) + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/ops/notify/notify.py b/ops/notify/notify.py new file mode 100644 index 0000000..e09a256 --- /dev/null +++ b/ops/notify/notify.py @@ -0,0 +1,114 @@ +"""Единый слой уведомлений. + +Matrix — ОСНОВНОЙ канал. Telegram — зеркало: если он недоступен, +уведомление всё равно уходит в Matrix и не теряется молча. + +Почему так: доступ к Telegram нестабилен, и строить оповещение +инфраструктуры на канале, который может не работать, нельзя. + +Отправка выполнена без внешних библиотек — только curl, как в +существующих скриптах: меньше зависимостей, проще проверять. +""" +import json +import os +import subprocess +import sys + +CFG_FILE = os.getenv("NOTIFY_CONFIG", "/root/.buryan-notify.env") +TOKENS_FILE = os.getenv("TOKENS_FILE", "/root/bots-tokens.env") +TG_PROXY = os.getenv("TG_PROXY", "http://192.168.1.10:10888") +ALERT_CHAT_ID = os.getenv("ALERT_CHAT_ID", "273442500") + + +def _load_env(path): + data = {} + try: + with open(path, encoding="utf-8") as fh: + for line in fh: + line = line.strip() + if not line or line.startswith("#") or "=" not in line: + continue + key, val = line.split("=", 1) + data[key.strip()] = val.strip() + except OSError: + pass + return data + + +def _matrix_env(): + env = _load_env(CFG_FILE) + return (env.get("MATRIX_HOMESERVER_LOCAL") or env.get("MATRIX_HOMESERVER", ""), + env.get("MATRIX_ACCESS_TOKEN", ""), + env.get("MATRIX_ALERT_ROOM", "")) + + +def send_matrix(text, plain=None): + """Отправляет в Matrix. Возвращает True при успехе.""" + hs, token, room = _matrix_env() + if not (hs and token and room): + print("Matrix не настроен — уведомление не отправлено", file=sys.stderr) + return False + body = json.dumps({"msgtype": "m.text", + "body": plain or text, + "format": "org.matrix.custom.html", + "formatted_body": text}) + url = f"{hs}/_matrix/client/v3/rooms/{room}/send/m.room.message/notify-{os.getpid()}-{abs(hash(text)) % 10**9}" + try: + res = subprocess.run( + ["curl", "-s", "-m", "25", "-X", "PUT", + "-H", f"Authorization: Bearer {token}", + "-H", "Content-Type: application/json", + "-d", body, url], + capture_output=True, text=True, timeout=40, + ) + if "event_id" in res.stdout: + return True + print(f"Matrix ответил ошибкой: {res.stdout[:180]}", file=sys.stderr) + return False + except Exception as exc: # noqa: BLE001 + print(f"не удалось отправить в Matrix: {exc}", file=sys.stderr) + return False + + +def send_telegram(text): + """Отправляет в Telegram (зеркало). Возвращает True при успехе.""" + env = _load_env(TOKENS_FILE) + token = env.get("ALERT_TOKEN") or "" + if not token: + print("нет токена бота алертов — зеркало не отправлено", file=sys.stderr) + return False + url = f"https://api.telegram.org/bot{token}/sendMessage" + try: + res = subprocess.run( + ["curl", "-s", "-m", "25", "-o", "/dev/null", "-w", "%{http_code}", + "-x", TG_PROXY, "-X", "POST", + "--data-urlencode", f"chat_id={ALERT_CHAT_ID}", + "--data-urlencode", f"text={text}", + "--data-urlencode", "parse_mode=HTML", + url], + capture_output=True, text=True, timeout=40, + ) + return res.stdout.strip() == "200" + except Exception as exc: # noqa: BLE001 + print(f"не удалось отправить в Telegram: {exc}", file=sys.stderr) + return False + + +def send(text, plain=None): + """Главная функция. Matrix основной, Telegram зеркало. + + Возвращает True, если доставлено ХОТЯ БЫ одним каналом, — чтобы + вызывающая сторона не слала уведомление повторно. + """ + to_matrix = send_matrix(text, plain=plain) + to_telegram = send_telegram(text) + parts = [] + parts.append("Matrix: " + ("отправлено" if to_matrix else "НЕ доставлено")) + parts.append("Telegram: " + ("отправлено" if to_telegram else "НЕ доставлено")) + print("уведомление — " + ", ".join(parts), file=sys.stderr) + return to_matrix or to_telegram + + +if __name__ == "__main__": + msg = sys.argv[1] if len(sys.argv) > 1 else "Проверка канала уведомлений" + print("результат:", send(msg))