Files

595 lines
23 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""
comms-agent — единый административный бот buryan-hub.
Собран слиянием двух прежних ботов:
* бот на CT 108 — /issues и heartbeat в agent_registry;
* бот на VPS — двусторонний Matrix и /restart через Remediation API.
Работает в режиме опроса Telegram, поэтому у бота НЕ должен быть
установлен webhook: Telegram не разрешает одновременно getUpdates и webhook.
Webhook закреплён за отдельным ботом Auth (@Adm_buryans_bot) для потока
самообслуживания F6-2.
"""
import os
import asyncio
import base64
import logging
import aiohttp
import asyncpg
from aiogram import Bot, Dispatcher
from aiogram.client.session.aiohttp import AiohttpSession
from aiogram.filters import Command
from aiogram.types import (
CallbackQuery,
InlineKeyboardButton,
InlineKeyboardMarkup,
Message,
)
from nio import AsyncClient, RoomMessageText
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
)
log = logging.getLogger("comms-agent")
dp = Dispatcher()
bot_instance: Bot | None = None
# --- Конфигурация -----------------------------------------------------------
ADMIN_ID = str(os.getenv("ADMIN_ID") or "0")
GITEA_URL = (os.getenv("GITEA_URL") or "http://192.168.1.140:3000").rstrip("/")
GITEA_REPO = os.getenv("GITEA_REPO") or "agent-qwen/buryan-infra"
GITEA_TOKEN = os.getenv("GITEA_TOKEN") or ""
PG_DSN = dict(
host=os.getenv("PG_HOST"),
database=os.getenv("PG_DB"),
user=os.getenv("PG_USER"),
password=os.getenv("PG_PASSWORD"),
port=int(os.getenv("PG_PORT") or 5432),
)
REMEDIATION_API_URL = (os.getenv("REMEDIATION_API_URL") or "").rstrip("/")
REMEDIATION_API_KEY = os.getenv("REMEDIATION_API_KEY") or ""
MATRIX_ROOM_ID = os.getenv("MATRIX_ROOM_ID") or ""
matrix_client = AsyncClient(os.getenv("MATRIX_HOMESERVER") or "https://matrix.buryans.ru")
def _load_help(bot_key: str = "adm") -> str:
"""Справка из общего справочника команд.
Команды не зашиты в код: правим commands.yaml, помощь обновляется сама.
Если справочник недоступен — прежний текст, бот продолжает работать.
"""
try:
import gen_help
return gen_help.help_text(gen_help.load(), bot_key)
except Exception as _exc: # noqa: BLE001
log.warning("справочник команд недоступен: %s", _exc)
return (
"Доступные команды:\n"
"/status — состояние хостов\n"
"/issues — открытые задачи Gitea\n"
"/runbook <сервис> — ранбук сервиса\n"
"/restart <сервис> — перезапуск через Remediation API"
)
HELP_TEXT = _load_help("adm")
gitea_headers = {"Authorization": f"token {GITEA_TOKEN}"}
def is_admin(obj) -> bool:
user = getattr(obj, "from_user", None)
if user is None and getattr(obj, "message", None) is not None:
user = obj.message.from_user
return user is not None and str(user.id) == ADMIN_ID
# --- Matrix -----------------------------------------------------------------
async def send_matrix_message(text: str) -> None:
if not MATRIX_ROOM_ID or not matrix_client.access_token:
return
html_text = text.replace("\n", "<br>").replace("**", "<b>").replace("`", "<code>")
try:
await matrix_client.room_send(
room_id=MATRIX_ROOM_ID,
message_type="m.room.message",
content={
"msgtype": "m.text",
"body": text,
"format": "org.matrix.custom.html",
"formatted_body": html_text,
},
)
except Exception as exc: # noqa: BLE001 - сообщение не должно ронять бота
log.error("Matrix send error: %s", exc)
async def reply(text: str, source: str, message: Message | None = None) -> None:
"""Отправляет ответ туда, откуда пришла команда, и дублирует в Matrix."""
if source == "telegram" and message is not None:
await message.answer(text)
else:
await send_matrix_message(text)
# --- Логика команд ----------------------------------------------------------
async def handle_status_logic(source: str, message: Message | None = None) -> None:
try:
conn = await asyncpg.connect(**PG_DSN)
rows = await conn.fetch(
"SELECT host, ip, mem, disk FROM host_states ORDER BY host ASC LIMIT 10;"
)
await conn.close()
if not rows:
text = "Данных о хостах пока нет."
else:
lines = [
f"{r['host']} ({r['ip']}): RAM {r['mem'] or '?'}%, диск {r['disk'] or '?'}%"
for r in rows
]
text = "Хосты:\n" + "\n".join(lines)
except Exception as exc: # noqa: BLE001
text = f"Ошибка базы: {exc}"
await reply(text, source, message)
async def handle_issues_logic(source: str, message: Message | None = None) -> None:
url = f"{GITEA_URL}/api/v1/repos/{GITEA_REPO}/issues?state=open&limit=10"
try:
async with aiohttp.ClientSession() as session:
async with session.get(url, headers=gitea_headers) as resp:
if resp.status != 200:
text = f"Gitea вернул {resp.status}"
else:
issues = await resp.json()
if not issues:
text = "Открытых задач нет."
else:
lines = [f"#{i['number']} {i['title']}" for i in issues]
text = f"Открытые задачи ({len(issues)}):\n" + "\n".join(lines)
except Exception as exc: # noqa: BLE001
text = f"Ошибка Gitea: {exc}"
await reply(text, source, message)
async def fetch_runbook(service: str) -> str | None:
"""Ищет ранбук сначала в services/, затем в knowledge/runbooks/."""
for path in (
f"services/{service}/runbook.md",
f"knowledge/runbooks/{service}.md",
):
url = f"{GITEA_URL}/api/v1/repos/{GITEA_REPO}/contents/{path}?ref=main"
try:
async with aiohttp.ClientSession() as session:
async with session.get(url, headers=gitea_headers) as resp:
if resp.status == 200:
data = await resp.json()
return base64.b64decode(data["content"]).decode("utf-8")
except Exception as exc: # noqa: BLE001
log.error("Gitea fetch error for %s: %s", path, exc)
return None
async def handle_runbook_logic(
service: str, source: str, message: Message | None = None
) -> None:
content = await fetch_runbook(service)
if content is None:
await reply(
f"Ранбук для «{service}» не найден ни в services/, ни в knowledge/runbooks/.",
source,
message,
)
return
# Отправляем без разметки: содержимое ранбука ломает парсер Markdown.
text = f"Ранбук: {service}\n\n{content[:3800]}"
if source == "telegram" and message is not None:
keyboard = InlineKeyboardMarkup(
inline_keyboard=[
[
InlineKeyboardButton(
text="Перезапустить", callback_data=f"restart_{service}"
)
]
]
)
await message.answer(text, reply_markup=keyboard)
else:
await send_matrix_message(text)
async def handle_restart_logic(
service: str, source: str, message: Message | None = None
) -> None:
if not REMEDIATION_API_URL:
await reply("Remediation API не настроен (REMEDIATION_API_URL пуст).", source, message)
return
await reply(f"Запрашиваю перезапуск: {service}...", source, message)
headers = {
"X-API-Key": REMEDIATION_API_KEY,
"Content-Type": "application/json",
}
try:
async with aiohttp.ClientSession() as session:
async with session.post(
f"{REMEDIATION_API_URL}/api/v1/remediate",
json={"action": "restart_service", "target": service},
headers=headers,
timeout=aiohttp.ClientTimeout(total=120),
) as resp:
data = await resp.json()
if resp.status == 200:
text = f"Готово: {data.get('message', 'ok')}"
else:
text = f"Отказ: {data.get('detail', resp.status)}"
except Exception as exc: # noqa: BLE001
text = f"Ошибка связи с Remediation API: {exc}"
await reply(text, source, message)
async def handle_runbook_and_restart(service: str, source: str, message: Message | None = None) -> None:
await handle_runbook_logic(service, source, message)
# --- Telegram ---------------------------------------------------------------
@dp.message(Command("start", "help"))
async def cmd_start(message: Message) -> None:
if is_admin(message):
await message.answer("comms-agent на связи.\n\n" + HELP_TEXT)
else:
await message.answer(f"Доступ запрещён. Ваш ID: {message.from_user.id}")
@dp.message(Command("status"))
async def cmd_status(message: Message) -> None:
if is_admin(message):
await handle_status_logic("telegram", message)
@dp.message(Command("issues"))
async def cmd_issues(message: Message) -> None:
if is_admin(message):
await handle_issues_logic("telegram", message)
@dp.message(Command("runbook"))
async def cmd_runbook(message: Message) -> None:
if not is_admin(message):
return
parts = message.text.split(maxsplit=1)
if len(parts) < 2:
await message.answer("Использование: /runbook <сервис>")
return
await handle_runbook_logic(parts[1].strip().lower(), "telegram", message)
@dp.message(Command("restart"))
async def cmd_restart(message: Message) -> None:
if not is_admin(message):
return
parts = message.text.split(maxsplit=1)
if len(parts) < 2:
await message.answer("Использование: /restart <сервис>")
return
await handle_restart_logic(parts[1].strip().lower(), "telegram", message)
@dp.callback_query(lambda c: (c.data or "").startswith("restart_"))
async def on_restart_callback(callback: CallbackQuery) -> None:
if not is_admin(callback):
await callback.answer("Доступ запрещён", show_alert=True)
return
service = callback.data.split("_", 1)[1]
await callback.message.edit_text(f"Запрашиваю перезапуск: {service}...")
await handle_restart_logic(service, "telegram")
await callback.answer()
# --- Одобрение обновлений (задача F6-4) -------------------------------------
UPDATE_ACTIONS = {
"update_now": ("now", "approved", "✅ Обновление одобрено, запустится в течение минуты"),
"update_defer": ("defer", "deferred", "⏰ Отложено до 03:00"),
"update_ignore": ("ignore", "cancelled", "❌ Обновление отклонено"),
}
async def decide_update(service: str, action: str, status: str, who: str) -> int | None:
"""Ставит решение по обновлению в очередь update_queue.
Если по этому сервису уже есть незакрытая заявка — обновляем её,
а не создаём вторую. Возвращает номер заявки.
"""
conn = await asyncpg.connect(**PG_DSN)
try:
row = await conn.fetchrow(
"""
UPDATE update_queue
SET action = $1, status = $2, decided_at = now(), requested_by = $3
WHERE id = (SELECT id FROM update_queue
WHERE service = $4
AND status IN ('pending', 'deferred', 'approved')
ORDER BY id DESC LIMIT 1)
RETURNING id
""",
action, status, who, service,
)
if row:
return row["id"]
row = await conn.fetchrow(
"""
INSERT INTO update_queue (service, action, status, requested_by, decided_at)
VALUES ($1, $2, $3, $4, now())
RETURNING id
""",
service, action, status, who,
)
return row["id"] if row else None
except Exception as exc: # noqa: BLE001
log.error("Не удалось записать решение по обновлению: %s", exc)
return None
finally:
await conn.close()
@dp.callback_query(lambda c: (c.data or "").startswith("update_"))
async def on_update_callback(callback: CallbackQuery) -> None:
"""Обрабатывает кнопки «Обновить сейчас», «Отложить», «Игнорировать».
Кнопки приходят боту, потому что он опрашивает Telegram: нажатие
доступно и без вебхука. Задача попадает в update_queue, откуда её
забирает update-runner.sh.
"""
if not is_admin(callback):
await callback.answer("Доступ запрещён", show_alert=True)
return
action_key, _, service = (callback.data or "").partition(":")
if action_key not in UPDATE_ACTIONS or not service:
await callback.answer("Неизвестное действие", show_alert=True)
return
action, status, text = UPDATE_ACTIONS[action_key]
who = callback.from_user.username or str(callback.from_user.id)
qid = await decide_update(service, action, status, who)
if qid is None:
await callback.answer("Не удалось записать решение", show_alert=True)
return
log.info("решение по обновлению: сервис=%s действие=%s заявка=%s", service, action, qid)
try:
await callback.message.edit_text(f"{callback.message.text}\n\n{text}")
except Exception: # noqa: BLE001
pass
await callback.answer(text)
# --- Matrix приём команд ----------------------------------------------------
# --- Команды обновлений в Matrix -------------------------------------------
# Администраторы Matrix: только они могут менять состояние служб.
# Раньше проверки прав в Matrix не было вовсе — команду мог вызвать
# любой участник комнаты. Здесь это исправлено.
MATRIX_ADMINS = {
u.strip() for u in (os.getenv("MATRIX_ADMINS") or "@akadmin:matrix.buryans.ru").split(",")
if u.strip()
}
def is_matrix_admin(sender: str) -> bool:
"""Может ли этот пользователь Matrix менять состояние служб."""
return sender in MATRIX_ADMINS
async def show_help(source: str, arg: str = "") -> None:
"""Справка из общего справочника команд."""
try:
import gen_help
data = gen_help.load()
if arg:
text = gen_help.command_help(data, arg) or gen_help.suggest(data, arg)
else:
text = gen_help.help_text(data, "adm")
except Exception as exc: # noqa: BLE001
log.warning("справочник недоступен: %s", exc)
text = HELP_TEXT
await reply(text, source)
async def show_update_queue(source: str) -> None:
"""Очередь обновлений: номер, служба, версия, состояние."""
try:
conn = await asyncpg.connect(**PG_DSN)
try:
rows = await conn.fetch(
"SELECT id, service, current_version, new_version, status "
"FROM update_queue ORDER BY id DESC LIMIT 15"
)
waiting = await conn.fetchval(
"SELECT count(*) FROM update_queue "
"WHERE status IN ('pending','deferred','approved')"
)
finally:
await conn.close()
except Exception as exc: # noqa: BLE001
await reply(f"Не удалось прочитать очередь: {exc}", source)
return
if not rows:
await reply("Очередь обновлений пуста.", source)
return
marks = {
"pending": "ждёт решения", "approved": "одобрено", "rejected": "отклонено",
"deferred": "отложено", "done": "выполнено", "failed": "неудача",
"cancelled": "отменено",
}
lines = ["<b>Очередь обновлений</b>", ""]
for r in rows:
ver = (r["current_version"] or "?") + " -> " + (r["new_version"] or "?")
lines.append('<b>No' + str(r["id"]) + '</b> ' + str(r["service"]) + " — " + ver)
lines.append(" " + marks.get(r["status"], r["status"] or "?"))
lines.append("")
lines.append("Ждут решения: " + str(waiting))
lines.append("Одобрить: <code>/approve НОМЕР</code> Отклонить: <code>/reject НОМЕР</code>")
await reply("\n".join(lines), source)
async def decide_by_number(arg: str, action: str, status: str, sender: str, source: str) -> None:
"""Одобрение или отклонение заявки по номеру."""
if not is_matrix_admin(sender):
await reply("Недостаточно прав для этого действия.", source)
return
arg = (arg or "").strip().lstrip("#")
if not arg.isdigit():
await reply("Укажите номер заявки, например: <code>/" + action + " 17</code>", source)
return
num = int(arg)
try:
conn = await asyncpg.connect(**PG_DSN)
try:
row = await conn.fetchrow(
"UPDATE update_queue SET status = $1, action = $2, decided_at = now(), "
"requested_by = $3 WHERE id = $4 "
"RETURNING id, service, new_version",
status, action, sender, num,
)
finally:
await conn.close()
except Exception as exc: # noqa: BLE001
await reply(f"Не удалось записать решение: {exc}", source)
return
if not row:
await reply(f"Заявка No{num} не найдена.", source)
return
word = "одобрена" if status == "approved" else "отклонена"
await reply(
"Заявка <b>No" + str(row["id"]) + "</b> (" + str(row["service"]) + " -> "
+ str(row["new_version"] or "?") + ") " + word + ".\n"
"Решение записано, исполнитель обновлений его подхватит.",
source,
)
async def matrix_message_callback(room, event) -> None:
if room.room_id != MATRIX_ROOM_ID:
return
if not isinstance(event, RoomMessageText):
return
if event.sender == matrix_client.user_id:
return
text = (event.body or "").strip()
log.info("Matrix команда от %s: %s", event.sender, text)
arg = text.split(" ", 1)[1].strip() if " " in text else ""
low = text.lower()
if low.startswith(("/help", "!help")):
await show_help("matrix", arg)
elif low.startswith(("/queue", "!queue")):
await show_update_queue("matrix")
elif low.startswith(("/approve", "!approve")):
await decide_by_number(arg, "approve", "approved", event.sender, "matrix")
elif low.startswith(("/reject", "!reject")):
await decide_by_number(arg, "reject", "rejected", event.sender, "matrix")
elif low.startswith(("/status", "!status")):
await handle_status_logic("matrix")
elif low.startswith(("/issues", "!issues")):
await handle_issues_logic("matrix")
elif low.startswith(("/runbook ", "!runbook ")):
await handle_runbook_logic(arg.lower(), "matrix")
elif low.startswith(("/restart ", "!restart ")):
if not is_matrix_admin(event.sender):
await reply("Недостаточно прав для перезапуска.", "matrix")
else:
await handle_restart_logic(arg.lower(), "matrix")
else:
try:
import gen_help
hint = gen_help.suggest(gen_help.load(), text.split(" ")[0])
except Exception: # noqa: BLE001
hint = "Неизвестная команда: " + text
await reply(hint, "matrix")
async def matrix_sync_loop() -> None:
matrix_client.access_token = os.getenv("MATRIX_ACCESS_TOKEN")
matrix_client.user_id = os.getenv(
"MATRIX_USER_ID", "@comms_agent:matrix.buryans.ru"
)
if not matrix_client.access_token:
log.warning("MATRIX_ACCESS_TOKEN не задан — Matrix-канал выключен")
return
try:
await matrix_client.sync(timeout=30000)
except Exception as exc: # noqa: BLE001
log.error("Первичная синхронизация Matrix не удалась: %s", exc)
return
matrix_client.add_event_callback(matrix_message_callback, RoomMessageText)
log.info("Matrix-слушатель запущен")
while True:
try:
await matrix_client.sync(timeout=30000)
except Exception as exc: # noqa: BLE001
log.error("Matrix sync error: %s", exc)
await asyncio.sleep(5)
# --- Реестр агентов ---------------------------------------------------------
async def heartbeat() -> None:
while True:
try:
conn = await asyncpg.connect(**PG_DSN)
await conn.execute(
"INSERT INTO agent_registry (name, domain, status, last_heartbeat) "
"VALUES ('comms-agent', 'comms', 'active', CURRENT_TIMESTAMP) "
"ON CONFLICT (name) DO UPDATE SET status='active', "
"last_heartbeat=CURRENT_TIMESTAMP"
)
await conn.close()
except Exception as exc: # noqa: BLE001
log.error("Heartbeat: %s", exc)
await asyncio.sleep(30)
# --- Запуск -----------------------------------------------------------------
async def main() -> None:
global bot_instance
log.info("Запуск comms-agent (Telegram + Matrix)...")
session = AiohttpSession(proxy=os.getenv("HTTP_PROXY") or None)
bot_instance = Bot(token=os.getenv("BOT_TOKEN"), session=session)
me = await bot_instance.get_me()
log.info("Бот @%s (id=%s), админ ID=%s", me.username, me.id, ADMIN_ID)
webhook = await bot_instance.get_webhook_info()
if webhook.url:
log.error(
"У бота установлен webhook (%s) — опрос работать не будет. "
"Нужен отдельный бот без webhook.",
webhook.url,
)
asyncio.create_task(heartbeat())
asyncio.create_task(matrix_sync_loop())
try:
await dp.start_polling(bot_instance)
finally:
await session.close()
if __name__ == "__main__":
asyncio.run(main())