единый слой уведомлений: Matrix основной канал, Telegram зеркало; три алерта переведены

This commit is contained in:
root committed 2026-10-15 15:49:29 +03:00
1 parent 1a3da7e408
commit cf2b2fd9ab
5 files changed
+953

No files matched your search

+50
View File
@@ -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) изменением
одного файла, а не сорока трёх.
+235
View File
@@ -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"✅ Сертификат <b>{host}</b> продлён, осталось {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"<b>{host}</b> — осталось {days} дней"
for host, days, status, _ in problems
]
send_alert(
f"⚠️ <b>Сроки сертификатов</b>: истекают у {len(problems)} домен(ов)\n\n"
+ "\n".join(lines)
+ "\n\nПродлением занимается обратный прокси (CT 101, npm-app-1).\n"
"Проверить: <code>pct exec 101 -- docker exec npm-app-1 "
"certbot renew --dry-run</code>"
)
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())
+256
View File
@@ -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"✅ <b>{item['title']}</b>: место освободилось\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"<b>{p['title']}</b> — {p['pct']}%"
for p in problems
]
head = (f"⚠️ <b>Заполнение дисков</b>: порог превышен "
f"на {len(problems)} точк(ах)\n\n")
tail = ("\n\nЧто делать:\n"
"• убрать разросшиеся логи: "
"<code>bash /opt/buryan-hub/scripts/fix-logs.sh</code>\n"
"• убрать старые образы: <code>docker system prune -a</code>\n"
"• расширить диск: <code>pct resize &lt;CT&gt; rootfs +4G</code>")
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())
+298
View File
@@ -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 (
"✅ <b>Пул томов PVE в норме</b>\n\n"
f"Занято: {pct}%\nСвободно в группе томов: {free} ГБ"
)
lines = [
"🔴 <b>Пул томов PVE переполнен</b>",
"",
f"Занято: <b>{pct}%</b>",
f"Свободно в группе томов: <b>{free} ГБ</b>",
]
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 и запустить "
"<code>/opt/buryan-hub/scripts/vzdump-rotate.sh</code>, затем "
"<code>fstrim -v /mnt/backups</code>.",
]
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()
+114
View File
@@ -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))