486 lines
27 KiB
Python
486 lines
27 KiB
Python
"""A native GusVoice UI for an already installed AWG Toolza server."""
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import contextlib
|
||
from dataclasses import dataclass
|
||
import logging
|
||
from pathlib import Path
|
||
import re
|
||
import secrets
|
||
import shutil
|
||
import time
|
||
|
||
from gusvoice_bot import GusVoiceApiError, InputFile
|
||
|
||
from . import __version__
|
||
from .core import AwgError, EXPIRE, LIMIT, NAME, SPEED, esc, redacted, size
|
||
|
||
log = logging.getLogger("awg-gus")
|
||
PAGE = 10
|
||
FILE_MAX = 25 * 1024 * 1024
|
||
|
||
|
||
def button(text, data):
|
||
if len(data.encode()) > 64:
|
||
raise ValueError("callback_data too long")
|
||
return {"text": text, "callback_data": data}
|
||
|
||
|
||
HOME = [button("🏠 Меню", "home")]
|
||
|
||
|
||
def client_status(c):
|
||
if c.get("blocked"):
|
||
return "🚫 заблокирован"
|
||
if c.get("online"):
|
||
return "🟢 онлайн"
|
||
return "⚪ офлайн" if c.get("handshake") else "⚪ ещё не подключался"
|
||
|
||
|
||
@dataclass
|
||
class Event:
|
||
uid: str
|
||
chat: str
|
||
update_id: int
|
||
message: str | None = None
|
||
text: str = ""
|
||
data: str = ""
|
||
|
||
|
||
class Bot:
|
||
def __init__(self, config, api, delivery, state):
|
||
self.config, self.api, self.io, self.state = config, api, delivery, state
|
||
self.owners = set(config["owners"])
|
||
self.steps = {}
|
||
self.confirmations = {}
|
||
self.tasks = {}
|
||
self.interrupted = {row[0] for row in state.db.execute("SELECT uid FROM pending")}
|
||
with state.db:
|
||
state.db.execute("DELETE FROM pending")
|
||
self.observed = {}
|
||
|
||
async def screen(self, e, text, rows=None):
|
||
out = await self.io.show(e.chat, text, rows if rows is not None else [HOME], e.message)
|
||
if isinstance(out, dict):
|
||
e.message = out.get("message_id")
|
||
return out
|
||
|
||
async def clients(self):
|
||
data = (await self.api.call("clients", "list")).get("data")
|
||
if not isinstance(data, list):
|
||
raise AwgError("Неверный ответ clients list")
|
||
return [c for c in data if isinstance(c, dict) and isinstance(c.get("name"), str) and NAME.fullmatch(c["name"])]
|
||
|
||
async def client(self, name):
|
||
if not NAME.fullmatch(name):
|
||
raise ValueError("Неверное имя клиента")
|
||
c = next((c for c in await self.clients() if c["name"] == name), None)
|
||
if c is None:
|
||
raise ValueError("Клиент уже удалён. Обновите список.")
|
||
return c
|
||
|
||
async def process(self, update):
|
||
n = update.get("update_id")
|
||
if not isinstance(n, int) or isinstance(n, bool) or n < self.state.get("offset", 0):
|
||
return
|
||
cb = update.get("callback_query")
|
||
msg = cb.get("message") if isinstance(cb, dict) else update.get("message")
|
||
author = cb.get("from") if isinstance(cb, dict) else (msg or {}).get("from")
|
||
msg, author = msg or {}, author or {}
|
||
chat = msg.get("chat") or {}
|
||
uid, cid = author.get("id"), chat.get("id")
|
||
allowed = (chat.get("type") == "dm" and uid in self.owners and isinstance(cid, str))
|
||
if not allowed:
|
||
self.state.claim(n)
|
||
if isinstance(cb, dict):
|
||
await self.io.ack(cb["id"], "Доступ только владельцу в личных сообщениях")
|
||
elif chat.get("type") == "dm" and (msg.get("text") or "").strip() == "/whoami":
|
||
await self.io.show(cid, f"Ваш ID: <code>{esc(uid)}</code>\nДоступ к управлению не выдан.")
|
||
return
|
||
key = (uid, cid)
|
||
busy = key in self.tasks and not self.tasks[key].done()
|
||
# Persist deduplication before ack or starting a privileged operation.
|
||
self.state.claim(n, uid, cid)
|
||
if isinstance(cb, dict):
|
||
try:
|
||
await self.io.ack(cb["id"], "Предыдущая операция ещё выполняется" if busy else None)
|
||
except Exception:
|
||
self.state.finish(n)
|
||
raise
|
||
if busy:
|
||
self.state.finish(n)
|
||
if not cb:
|
||
await self.io.show(cid, "⏳ Предыдущая операция ещё выполняется. Дождитесь результата.")
|
||
return
|
||
e = Event(uid, cid, n, msg.get("message_id") if cb else None,
|
||
msg.get("text") or "", cb.get("data") or "" if cb else "")
|
||
self.tasks[key] = asyncio.create_task(self._handle(e), name="awg-gus-action")
|
||
|
||
async def _handle(self, e):
|
||
completed = True
|
||
try:
|
||
if e.uid in self.interrupted:
|
||
self.interrupted.remove(e.uid)
|
||
await self.io.show(e.chat, "⚠️ Предыдущий запуск прервался во время обработки. "
|
||
"Проверьте состояние: незавершённые действия автоматически не повторяются.")
|
||
if e.data:
|
||
await self.action(e)
|
||
else:
|
||
await self.message(e)
|
||
except asyncio.CancelledError:
|
||
completed = False
|
||
raise
|
||
except (AwgError, ValueError) as exc:
|
||
await self._error(e, str(exc))
|
||
except Exception as exc:
|
||
# API/transport exceptions may contain a sensitive URL. Log class only.
|
||
log.error("Handler failed: %s (update %s)", type(exc).__name__, e.update_id)
|
||
await self._error(e, "Ошибка связи или обработки. Если действие изменяло сервер, проверьте результат перед повтором.")
|
||
finally:
|
||
if completed:
|
||
self.state.finish(e.update_id)
|
||
|
||
def cancel_confirmations(self, e):
|
||
self.confirmations = {k: v for k, v in self.confirmations.items() if v[:2] != (e.uid, e.chat)}
|
||
|
||
async def _error(self, e, text):
|
||
with contextlib.suppress(Exception):
|
||
await self.screen(e, "❌ " + esc(redacted(text)[:650]))
|
||
|
||
async def message(self, e):
|
||
text = e.text.strip()
|
||
command = text.split(maxsplit=1)[0].split("@", 1)[0] if text else ""
|
||
if command.startswith("/"):
|
||
self.cancel_confirmations(e)
|
||
if command in {"/start", "/menu", "/status", "/cancel"}:
|
||
self.steps.pop((e.uid, e.chat), None)
|
||
await self.home(e)
|
||
elif command == "/clients":
|
||
await self.list_clients(e)
|
||
elif command == "/whoami":
|
||
await self.screen(e, f"Ваш ID: <code>{esc(e.uid)}</code>\nДоступ: владелец.")
|
||
elif command == "/help":
|
||
await self.screen(e, "<b>AWG для Гуся</b>\n/menu — главное меню\n/clients — клиенты\n"
|
||
"/cancel — отменить ввод\n/whoami — ваш ID\n\n"
|
||
"Изменения клиентов общие с Telegram-ботом: оба управляют одним awg2.")
|
||
elif command == "/new":
|
||
await self.prompt(e, "add", "", "Имя нового клиента: латиница, цифры, _ и -, до 32 символов.")
|
||
elif (e.uid, e.chat) in self.steps:
|
||
await self.input(e, text)
|
||
else:
|
||
await self.home(e)
|
||
|
||
async def home(self, e):
|
||
d = (await self.api.call("status")).get("data") or {}
|
||
s = d.get("server") or {}
|
||
state = "🟢 работает" if s.get("up") else "🔴 не поднят"
|
||
text = (f"<b>🪿 AWG для Гуся · {__version__}</b>\n"
|
||
+ (f"Подключение: {esc(self.config['label'])}\n" if self.config.get("label") else "") +
|
||
f"Toolza: {esc(d.get('version', '?'))}\n"
|
||
f"Сервер: {esc(d.get('host', '?'))}\nAWG: {state}\n"
|
||
f"Клиенты: {s.get('clients', 0)} · онлайн {s.get('online', 0)}\n"
|
||
f"Протокол: {esc(s.get('proto', '?'))} · порт {esc(s.get('port', '?'))}")
|
||
await self.screen(e, text, [
|
||
[button("👥 Клиенты", "list:0"), button("➕ Создать", "new")],
|
||
[button("🖥 Сервер", "server"), button("🩺 Диагностика", "diag")],
|
||
[button("💾 Резервная копия", "backup"), button("📦 Экспорт клиентов", "export")],
|
||
[button("🔔 Уведомления", "notices"), button("ℹ️ О боте", "about")],
|
||
[button("🔄 Обновить", "home")]])
|
||
|
||
async def list_clients(self, e, page=0):
|
||
rows = sorted(await self.clients(), key=lambda c: (not c.get("online"), c["name"].lower()))
|
||
page = min(max(0, page), max(0, (len(rows) - 1) // PAGE))
|
||
buttons = [[button(f"{'🚫' if c.get('blocked') else '🟢' if c.get('online') else '⚪'} {c['name']}",
|
||
"client:" + c["name"])] for c in rows[page * PAGE:(page + 1) * PAGE]]
|
||
nav = []
|
||
if page:
|
||
nav.append(button("←", f"list:{page-1}"))
|
||
if (page + 1) * PAGE < len(rows):
|
||
nav.append(button("→", f"list:{page+1}"))
|
||
if nav:
|
||
buttons.append(nav)
|
||
buttons += [[button("➕ Создать", "new"), button("🔄 Обновить", f"list:{page}")], HOME]
|
||
await self.screen(e, f"<b>👥 Клиенты: {len(rows)}</b>\nСтраница {page+1}. Выберите клиента.", buttons)
|
||
|
||
async def card(self, e, name):
|
||
c = await self.client(name)
|
||
exp = c.get("expires")
|
||
expiry = time.strftime("%Y-%m-%d %H:%M", time.localtime(exp)) if exp else "без ограничения"
|
||
text = (f"<b>👤 {esc(name)}</b>\n{client_status(c)}\nIP: <code>{esc(c.get('ip', ''))}</code>\n"
|
||
f"Трафик: ↓ {size(c.get('rx'))} · ↑ {size(c.get('tx'))}\nСрок: {expiry} (время сервера)\n")
|
||
text += (f"Лимит: {size(c.get('used'))} / {size(c['limit'])} ({esc(c.get('period', 'month'))})\n"
|
||
if c.get("limit") else "Лимит: нет\n")
|
||
text += f"Скорость: {esc(c.get('speed') or 'не ограничена')}" + (" Мбит/с" if c.get("speed") else "")
|
||
watching = self.state.watched(e.uid, name)
|
||
await self.screen(e, text, [
|
||
[button("📄 Конфиг + QR", f"conf:{name}"), button("🔄 Обновить", f"client:{name}")],
|
||
[button("📅 Срок", f"expiry:{name}"), button("📊 Лимит", f"limit:{name}")],
|
||
[button("🚀 Скорость", f"speed:{name}"), button("✏️ Имя", f"rename:{name}")],
|
||
[button("🔑 Новый ключ", f"reissue:{name}"), button("🗑 Удалить", f"delete:{name}")],
|
||
[button("🔕 Не следить" if watching else "🔔 Следить", f"watch:{name}"),
|
||
button("♻️ Сбросить трафик", f"reset:{name}")],
|
||
[button("← Клиенты", "list:0")], HOME])
|
||
|
||
async def action(self, e):
|
||
op, _, arg = e.data.partition(":")
|
||
if op != "yes":
|
||
self.steps.pop((e.uid, e.chat), None)
|
||
self.cancel_confirmations(e)
|
||
if op == "home":
|
||
await self.home(e)
|
||
elif op == "list":
|
||
await self.list_clients(e, int(arg) if arg.isdigit() else 0)
|
||
elif op == "new":
|
||
await self.prompt(e, "add", "", "Имя нового клиента: латиница, цифры, _ и -, до 32 символов.")
|
||
elif op == "client":
|
||
await self.card(e, arg)
|
||
elif op == "conf":
|
||
await self.client(arg)
|
||
await self.send_config(e, arg)
|
||
elif op == "expiry":
|
||
await self.client(arg)
|
||
await self.screen(e, f"<b>Срок: {esc(arg)}</b>\nОтсчитывается от момента применения.", [
|
||
[button("1 день", f"exp:{arg}:+1d"), button("7 дней", f"exp:{arg}:+7d")],
|
||
[button("30 дней", f"exp:{arg}:+30d"), button("Без срока", f"exp:{arg}:off")],
|
||
[button("← Клиент", f"client:{arg}")]])
|
||
elif op == "exp":
|
||
name, _, value = arg.partition(":")
|
||
await self.client(name)
|
||
args = ["client", "unexpire", name] if value == "off" else ["client", "expire", name, value]
|
||
await self.confirm(e, f"Изменить срок {esc(name)}: {esc(value)}?", args, name)
|
||
elif op in {"rename", "limit", "speed"}:
|
||
await self.client(arg)
|
||
prompt = {"rename": "Новое имя: латиница, цифры, _ и -, до 32 символов.",
|
||
"limit": "Лимит: например 50G или 500M. Добавьте total для общего лимита: 50G total.\n"
|
||
"По умолчанию — за месяц. off — снять ограничение.",
|
||
"speed": "Скорость в Мбит/с: целое число, например 20. off — снять ограничение."}[op]
|
||
await self.prompt(e, op, arg, prompt)
|
||
elif op in {"delete", "reissue", "reset"}:
|
||
await self.client(arg)
|
||
verb, label = {"delete": ("del", "Удалить клиента и его доступ"),
|
||
"reissue": ("reissue", "Перевыпустить ключ: старый конфиг перестанет работать"),
|
||
"reset": ("limit-reset", "Сбросить счётчик лимита трафика")}[op]
|
||
await self.confirm(e, f"{label}: <b>{esc(arg)}</b>?", ["client", verb, arg], arg)
|
||
elif op == "watch":
|
||
await self.client(arg)
|
||
self.state.watch(e.uid, arg)
|
||
await self.card(e, arg)
|
||
elif op == "newexp":
|
||
draft = self.state.get(f"draft:{e.uid}:{e.chat}")
|
||
if not draft or time.time() - draft["time"] > 600:
|
||
raise ValueError("Ввод устарел. Создайте клиента заново.")
|
||
value = arg
|
||
args = ["client", "add", draft["name"], "mimicry=server"]
|
||
if value != "off":
|
||
args.append("expire=" + value)
|
||
await self.confirm(e, f"Создать <b>{esc(draft['name'])}</b>?\nСрок: {esc(value)}; мимикрия сервера.", args, draft["name"])
|
||
elif op == "yes":
|
||
await self.execute(e, arg)
|
||
elif op == "server":
|
||
d = (await self.api.call("server", "info")).get("data") or {}
|
||
text = "<b>🖥 Сервер AWG</b>\n" + "\n".join(
|
||
f"{label}: {esc(d.get(key, '—'))}" for key, label in
|
||
[("up", "Работает"), ("proto", "Протокол"), ("profile", "Профиль"),
|
||
("endpoint", "Endpoint"), ("net", "Подсеть"), ("mtu", "MTU"), ("clients", "Клиенты")])
|
||
await self.screen(e, text, [[button("🔄 Перезапустить AWG", "restart")], HOME])
|
||
elif op == "restart":
|
||
await self.confirm(e, "Перезапустить интерфейс AWG? Соединения VPN кратковременно прервутся.", ["server", "restart"])
|
||
elif op == "diag":
|
||
r = await self.api.call("diag", "status")
|
||
text = redacted(r.get("log") or "Диагностика завершена")
|
||
text = re.sub(r"\x1b\[[0-9;]*[A-Za-z]", "", text)
|
||
await self.screen(e, "<b>🩺 Диагностика</b>\n<pre>" + esc(text[-1800:]) + "</pre>")
|
||
elif op in {"backup", "export"}:
|
||
args = ["backup", "create"] if op == "backup" else ["clients", "export"]
|
||
await self.confirm(e, "Создать и прислать архив в эту личную беседу? Архив содержит ключи VPN.", args)
|
||
elif op == "notices":
|
||
on = self.state.get(f"notify:{e.uid}", False)
|
||
watches = [r[0] for r in self.state.db.execute("SELECT name FROM watches WHERE uid=?", (e.uid,))]
|
||
await self.screen(e, "<b>🔔 Уведомления</b>\nСостояние сервера: " + ("включены" if on else "выключены") +
|
||
"\nНаблюдение за клиентами: " + esc(", ".join(watches) or "нет") +
|
||
"\nПроверка раз в минуту. Клиент офлайн после 5 минут без рукопожатия.\n"
|
||
"При старте бот запоминает состояние без рассылки.",
|
||
[[button("Выключить серверные" if on else "Включить серверные", "notify")], HOME])
|
||
elif op == "notify":
|
||
key = f"notify:{e.uid}"
|
||
self.state.set(key, not self.state.get(key, False))
|
||
e.data = "notices"
|
||
await self.action(e)
|
||
elif op == "about":
|
||
await self.screen(e, f"<b>AWG для Гуся {__version__}</b>\n"
|
||
"Отдельная служба: awg-gus-bot. Управление тем же awg2, что и в Telegram.\n"
|
||
"Обновление на сервере: <code>sudo awg-gus-bot update</code>\n"
|
||
"Проверка: <code>sudo awg-gus-bot check</code>\n"
|
||
"В этой версии: клиенты, ключи/QR, сроки, трафик, скорость, диагностика, "
|
||
"бэкап и экспорт, перезапуск AWG, уведомления.\n"
|
||
"Установка AWG, туннели, обновление ядра и восстановление бэкапа — через меню awg2.")
|
||
else:
|
||
raise ValueError("Кнопка устарела. Откройте /menu.")
|
||
|
||
async def prompt(self, e, kind, name, text):
|
||
self.steps[(e.uid, e.chat)] = (kind, name, time.monotonic() + 600)
|
||
await self.screen(e, text + "\n\nОтмена: /cancel", [HOME])
|
||
|
||
async def input(self, e, text):
|
||
key = (e.uid, e.chat)
|
||
kind, name, expires = self.steps[key]
|
||
if time.monotonic() > expires:
|
||
self.steps.pop(key, None)
|
||
raise ValueError("Ввод устарел. Откройте меню заново.")
|
||
if kind in {"add", "rename"}:
|
||
if not NAME.fullmatch(text):
|
||
raise ValueError("Имя: латиница, цифры, _ и -, от 1 до 32 символов. Повторите ввод.")
|
||
if any(c["name"] == text for c in await self.clients()):
|
||
raise ValueError("Такое имя уже существует. Введите другое.")
|
||
if kind == "add":
|
||
self.state.set(f"draft:{e.uid}:{e.chat}", {"name": text, "time": time.time()})
|
||
await self.screen(e, f"Срок нового клиента <b>{esc(text)}</b>:", [
|
||
[button("1 день", "newexp:+1d"), button("7 дней", "newexp:+7d")],
|
||
[button("30 дней", "newexp:+30d"), button("Без срока", "newexp:off")], HOME])
|
||
else:
|
||
await self.confirm(e, f"Переименовать {esc(name)} → {esc(text)}?", ["client", "rename", name, text], text)
|
||
elif kind == "limit":
|
||
parts = text.split()
|
||
value = parts[0] if parts else ""
|
||
value = value if value == "off" else value.upper()
|
||
period = parts[1] if len(parts) == 2 else "month"
|
||
if len(parts) > 2 or not LIMIT.fullmatch(value) or period not in {"month", "total"}:
|
||
raise ValueError("Введите 50G, 500M, 50G total или off.")
|
||
await self.confirm(e, f"Лимит {esc(name)}: {esc(value)} ({period})?", ["client", "limit", name, value, period], name)
|
||
elif kind == "speed":
|
||
if not SPEED.fullmatch(text):
|
||
raise ValueError("Введите целое число Мбит/с или off.")
|
||
await self.confirm(e, f"Скорость {esc(name)}: {esc(text)} Мбит/с?", ["client", "speed", name, text], name)
|
||
self.steps.pop(key, None)
|
||
|
||
async def confirm(self, e, text, args, name=""):
|
||
from .core import validate_command
|
||
validate_command(args)
|
||
now = time.monotonic()
|
||
self.confirmations = {k: v for k, v in self.confirmations.items()
|
||
if v[0:2] != (e.uid, e.chat) and v[2] > now}
|
||
token = secrets.token_hex(8)
|
||
self.confirmations[token] = (e.uid, e.chat, now + 120, args, name)
|
||
await self.screen(e, text + "\n\nПодтверждение действует 2 минуты.",
|
||
[[button("✅ Подтвердить", "yes:" + token), button("Отмена", "home")]])
|
||
|
||
async def execute(self, e, token):
|
||
pending = self.confirmations.get(token)
|
||
if not pending or pending[:2] != (e.uid, e.chat) or pending[2] < time.monotonic():
|
||
raise ValueError("Подтверждение устарело или уже использовано. Повторите действие из меню.")
|
||
self.confirmations.pop(token)
|
||
args, name = pending[3:]
|
||
await self.screen(e, "⏳ Выполняю…")
|
||
r = await self.api.call(*args)
|
||
await self.screen(e, "✅ Выполнено", [[button("👥 Клиенты", "list:0")], HOME])
|
||
if args[:2] in (["client", "add"], ["client", "reissue"]):
|
||
await self.send_config(e, name)
|
||
elif args[:2] in (["backup", "create"], ["clients", "export"]):
|
||
data = r.get("data") or {}
|
||
path = Path(data.get("path") or data.get("file") or "")
|
||
if not path.is_absolute() or not path.is_file():
|
||
raise AwgError("Архив создан, но awg2 не вернул путь к файлу.")
|
||
if path.stat().st_size > FILE_MAX:
|
||
await self.io.show(e.chat, "Архив больше 25 МиБ и сохранён на сервере. Заберите его через SSH.")
|
||
else:
|
||
await self.io.call("send_message", chat_id=e.chat, text="Архив AWG: содержит ключи VPN.", files=[InputFile(path)])
|
||
|
||
async def send_config(self, e, name):
|
||
data = (await self.api.call("client", "conf", name)).get("data") or {}
|
||
text = data.get("text")
|
||
if not isinstance(text, str) or not text or len(text.encode()) > FILE_MAX:
|
||
raise AwgError("Конфиг отсутствует или превышает допустимый размер.")
|
||
files = [InputFile(text.encode(), filename=name + ".conf", content_type="text/plain")]
|
||
note = ""
|
||
if len(text.encode()) <= 2800 and shutil.which("qrencode"):
|
||
proc = await asyncio.create_subprocess_exec("qrencode", "-t", "PNG", "-o", "-", "-s", "8", "-m", "2",
|
||
stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL)
|
||
try:
|
||
png, _ = await asyncio.wait_for(proc.communicate(text.encode()), 10)
|
||
if proc.returncode == 0 and png.startswith(b"\x89PNG\r\n\x1a\n"):
|
||
files.append(InputFile(png, filename=name + ".png", content_type="image/png"))
|
||
else:
|
||
note = " QR не сформирован; импортируйте файл."
|
||
except (asyncio.TimeoutError, asyncio.CancelledError) as exc:
|
||
with contextlib.suppress(ProcessLookupError):
|
||
proc.kill()
|
||
await proc.wait()
|
||
if isinstance(exc, asyncio.CancelledError):
|
||
raise
|
||
note = " QR не сформирован; импортируйте файл."
|
||
else:
|
||
note = " QR недоступен или конфиг слишком длинный; импортируйте файл."
|
||
await self.io.call("send_message", chat_id=e.chat, text=f"{name} — импорт в AmneziaVPN / AmneziaWG.{note}", files=files)
|
||
|
||
async def monitor_tick(self):
|
||
watches = list(self.state.db.execute("SELECT uid,name FROM watches"))
|
||
notify = [uid for uid in self.owners if self.state.get(f"notify:{uid}", False)]
|
||
if not watches and not notify:
|
||
return
|
||
clients = {c["name"]: c for c in await self.clients()} if watches else {}
|
||
current = {}
|
||
for uid, name in watches:
|
||
if uid not in self.owners:
|
||
continue
|
||
c = clients.get(name)
|
||
status = "удалён" if c is None else "заблокирован" if c.get("blocked") else (
|
||
"онлайн" if c.get("handshake") and float(c.get("ago") or 0) < 300 else "офлайн")
|
||
current[(uid, name)] = status
|
||
if notify:
|
||
d = (await self.api.call("server", "info")).get("data") or {}
|
||
for uid in notify:
|
||
current[(uid, "Сервер AWG")] = "работает" if d.get("up") else "не поднят"
|
||
for key, status in current.items():
|
||
previous = self.observed.get(key)
|
||
if previous is not None and previous != status:
|
||
row = self.state.db.execute("SELECT chat FROM chats WHERE uid=?", (key[0],)).fetchone()
|
||
if row:
|
||
await self.io.show(row[0], f"🔔 <b>{esc(key[1])}</b>: {esc(previous)} → {esc(status)}")
|
||
self.observed = current
|
||
|
||
async def monitor(self):
|
||
while True:
|
||
try:
|
||
await self.monitor_tick()
|
||
except Exception as exc:
|
||
log.warning("Monitor failed: %s", type(exc).__name__)
|
||
await asyncio.sleep(60)
|
||
|
||
async def run(self):
|
||
webhook = await self.io.call("get_webhook_info")
|
||
if webhook.get("url"):
|
||
raise ValueError("У этого бота уже настроен webhook. Используйте отдельного бота Гуся.")
|
||
await self.io.call("set_my_commands", commands=[
|
||
{"command": "menu", "description": "Управление AWG"},
|
||
{"command": "clients", "description": "Клиенты VPN"},
|
||
{"command": "new", "description": "Создать клиента"},
|
||
{"command": "cancel", "description": "Отменить ввод"},
|
||
{"command": "help", "description": "Помощь"}])
|
||
monitor = asyncio.create_task(self.monitor())
|
||
delay = 1
|
||
try:
|
||
while True:
|
||
try:
|
||
updates = await self.io.call("get_updates", offset=self.state.get("offset", 0), timeout=30,
|
||
allowed_updates=["message", "callback_query"])
|
||
for update in updates:
|
||
await self.process(update)
|
||
delay = 1
|
||
except GusVoiceApiError as exc:
|
||
if exc.code in {401, 403, 404, 409}:
|
||
log.error("Polling stopped: HTTP %s. Check token, enabled bots, webhook and duplicate processes.", exc.code)
|
||
raise
|
||
log.warning("Polling retry: HTTP %s", exc.code)
|
||
await asyncio.sleep(delay)
|
||
delay = min(30, delay * 2)
|
||
except (OSError, TimeoutError) as exc:
|
||
log.warning("Network retry: %s", type(exc).__name__)
|
||
await asyncio.sleep(delay)
|
||
delay = min(30, delay * 2)
|
||
finally:
|
||
monitor.cancel()
|
||
for task in self.tasks.values():
|
||
task.cancel()
|
||
await asyncio.gather(monitor, *self.tasks.values(), return_exceptions=True)
|