Telegram Bot API library and sample of a Telegram chat bot

CMakeLists.txt

@@ -185,6 +185,10 @@ if (USERVER_FEATURE_MYSQL)
  add_subdirectory(mysql "${CMAKE_BINARY_DIR}/userver/mysql")
 endif()
 
+if (USERVER_FEATURE_CORE)
+ add_subdirectory(telegram "${CMAKE_BINARY_DIR}/userver/telegram")
+endif()
+
 if (USERVER_IS_THE_ROOT_PROJECT AND USERVER_FEATURE_CORE)
  add_subdirectory(samples)
 endif()

samples/CMakeLists.txt

@@ -46,6 +46,9 @@ add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-tcp_service)
 add_subdirectory(tcp_full_duplex_service)
 add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-tcp_full_duplex_service)
 
+add_subdirectory(telegram_bot_service)
+add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-telegram_bot_service)
+
 if (USERVER_FEATURE_MONGODB)
  add_subdirectory(http_caching)
  add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-http_caching)

samples/telegram_bot_service/CMakeLists.txt

@@ -0,0 +1,6 @@
+project(userver-samples-telegram_bot_service CXX)
+
+add_executable(${PROJECT_NAME} "telegram_bot_service.cpp")
+target_link_libraries(${PROJECT_NAME} userver-core userver-telegram)
+
+userver_sample_testsuite_add()

samples/telegram_bot_service/dynamic_config_fallback.json

@@ -0,0 +1,76 @@
+{
+ "BAGGAGE_SETTINGS": {
+ "allowed_keys": []
+ },
+ "HTTP_CLIENT_CONNECTION_POOL_SIZE": 1000,
+ "HTTP_CLIENT_CONNECT_THROTTLE": {
+ "max-size": 100,
+ "token-update-interval-ms": 0
+ },
+ "USERVER_BAGGAGE_ENABLED": false,
+ "USERVER_CACHES": {},
+ "USERVER_CANCEL_HANDLE_REQUEST_BY_DEADLINE": false,
+ "USERVER_CHECK_AUTH_IN_HANDLERS": true,
+ "USERVER_DEADLINE_PROPAGATION_ENABLED": true,
+ "USERVER_DUMPS": {},
+ "USERVER_FILES_CONTENT_TYPE_MAP": {
+ ".css": "text/css",
+ ".gif": "image/gif",
+ ".htm": "text/html",
+ ".html": "text/html",
+ ".jpeg": "image/jpeg",
+ ".js": "application/javascript",
+ ".json": "application/json",
+ ".md": "text/markdown",
+ ".png": "image/png",
+ ".svg": "image/svg+xml",
+ "__default__": "text/plain"
+ },
+ "USERVER_HANDLER_STREAM_API_ENABLED": false,
+ "USERVER_HTTP_PROXY": "",
+ "USERVER_LOG_DYNAMIC_DEBUG": {
+ "force-disabled": [],
+ "force-enabled": []
+ },
+ "USERVER_LOG_REQUEST": true,
+ "USERVER_LOG_REQUEST_HEADERS": false,
+ "USERVER_LRU_CACHES": {},
+ "USERVER_NO_LOG_SPANS": {
+ "names": [],
+ "prefixes": []
+ },
+ "USERVER_RPS_CCONTROL": {
+ "down-level": 1,
+ "down-rate-percent": 2,
+ "min-limit": 10,
+ "no-limit-seconds": 1000,
+ "overload-off-seconds": 3,
+ "overload-on-seconds": 3,
+ "up-level": 2,
+ "up-rate-percent": 2
+ },
+ "USERVER_RPS_CCONTROL_ACTIVATED_FACTOR_METRIC": 5,
+ "USERVER_RPS_CCONTROL_CUSTOM_STATUS": {},
+ "USERVER_RPS_CCONTROL_ENABLED": false,
+ "USERVER_TASK_PROCESSOR_PROFILER_DEBUG": {
+ "fs-task-processor": {
+ "enabled": false,
+ "execution-slice-threshold-us": 1000000
+ },
+ "main-task-processor": {
+ "enabled": false,
+ "execution-slice-threshold-us": 2000
+ }
+ },
+ "USERVER_TASK_PROCESSOR_QOS": {
+ "default-service": {
+ "default-task-processor": {
+ "wait_queue_overload": {
+ "action": "ignore",
+ "length_limit": 5000,
+ "time_limit_us": 3000
+ }
+ }
+ }
+ }
+}

samples/telegram_bot_service/static_config.yaml

