595 lines
23 KiB
Python
595 lines
23 KiB
Python
"""
|
||
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())
|