Remove keyboards.py and some refactor

.gitignore

@@ -3,5 +3,6 @@ __pycache__/
 venv/
 .venv/
 logs/
+data/
 *.env
 *.db

Dockerfile

@@ -19,21 +19,21 @@ RUN --mount=type=cache,target=/root/.cache/pip \
     --mount=type=bind,source=requirements.txt,target=requirements.txt \
     pip install -r requirements.txt
 
-# copy i18n files
-COPY --chown=bot i18n.yaml i18n/i18n.yaml
+# copy sources
+COPY --chown=bot --chmod=774 docker-entrypoint.sh /app/
+COPY --chown=bot migrations /app/migrations
+COPY --chown=bot mybot /app/mybot
+COPY --chown=bot i18n.yaml /app/
 
-# copy default configs
-WORKDIR /app
-COPY --chown=bot mybot mybot
-COPY --chown=bot webapp webapp
+# prepare environment
+ENV I18N_PATH=/data/i18n.yaml
+ENV DB_URL=sqlite:////data/bot.db
 
-# preapre environment
-ENV SS_TYPE=memory
-ENV I18N_PATH=/i18n/i18n.yaml
+RUN mkdir -p /data
+RUN chown bot:bot /data
+VOLUME /data
 
-# set user
 USER bot
+WORKDIR /app
 
-CMD ["python3", "-m", "mybot"]
-
-VOLUME i18n/
+ENTRYPOINT ["./docker-entrypoint.sh"]

docker-compose.yml

@@ -16,10 +16,8 @@ services:
       - i18n:/i18n
     env_file: .env
     environment:
-      - SS_TYPE=memory  # redis currently is broken
+      - SS_TYPE=redis
       - SS_REDIS_HOST=redis
-      - SS_REDIS_PORT=6379
-      - SS_REDIS_PASSWORD=bot
 
   redis:
     image: redis
@@ -27,4 +25,4 @@ services:
     volumes:
       - redis-config:/etc/redis
       - redis-data:/data
-    command: redis-server --save 20 1 --loglevel warning --requirepass bot
+    command: redis-server --save 20 1

docker-entrypoint.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+if [ ! -f ${I18N_PATH} ]; then
+    cp i18n.yaml ${I18N_PATH}
+fi
+
+alembic -c migrations/alembic.ini upgrade head
+
+if [ $# -eq 0 ]; then
+  if [ -z "${USE_WEBHOOK}" ]; then
+    exec python3 -m mybot
+  else
+    exec gunicorn -b 0.0.0.0:8080 "mybot:main()"
+  fi
+else
+  exec $1
+fi

migrations/env.py

@@ -5,7 +5,7 @@ from sqlalchemy import pool
 
 from alembic import context
 
-from mybot.config import Config as AppConfig
+from mybot.config import load_config
 from mybot.database import Base
 import mybot.database.models  # do not delete this
 
@@ -19,8 +19,8 @@ if config.config_file_name is not None:
 target_metadata = Base.metadata
 
 # set sqlalchemy.url since it can not be set in alembic.ini file
-app_config = AppConfig()
-config.set_main_option("sqlalchemy.url", app_config.DB_URL)
+app_config = load_config()
+config.set_main_option("sqlalchemy.url", app_config.database.url)
 
 
 def run_migrations_offline() -> None:

mybot/__init__.py

@@ -8,6 +8,7 @@ from .states import get_state_storage
 from .handlers import register_handlers
 from .middlewares import setup_middlewares
 from .filters import add_custom_filters
+from .webhook import create_app
 
 
 def create_bot(config: Config, i18n: I18N, engine):
@@ -17,15 +18,18 @@ def create_bot(config: Config, i18n: I18N, engine):
                   skip_pending=config.bot.skip_pending,
                   num_threads=config.bot.num_threads,
                   use_class_middlewares=True,
-                  state_storage=state_storage)
+                  state_storage=state_storage,
+                  threaded=False if config.use_webhook else True)
     register_handlers(bot)
     setup_middlewares(bot, i18n, engine)
     add_custom_filters(bot, config)
-    if config.use_webhook:
     bot.delete_webhook()
+    if config.use_webhook:
         bot.set_webhook(config.webhook.url,
                         drop_pending_updates=config.webhook.drop_pending_updates,
-                        max_connections=config.webhook.max_connections)
+                        max_connections=config.webhook.max_connections,
+                        secret_token=config.webhook.secret_token,
+                        certificate=config.webhook.cert_path)
     return bot
 
 
@@ -35,6 +39,11 @@ def main():
     i18n = I18N(config.i18n)
     engine = get_engine(config.database)
     bot = create_bot(config, i18n, engine)