@@ -0,0 +1,61 @@
+# yaml
+components_manager:
+ coro_pool:
+ initial_size: 500 # Preallocate 500 coroutines at startup.
+ max_size: 1000 # Do not keep more than 1000 preallocated coroutines.
+
+ task_processors: # Task processor is an executor for coroutine tasks
+
+ main-task-processor: # Make a task processor for CPU-bound couroutine tasks.
+ worker_threads: 4 # Process tasks in 4 threads.
+ thread_name: main-worker # OS will show the threads of this task processor with 'main-worker' prefix.
+
+ fs-task-processor: # Make a separate task processor for filesystem bound tasks.
+ thread_name: fs-worker
+ worker_threads: 4
+
+ default_task_processor: main-task-processor
+
+ components: # Configuring components that were registered via component_list
+ http-client:
+ fs-task-processor: fs-task-processor
+
+ dns-client: # Asynchronous DNS component
+ fs-task-processor: fs-task-processor
+
+ testsuite-support:
+ tests-control:
+ # Some options from server::handlers::HttpHandlerBase
+ path: /tests/{action}
+ method: POST
+ task_processor: main-task-processor
+
+ server:
+ # ...
+ listener: # configuring the main listening socket...
+ port: 8080 # ...to listen on this port and...
+ task_processor: main-task-processor # ...process incoming requests on this task processor.
+
+ logging:
+ fs-task-processor: fs-task-processor
+ loggers:
+ default:
+ file_path: '@stderr'
+ level: debug
+ overflow_behavior: discard # Drop logs if the system is too busy to write them down.
+
+ tracer: # Component that helps to trace execution times and requests in logs.
+ service-name: telegram-bot-service # "You know. You all know exactly who I am. Say my name. " (c)
+
+ dynamic-config: # Dynamic config storage options, do nothing
+ fs-cache-path: ''
+ dynamic-config-fallbacks: # Load options from file and push them into the dynamic config storage.
+ fallback-path: /etc/telegram_bot_service/dynamic_config_fallback.json
+
+ telegram-bot-client:
+ bot-token: your-bot-token
+
+ handler-greet-user:
+ fs-task-processor: fs-task-processor
+ greeting-photo-path: /etc/telegram_bot_service/assets/userver_greeting.jpg
+ polling-frequency: 50ms

samples/telegram_bot_service/telegram_bot_service.cpp

