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))