Fix blocklist provider reporting wrong number of loaded blocklists (#293)

code/backend/Cleanuparr.Api/Controllers/ConfigurationController.cs

@@ -1173,6 +1173,9 @@ public class ConfigurationController : ControllerBase
                 }
             }
             
+            // Handle logging configuration changes
+            var loggingChanged = HasLoggingConfigurationChanged(oldConfig.Log, newConfig.Log);
+            
             newConfig.Adapt(oldConfig, config);
 
             // Persist the configuration
@@ -1185,9 +1188,6 @@ public class ConfigurationController : ControllerBase
             dynamicHttpClientFactory.UpdateAllClientsFromGeneralConfig(oldConfig);
             
             _logger.LogInformation("Updated all HTTP client configurations with new general settings");
-
-            // Handle logging configuration changes
-            var loggingChanged = HasLoggingConfigurationChanged(oldConfig.Log, newConfig.Log);
             
             if (loggingChanged.LevelOnly)
             {

code/backend/Cleanuparr.Infrastructure/Features/MalwareBlocker/BlocklistProvider.cs

@@ -41,6 +41,29 @@ public sealed class BlocklistProvider
         _httpClient = httpClientFactory.CreateClient(Constants.HttpClientWithRetryName);
     }
 
+    private async Task<bool> EnsureInstanceLoadedAsync(BlocklistSettings settings, InstanceType instanceType)
+    {
+        if (!settings.Enabled || string.IsNullOrEmpty(settings.BlocklistPath))
+        {
+            return false;
+        }
+
+        string hash = GenerateSettingsHash(settings);
+        var interval = GetLoadInterval(settings.BlocklistPath);
+        var identifier = $"{instanceType}_{settings.BlocklistPath}";
+
+        if (ShouldReloadBlocklist(identifier, interval) || !_configHashes.TryGetValue(instanceType, out string? oldHash) || hash != oldHash)
+        {
+            _logger.LogDebug("Loading {instance} blocklist", instanceType);
+            await LoadPatternsAndRegexesAsync(settings, instanceType);
+            _configHashes[instanceType] = hash;
+            _lastLoadTimes[identifier] = DateTime.UtcNow;
+            return true;
+        }
+
+        return false;
+    }
+
     public async Task LoadBlocklistsAsync()
     {
         try
@@ -58,74 +81,21 @@ public sealed class BlocklistProvider
                 return;
             }
             