@@ -0,0 +1,182 @@
+#include <userver/testsuite/testsuite_support.hpp>
+#include <userver/utest/using_namespace_userver.hpp>
+
+#include <userver/clients/dns/component.hpp>
+#include <userver/clients/http/component.hpp>
+#include <userver/components/component.hpp>
+#include <userver/components/minimal_server_component_list.hpp>
+#include <userver/fs/read.hpp>
+#include <userver/server/handlers/tests_control.hpp>
+#include <userver/utils/daemon_run.hpp>
+#include <userver/yaml_config/merge_schemas.hpp>
+
+#include <userver/telegram/bot/client/client.hpp>
+#include <userver/telegram/bot/components/client.hpp>
+#include <userver/telegram/bot/components/long_poller.hpp>
+
+#include <codecvt>
+#include <locale>
+
+namespace samples::telegram_bot {
+
+class GreetUser final : public telegram::bot::TelegramBotLongPoller {
+ public:
+ static constexpr std::string_view kName = "handler-greet-user";
+
+ GreetUser(const components::ComponentConfig& config,
+ const components::ComponentContext& context);
+
+ void HandleUpdate(telegram::bot::Update update,
+ telegram::bot::ClientPtr client) override;
+
+ static yaml_config::Schema GetStaticConfigSchema();
+
+ private:
+ std::int64_t SendGreeting(
+ telegram::bot::ClientPtr client,
+ std::int64_t chat_id,
+ const std::optional<std::string>& username) const;
+
+ static std::string GreetingCaption(
+ const std::optional<std::string>& username);
+
+ static std::vector<telegram::bot::MessageEntity> GreetingMessageEntities(
+ std::string_view caption);
+
+ telegram::bot::SendPhotoMethod::Parameters::Photo GreetingPhoto() const;
+
+ static std::shared_ptr<std::string> ReadPhoto(
+ const components::ComponentConfig& config,
+ const components::ComponentContext& context);
+
+ telegram::bot::RequestOptions request_options_;
+ mutable rcu::Variable<std::string> photo_file_id_;
+ const std::shared_ptr<std::string> photo_;
+};
+
+} // namespace samples::telegram_bot
+
+namespace samples::telegram_bot {
+
+GreetUser::GreetUser(const components::ComponentConfig& config,
+ const components::ComponentContext& context)
+ : telegram::bot::TelegramBotLongPoller (config, context),
+ request_options_{std::chrono::seconds{5}},
+ photo_(ReadPhoto(config, context)) {}
+
+void GreetUser::HandleUpdate(telegram::bot::Update update,
+ telegram::bot::ClientPtr client) {
+ if (!update.message) {
+ return;
+ }
+ try {
+ const std::int64_t chat_id = update.message->chat->id;
+ const auto& username = update.message->chat->first_name;
+ SendGreeting(client, chat_id, username);
+ } catch (std::exception& ex) {
+ LOG_ERROR() << "Error send greeting: " << ex.what();
+ }
+}
+
+yaml_config::Schema GreetUser::GetStaticConfigSchema() {
+ return yaml_config::MergeSchemas<telegram::bot::TelegramBotLongPoller>(R"(
+type: object
+description: The component for sending a greeting to a user on behalf of a bot
+additionalProperties: false
+properties:
+ fs-task-processor:
+ type: string
+ description: fs-task-processor
+ greeting-photo-path:
+ type: string
+ description: The path to the greeting picture
+)");
+ }
+
+std::int64_t GreetUser::SendGreeting(
+ telegram::bot::ClientPtr client,
+ std::int64_t chat_id,
+ const std::optional<std::string>& username) const {
+ auto upload_action = telegram::bot::SendChatActionMethod::Parameters::Action::kUploadPhoto;
+ auto send_action_request = client->SendChatAction({chat_id, upload_action},
+ request_options_);
+ send_action_request.Perform();
+
+ telegram::bot::SendPhotoMethod::Parameters parameters{chat_id,
+ GreetingPhoto()};
+ parameters.caption = GreetingCaption(username);
+ parameters.caption_entities = GreetingMessageEntities(
+ parameters.caption.value());
+
+ auto send_photo_request = client->SendPhoto(parameters, request_options_);
+ auto result = send_photo_request.Perform();
+ if (!result.photo->empty()) {
+ auto file_id = photo_file_id_.StartWrite();
+ *file_id = std::move(result.photo->back().file_id);
+ file_id.Commit();
+ }
+ return result.message_id;
+}
+
+std::string GreetUser::GreetingCaption(
+ const std::optional<std::string>& username) {
+ if (username) {
+ return fmt::format("Hello, {}! This is a test telegram bot written on "
+ "userver.",
+ username.value());
+ } else {
+ return "Hello! This is a test telegram bot written on userver.";
+ }
+}
+
+std::vector<telegram::bot::MessageEntity> GreetUser::GreetingMessageEntities(
+ std::string_view caption) {
+ std::vector<telegram::bot::MessageEntity> result;
+ telegram::bot::MessageEntity& linkEntity = result.emplace_back();
+
+ std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> convert;
+ std::wstring wcaption = convert.from_bytes(caption.data());
+
+ linkEntity.offset = wcaption.size() - 8;
+ linkEntity.length = 7;
+ linkEntity.type = telegram::bot::MessageEntity::Type::kTextLink;
+ linkEntity.url = "https://userver.tech/index.html";
+ return result;
+}
+
+telegram::bot::SendPhotoMethod::Parameters::Photo GreetUser::GreetingPhoto() const {
+ {
+ auto file_id = photo_file_id_.Read();
+ if (!file_id->empty()) {
+ return *file_id;
+ }
+ }
+ return telegram::bot::InputFile{photo_,
+ "/userver_greeting_photo.jpg",
+ "image/jpeg"};
+}
+
+std::shared_ptr<std::string> GreetUser::ReadPhoto(
+ const components::ComponentConfig& config,
+ const components::ComponentContext& context) {
+ const auto fs_tp_name = config["fs-task-processor"].As<std::string>();
+ const auto greeting_photo_path = config["greeting-photo-path"]
+ .As<std::string>();
+ auto& fs_task_processor = context.GetTaskProcessor(fs_tp_name);
+ return std::make_shared<std::string>(
+ fs::ReadFileContents(fs_task_processor, greeting_photo_path));
+}
+
+} // namespace samples::telegram_bot
+
+int main(int argc, char* argv[]) {
+ const auto component_list =
+ components::MinimalServerComponentList()
+ .Append<telegram::bot::TelegramBotClient>()
+ .Append<samples::telegram_bot::GreetUser>()
+ .Append<clients::dns::Component>()
+ .Append<components::HttpClient>()
+ .Append<components::TestsuiteSupport>()
+ .Append<server::handlers::TestsControl>();
+ return utils::DaemonMain(argc, argv, component_list);
+}