Lumen / lumen_admin.py
SilverElixir
fix(F-019,F-020,F-053,F-058,F-091,F-096): I/O вне петли, кап кэша, владелец буфера альбома, neurons fallback, план Gemini до среза
b8d79c3
Raw History Blame Contribute Delete
23.2 kB
"""
lumen_admin.py — HTTP-слой: FastAPI-приложение, секрет-гейты, admin/diag/export.
Связь с bot.py — только через отложенный `import bot` внутри функций.
"""
from __future__ import annotations
import asyncio
import contextlib
import copy
import hmac
import logging
import os
import time
from collections import deque
from datetime import datetime, timezone
from typing import Any
import aiohttp
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import lumen_images
from lumen_state_storage import _serialize_chat_state
log = logging.getLogger("bot")
# Схемы FastAPI выключены намеренно: /docs, /redoc и /openapi.json на публичном
# Space описывали все эндпоинты и их параметры бесплатно (аудит 26.09.2026).
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
def _check_bearer_token(request: Request, expected: str) -> bool:
"""Только Bearer-заголовок: секрет в URL светится в логах/истории/Referer (CWE-598)."""
auth_header = request.headers.get("Authorization", "")
provided = auth_header[7:].strip() if auth_header.lower().startswith("bearer ") else ""
# Сравнение в байтах: str-вариант compare_digest падает TypeError на не-ASCII.
return bool(expected) and bool(provided) and hmac.compare_digest(provided.encode(), expected.encode())
def _check_admin_key(request: Request) -> bool:
import bot
return _check_bearer_token(request, bot.ADMIN_PANEL_KEY)
def _log_denied(request: Request, what: str) -> None:
"""Попытка без верного ключа видна в логах: раньше брутфорс /admin_keys или
/export_state не оставлял следов, а ответ был 200 с телом {"error": ...}
(аудит 26.09.2026)."""
log.warning(
'[admin] Denied %s: no valid Authorization: Bearer <key> from %s',
what, getattr(getattr(request, "client", None), "host", "?"),
)
def _forbidden() -> JSONResponse:
return JSONResponse(
status_code=401,
content={"error": "forbidden — missing or invalid Authorization: Bearer <key> header"},
)
def _redact_secret(value: str) -> str:
"""Отпечаток: последние символы для сверки между рестартами, воспользоваться нельзя."""
if not value:
return "<empty>"
return "…" + value[-6:] if len(value) > 6 else "…" + value
def _check_bot_token_auth(request: Request) -> bool:
"""Как _check_admin_key, но мастер-секрет BOT_TOKEN; только для /admin_keys (иначе круг)."""
import bot
return _check_bearer_token(request, bot.BOT_TOKEN)
@app.get("/")
async def healthcheck() -> dict[str, Any]:
# Только in-memory готовность (bot/client), без сети — healthcheck обязан быть дешёвым.
import bot
ready = bot.bot is not None and bot.client is not None
return {"status": "ok" if ready else "starting", "ready": ready}
@app.get("/admin_keys")
async def get_admin_keys(request: Request) -> Any:
"""Полные секреты только по Bearer BOT_TOKEN (не ADMIN_PANEL_KEY — иначе круг); раньше светились в логах."""
if not _check_bot_token_auth(request):
_log_denied(request, "GET /admin_keys")
return _forbidden()
import bot
return {"webhook_secret": bot.WEBHOOK_SECRET, "admin_panel_key": bot.ADMIN_PANEL_KEY}
@app.get("/webhook_url")
async def get_webhook_url(request: Request) -> Any:
if not _check_admin_key(request):
_log_denied(request, "GET /webhook_url")
return _forbidden()
space_host = os.getenv("SPACE_HOST", "").strip()
if not space_host:
author = os.getenv("SPACE_AUTHOR_NAME", "silverelixir").lower()
repo = os.getenv("SPACE_REPO_NAME", "lumen").lower()
space_host = f"{author}-{repo}.hf.space"
webhook_url = f"https://{space_host}/webhook"
# Токен в URL не отдаём: ссылка с botTOKEN светилась бы в истории браузера
# и логах прокси (AUD-D-001). Токен владелец берёт у @BotFather.
return {
"webhook_url": webhook_url,
"register_url_template": (
"https://api.telegram.org/bot<TOKEN>/setWebhook"
f"?url={webhook_url}"
"&secret_token=<ADMIN_SECRET>"
"&drop_pending_updates=true"
),
"instruction": "Подставь BOT_TOKEN и WEBHOOK_SECRET вручную и вызови ссылку curl, а не браузером",
}
# Апдейт Telegram маленький: всё сверх капа отклоняем до разбора.
WEBHOOK_MAX_BODY_BYTES = 512 * 1024
# Фоновых задач апдейтов держим ограниченно: переполнение просим повторить.
WEBHOOK_MAX_INFLIGHT_TASKS = 100
# Отклонения по секрету/капу гроздьями логируем суммарно, а не по одному.
_WEBHOOK_DENIED_LOG_INTERVAL_SEC = 60.0
_webhook_denied_count = 0
# -1e9, а не 0: на свежем хосте monotonic() < 60, и первое отклонение
# ждало минуту до строки лога (ревью 17.11.2026).
_webhook_denied_last_log = -1e9
# Telegram может доставить один update_id повторно (retry после таймаута).
# Помним последние N: дубль не должен дать второй ответ, скачивание и трату квоты.
_SEEN_UPDATE_IDS_MAX = 2000
_seen_update_ids: deque[int] = deque()
_seen_update_id_set: set[int] = set()
def _is_duplicate_update(update_id: Any) -> bool:
if not isinstance(update_id, int):
return False
if update_id in _seen_update_id_set:
return True
if len(_seen_update_ids) >= _SEEN_UPDATE_IDS_MAX:
old = _seen_update_ids.popleft()
_seen_update_id_set.discard(old)
_seen_update_ids.append(update_id)
_seen_update_id_set.add(update_id)
return False
def _log_webhook_denied(reason: str) -> None:
"""Троттлинг отказов: каждая строка в SimpleQueue-лог без края, гроздья — одной."""
global _webhook_denied_count, _webhook_denied_last_log
now = time.monotonic()
_webhook_denied_count += 1
if now - _webhook_denied_last_log >= _WEBHOOK_DENIED_LOG_INTERVAL_SEC:
log.warning(
"[webhook] Rejected %d request(s): %s",
_webhook_denied_count, reason,
)
_webhook_denied_count = 0
_webhook_denied_last_log = now
@app.post("/webhook")
async def webhook_handler(request: Request) -> Any:
import bot
import json as _json
token = request.headers.get("X-Telegram-Bot-Api-Secret-Token", "")
# Пустой секрет невалиден, сравнение в байтах держит не-ASCII без TypeError.
if not bot.WEBHOOK_SECRET or not token or not hmac.compare_digest(token.encode(), bot.WEBHOOK_SECRET.encode()):
_log_webhook_denied("invalid secret token")
return {"ok": False}
# Состояние ещё грузится: 503, чтобы Telegram повторил позже, а не создал
# пустой чат и не перезаписал удалённую историю (аудит 28.10.2026).
if not getattr(bot, "_state_ready", True):
log.info("[webhook] State is still loading, asking Telegram to retry")
return JSONResponse(status_code=503, content={"ok": False, "retry": True})
# Тело апдейта маленькое: отсекаем мусор по заголовку до чтения.
content_length = request.headers.get("Content-Length")
if content_length is not None:
try:
if int(content_length) > WEBHOOK_MAX_BODY_BYTES:
_log_webhook_denied(f"body larger than the {WEBHOOK_MAX_BODY_BYTES} byte cap")
return {"ok": False}
except ValueError:
pass
# Очередь фоновых задач ограничена: переполнение просим повторить позже.
if len(bot._inflight_tasks) >= WEBHOOK_MAX_INFLIGHT_TASKS:
log.warning("[webhook] Too many in-flight updates (%d), asking Telegram to retry", len(bot._inflight_tasks))
return JSONResponse(status_code=503, content={"ok": False, "retry": True})
try:
# Читаем потоком и рвём на капе: request.body() втягивал chunked-тело
# целиком, и лимит срабатывал после чтения (аудит 26.10.2026).
chunks: list[bytes] = []
total = 0
async for chunk in request.stream():
total += len(chunk)
if total > WEBHOOK_MAX_BODY_BYTES:
_log_webhook_denied(f"body larger than the {WEBHOOK_MAX_BODY_BYTES} byte cap")
return {"ok": False}
chunks.append(chunk)
body = _json.loads(b"".join(chunks))
if bot.bot is None:
# 503 вместо 200: пусть Telegram повторит апдейт, а не считает дроп
# успехом. Проверяем ДО дедупликации: иначе update_id помечается
# обработанным, а повтор приходит как duplicate и теряется
# (аудит 29.10.2026).
log.warning("[webhook] Bot not initialized yet, asking Telegram to retry")
return JSONResponse(status_code=503, content={"ok": False, "retry": True})
if isinstance(body, dict) and _is_duplicate_update(body.get("update_id")):
log.info("[webhook] Duplicate update_id %s ignored", body.get("update_id"))
return {"ok": True}
# Перепроверка капа прямо перед create_task: между первой проверкой и этим
# местом есть await'ы (чтение тела), и пачка одновременных POST проходила
# на пустом наборе, создавая больше задач, чем кап (аудит 16.11.2026).
if len(bot._inflight_tasks) >= WEBHOOK_MAX_INFLIGHT_TASKS:
log.warning("[webhook] In-flight cap reached after body read (%d), asking Telegram to retry",
len(bot._inflight_tasks))
return JSONResponse(status_code=503, content={"ok": False, "retry": True})
bot._track_inflight_task(asyncio.create_task(bot._process_raw_update(body)))
except Exception as exc:
log.warning("[webhook] Failed to process incoming update: %s", exc, exc_info=True)
# Битое тело — не успех: пусть Telegram повторит, а не считает дроп
# обработанным (аудит M2, 10.2026).
return JSONResponse(status_code=503, content={"ok": False, "retry": True})
return {"ok": True}
async def probe_url(
session: Any, url: str, *, timeout_sec: float = 6.0, redact: str = "",
headers: dict[str, str] | None = None,
) -> dict[str, Any]:
"""Один GET-зонд: та же логика и тот же формат результата для /diag и /selftest.
ok только для 2xx/3xx: раньше 401 от защищённого прокси и 403 от TikWM
считались здоровьем, и диагностика врала зелёным при мёртвом пути.
"""
start = time.time()
try:
async with session.get(
url, timeout=aiohttp.ClientTimeout(total=timeout_sec), headers=headers or None,
) as resp:
status = int(resp.status)
ok = 200 <= status < 400
if not ok and status == 401:
# 401 с JSON Telegram — прокси и API живы, просто тестовый токен
# обрезан; 401 самого прокси — тело "Unauthorized" и остаётся красным.
with contextlib.suppress(Exception):
body = await resp.content.read(512)
if b'"error_code"' in body and b'"description"' in body:
ok = True
return {"status": resp.status, "elapsed_sec": round(time.time() - start, 2), "ok": ok}
except Exception as exc:
elapsed = round(time.time() - start, 2)
exc_str = str(exc) or repr(exc) or type(exc).__name__
if redact:
exc_str = exc_str.replace(redact, "<TOKEN>")
return {"error": exc_str, "elapsed_sec": elapsed, "ok": False}
def _diag_budget_sec() -> float:
"""Лениво через bot._env_number: голый float() давал 500 на мусоре в env."""
import bot
return bot._env_number("DIAG_TOTAL_BUDGET_SEC", 25, min_value=1)
@app.get("/diag")
async def network_diagnostics(request: Request) -> dict[str, Any]:
"""Проверяет исходящую сетевую доступность различных хостов из контейнера.
Открой в браузере чтобы увидеть, что реально заблокировано на исходящих
соединениях из HF Spaces, а что доступно."""
if not _check_admin_key(request):
_log_denied(request, "GET /diag")
return _forbidden()
import bot
from urllib.parse import quote, urlsplit
bot_token = bot.BOT_TOKEN
tikwm_base = bot.TIKWM_API_BASE_URL
# Прямой хост TikWM секрет не получает: он нужен только прокси.
tikwm_via_proxy = bool(tikwm_base) and urlsplit(tikwm_base).hostname not in {"www.tikwm.com", "tikwm.com"}
targets = {
"telegram_api": "https://api.telegram.org",
"telegram_file_api": "https://api.telegram.org/bot" + (bot_token[:6] if bot_token else "x") + "/getMe",
# Проверяем реально настроенный прокси, а не забытый хардкод: иначе "всё ок" при мёртвом адресе.
"configured_tg_proxy": bot.TELEGRAM_API_BASE_URL + "/bot" + (bot_token[:6] if bot_token else "x") + "/getMe",
"cloudflare_dot_com": "https://www.cloudflare.com",
# Голый workers.dev — ненадёжный сигнал; смотреть на configured_tg_proxy.
"cloudflare_workers_dev_root": "https://workers.dev",
"deno_deploy": "https://deno.com",
# Лишние хостинги убраны: сигнал нужен только по реально используемым (workers/deno).
"google_generic": "https://www.google.com",
"gemini_api": "https://generativelanguage.googleapis.com",
"huggingface": "https://huggingface.co",
"groq_api": "https://api.groq.com",
# Реальный API-путь справочного слоя поиска: корень отвечал бы 200 и при
# недоступном api.php — тот же принцип, что у pollinations_models.
"wikipedia_api": "https://ru.wikipedia.org/w/api.php?action=query&meta=siteinfo&format=json",
# Голое начало адреса: путь /chat/completions без ключа ответил бы 401/404
# и окрасил живой хост красным.
"munito_api": urlsplit(bot.MUNITO_BASE_URL)._replace(path="", query="", fragment="").geturl(),
# /api/ — тот же путь, что у реальных запросов: корень прокси мог
# отвечать 200, пока сам API-путь сломан (ревью 28.10.2026).
"tikwm": (tikwm_base + "/api/") if tikwm_via_proxy else "https://www.tikwm.com",
# /models вместо корня эндпоинта: корень отвечал 200 и при мёртвой генерации,
# диагностика врала зелёным (аудит 09.11.2026).
"pollinations_models": "https://image.pollinations.ai/models",
# Список моделей аккаунта с токеном — тот же путь, что у реальных генераций;
# без настройки Cloudflare остаётся просто проверка, что хост доступен.
# /ai/models/search — реальный путь каталога (его сам wrangler и зовёт);
# голый /ai/models отдаёт 404 и красил бы живой аккаунт.
"cloudflare_ai": (
f"{lumen_images.CLOUDFLARE_AI_BASE_URL}/{quote(lumen_images.CLOUDFLARE_ACCOUNT_ID, safe='')}"
"/ai/models/search?limit=1"
if lumen_images.cloudflare_configured() else "https://api.cloudflare.com"
),
"upstash": bot.UPSTASH_REDIS_REST_URL if bot.USE_UPSTASH else "https://upstash.com",
}
results: dict[str, Any] = {}
session = await bot._get_http_session()
# Общий бюджет вместо последовательных 14×6с (~84с висящей диагностики):
# зонды идут параллельно, хвост обрезается бюджетом (AUD-F-001).
diag_budget = _diag_budget_sec()
proxy_headers = (
{"X-Lumen-Proxy-Secret": bot.LUMEN_PROXY_SECRET} if bot.LUMEN_PROXY_SECRET else {}
)
async def _probe(name: str, url: str) -> tuple[str, dict[str, Any]]:
# Секрет шлём только на реально настроенный прокси: прямой
# api.telegram.org не должен видеть заголовок (аудит 28.10.2026).
headers = None
if name == "configured_tg_proxy" and bot.TELEGRAM_API_BASE_URL != "https://api.telegram.org":
headers = proxy_headers
elif name == "cloudflare_ai" and lumen_images.cloudflare_configured():
# Токен только в заголовке и только на сам Cloudflare: в URL его нет,
# поэтому error-ветка probe_url его не выдаёт. 403 здесь — не мёртвый
# хост, а токен без права на каталог моделей: генерация при этом жива.
headers = {"Authorization": f"Bearer {lumen_images.CLOUDFLARE_API_TOKEN}"}
return name, await probe_url(
session, url, timeout_sec=6.0, redact=bot_token or "", headers=headers,
)
tasks = {asyncio.create_task(_probe(name, url)): name for name, url in targets.items()}
done, pending = await asyncio.wait(tasks, timeout=diag_budget)
for task in done:
try:
name, res = task.result()
except Exception as exc:
name, res = tasks[task], {"error": str(exc), "elapsed_sec": diag_budget, "ok": False}
results[name] = res
for task in pending:
task.cancel()
results[tasks[task]] = {"error": "diag budget exceeded", "elapsed_sec": diag_budget, "ok": False}
with contextlib.suppress(Exception):
await asyncio.gather(*pending, return_exceptions=True)
# Состояние хранилища — здесь же: «замороженная» запись чатов после сбоя
# индекса иначе видна только в логе (аудит 16.11.2026).
import lumen_chat_state as lcs
state_info = {
"ready": bool(getattr(bot, "_state_ready", True)),
"index_unreadable": bool(lcs._state_load_failed),
"quota_unreadable": bool(lcs._quota_load_failed),
"persist_frozen_chats": len(lcs._chat_snapshot_unloaded),
}
return {"diagnostics": results, "state": state_info,
"telegram_api_base_configured": bot.TELEGRAM_API_BASE_URL}
@app.get("/export_state")
async def export_state(request: Request) -> Any:
"""Ручной бэкап для cron: эфемерный диск и тир Upstash без реплики; гейт ADMIN_PANEL_KEY."""
if not _check_admin_key(request):
_log_denied(request, "GET /export_state")
return _forbidden()
import bot
if not getattr(bot, "_state_ready", True):
# Бэкап во время загрузки — пустой или частичный, а state-backup.yml
# закоммитил бы его как дневной (аудит 16.11.2026). Пусть cron повторит.
log.info("[admin] /export_state requested while state is still loading, asking to retry")
return JSONResponse(status_code=503, content={"ok": False, "retry": True})
import lumen_chat_state as lcs
if lcs._state_load_failed or lcs._quota_load_failed:
# Сбой загрузки: снимок будет пустым, а state-backup.yml закоммитит его
# как дневной бэкап (ревью 17.11.2026). Честный 503 — cron повторит.
log.warning("[admin] /export_state requested after a failed startup load, asking to retry")
return JSONResponse(status_code=503, content={"ok": False, "retry": True})
# Снимок живых структур: экспорт отдавал ссылки на мутабельные объекты —
# запись между возвратом и сериализацией ответа давала несогласованный бэкап.
chats = {str(cid): _serialize_chat_state(state) for cid, state in list(bot.chat_state.items())}
# Квота вложенная (счётчики per-model) — только deepcopy отцепляет её целиком.
quota = copy.deepcopy(dict(bot.GLOBAL_QUOTA))
return {
"exported_at": datetime.now(timezone.utc).isoformat(),
"chats": chats,
"global_quota": quota,
}
@app.get("/devtrace")
async def devtrace(request: Request, n: int = 200) -> Any:
"""Хвост JSONL-следа запросов и ответов для разбора багов; гейт ADMIN_PANEL_KEY."""
if not _check_admin_key(request):
_log_denied(request, "GET /devtrace")
return _forbidden()
import lumen_devtrace as _devtrace
try:
count = int(n)
except (TypeError, ValueError):
count = 200
# Чтение хвоста 5 МБ в потоке: раньше блокировало петлю (ревью 17.11.2026).
entries = await asyncio.to_thread(_devtrace.read_tail, count)
return {
"enabled": _devtrace.enabled(),
"path": str(_devtrace.trace_path()),
"count": len(entries),
"entries": entries,
}