-            // Check and update Sonarr blocklist if needed
-            string sonarrHash = GenerateSettingsHash(malwareBlockerConfig.Sonarr);
-            var sonarrInterval = GetLoadInterval(malwareBlockerConfig.Sonarr.BlocklistPath);
-            var sonarrIdentifier = $"Sonarr_{malwareBlockerConfig.Sonarr.BlocklistPath}";
-            if (ShouldReloadBlocklist(sonarrIdentifier, sonarrInterval) || !_configHashes.TryGetValue(InstanceType.Sonarr, out string? oldSonarrHash) || sonarrHash != oldSonarrHash)
+            var instances = new Dictionary<InstanceType, BlocklistSettings>
             {
-                _logger.LogDebug("Loading Sonarr blocklist");
-                
-                await LoadPatternsAndRegexesAsync(malwareBlockerConfig.Sonarr, InstanceType.Sonarr);
-                _configHashes[InstanceType.Sonarr] = sonarrHash;
-                _lastLoadTimes[sonarrIdentifier] = DateTime.UtcNow;
-                changedCount++;
-            }
-            
-            // Check and update Radarr blocklist if needed
-            string radarrHash = GenerateSettingsHash(malwareBlockerConfig.Radarr);
-            var radarrInterval = GetLoadInterval(malwareBlockerConfig.Radarr.BlocklistPath);
-            var radarrIdentifier = $"Radarr_{malwareBlockerConfig.Radarr.BlocklistPath}";
-            if (ShouldReloadBlocklist(radarrIdentifier, radarrInterval) || !_configHashes.TryGetValue(InstanceType.Radarr, out string? oldRadarrHash) || radarrHash != oldRadarrHash)
+                { InstanceType.Sonarr, malwareBlockerConfig.Sonarr },
+                { InstanceType.Radarr, malwareBlockerConfig.Radarr },
+                { InstanceType.Lidarr, malwareBlockerConfig.Lidarr },
+                { InstanceType.Readarr, malwareBlockerConfig.Readarr },
+                { InstanceType.Whisparr, malwareBlockerConfig.Whisparr }
+            };
+
+            foreach (var kv in instances)
             {
-                _logger.LogDebug("Loading Radarr blocklist");
-                
-                await LoadPatternsAndRegexesAsync(malwareBlockerConfig.Radarr, InstanceType.Radarr);
-                _configHashes[InstanceType.Radarr] = radarrHash;
-                _lastLoadTimes[radarrIdentifier] = DateTime.UtcNow;
-                changedCount++;
-            }
-            
-            // Check and update Lidarr blocklist if needed
-            string lidarrHash = GenerateSettingsHash(malwareBlockerConfig.Lidarr);
-            var lidarrInterval = GetLoadInterval(malwareBlockerConfig.Lidarr.BlocklistPath);
-            var lidarrIdentifier = $"Lidarr_{malwareBlockerConfig.Lidarr.BlocklistPath}";
-            if (ShouldReloadBlocklist(lidarrIdentifier, lidarrInterval) || !_configHashes.TryGetValue(InstanceType.Lidarr, out string? oldLidarrHash) || lidarrHash != oldLidarrHash)
-            {
-                _logger.LogDebug("Loading Lidarr blocklist");
-                
-                await LoadPatternsAndRegexesAsync(malwareBlockerConfig.Lidarr, InstanceType.Lidarr);
-                _configHashes[InstanceType.Lidarr] = lidarrHash;
-                _lastLoadTimes[lidarrIdentifier] = DateTime.UtcNow;
-                changedCount++;
-            }
-            
-            // Check and update Readarr blocklist if needed
-            string readarrHash = GenerateSettingsHash(malwareBlockerConfig.Readarr);
-            var readarrInterval = GetLoadInterval(malwareBlockerConfig.Readarr.BlocklistPath);
-            var readarrIdentifier = $"Readarr_{malwareBlockerConfig.Readarr.BlocklistPath}";
-            if (ShouldReloadBlocklist(readarrIdentifier, readarrInterval) || !_configHashes.TryGetValue(InstanceType.Readarr, out string? oldReadarrHash) || readarrHash != oldReadarrHash)
-            {
-                _logger.LogDebug("Loading Readarr blocklist");
-                
-                await LoadPatternsAndRegexesAsync(malwareBlockerConfig.Readarr, InstanceType.Readarr);
-                _configHashes[InstanceType.Readarr] = readarrHash;
-                _lastLoadTimes[readarrIdentifier] = DateTime.UtcNow;
-                changedCount++;
-            }
-            
-            // Check and update Whisparr blocklist if needed
-            string whisparrHash = GenerateSettingsHash(malwareBlockerConfig.Whisparr);
-            var whisparrInterval = GetLoadInterval(malwareBlockerConfig.Whisparr.BlocklistPath);
-            var whisparrIdentifier = $"Whisparr_{malwareBlockerConfig.Whisparr.BlocklistPath}";
-            if (ShouldReloadBlocklist(whisparrIdentifier, whisparrInterval) || !_configHashes.TryGetValue(InstanceType.Whisparr, out string? oldWhisparrHash) || whisparrHash != oldWhisparrHash)
-            {
-                _logger.LogDebug("Loading Whisparr blocklist");
-                
-                await LoadPatternsAndRegexesAsync(malwareBlockerConfig.Whisparr, InstanceType.Whisparr);
-                _configHashes[InstanceType.Whisparr] = whisparrHash;
-                _lastLoadTimes[whisparrIdentifier] = DateTime.UtcNow;
-                changedCount++;
+                if (await EnsureInstanceLoadedAsync(kv.Value, kv.Key))
+                {
+                    changedCount++;
+                }
             }
             
             // Always check and update malware patterns
@@ -315,7 +285,7 @@ public sealed class BlocklistProvider
     private string GenerateSettingsHash(BlocklistSettings blocklistSettings)
     {
         // Create a string that represents the relevant blocklist configuration
-        var configStr = $"{blocklistSettings.BlocklistPath ?? string.Empty}|{blocklistSettings.BlocklistType}";
+        var configStr = $"{blocklistSettings.Enabled}|{blocklistSettings.BlocklistPath ?? string.Empty}|{blocklistSettings.BlocklistType}";
         
         // Create SHA256 hash of the configuration string
         using var sha = SHA256.Create();

code/backend/Cleanuparr.Infrastructure/Logging/LoggingConfigManager.cs

@@ -32,6 +32,7 @@ public static class LoggingConfigManager
     {
         using var context = DataContext.CreateStaticInstance();
         var config = context.GeneralConfigs.AsNoTracking().First();
+        SetLogLevel(config.Log.Level);
         
         const string categoryTemplate = "{#if Category is not null} {Concat('[',Category,']'),CAT_PAD}{#end}";
         const string jobNameTemplate = "{#if JobName is not null} {Concat('[',JobName,']'),JOB_PAD}{#end}";