единый слой уведомлений: Matrix основной канал, Telegram зеркало; три алерта переведены
This commit is contained in:
1 parent
1a3da7e408
commit
cf2b2fd9ab
5 files changed
+953
No files matched your search
@@ -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) изменением
|
||||
одного файла, а не сорока трёх.
|
||||
Executable
+235
@@ -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())
|
||||
Executable
+256
@@ -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 <CT> 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())
|
||||
Executable
+298
@@ -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()
|
||||
@@ -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))
|
||||
Reference in new issue
Block a user