299 lines
11 KiB
Python
Executable File
299 lines
11 KiB
Python
Executable File
#!/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()
|