From 2f3223668035e962f62b62d29aba40fa2dc1b996 Mon Sep 17 00:00:00 2001 From: _run Date: Thu, 7 Jul 2022 22:56:13 +0500 Subject: [PATCH] Added run_webhooks for asynctelebot --- .../webhooks/run_webhooks.py | 45 ++++++++ examples/webhook_examples/run_webhooks.py | 45 ++++++++ telebot/__init__.py | 2 +- telebot/async_telebot.py | 83 ++++++++++++++ telebot/extensions/__init__.py | 7 +- telebot/extensions/webhooks.py | 103 +++++++++++++++++- 6 files changed, 278 insertions(+), 7 deletions(-) create mode 100644 examples/asynchronous_telebot/webhooks/run_webhooks.py create mode 100644 examples/webhook_examples/run_webhooks.py diff --git a/examples/asynchronous_telebot/webhooks/run_webhooks.py b/examples/asynchronous_telebot/webhooks/run_webhooks.py new file mode 100644 index 0000000..fa145fc --- /dev/null +++ b/examples/asynchronous_telebot/webhooks/run_webhooks.py @@ -0,0 +1,45 @@ +#!/usr/bin/python + +# This is a simple echo bot using the decorator mechanism. +# It echoes any incoming text messages. +# Example on built-in function to receive and process webhooks. + +from telebot.async_telebot import AsyncTeleBot +import asyncio +bot = AsyncTeleBot('TOKEN') + + +WEBHOOK_SSL_CERT = './webhook_cert.pem' # Path to the ssl certificate +WEBHOOK_SSL_PRIV = './webhook_pkey.pem' # Path to the ssl private key +DOMAIN = '123.12.33.22' # either domain, or ip address of vps + +# Quick'n'dirty SSL certificate generation: +# +# openssl genrsa -out webhook_pkey.pem 2048 +# openssl req -new -x509 -days 3650 -key webhook_pkey.pem -out webhook_cert.pem +# +# When asked for "Common Name (e.g. server FQDN or YOUR name)" you should reply +# with the same value in you put in WEBHOOK_HOST + + +# Handle '/start' and '/help' +@bot.message_handler(commands=['help', 'start']) +async def send_welcome(message): + await bot.reply_to(message, """\ +Hi there, I am EchoBot. +I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!\ +""") + + +# Handle all other messages with content_type 'text' (content_types defaults to ['text']) +@bot.message_handler(func=lambda message: True) +async def echo_message(message): + await bot.reply_to(message, message.text) + + +# it uses fastapi + uvicorn +asyncio.run(bot.run_webhooks( + listen=DOMAIN, + certificate=WEBHOOK_SSL_CERT, + certificate_key=WEBHOOK_SSL_PRIV +)) \ No newline at end of file diff --git a/examples/webhook_examples/run_webhooks.py b/examples/webhook_examples/run_webhooks.py new file mode 100644 index 0000000..8332d30 --- /dev/null +++ b/examples/webhook_examples/run_webhooks.py @@ -0,0 +1,45 @@ +#!/usr/bin/python + +# This is a simple echo bot using the decorator mechanism. +# It echoes any incoming text messages. +# Example on built-in function to receive and process webhooks. + +import telebot + +API_TOKEN = 'TOKEN' + +bot = telebot.TeleBot(API_TOKEN) + +WEBHOOK_SSL_CERT = './webhook_cert.pem' # Path to the ssl certificate +WEBHOOK_SSL_PRIV = './webhook_pkey.pem' # Path to the ssl private key +DOMAIN = '123.12.33.22' # either domain, or ip address of vps + +# Quick'n'dirty SSL certificate generation: +# +# openssl genrsa -out webhook_pkey.pem 2048 +# openssl req -new -x509 -days 3650 -key webhook_pkey.pem -out webhook_cert.pem +# +# When asked for "Common Name (e.g. server FQDN or YOUR name)" you should reply +# with the same value in you put in WEBHOOK_HOST + + +# Handle '/start' and '/help' +@bot.message_handler(commands=['help', 'start']) +def send_welcome(message): + bot.reply_to(message, """\ +Hi there, I am EchoBot. +I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!\ +""") + + +# Handle all other messages with content_type 'text' (content_types defaults to ['text']) +@bot.message_handler(func=lambda message: True) +def echo_message(message): + bot.reply_to(message, message.text) + + +bot.run_webhooks( + listen=DOMAIN, + certificate=WEBHOOK_SSL_CERT, + certificate_key=WEBHOOK_SSL_PRIV +) \ No newline at end of file diff --git a/telebot/__init__.py b/telebot/__init__.py index 4018e52..cc624bc 100644 --- a/telebot/__init__.py +++ b/telebot/__init__.py @@ -375,7 +375,7 @@ class TeleBot: ssl_context = (certificate, certificate_key) if certificate else None self.webhook_listener = SyncWebhookListener(self, secret_token, listen, port, ssl_context, '/'+url_path, debug) self.webhook_listener.run_app() - return self.webhook_listener + def delete_webhook(self, drop_pending_updates=None, timeout=None): diff --git a/telebot/async_telebot.py b/telebot/async_telebot.py index 000746e..fd21d30 100644 --- a/telebot/async_telebot.py +++ b/telebot/async_telebot.py @@ -30,6 +30,13 @@ REPLY_MARKUP_TYPES = Union[ types.ReplyKeyboardRemove, types.ForceReply] +# for webhooks +from telebot.extensions import AsyncWebhookListener +import string +import random +import ssl + + """ Module : telebot """ @@ -1438,6 +1445,82 @@ class AsyncTeleBot: drop_pending_updates, timeout, secret_token) + async def run_webhooks(self, + listen: Optional[str]="127.0.0.1", + port: Optional[int]=443, + url_path: Optional[str]=None, + certificate: Optional[str]=None, + certificate_key: Optional[str]=None, + webhook_url: Optional[str]=None, + max_connections: Optional[int]=None, + allowed_updates: Optional[List]=None, + ip_address: Optional[str]=None, + drop_pending_updates: Optional[bool] = None, + timeout: Optional[int]=None, + secret_token: Optional[str]=None, + secret_token_length: Optional[int]=20, + debug: Optional[bool]=False): + """ + This class sets webhooks and listens to a given url and port. + + :param listen: IP address to listen to. Defaults to + 0.0.0.0 + :param port: A port which will be used to listen to webhooks. + :param url_path: Path to the webhook. Defaults to /token + :param certificate: Path to the certificate file. + :param certificate_key: Path to the certificate key file. + :param webhook_url: Webhook URL. + :param max_connections: Maximum allowed number of simultaneous HTTPS connections to the webhook for update delivery, 1-100. Defaults to 40. Use lower values to limit the load on your bot's server, and higher values to increase your bot's throughput. + :param allowed_updates: A JSON-serialized list of the update types you want your bot to receive. For example, specify [“message”, “edited_channel_post”, “callback_query”] to only receive updates of these types. See Update for a complete list of available update types. Specify an empty list to receive all updates regardless of type (default). If not specified, the previous setting will be used. + :param ip_address: The fixed IP address which will be used to send webhook requests instead of the IP address resolved through DNS + :param drop_pending_updates: Pass True to drop all pending updates + :param timeout: Integer. Request connection timeout + :param secret_token: Secret token to be used to verify the webhook request. + :return: + """ + + # generate secret token if not set + if not secret_token: + secret_token = ''.join(random.choices(string.ascii_uppercase + string.digits, k=secret_token_length)) + + + if not url_path: + url_path = self.token + '/' + if url_path[-1] != '/': url_path += '/' + + + + protocol = "https" if certificate else "http" + if not webhook_url: + webhook_url = "{}://{}:{}/{}".format(protocol, listen, port, url_path) + + if certificate and certificate_key: + ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) + ssl_ctx.load_cert_chain(certificate, certificate_key) + else: + ssl_ctx = None + + # open certificate if it exists + cert_file = open(certificate, 'rb') if certificate else None + await self.set_webhook( + url=webhook_url, + certificate=cert_file, + max_connections=max_connections, + allowed_updates=allowed_updates, + ip_address=ip_address, + drop_pending_updates=drop_pending_updates, + timeout=timeout, + secret_token=secret_token + ) + if cert_file: cert_file.close() + + ssl_context = (certificate, certificate_key) if certificate else (None, None) + self.webhook_listener = AsyncWebhookListener(self, secret_token, listen, port, ssl_context, '/'+url_path, debug) + # create a new loop, set it, and pass it + asyncio.set_event_loop(asyncio.new_event_loop()) + await self.webhook_listener.run_app() + + async def delete_webhook(self, drop_pending_updates=None, timeout=None): """ diff --git a/telebot/extensions/__init__.py b/telebot/extensions/__init__.py index 9eb87c7..9535cbe 100644 --- a/telebot/extensions/__init__.py +++ b/telebot/extensions/__init__.py @@ -1,7 +1,8 @@ -from .webhooks import SyncWebhookListener +from .webhooks import SyncWebhookListener, AsyncWebhookListener __all__ = [ - 'SyncWebhookListener' -] + 'SyncWebhookListener', + 'AsyncWebhookListener' +] \ No newline at end of file diff --git a/telebot/extensions/webhooks.py b/telebot/extensions/webhooks.py index ddfae41..9f44c48 100644 --- a/telebot/extensions/webhooks.py +++ b/telebot/extensions/webhooks.py @@ -2,11 +2,14 @@ This file is used by TeleBot.run_webhooks() & AsyncTeleBot.run_webhooks() functions. -Flask/Aiohttp is required to run this script. +Flask/fastapi is required to run this script. """ - +# modules required flask_installed = True +fastapi_installed = True +uvicorn_installed = True + try: import flask from werkzeug.serving import _TSSLContextArg @@ -14,7 +17,20 @@ except ImportError: flask_installed = False _TSSLContextArg = None +try: + import fastapi + from fastapi.responses import JSONResponse +except ImportError: + fastapi_installed = False + +try: + from uvicorn import Server, Config +except ImportError: + uvicorn_installed = False + + +import asyncio from telebot.types import Update @@ -85,4 +101,85 @@ class SyncWebhookListener: ssl_context=self._ssl_context, debug=self._debug ) - return self \ No newline at end of file + + + + +class AsyncWebhookListener: + def __init__(self, bot, + secret_token: str, host: Optional[str]="127.0.0.1", + port: Optional[int]=8000, + ssl_context: Optional[_TSSLContextArg]=None, + url_path: Optional[str]=None, + debug: Optional[bool]=False + ) -> None: + """ + Synchronous implementation of webhook listener + for synchronous version of telebot. + + :param bot: TeleBot instance + :param secret_token: Telegram secret token + :param host: Webhook host + :param port: Webhook port + :param ssl_context: SSL context + """ + self._check_dependencies() + + self.app = fastapi.FastAPI() + self._secret_token = secret_token + self._bot = bot + self._port = port + self._host = host + self._ssl_context = ssl_context + self._url_path = url_path + self._debug = debug + self._prepare_endpoint_urls() + + + def _check_dependencies(self): + if not fastapi_installed: + raise ImportError('Fastapi is not installed. Please install it via pip.') + if not uvicorn_installed: + raise ImportError('Uvicorn is not installed. Please install it via pip.') + + import starlette + if starlette.__version__ < '0.20.2': + raise ImportError('Starlette version is too old. Please upgrade it.') + return + + + def _prepare_endpoint_urls(self): + self.app.add_api_route(endpoint=self.process_update,path= self._url_path, methods=["POST"]) + + + async def process_update(self, request: fastapi.Request): + """ + Processes updates. + """ + # header containsX-Telegram-Bot-Api-Secret-Token + if request.headers.get('X-Telegram-Bot-Api-Secret-Token') != self._secret_token: + # secret token didn't match + return JSONResponse(status_code=403, content={"error": "Forbidden"}) + if request.headers.get('content-type') == 'application/json': + json_string = await request.json() + asyncio.create_task(self._bot.process_new_updates([Update.de_json(json_string)])) + return JSONResponse('', status_code=200) + + return JSONResponse(status_code=403, content={"error": "Forbidden"}) + + + async def run_app(self): + """ + Run app with the given parameters. + """ + + config = Config(app=self.app, + host=self._host, + port=self._port, + debug=self._debug, + ssl_certfile=self._ssl_context[0], + ssl_keyfile=self._ssl_context[1] + ) + server = Server(config) + await server.serve() + await self._bot.close_session() \ No newline at end of file