🐗 Migrate away from deprecated QueuedUpdateReceiver

Author: database64128

CubicBot.Telegram/BotService.cs

@@ -2,7 +2,6 @@
 using Microsoft.Extensions.Logging;
 using Telegram.Bot;
 using Telegram.Bot.Exceptions;
-using Telegram.Bot.Polling;
 using Telegram.Bot.Types;
 
 namespace CubicBot.Telegram;
@@ -85,28 +84,27 @@ private async Task RunBotAsync(CancellationToken cancellationToken = default)
 
         logger.LogInformation("Started Telegram bot: @{BotUsername} ({BotId})", me.Username, me.Id);
 
-        var updateReceiver = new QueuedUpdateReceiver(bot, null, updateHandler.HandleErrorAsync);
         var saveDataTask = SaveDataHourlyAsync(data, cancellationToken);
 
         try
         {
-            await updateHandler.HandleUpdateStreamAsync(bot, updateReceiver, cancellationToken);
+            await updateHandler.RunAsync(bot, cancellationToken);
         }
         finally
         {
             await saveDataTask;
         }
     }
 
+    private static readonly TimeSpan s_saveDataInterval = TimeSpan.FromHours(1);
+
     private async Task SaveDataHourlyAsync(Data data, CancellationToken cancellationToken = default)
     {
-        TimeSpan interval = TimeSpan.FromHours(1);
-
         while (!cancellationToken.IsCancellationRequested)
         {
             try
             {
-                await Task.Delay(interval, cancellationToken);
+                await Task.Delay(s_saveDataInterval, cancellationToken);
             }
             catch (TaskCanceledException)
             {

CubicBot.Telegram/UpdateHandler.cs

@@ -50,40 +50,63 @@ public async Task RegisterCommandsAsync(ITelegramBotClient botClient, Cancellati
     [LoggerMessage(Level = LogLevel.Information, Message = "Registered {CommandCount} bot commands")]
     private partial void LogRegisteredCommands(int commandCount);
 
-    public async Task HandleUpdateStreamAsync(ITelegramBotClient botClient, IAsyncEnumerable<Update> updates, CancellationToken cancellationToken = default)
+    public async Task RunAsync(ITelegramBotClient botClient, CancellationToken cancellationToken = default)
     {
-        await foreach (var update in updates.WithCancellation(cancellationToken))
+        while (!cancellationToken.IsCancellationRequested)
         {
-            LogReceivedUpdate(update.Id, update.Type);
+            try
+            {
+                Update[] updates = await botClient.GetUpdates(allowedUpdates: [UpdateType.Message], cancellationToken: cancellationToken);
+                foreach (Update update in updates)
+                {
+                    LogReceivedUpdate(update.Id, update.Type);
+
+                    if (update.Type == UpdateType.Message && update.Message is Message message)
+                    {
+                        var messageContext = new MessageContext(botClient, message, _data);
 
-            if (update.Type == UpdateType.Message && update.Message is not null)
+                        foreach (var dispatch in _dispatches)
+                        {
+                            _ = dispatch.HandleAsync(messageContext, cancellationToken)
+                                        .ContinueWith(t =>
+                                        {
+                                            if (t?.Exception?.InnerException is not null)
+                                            {
+                                                LogFailedToHandleUpdate(t.Exception.InnerException);
+                                            }
+                                        }, TaskContinuationOptions.OnlyOnFaulted);
+                        }
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                return;
+            }
+            catch (Exception ex)
             {
-                var messageContext = new MessageContext(botClient, update.Message, _data);
+                LogFailedToReceiveUpdates(ex);
 
-                foreach (var dispatch in _dispatches)
+                try
+                {
+                    await Task.Delay(s_delayOnError, cancellationToken);
+                }
+                catch (TaskCanceledException)
                 {
-                    _ = dispatch.HandleAsync(messageContext, cancellationToken)
-                                .ContinueWith(t =>
-                                {
-                                    if (t?.Exception?.InnerException is not null)
-                                    {
-                                        HandleError(t.Exception.InnerException);
-                                    }
-                                }, TaskContinuationOptions.OnlyOnFaulted);
+                    return;
                 }
             }
         }
     }
 
+    private static readonly TimeSpan s_delayOnError = TimeSpan.FromSeconds(5);
+
     [LoggerMessage(Level = LogLevel.Trace, Message = "Received update with ID {UpdateId} and type {UpdateType}")]
     private partial void LogReceivedUpdate(int updateId, UpdateType updateType);
 
-    public Task HandleErrorAsync(Exception ex, CancellationToken _ = default)
-    {
-        HandleError(ex);
-        return Task.CompletedTask;
-    }
+    [LoggerMessage(Level = LogLevel.Warning, Message = "Failed to receive updates")]
+    private partial void LogFailedToReceiveUpdates(Exception ex);
 
     [LoggerMessage(Level = LogLevel.Warning, Message = "Failed to handle update")]
-    private partial void HandleError(Exception ex);
+    private partial void LogFailedToHandleUpdate(Exception ex);
 }