Botik / src /botik /webhook_app.py
AnataBak's picture
Upload folder using huggingface_hub
217c89a verified
Raw History Blame Contribute Delete
6 kB
from __future__ import annotations
import asyncio
import logging
from contextlib import asynccontextmanager
import uvicorn
from fastapi import FastAPI, Header, HTTPException, Request
from telegram import Update
from telegram.ext import Application
from botik.config import Settings
from botik.telegram_app import _cache_bot_info
logger = logging.getLogger(__name__)
WEBHOOK_PATH = "/telegram/webhook"
def run_webhook_server(application: Application, settings: Settings) -> None:
app = create_webhook_app(application=application, settings=settings)
uvicorn.run(app, host="0.0.0.0", port=settings.port)
def create_webhook_app(application: Application, settings: Settings) -> FastAPI:
startup_state = {
"ready": False,
"task": None,
"watchdog_task": None,
}
@asynccontextmanager
async def lifespan(_: FastAPI):
startup_state["task"] = asyncio.create_task(
_startup_until_ready(application, settings, startup_state)
)
try:
yield
finally:
task = startup_state["task"]
if task is not None:
task.cancel()
try:
await task
except asyncio.CancelledError:
pass
watchdog_task = startup_state["watchdog_task"]
if watchdog_task is not None:
watchdog_task.cancel()
try:
await watchdog_task
except asyncio.CancelledError:
pass
if startup_state["ready"]:
await application.bot.delete_webhook()
if application.updater is not None:
await application.updater.stop()
await application.stop()
await application.shutdown()
app = FastAPI(lifespan=lifespan)
@app.get("/")
async def healthcheck() -> dict[str, str]:
return {"status": "ok", "bot_ready": str(startup_state["ready"]).lower()}
@app.post(WEBHOOK_PATH)
async def telegram_webhook(
request: Request,
x_telegram_bot_api_secret_token: str | None = Header(default=None),
) -> dict[str, bool]:
if settings.run_mode != "webhook":
raise HTTPException(status_code=404, detail="Webhook mode is disabled")
expected_secret = settings.webhook_secret
if expected_secret and x_telegram_bot_api_secret_token != expected_secret:
raise HTTPException(status_code=401, detail="Invalid secret token")
if not startup_state["ready"]:
raise HTTPException(status_code=503, detail="Bot is still starting")
payload = await request.json()
update = Update.de_json(payload, application.bot)
await application.process_update(update)
return {"ok": True}
return app
async def _startup_until_ready(
application: Application,
settings: Settings,
startup_state: dict[str, object],
) -> None:
attempt = 0
while True:
attempt += 1
try:
await application.initialize()
await application.start()
await _cache_bot_info(application)
if settings.run_mode == "webhook":
webhook_url = _build_webhook_url(settings)
await application.bot.set_webhook(
url=webhook_url,
secret_token=settings.webhook_secret,
allowed_updates=Update.ALL_TYPES,
)
logger.info("Webhook is set to %s", webhook_url)
else:
await application.bot.delete_webhook(drop_pending_updates=False)
if application.updater is None:
raise RuntimeError("Polling mode requires an updater")
await application.updater.start_polling(
poll_interval=1.0,
timeout=5,
bootstrap_retries=-1,
allowed_updates=Update.ALL_TYPES,
drop_pending_updates=False,
error_callback=_polling_error_callback,
)
startup_state["watchdog_task"] = asyncio.create_task(
_polling_watchdog(application)
)
logger.info("Polling mode started")
startup_state["ready"] = True
return
except Exception as error:
logger.warning("Startup attempt %s failed: %s", attempt, error)
if application.updater is not None:
try:
await application.updater.stop()
except Exception:
pass
try:
if application.updater is not None:
await application.updater.stop()
except Exception:
pass
try:
await application.stop()
except Exception:
pass
try:
await application.shutdown()
except Exception:
pass
await asyncio.sleep(min(30, 5 * attempt))
def _build_webhook_url(settings: Settings) -> str:
assert settings.app_base_url is not None
return f"{settings.app_base_url.rstrip('/')}{WEBHOOK_PATH}"
def _polling_error_callback(error: Exception) -> None:
logger.warning("Polling error: %s", error)
async def _polling_watchdog(application: Application) -> None:
if application.updater is None:
return
while True:
await asyncio.sleep(15)
if application.updater.running:
continue
logger.warning("Polling watchdog: updater stopped, restarting polling")
await application.updater.start_polling(
poll_interval=1.0,
timeout=5,
bootstrap_retries=-1,
allowed_updates=Update.ALL_TYPES,
drop_pending_updates=False,
error_callback=_polling_error_callback,
)