Rework the services to be more "fire and forget"

Author: Sella-GH

AzzyBot-Next/Logging/LoggerActions.cs

@@ -23,13 +23,13 @@ public static partial class LoggerActions
     [LoggerMessage(10, LogLevel.Debug, "AzuraCastFileServiceHost started")]
     public static partial void AzuraCastFileServiceHostStart(this ILogger<AzuraCastFileServiceHost> logger);
 
-    [LoggerMessage(11, LogLevel.Debug, "AzuraCastFileService started")]
-    public static partial void AzuraCastFileServiceStart(this ILogger<AzuraCastFileService> logger);
+    [LoggerMessage(11, LogLevel.Debug, "AzuraCastBackgroundService started")]
+    public static partial void AzuraCastBackgroundServiceStart(this ILogger<AzuraCastBackgroundService> logger);
 
     [LoggerMessage(12, LogLevel.Debug, "AzuraCastFileServiceHost running")]
     public static partial void AzuraCastFileServiceHostRun(this ILogger<AzuraCastFileServiceHost> logger);
 
-    [LoggerMessage(13, LogLevel.Debug, "Creating work item for AzuraCastFileService")]
+    [LoggerMessage(13, LogLevel.Debug, "Creating work items...")]
     public static partial void AzuraCastFileServiceWorkItem(this ILogger<AzuraCastFileService> logger);
 
     [LoggerMessage(90, LogLevel.Debug, "Stopping global timer")]

AzzyBot-Next/Services/Modules/AzuraCastBackgroundService.cs

@@ -0,0 +1,33 @@
+using System.Threading;
+using System.Threading.Tasks;
+using AzzyBot.Logging;
+using AzzyBot.Utilities.Enums;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace AzzyBot.Services.Modules;
+
+public sealed class AzuraCastBackgroundService(IHostApplicationLifetime applicationLifetime, ILogger<AzuraCastBackgroundService> logger, AzuraCastFileService azuraCastFileService)
+{
+    private readonly ILogger<AzuraCastBackgroundService> _logger = logger;
+    private readonly AzuraCastFileService _azuraCastFileService = azuraCastFileService;
+    private readonly CancellationToken _cancellationToken = applicationLifetime.ApplicationStopping;
+
+    public async Task StartAzuraCastBackgroundServiceAsync(AzuraCastChecks checks)
+    {
+        _logger.AzuraCastBackgroundServiceStart();
+
+        if (_cancellationToken.IsCancellationRequested)
+            return;
+
+        switch (checks)
+        {
+            case AzuraCastChecks.CheckForUpdates:
+                break;
+
+            case AzuraCastChecks.CheckForFileChanges:
+                await _azuraCastFileService.QueueFileChangesChecksAsync();
+                break;
+        }
+    }
+}

AzzyBot-Next/Services/Modules/AzuraCastFileService.cs

@@ -12,43 +12,34 @@
 using AzzyBot.Services.Interfaces;
 using AzzyBot.Utilities;
 using AzzyBot.Utilities.Encryption;
-using AzzyBot.Utilities.Enums;
 using AzzyBot.Utilities.Records.AzuraCast;
 using DSharpPlus.Entities;
-using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
 namespace AzzyBot.Services.Modules;
 