+
+    if config.use_webhook:
+        app = create_app(bot, config)
+        return app
+
     bot.infinity_polling(
         timeout=config.bot.timeout,
         long_polling_timeout=config.bot.polling_timeout,

mybot/config.py

@@ -1,5 +1,7 @@
 import os
+import secrets
 from dataclasses import dataclass
+from typing import Optional
 
 
 @dataclass
@@ -23,15 +25,35 @@ class BotConfig:
 
 @dataclass
 class WebhookConfig:
-    url: str
+    domain: Optional[str]
+    url_path: str
     max_connections: int
     drop_pending_updates: bool
 
+    # secret token
+    use_secret_token: bool
+    secret_token: Optional[str]
+
+    # self-signed certificate
+    cert_path: Optional[str]
+
+    def __post_init__(self):
+        if self.use_secret_token and not self.secret_token:
+            self.secret_token = secrets.token_hex()
+
+    @property
+    def url(self):
+        return f"https://{self.domain}{self.url_path}"
+
     @classmethod
     def from_env(cls):
-        return cls(os.getenv("WEBHOOK_URL"),
+        return cls(os.getenv("WEBHOOK_DOMAIN"),
+                   os.getenv("WEBHOOK_URL_PATH", "/"),
                    int(os.getenv("WEBHOOK_MAX_CONNECTIONS", 40)),
-                   bool(int(os.getenv("WEBHOOK_DROP_PENDING", True))))
+                   bool(int(os.getenv("WEBHOOK_DROP_PENDING", True))),
+                   bool(int(os.getenv("WEBHOOK_USE_SECRET_TOKEN", True))),
+                   os.getenv("WEBHOOK_SECRET_TOKEN"),
+                   os.getenv("WEBHOOK_CERT_PATH"))
 
 
 @dataclass
@@ -50,10 +72,10 @@ class I18NConfig:
 @dataclass
 class StateStorageConfig:
     type: str
-    redis_host: str
+    redis_host: Optional[str]
     redis_port: int
     redis_db: int
-    redis_pass: str
+    redis_pass: Optional[str]
 
     @classmethod
     def from_env(cls):

mybot/keyboards.py

@@ -1 +0,0 @@
-# keyboards will be defined here

mybot/logger.py

@@ -27,4 +27,3 @@ def create_logger(name: str,
         logger.addHandler(file_handler)
 
     return logger
-

mybot/states.py

@@ -12,6 +12,3 @@ def get_state_storage(config: StateStorageConfig):
     else:
         raise RuntimeWarning(f"Unknown state storage type: '{config.type}'")
     return state_storage
-
-
-# states will be defined here

mybot/webhook/__init__.py

@@ -0,0 +1,35 @@
+from flask import Flask, request, abort, g
+from telebot import TeleBot
+from telebot.types import Update
+
+from ..config import Config
+
+
+def handle_updates():
+    if request.method == "GET":
+        abort(404)  # safer to 404
+    if g.config.webhook.use_secret_token:
+        if request.headers.get("X-Telegram-Bot-Api-Secret-Token") != g.config.webhook.secret_token:
+            abort(404)
+    if request.headers.get("content-type") == "application/json":
+        update = Update.de_json(request.get_json())
+        g.bot.process_new_updates([update])
+        return ""
+    else:
+        abort(404)  # safer to 404
+
+
+def inject_g(**kwargs):
+    def inner():
+        for k, v in kwargs.items():
+            setattr(g, k, v)
+    return inner
+
+
+def create_app(bot: TeleBot, config: Config):
+    app = Flask(__name__)
+    app.add_url_rule(config.webhook.url_path,
+                     view_func=handle_updates,
+                     methods=["GET", "POST"])
+    app.before_request(inject_g(bot=bot, config=config))
+    return app

requirements.txt

@@ -3,5 +3,7 @@ pyyaml
 sqlalchemy
 alembic
 psycopg
+pymysql[rsa]
 flask
 gunicorn
+redis

webapp/__init__.py

@@ -1,27 +0,0 @@
-from flask import Flask, g
-from telebot import TeleBot
-
-from mybot import create_bot
-from mybot.config import load_config
-from mybot.database import get_engine
-from mybot.i18n import I18N
-
-from .bot import bp as bot_bp
-
-
-def inject_bot(bot: TeleBot):
-    def inner():
-        g.bot = bot
-    return inner
-
-
-def create_app():
-    config = load_config()
-    i18n = I18N(config.i18n)
-    engine = get_engine(config.database)
-    bot = create_bot(config, i18n, engine)
-
-    app = Flask(__name__)
-    app.register_blueprint(bot_bp, url_prefix=f"/{config.bot.token}")
-    app.before_request(inject_bot(bot))
-    return app

webapp/bot.py

@@ -1,16 +0,0 @@
-from flask import Blueprint, request, abort, g, Response
-from telebot.types import Update
-
-
-bp = Blueprint("bot", __name__)
-
-
-@bp.route("/", methods=["POST"])
-def handle_updates():
-    if request.headers.get("content-type") == "application/json":
-        json_string = request.get_data().decode("utf-8")
-        update = Update.de_json(json_string)
-        g.bot.process_new_updates([update])
-        return Response("", 200)
-    else:
-        abort(403)