-public sealed class AzuraCastFileService(IHostApplicationLifetime applicationLifetime, ILogger<AzuraCastFileService> logger, IQueuedBackgroundTask taskQueue, AzuraCastApiService azuraCast, DbActions dbActions, DiscordBotService discordBotService)
+public sealed class AzuraCastFileService(ILogger<AzuraCastFileService> logger, IQueuedBackgroundTask taskQueue, AzuraCastApiService azuraCast, DbActions dbActions, DiscordBotService discordBotService)
 {
     private readonly ILogger<AzuraCastFileService> _logger = logger;
     private readonly IQueuedBackgroundTask _taskQueue = taskQueue;
     private readonly AzuraCastApiService _azuraCast = azuraCast;
     private readonly DbActions _dbActions = dbActions;
     private readonly DiscordBotService _botService = discordBotService;
-    private readonly CancellationToken _cancellationToken = applicationLifetime.ApplicationStopping;
     private readonly JsonSerializerOptions _serializerOptions = new() { WriteIndented = true };
 
-    public void StartAzuraCastFileService(AzuraCastChecks check)
+    public async ValueTask QueueFileChangesChecksAsync()
     {
-        _logger.AzuraCastFileServiceStart();
-
-        if (_cancellationToken.IsCancellationRequested)
-            return;
-
-        switch (check)
+        List<GuildsEntity> guilds = await _dbActions.GetGuildsAsync();
+        foreach (AzuraCastEntity azuraCast in guilds.Where(g => g.AzuraCast is not null).Select(g => g.AzuraCast!))
         {
-            case AzuraCastChecks.CheckForUpdates:
-                break;
-
-            case AzuraCastChecks.CheckForFileChanges:
-                Task.Run(async () => await _taskQueue.QueueBackgroundWorkItemAsync(CheckForFileChangesAsync));
-                break;
+            foreach (AzuraCastStationEntity station in azuraCast.Stations.Where(s => s.Checks.FileChanges))
+            {
+                _ = Task.Run(async () => await _taskQueue.QueueBackgroundWorkItemAsync(async ct => await CheckForFileChangesAsync(station, ct)));
+            }
         }
     }
 
-    private async ValueTask CheckForFileChangesAsync(CancellationToken cancellationToken)
+    private async ValueTask CheckForFileChangesAsync(AzuraCastStationEntity station, CancellationToken cancellationToken)
     {
         _logger.AzuraCastFileServiceWorkItem();
 
@@ -59,19 +50,12 @@ private async ValueTask CheckForFileChangesAsync(CancellationToken cancellationT
 
         try
         {
-            List<GuildsEntity> guilds = await _dbActions.GetGuildsAsync();
-            foreach (AzuraCastEntity azuraCast in guilds.Where(g => g.AzuraCast is not null).Select(g => g.AzuraCast!))
-            {
-                foreach (AzuraCastStationEntity station in azuraCast.Stations.Where(s => s.Checks.FileChanges))
-                {
-                    string apiKey = (string.IsNullOrWhiteSpace(station.ApiKey)) ? azuraCast.AdminApiKey : station.ApiKey;
+            string apiKey = (string.IsNullOrWhiteSpace(station.ApiKey)) ? station.AzuraCast.AdminApiKey : station.ApiKey;
 
-                    IReadOnlyList<FilesRecord> onlineFiles = await _azuraCast.GetFilesOnlineAsync(new(Crypto.Decrypt(azuraCast.BaseUrl)), Crypto.Decrypt(apiKey), station.StationId);
-                    IReadOnlyList<FilesRecord> localFiles = await _azuraCast.GetFilesLocalAsync(station.Id, station.StationId);
+            IReadOnlyList<FilesRecord> onlineFiles = await _azuraCast.GetFilesOnlineAsync(new(Crypto.Decrypt(station.AzuraCast.BaseUrl)), Crypto.Decrypt(apiKey), station.StationId);
+            IReadOnlyList<FilesRecord> localFiles = await _azuraCast.GetFilesLocalAsync(station.Id, station.StationId);
 
-                    await CheckIfFilesWereModifiedAsync(onlineFiles, localFiles, station.Id, station.StationId, Crypto.Decrypt(station.Name), azuraCast.NotificationChannelId);
-                }
-            }
+            await CheckIfFilesWereModifiedAsync(onlineFiles, localFiles, station.Id, station.StationId, Crypto.Decrypt(station.Name), station.AzuraCast.NotificationChannelId);
         }
         catch (OperationCanceledException)
         {

AzzyBot-Next/Services/TimerServiceHost.cs

@@ -11,10 +11,10 @@
 
 namespace AzzyBot.Services;
 
-public sealed class TimerServiceHost(ILogger<TimerServiceHost> logger, AzuraCastFileService azuraCastFileService, DiscordBotService discordBotService, UpdaterService updaterService) : IAsyncDisposable, IHostedService
+public sealed class TimerServiceHost(ILogger<TimerServiceHost> logger, AzuraCastBackgroundService azuraCastBackgroundService, DiscordBotService discordBotService, UpdaterService updaterService) : IAsyncDisposable, IHostedService
 {
     private readonly ILogger<TimerServiceHost> _logger = logger;
-    private readonly AzuraCastFileService _azuraCastFileService = azuraCastFileService;
+    private readonly AzuraCastBackgroundService _azuraCastBackgroundService = azuraCastBackgroundService;
     private readonly DiscordBotService _discordBotService = discordBotService;
     private readonly UpdaterService _updaterService = updaterService;
     private readonly bool _isDev = AzzyStatsSoftware.GetBotEnvironment == Environments.Development;
@@ -69,7 +69,7 @@ private async void TimerTimeoutAsync(object? o)
                 _logger.GlobalTimerCheckForAzuraCastFiles();
                 _lastAzuraCastFileCheck = now;
 
-                _azuraCastFileService.StartAzuraCastFileService(AzuraCastChecks.CheckForFileChanges);
+                await _azuraCastBackgroundService.StartAzuraCastBackgroundServiceAsync(AzuraCastChecks.CheckForFileChanges);
             }
         }
         catch (Exception ex)