Merge pull request #23 from xpsony/multiInstance_serilog

Multi *Arr Instance Support , Add Serilog for better logging, Add Fluent Validator

README.md

@@ -33,6 +33,7 @@ Einige Beispiele finden sich [weiter unten](https://github.com/PCJones/UmlautAda
 | Anfragen-Caching für 12 Minuten zur Reduzierung der API-Zugriffe   | ✓             |
 | Usenet (newznab) Support                                          |✓|
 | Torrent (torznab) Support                                         |✓|
+| Support von meheren *arrs Instanzen                               | ✓             
 | Radarr Support                                                    | Geplant       |
 | Prowlarr Unterstützung für "DE" SceneNZBs Kategorien              | Geplant       |
 | Unterstützung weiterer Sprachen neben Deutsch                     | Geplant       |

UmlautAdaptarr/Interfaces/IArrApplication.cs

@@ -0,0 +1,10 @@
+using UmlautAdaptarr.Models;
+
+namespace UmlautAdaptarr.Interfaces;
+
+public interface IArrApplication
+{
+    Task<IEnumerable<SearchItem>> FetchAllItemsAsync();
+    Task<SearchItem?> FetchItemByExternalIdAsync(string externalId);
+    Task<SearchItem?> FetchItemByTitleAsync(string title);
+}

UmlautAdaptarr/Models/IpInfo.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+
+namespace UmlautAdaptarr.Utilities;
+
+public class IpInfo
+{
+    [JsonPropertyName("ip")]
+    public string Ip { get; set; }
+
+    [JsonPropertyName("hostname")]
+    public string Hostname { get; set; }
+
+    [JsonPropertyName("city")]
+    public string City { get; set; }
+
+    [JsonPropertyName("region")]
+    public string Region { get; set; }
+
+    [JsonPropertyName("country")]
+    public string Country { get; set; }
+
+    [JsonPropertyName("loc")]
+    public string Loc { get; set; }
+
+    [JsonPropertyName("org")]
+    public string Org { get; set; }
+
+    [JsonPropertyName("postal")]
+    public string Postal { get; set; }
+
+    [JsonPropertyName("timezone")]
+    public string Timezone { get; set; }
+}

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/GlobalInstanceOptions.cs

@@ -1,15 +1,17 @@
-namespace UmlautAdaptarr.Options.ArrOptions
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions
 {
-    /// <summary>
+    public class GlobalInstanceOptions
-    /// Base Options for ARR applications
-    /// </summary>
-    public class ArrApplicationBaseOptions
     {
         /// <summary>
         /// Indicates whether the Arr application is enabled.
         /// </summary>
         public bool Enabled { get; set; }
 
+        /// <summary>
+        /// Name of the Instance
+        /// </summary>
+        public string Name { get; set; }
+
         /// <summary>
         /// The host of the ARR application.
         /// </summary>

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/LidarrInstanceOptions.cs

@@ -0,0 +1,6 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+public class LidarrInstanceOptions : GlobalInstanceOptions
+{
+    
+}

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/ReadarrInstanceOptions.cs

@@ -0,0 +1,6 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+public class ReadarrInstanceOptions : GlobalInstanceOptions
+{
+    
+}

UmlautAdaptarr/Options/ArrOptions/InstanceOptions/SonarrInstanceOptions.cs

@@ -0,0 +1,6 @@
+namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+public class SonarrInstanceOptions : GlobalInstanceOptions
+{
+    
+}

UmlautAdaptarr/Options/ArrOptions/LidarrInstanceOptions.cs

@@ -1,9 +0,0 @@
-namespace UmlautAdaptarr.Options.ArrOptions
-{
-    /// <summary>
-    /// Lidarr Options
-    /// </summary>
-    public class LidarrInstanceOptions : ArrApplicationBaseOptions
-    {
-    }
-}

UmlautAdaptarr/Options/ArrOptions/ReadarrInstanceOptions.cs

@@ -1,9 +0,0 @@
-namespace UmlautAdaptarr.Options.ArrOptions
-{
-    /// <summary>
-    /// Readarr Options
-    /// </summary>
-    public class ReadarrInstanceOptions : ArrApplicationBaseOptions
-    {
-    }
-}

UmlautAdaptarr/Options/ArrOptions/SonarrInstanceOptions.cs

@@ -1,9 +0,0 @@
-namespace UmlautAdaptarr.Options.ArrOptions
-{
-    /// <summary>
-    /// Sonarr Options
-    /// </summary>
-    public class SonarrInstanceOptions : ArrApplicationBaseOptions
-    {
-    }
-}

UmlautAdaptarr/Program.cs

@@ -1,27 +1,45 @@
 using System.Net;
+using Serilog;
+using Serilog.Filters;
 using UmlautAdaptarr.Options;
 using UmlautAdaptarr.Routing;
 using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Services.Factory;
 using UmlautAdaptarr.Utilities;
 
 internal class Program
 {
     private static void Main(string[] args)
     {
+
+
+        Helper.ShowLogo();
+        Helper.ShowInformation();
         // TODO:
         // add option to sort by nzb age
-
+        var builder = WebApplication.CreateBuilder(args);
-    
-       var builder = WebApplication.CreateBuilder(args);
-
         var configuration = builder.Configuration;
 
+        // TODO workaround to not log api keys
+        Log.Logger = new LoggerConfiguration()
+            .ReadFrom.Configuration(configuration)
+            .WriteTo.Console(outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
+            .Filter.ByExcluding(Matching.FromSource("System.Net.Http.HttpClient"))
+            .Filter.ByExcluding(Matching.FromSource("Microsoft.Extensions.Http.DefaultHttpClientFactory"))
+            //.Enrich.With(new ApiKeyMaskingEnricher("appsettings.json")) // Not Work currently
+            .CreateLogger();
+
+
+
+        builder.Services.AddSerilog();
+
         // Add services to the container.
         builder.Services.AddHttpClient("HttpClient").ConfigurePrimaryHttpMessageHandler(() =>
         {
             var handler = new HttpClientHandler
             {
-                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate | DecompressionMethods.Brotli
+                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate |
+                                         DecompressionMethods.Brotli
             };
 
             var proxyOptions = configuration.GetSection("Proxy").Get<ProxyOptions>();
@@ -35,20 +53,8 @@ internal class Program
             //options.SizeLimit = 20000;
         });
 
-
+        builder.Services.AllowResolvingKeyedServicesAsDictionary();
-        // TODO workaround to not log api keys
-        builder.Logging.AddFilter((category, level) =>
-        {
-            // Prevent logging of HTTP request and response if the category is HttpClient
-            if (category.Contains("System.Net.Http.HttpClient") || category.Contains("Microsoft.Extensions.Http.DefaultHttpClientFactory"))
-            {
-                return false;
-            }
-            return true;
-        });
-
         builder.Services.AddControllers();
-        builder.Services.AddHostedService<ArrSyncBackgroundService>();
         builder.AddTitleLookupService();
         builder.Services.AddSingleton<SearchItemLookupService>();
         builder.Services.AddSingleton<TitleMatchingService>();
@@ -57,6 +63,8 @@ internal class Program
         builder.AddReadarrSupport();
         builder.Services.AddSingleton<CacheService>();
         builder.Services.AddSingleton<ProxyRequestService>();
+        builder.Services.AddSingleton<ArrApplicationFactory>();
+        builder.Services.AddHostedService<ArrSyncBackgroundService>();
         builder.Services.AddSingleton<IHostedService, HttpProxyService>();
 
         var app = builder.Build();
@@ -65,36 +73,35 @@ internal class Program
         app.UseHttpsRedirection();
         app.UseAuthorization();
 
-        app.MapControllerRoute(name: "caps",
+        app.MapControllerRoute("caps",
-                pattern: "{options}/{*domain}",
+            "{options}/{*domain}",
-                defaults: new { controller = "Caps", action = "Caps" },
+            new { controller = "Caps", action = "Caps" },
-                constraints: new { t = new TRouteConstraint("caps") });
+            new { t = new TRouteConstraint("caps") });
 
-        app.MapControllerRoute(name: "movie-search",
+        app.MapControllerRoute("movie-search",
-                pattern: "{options}/{*domain}",
+            "{options}/{*domain}",
-                defaults: new { controller = "Search", action = "MovieSearch" },
+            new { controller = "Search", action = "MovieSearch" },
-                constraints: new { t = new TRouteConstraint("movie") });
+            new { t = new TRouteConstraint("movie") });
 
-        app.MapControllerRoute(name: "tv-search",
+        app.MapControllerRoute("tv-search",
-                pattern: "{options}/{*domain}",
+            "{options}/{*domain}",
-                defaults: new { controller = "Search", action = "TVSearch" },
+            new { controller = "Search", action = "TVSearch" },
-                constraints: new { t = new TRouteConstraint("tvsearch") });
+            new { t = new TRouteConstraint("tvsearch") });
 
-        app.MapControllerRoute(name: "music-search",
+        app.MapControllerRoute("music-search",
-                pattern: "{options}/{*domain}",
+            "{options}/{*domain}",
-                defaults: new { controller = "Search", action = "MusicSearch" },
+            new { controller = "Search", action = "MusicSearch" },
-                constraints: new { t = new TRouteConstraint("music") });
+            new { t = new TRouteConstraint("music") });
 
-        app.MapControllerRoute(name: "book-search",
+        app.MapControllerRoute("book-search",
-               pattern: "{options}/{*domain}",
+            "{options}/{*domain}",
-               defaults: new { controller = "Search", action = "BookSearch" },
+            new { controller = "Search", action = "BookSearch" },
-               constraints: new { t = new TRouteConstraint("book") });
+            new { t = new TRouteConstraint("book") });
-
-        app.MapControllerRoute(name: "generic-search",
-                pattern: "{options}/{*domain}",
-                defaults: new { controller = "Search", action = "GenericSearch" },
-                constraints: new { t = new TRouteConstraint("search") });
 
+        app.MapControllerRoute("generic-search",
+            "{options}/{*domain}",
+            new { controller = "Search", action = "GenericSearch" },
+            new { t = new TRouteConstraint("search") });
         app.Run();
     }
 }

UmlautAdaptarr/Providers/ArrClientBase.cs

@@ -1,13 +1,12 @@
-using Microsoft.Extensions.Caching.Memory;
+using UmlautAdaptarr.Interfaces;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Services;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public abstract class ArrClientBase : IArrApplication
 {
-    public abstract class ArrClientBase()
+    public string InstanceName;
-    {
+    public abstract Task<IEnumerable<SearchItem>> FetchAllItemsAsync();
-        public abstract Task<IEnumerable<SearchItem>> FetchAllItemsAsync();
+    public abstract Task<SearchItem?> FetchItemByExternalIdAsync(string externalId);
-        public abstract Task<SearchItem?> FetchItemByExternalIdAsync(string externalId);
+    public abstract Task<SearchItem?> FetchItemByTitleAsync(string title);
-        public abstract Task<SearchItem?> FetchItemByTitleAsync(string title);
-    }
 }

UmlautAdaptarr/Providers/ArrClientFactory.cs

@@ -1,17 +0,0 @@
-namespace UmlautAdaptarr.Providers
-{
-    public static class ArrClientFactory
-    {
-        // TODO, still uses old IConfiguration
-        // TODO not used yet
-        public static IEnumerable<TClient> CreateClients<TClient>(
-            Func<string, TClient> constructor, IConfiguration configuration, string configKey) where TClient : ArrClientBase
-        {
-            var hosts = configuration.GetValue<string>(configKey)?.Split(',') ?? throw new ArgumentException($"{configKey} environment variable must be set if the app is enabled");
-            foreach (var host in hosts)
-            {
-                yield return constructor(host.Trim());
-            }
-        }
-    }
-}

UmlautAdaptarr/Providers/LidarrClient.cs

@@ -1,149 +1,168 @@
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Options.ArrOptions;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public class LidarrClient : ArrClientBase
 {
-    public class LidarrClient(
+    private readonly IMemoryCache _cache;
+    private readonly CacheService _cacheService;
+    private readonly IHttpClientFactory _clientFactory;
+    private readonly ILogger<LidarrClient> _logger;
+    private readonly string _mediaType = "audio";
+
+    public LidarrClient([ServiceKey] string instanceName,
         IHttpClientFactory clientFactory,
         CacheService cacheService,
-        IMemoryCache cache,
+        IMemoryCache cache, IOptionsMonitor<LidarrInstanceOptions> options,
-        ILogger<LidarrClient> logger, IOptions<LidarrInstanceOptions> options) : ArrClientBase()
+        ILogger<LidarrClient> logger)
     {
-        public LidarrInstanceOptions LidarrOptions { get; } = options.Value;
+        _clientFactory = clientFactory;
-        private readonly string _mediaType = "audio";
+        _cacheService = cacheService;
+        _cache = cache;
+        _logger = logger;
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init Lidarr ({InstanceName})");
+    }
 
-        public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+    public LidarrInstanceOptions Options { get; init; }
+
+
+    public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+    {
+        var httpClient = _clientFactory.CreateClient();
+        var items = new List<SearchItem>();
+
+        try
         {
-            var httpClient = clientFactory.CreateClient();
+            var lidarrArtistsUrl = $"{Options.Host}/api/v1/artist?apikey={Options.ApiKey}";
-            var items = new List<SearchItem>();
+            _logger.LogInformation(
+                $"Fetching all artists from Lidarr ({InstanceName}) : {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
+            var artistsApiResponse = await httpClient.GetStringAsync(lidarrArtistsUrl);
+            var artists = JsonConvert.DeserializeObject<List<dynamic>>(artistsApiResponse);
 
-            try
+            if (artists == null)
             {
-                var lidarrArtistsUrl = $"{LidarrOptions.Host}/api/v1/artist?apikey={LidarrOptions.ApiKey}";
+                _logger.LogError($"Lidarr ({InstanceName}) artists API request resulted in null");
-                logger.LogInformation($"Fetching all artists from Lidarr: {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
+                return items;
-                var artistsApiResponse = await httpClient.GetStringAsync(lidarrArtistsUrl);
+            }
-                var artists = JsonConvert.DeserializeObject<List<dynamic>>(artistsApiResponse);
 
-                if (artists == null)
+            _logger.LogInformation($"Successfully fetched {artists.Count} artists from Lidarr ({InstanceName}).");
+            foreach (var artist in artists)
+            {
+                var artistId = (int)artist.id;
+
+                var lidarrAlbumUrl = $"{Options.Host}/api/v1/album?artistId={artistId}&apikey={Options.ApiKey}";
+
+                // TODO add caching here
+                // Disable cache for now as it can result in problems when adding new albums that aren't displayed on the artists page initially
+                //if (cache.TryGetValue(lidarrAlbumUrl, out List<dynamic>? albums))
+                //{
+                //    logger.LogInformation($"Using cached albums for {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
+                //}
+                //else
+                //{
+                _logger.LogInformation(
+                    $"Fetching all albums from artistId {artistId} from Lidarr ({InstanceName}) : {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
+                var albumApiResponse = await httpClient.GetStringAsync(lidarrAlbumUrl);
+                var albums = JsonConvert.DeserializeObject<List<dynamic>>(albumApiResponse);
+                //}
+
+                if (albums == null)
                 {
-                    logger.LogError($"Lidarr artists API request resulted in null");
+                    _logger.LogWarning(
-                    return items;
+                        $"Lidarr ({InstanceName}) album API request for artistId {artistId} resulted in null");
-                }
+                    continue;
-                logger.LogInformation($"Successfully fetched {artists.Count} artists from Lidarr.");
-                foreach (var artist in artists)
-                {
-                    var artistId = (int)artist.id;
-
-                    var lidarrAlbumUrl = $"{LidarrOptions.Host}/api/v1/album?artistId={artistId}&apikey={LidarrOptions.ApiKey}";
-
-                    // TODO add caching here
-                    // Disable cache for now as it can result in problems when adding new albums that aren't displayed on the artists page initially
-                    //if (cache.TryGetValue(lidarrAlbumUrl, out List<dynamic>? albums))
-                    //{
-                    //    logger.LogInformation($"Using cached albums for {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
-                    //}
-                    //else
-                    //{
-                    logger.LogInformation($"Fetching all albums from artistId {artistId} from Lidarr: {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
-                    var albumApiResponse = await httpClient.GetStringAsync(lidarrAlbumUrl);
-                    var albums = JsonConvert.DeserializeObject<List<dynamic>>(albumApiResponse);
-                    //}
-
-                    if (albums == null)
-                    {
-                        logger.LogWarning($"Lidarr album API request for artistId {artistId} resulted in null");
-                        continue;
-                    }
-
-                    logger.LogInformation($"Successfully fetched {albums.Count} albums for artistId {artistId} from Lidarr.");
-
-                    // Cache albums for 3 minutes
-                    cache.Set(lidarrAlbumUrl, albums, TimeSpan.FromMinutes(3));
-
-                    foreach (var album in albums)
-                    {
-                        var artistName = (string)album.artist.artistName;
-                        var albumTitle = (string)album.title;
-
-                        var expectedTitle = $"{artistName} {albumTitle}";
-
-                        string[]? aliases = null;
-
-                        // Abuse externalId to set the search string Lidarr uses
-                        var externalId = expectedTitle.GetLidarrTitleForExternalId();
-
-                        var searchItem = new SearchItem
-                        (
-                            arrId: artistId,
-                            externalId: externalId,
-                            title: albumTitle,
-                            expectedTitle: albumTitle,
-                            germanTitle: null,
-                            aliases: aliases,
-                            mediaType: _mediaType,
-                            expectedAuthor: artistName
-                        );
-
-                        items.Add(searchItem);
-                    }
                 }
 
-                logger.LogInformation($"Finished fetching all items from Lidarr");
+                _logger.LogInformation(
-            }
+                    $"Successfully fetched {albums.Count} albums for artistId {artistId} from Lidarr ({InstanceName}).");
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching all artists from Lidarr: {ex.Message}");
-            }
 
-            return items;
+                // Cache albums for 3 minutes
-        }
+                _cache.Set(lidarrAlbumUrl, albums, TimeSpan.FromMinutes(3));
 
-        public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
+                foreach (var album in albums)
-        {
-            try
-            {
-                // For now we have to fetch all items every time
-                // TODO if possible look at the author in search query and only update for author
-                var searchItems = await FetchAllItemsAsync();
-                foreach (var searchItem in searchItems ?? [])
                 {
-                    try
+                    var artistName = (string)album.artist.artistName;
-                    {
+                    var albumTitle = (string)album.title;
-                        cacheService.CacheSearchItem(searchItem);
+
-                    }
+                    var expectedTitle = $"{artistName} {albumTitle}";
-                    catch (Exception ex)
+
-                    {
+                    string[]? aliases = null;
-                        logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
+
-                    }
+                    // Abuse externalId to set the search string Lidarr uses
+                    var externalId = expectedTitle.GetLidarrTitleForExternalId();
+
+                    var searchItem = new SearchItem
+                    (
+                        artistId,
+                        externalId,
+                        albumTitle,
+                        albumTitle,
+                        null,
+                        aliases: aliases,
+                        mediaType: _mediaType,
+                        expectedAuthor: artistName
+                    );
+
+                    items.Add(searchItem);
                 }
             }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single artist from Lidarr: {ex.Message}");
-            }
 
-            return null;
+            _logger.LogInformation($"Finished fetching all items from Lidarr ({InstanceName})");
         }
-
+        catch (Exception ex)
-        public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
         {
-            try
+            _logger.LogError($"Error fetching all artists from Lidarr ({InstanceName}) : {ex.Message}");
-            {
-                // this should never be called at the moment
-                throw new NotImplementedException();
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single artist from Lidarr: {ex.Message}");
-            }
-
-            return null;
         }
+
+        return items;
+    }
+
+    public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
+    {
+        try
+        {
+            // For now we have to fetch all items every time
+            // TODO if possible look at the author in search query and only update for author
+            var searchItems = await FetchAllItemsAsync();
+            foreach (var searchItem in searchItems ?? [])
+                try
+                {
+                    _cacheService.CacheSearchItem(searchItem);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex,
+                        $"An error occurred while caching search item with ID {searchItem.ArrId} in Lidarr ({InstanceName}).");
+                }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single artist from Lidarr ({InstanceName}) : {ex.Message}");
+        }
+
+        return null;
+    }
+
+    public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
+    {
+        try
+        {
+            // this should never be called at the moment
+            throw new NotImplementedException();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single artist from Lidarr ({InstanceName}): {ex.Message}");
+        }
+
+        return null;
     }
 }

UmlautAdaptarr/Providers/ReadarrClient.cs

@@ -1,174 +1,186 @@
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Options.ArrOptions;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public class ReadarrClient : ArrClientBase
 {
-    public class ReadarrClient(
+    private readonly IMemoryCache _cache;
-        IHttpClientFactory clientFactory,
+    private readonly CacheService _cacheService;
+    private readonly IHttpClientFactory _clientFactory;
+    private readonly ILogger<ReadarrClient> _logger;
+    private readonly string _mediaType = "book";
+
+    public ReadarrClient([ServiceKey] string instanceName, IHttpClientFactory clientFactory,
         CacheService cacheService,
         IMemoryCache cache,
-        IOptions<ReadarrInstanceOptions> options,
+        IOptionsMonitor<ReadarrInstanceOptions> options,
-        ILogger<ReadarrClient> logger) : ArrClientBase()
+        ILogger<ReadarrClient> logger)
     {
+        _clientFactory = clientFactory;
+        _cacheService = cacheService;
+        _cache = cache;
+        _logger = logger;
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init ReadarrClient ({InstanceName})");
+    }
 
-        public ReadarrInstanceOptions ReadarrOptions { get; } = options.Value;
+    public ReadarrInstanceOptions Options { get; init; }
-        private readonly string _mediaType = "book";
 
-        public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+    public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+    {
+        var httpClient = _clientFactory.CreateClient();
+        var items = new List<SearchItem>();
+
+        try
         {
-            var httpClient = clientFactory.CreateClient();
+            var readarrAuthorUrl = $"{Options.Host}/api/v1/author?apikey={Options.ApiKey}";
-            var items = new List<SearchItem>();
+            _logger.LogInformation(
+                $"Fetching all authors from Readarr ({InstanceName}) : {UrlUtilities.RedactApiKey(readarrAuthorUrl)}");
+            var authorApiResponse = await httpClient.GetStringAsync(readarrAuthorUrl);
+            var authors = JsonConvert.DeserializeObject<List<dynamic>>(authorApiResponse);
 
-            try
+            if (authors == null)
             {
-                var readarrAuthorUrl = $"{ReadarrOptions.Host}/api/v1/author?apikey={ReadarrOptions.ApiKey}";
+                _logger.LogError($"Readarr ({InstanceName}) authors API request resulted in null");
-                logger.LogInformation($"Fetching all authors from Readarr: {UrlUtilities.RedactApiKey(readarrAuthorUrl)}");
+                return items;
-                var authorApiResponse = await httpClient.GetStringAsync(readarrAuthorUrl);
+            }
-                var authors = JsonConvert.DeserializeObject<List<dynamic>>(authorApiResponse);
 
-                if (authors == null)
+            _logger.LogInformation($"Successfully fetched {authors.Count} authors from Readarr ({InstanceName}).");
+            foreach (var author in authors)
+            {
+                var authorId = (int)author.id;
+
+                var readarrBookUrl = $"{Options.Host}/api/v1/book?authorId={authorId}&apikey={Options.ApiKey}";
+
+                // TODO add caching here
+                _logger.LogInformation(
+                    $"Fetching all books from authorId {authorId} from Readarr ({InstanceName}) : {UrlUtilities.RedactApiKey(readarrBookUrl)}");
+                var bookApiResponse = await httpClient.GetStringAsync(readarrBookUrl);
+                var books = JsonConvert.DeserializeObject<List<dynamic>>(bookApiResponse);
+
+                if (books == null)
                 {
-                    logger.LogError($"Readarr authors API request resulted in null");
+                    _logger.LogWarning(
-                    return items;
+                        $"Readarr ({InstanceName}) book API request for authorId {authorId} resulted in null");
-                }
+                    continue;
-                logger.LogInformation($"Successfully fetched {authors.Count} authors from Readarr.");
-                foreach (var author in authors)
-                {
-                    var authorId = (int)author.id;
-
-                    var readarrBookUrl = $"{ReadarrOptions.Host}/api/v1/book?authorId={authorId}&apikey={ReadarrOptions.ApiKey}";
-
-                    // TODO add caching here
-                    logger.LogInformation($"Fetching all books from authorId {authorId} from Readarr: {UrlUtilities.RedactApiKey(readarrBookUrl)}");
-                    var bookApiResponse = await httpClient.GetStringAsync(readarrBookUrl);
-                    var books = JsonConvert.DeserializeObject<List<dynamic>>(bookApiResponse);
-
-                    if (books == null)
-                    {
-                        logger.LogWarning($"Readarr book API request for authorId {authorId} resulted in null");
-                        continue;
-                    }
-
-                    logger.LogInformation($"Successfully fetched {books.Count} books for authorId {authorId} from Readarr.");
-
-                    // Cache books for 3 minutes
-                    cache.Set(readarrBookUrl, books, TimeSpan.FromMinutes(3));
-
-                    foreach (var book in books)
-                    {
-                        var authorName = (string)author.authorName;
-                        var bookTitle = GetSearchBookTitle((string)book.title, authorName);
-
-                        var expectedTitle = $"{bookTitle} {authorName}";
-
-                        string[]? aliases = null;
-
-                        // Abuse externalId to set the search string Readarr uses
-                        // TODO use own method or rename
-                        var externalId = expectedTitle.GetReadarrTitleForExternalId();
-
-                        var searchItem = new SearchItem
-                        (
-                            arrId: authorId,
-                            externalId: externalId,
-                            title: bookTitle,
-                            expectedTitle: bookTitle,
-                            germanTitle: null,
-                            aliases: aliases,
-                            mediaType: _mediaType,
-                            expectedAuthor: authorName
-                        );
-
-                        items.Add(searchItem);
-                    }
                 }
 
-                logger.LogInformation($"Finished fetching all items from Readarr");
+                _logger.LogInformation(
-            }
+                    $"Successfully fetched {books.Count} books for authorId {authorId} from Readarr ({InstanceName}) .");
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching all authors from Readarr: {ex.Message}");
-            }
 
-            return items;
+                // Cache books for 3 minutes
-        }
+                _cache.Set(readarrBookUrl, books, TimeSpan.FromMinutes(3));
 
-        // Logic based on https://github.com/Readarr/Readarr/blob/develop/src/NzbDrone.Core/Parser/Parser.cs#L541
+                foreach (var book in books)
-        public static string GetSearchBookTitle(string bookTitle, string authorName)
-        {
-            // Remove author prefix from title if present, e.g., "Tom Clancy: Ghost Protocol"
-            if (!string.IsNullOrEmpty(authorName) && bookTitle.StartsWith($"{authorName}:"))
-            {
-                bookTitle = bookTitle[(authorName.Length + 1)..].Trim();
-            }
-
-            // Remove subtitles or additional info enclosed in parentheses or following a colon, if any
-            int firstParenthesisIndex = bookTitle.IndexOf('(');
-            int firstColonIndex = bookTitle.IndexOf(':');
-
-            if (firstParenthesisIndex > -1)
-            {
-                int endParenthesisIndex = bookTitle.IndexOf(')', firstParenthesisIndex);
-                if (endParenthesisIndex > -1 && bookTitle.Substring(firstParenthesisIndex + 1, endParenthesisIndex - firstParenthesisIndex - 1).Contains(' '))
                 {
-                    bookTitle = bookTitle[..firstParenthesisIndex].Trim();
+                    var authorName = (string)author.authorName;
+                    var bookTitle = GetSearchBookTitle((string)book.title, authorName);
+
+                    var expectedTitle = $"{bookTitle} {authorName}";
+
+                    string[]? aliases = null;
+
+                    // Abuse externalId to set the search string Readarr uses
+                    // TODO use own method or rename
+                    var externalId = expectedTitle.GetReadarrTitleForExternalId();
+
+                    var searchItem = new SearchItem
+                    (
+                        authorId,
+                        externalId,
+                        bookTitle,
+                        bookTitle,
+                        null,
+                        aliases: aliases,
+                        mediaType: _mediaType,
+                        expectedAuthor: authorName
+                    );
+
+                    items.Add(searchItem);
                 }
             }
-            else if (firstColonIndex > -1)
-            {
-                bookTitle = bookTitle[..firstColonIndex].Trim();
-            }
 
-            return bookTitle;
+            _logger.LogInformation($"Finished fetching all items from Readarr ({InstanceName})");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching all authors from Readarr ({InstanceName}): {ex.Message}");
         }
 
+        return items;
+    }
 
-        public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
+    // Logic based on https://github.com/Readarr/Readarr/blob/develop/src/NzbDrone.Core/Parser/Parser.cs#L541
+    public static string GetSearchBookTitle(string bookTitle, string authorName)
+    {
+        // Remove author prefix from title if present, e.g., "Tom Clancy: Ghost Protocol"
+        if (!string.IsNullOrEmpty(authorName) && bookTitle.StartsWith($"{authorName}:"))
+            bookTitle = bookTitle[(authorName.Length + 1)..].Trim();
+
+        // Remove subtitles or additional info enclosed in parentheses or following a colon, if any
+        var firstParenthesisIndex = bookTitle.IndexOf('(');
+        var firstColonIndex = bookTitle.IndexOf(':');
+
+        if (firstParenthesisIndex > -1)
         {
-            try
+            var endParenthesisIndex = bookTitle.IndexOf(')', firstParenthesisIndex);
-            {
+            if (endParenthesisIndex > -1 && bookTitle
-                // For now we have to fetch all items every time
+                    .Substring(firstParenthesisIndex + 1, endParenthesisIndex - firstParenthesisIndex - 1)
-                // TODO if possible look at the author in search query and only update for author
+                    .Contains(' ')) bookTitle = bookTitle[..firstParenthesisIndex].Trim();
-                var searchItems = await FetchAllItemsAsync();
+        }
-                foreach (var searchItem in searchItems ?? [])
+        else if (firstColonIndex > -1)
+        {
+            bookTitle = bookTitle[..firstColonIndex].Trim();
+        }
+
+        return bookTitle;
+    }
+
+
+    public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
+    {
+        try
+        {
+            // For now we have to fetch all items every time
+            // TODO if possible look at the author in search query and only update for author
+            var searchItems = await FetchAllItemsAsync();
+            foreach (var searchItem in searchItems ?? [])
+                try
                 {
-                    try
+                    _cacheService.CacheSearchItem(searchItem);
-                    {
+                }
-                        cacheService.CacheSearchItem(searchItem);
+                catch (Exception ex)
-                    }
+                {
-                    catch (Exception ex)
+                    _logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
-                    {
-                        logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
-                    }
                 }
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single author from Readarr: {ex.Message}");
-            }
-
-            return null;
         }
-
+        catch (Exception ex)
-        public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
         {
-            try
+            _logger.LogError($"Error fetching single author from Readarr ({InstanceName}) : {ex.Message}");
-            {
-                // this should never be called at the moment
-                throw new NotImplementedException();
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single author from Readarr: {ex.Message}");
-            }
-
-            return null;
         }
+
+        return null;
+    }
+
+    public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
+    {
+        try
+        {
+            // this should never be called at the moment
+            throw new NotImplementedException();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single author from Readarr ({InstanceName}) : {ex.Message}");
+        }
+
+        return null;
     }
 }

UmlautAdaptarr/Providers/SonarrClient.cs

@@ -1,171 +1,192 @@
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Options.ArrOptions;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Services;
 using UmlautAdaptarr.Utilities;
 
-namespace UmlautAdaptarr.Providers
+namespace UmlautAdaptarr.Providers;
+
+public class SonarrClient : ArrClientBase
 {
-    public class SonarrClient(
+    private readonly IHttpClientFactory _clientFactory;
+    private readonly ILogger<SonarrClient> _logger;
+
+    private readonly string _mediaType = "tv";
+    private readonly TitleApiService _titleService;
+
+
+    public SonarrClient([ServiceKey] string instanceName,
         IHttpClientFactory clientFactory,
         TitleApiService titleService,
-        IOptions<SonarrInstanceOptions> options,
+        IOptionsMonitor<SonarrInstanceOptions> options,
-        ILogger<SonarrClient> logger) : ArrClientBase()
+        ILogger<SonarrClient> logger)
     {
-        public SonarrInstanceOptions SonarrOptions { get; } = options.Value;
+        _clientFactory = clientFactory;
-        private readonly string _mediaType = "tv";
+        _titleService = titleService;
+        _logger = logger;
 
-        public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+        InstanceName = instanceName;
+        Options = options.Get(InstanceName);
+        _logger.LogInformation($"Init SonarrClient ({InstanceName})");
+    }
+
+    public SonarrInstanceOptions Options { get; init; }
+
+    public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
+    {
+        var httpClient = _clientFactory.CreateClient();
+        var items = new List<SearchItem>();
+
+        try
         {
-            var httpClient = clientFactory.CreateClient();
+            var sonarrUrl = $"{Options.Host}/api/v3/series?includeSeasonImages=false&apikey={Options.ApiKey}";
-            var items = new List<SearchItem>();
+            _logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
+            var response = await httpClient.GetStringAsync(sonarrUrl);
+            var shows = JsonConvert.DeserializeObject<List<dynamic>>(response);
 
-            try
+            if (shows != null)
             {
-                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
+                _logger.LogInformation($"Successfully fetched {shows.Count} items from Sonarr ({InstanceName}).");
-                logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
+                foreach (var show in shows)
-                var response = await httpClient.GetStringAsync(sonarrUrl);
-                var shows = JsonConvert.DeserializeObject<List<dynamic>>(response);
-
-                if (shows != null)
-                {
-                    logger.LogInformation($"Successfully fetched {shows.Count} items from Sonarr.");
-                    foreach (var show in shows)
-                    {
-                        var tvdbId = (string)show.tvdbId;
-                        if (tvdbId == null)
-                        {
-                            logger.LogWarning($"Sonarr Show {show.id} doesn't have a tvdbId.");
-                            continue;
-                        }
-
-                        (var germanTitle, var aliases) = await titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
-                        var searchItem = new SearchItem
-                        (
-                            arrId: (int)show.id,
-                            externalId: tvdbId,
-                            title: (string)show.title,
-                            expectedTitle: (string)show.title,
-                            germanTitle: germanTitle,
-                            aliases: aliases,
-                            mediaType: _mediaType
-                        );
-
-                        items.Add(searchItem);
-                    }
-                }
-
-                logger.LogInformation($"Finished fetching all items from Sonarr");
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching all shows from Sonarr: {ex.Message}");
-            }
-
-            return items;
-        }
-
-        public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
-        {
-            var httpClient = clientFactory.CreateClient();
-
-            try
-            {
-                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
-                logger.LogInformation($"Fetching item by external ID from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
-                var response = await httpClient.GetStringAsync(sonarrUrl);
-                var shows = JsonConvert.DeserializeObject<dynamic>(response);
-                var show = shows?[0];
-
-                if (show != null)
                 {
                     var tvdbId = (string)show.tvdbId;
                     if (tvdbId == null)
                     {
-                        logger.LogWarning($"Sonarr Show {show.id} doesn't have a tvdbId.");
+                        _logger.LogWarning($"Sonarr ({InstanceName}) Show {show.id} doesn't have a tvdbId.");
-                        return null;
+                        continue;
                     }
-                    (var germanTitle, var aliases) = await titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
 
+                    var (germanTitle, aliases) =
+                        await _titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
                     var searchItem = new SearchItem
                     (
-                        arrId: (int)show.id,
+                        (int)show.id,
-                        externalId: tvdbId,
+                        tvdbId,
-                        title: (string)show.title,
+                        (string)show.title,
-                        expectedTitle: (string)show.title,
+                        (string)show.title,
-                        germanTitle: germanTitle,
+                        germanTitle,
                         aliases: aliases,
                         mediaType: _mediaType
                     );
 
-                    logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr.");
+                    items.Add(searchItem);
-                    return searchItem;
                 }
             }
-            catch (Exception ex)
-            {
-                logger.LogError($"Error fetching single show from Sonarr: {ex.Message}");
-            }
 
-            return null;
+            _logger.LogInformation($"Finished fetching all items from Sonarr ({InstanceName})");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching all shows from Sonarr ({InstanceName}) : {ex.Message}");
         }
 
-        public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
+        return items;
+    }
+
+    public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
+    {
+        var httpClient = _clientFactory.CreateClient();
+
+        try
         {
-            var httpClient = clientFactory.CreateClient();
+            var sonarrUrl =
+                $"{Options.Host}/api/v3/series?tvdbId={externalId}&includeSeasonImages=false&apikey={Options.ApiKey}";
+            _logger.LogInformation(
+                $"Fetching item by external ID from Sonarr ({InstanceName}): {UrlUtilities.RedactApiKey(sonarrUrl)}");
+            var response = await httpClient.GetStringAsync(sonarrUrl);
+            var shows = JsonConvert.DeserializeObject<dynamic>(response);
+            var show = shows?[0];
 
-            try
+            if (show != null)
             {
-                (string? germanTitle, string? tvdbId, string[]? aliases) = await titleService.FetchGermanTitleAndExternalIdAndAliasesByTitle(_mediaType, title);
+                var tvdbId = (string)show.tvdbId;
-
                 if (tvdbId == null)
                 {
+                    _logger.LogWarning($"Sonarr ({InstanceName}) Show {show.id} doesn't have a tvdbId.");
                     return null;
                 }
 
-                var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
+                var (germanTitle, aliases) =
-                var sonarrApiResponse = await httpClient.GetStringAsync(sonarrUrl);
+                    await _titleService.FetchGermanTitleAndAliasesByExternalIdAsync(_mediaType, tvdbId);
-                var shows = JsonConvert.DeserializeObject<dynamic>(sonarrApiResponse);
-
-                if (shows == null)
-                {
-                    logger.LogError($"Parsing Sonarr API response for TVDB ID {tvdbId} resulted in null");
-                    return null;
-                }
-                else if (shows.Count == 0)
-                {
-                    logger.LogWarning($"No results found for TVDB ID {tvdbId}");
-                    return null;
-                }
-
-                var expectedTitle = (string)shows[0].title;
-                if (expectedTitle == null)
-                {
-                    logger.LogError($"Sonarr Title for TVDB ID {tvdbId} is null");
-                    return null;
-                }
 
                 var searchItem = new SearchItem
                 (
-                    arrId: (int)shows[0].id,
+                    (int)show.id,
-                    externalId: tvdbId,
+                    tvdbId,
-                    title: (string)shows[0].title,
+                    (string)show.title,
-                    expectedTitle: (string)shows[0].title,
+                    (string)show.title,
-                    germanTitle: germanTitle,
+                    germanTitle,
                     aliases: aliases,
                     mediaType: _mediaType
                 );
 
-                logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr.");
+                _logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr ({InstanceName}).");
                 return searchItem;
             }
-            catch (Exception ex)
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single show from Sonarr ({InstanceName}): {ex.Message}");
+        }
+
+        return null;
+    }
+
+    public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
+    {
+        var httpClient = _clientFactory.CreateClient();
+
+        try
+        {
+            var (germanTitle, tvdbId, aliases) =
+                await _titleService.FetchGermanTitleAndExternalIdAndAliasesByTitle(_mediaType, title);
+
+            if (tvdbId == null) return null;
+
+            var sonarrUrl =
+                $"{Options.Host}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={Options.ApiKey}";
+            var sonarrApiResponse = await httpClient.GetStringAsync(sonarrUrl);
+            var shows = JsonConvert.DeserializeObject<dynamic>(sonarrApiResponse);
+
+            if (shows == null)
             {
-                logger.LogError($"Error fetching single show from Sonarr: {ex.Message}");
+                _logger.LogError($"Parsing Sonarr ({InstanceName}) API response for TVDB ID {tvdbId} resulted in null");
+                return null;
             }
 
-            return null;
+            if (shows.Count == 0)
+            {
+                _logger.LogWarning($"No results found for TVDB ID {tvdbId}");
+                return null;
+            }
+
+            var expectedTitle = (string)shows[0].title;
+            if (expectedTitle == null)
+            {
+                _logger.LogError($"Sonarr ({InstanceName}) : Title for TVDB ID {tvdbId} is null");
+                return null;
+            }
+
+            var searchItem = new SearchItem
+            (
+                (int)shows[0].id,
+                tvdbId,
+                (string)shows[0].title,
+                (string)shows[0].title,
+                germanTitle,
+                aliases: aliases,
+                mediaType: _mediaType
+            );
+
+            _logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr ({InstanceName}).");
+            return searchItem;
         }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error fetching single show from Sonarr ({InstanceName}) : {ex.Message}");
+        }
+
+        return null;
     }
 }

UmlautAdaptarr/Services/ArrSyncBackgroundService.cs

@@ -1,145 +1,170 @@
-using Microsoft.Extensions.Caching.Memory;
+using UmlautAdaptarr.Models;
-using Microsoft.Extensions.DependencyInjection;
+using UmlautAdaptarr.Services.Factory;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Newtonsoft.Json;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using UmlautAdaptarr.Models;
-using UmlautAdaptarr.Providers;
 
-namespace UmlautAdaptarr.Services
+namespace UmlautAdaptarr.Services;
+
+public class ArrSyncBackgroundService(
+    ArrApplicationFactory arrApplicationFactory,
+    CacheService cacheService,
+    ILogger<ArrSyncBackgroundService> logger)
+    : BackgroundService
 {
-    public class ArrSyncBackgroundService(
+    public ArrApplicationFactory ArrApplicationFactory { get; } = arrApplicationFactory;
-        SonarrClient sonarrClient,
+
-        LidarrClient lidarrClient,
+
-        ReadarrClient readarrClient,
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-        CacheService cacheService,
-        ILogger<ArrSyncBackgroundService> logger) : BackgroundService
     {
-        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        logger.LogInformation("ArrSyncBackgroundService is starting.");
+        var lastRunSuccess = true;
+
+        while (!stoppingToken.IsCancellationRequested)
         {
-            logger.LogInformation("ArrSyncBackgroundService is starting.");
+            logger.LogInformation("ArrSyncBackgroundService is running.");
-            bool lastRunSuccess = true;
+            var syncSuccess = await FetchAndUpdateDataAsync();
+            logger.LogInformation("ArrSyncBackgroundService has completed an iteration.");
 
-            while (!stoppingToken.IsCancellationRequested)
+            if (syncSuccess)
             {
-                logger.LogInformation("ArrSyncBackgroundService is running.");
+                lastRunSuccess = true;
-                var syncSuccess = await FetchAndUpdateDataAsync();
+                await Task.Delay(TimeSpan.FromHours(12), stoppingToken);
-                logger.LogInformation("ArrSyncBackgroundService has completed an iteration.");
+            }
-
+            else
-                if (syncSuccess)
+            {
+                if (lastRunSuccess)
                 {
-                    lastRunSuccess = true;
+                    lastRunSuccess = false;
-                    await Task.Delay(TimeSpan.FromHours(12), stoppingToken);
+                    logger.LogInformation(
+                        "ArrSyncBackgroundService is trying again in 2 minutes because not all syncs were successful.");
+                    await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);
                 }
                 else
                 {
-                    if (lastRunSuccess)
+                    logger.LogInformation(
-                    {
+                        "ArrSyncBackgroundService is trying again in one hour only because not all syncs were successful twice in a row.");
-                        lastRunSuccess = false;
+                    await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
-                        logger.LogInformation("ArrSyncBackgroundService is trying again in 2 minutes because not all syncs were successful.");
-                        await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);
-                    }
-                    else
-                    {
-                        logger.LogInformation("ArrSyncBackgroundService is trying again in one hour only because not all syncs were successful twice in a row.");
-                        await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
-                    }
                 }
             }
-
-            logger.LogInformation("ArrSyncBackgroundService is stopping.");
         }
 
-        private async Task<bool> FetchAndUpdateDataAsync()
+        logger.LogInformation("ArrSyncBackgroundService is stopping.");
+    }
+
+    private async Task<bool> FetchAndUpdateDataAsync()
+    {
+        try
         {
+            var success = true;
+
+
+            if (ArrApplicationFactory.SonarrInstances.Any())
+            {
+                var syncSuccess = await FetchItemsFromSonarrAsync();
+                success = success && syncSuccess;
+            }
+
+            if (ArrApplicationFactory.ReadarrInstances.Any())
+            {
+                var syncSuccess = await FetchItemsFromReadarrAsync();
+                success = success && syncSuccess;
+            }
+
+            if (ArrApplicationFactory.ReadarrInstances.Any())
+            {
+                var syncSuccess = await FetchItemsFromLidarrAsync();
+                success = success && syncSuccess;
+            }
+
+
+            return success;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An error occurred while fetching items from the Arrs.");
+        }
+
+        return false;
+    }
+
+    private async Task<bool> FetchItemsFromSonarrAsync()
+    {
+        try
+        {
+            var items = new List<SearchItem>();
+
+            foreach (var sonarrClient in ArrApplicationFactory.SonarrInstances)
+            {
+                var result = await sonarrClient.FetchAllItemsAsync();
+                items = items.Union(result).ToList();
+            }
+
+
+            UpdateSearchItems(items);
+            return items?.Any() ?? false;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An error occurred while updating search item from Sonarr.");
+        }
+
+        return false;
+    }
+
+    private async Task<bool> FetchItemsFromLidarrAsync()
+    {
+        try
+        {
+            var items = new List<SearchItem>();
+
+            foreach (var lidarrClient in ArrApplicationFactory.LidarrInstances)
+            {
+                var result = await lidarrClient.FetchAllItemsAsync();
+                items = items.Union(result).ToList();
+            }
+
+            UpdateSearchItems(items);
+            return items?.Any() ?? false;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
+        }
+
+        return false;
+    }
+
+    private async Task<bool> FetchItemsFromReadarrAsync()
+    {
+        try
+        {
+            var items = new List<SearchItem>();
+
+            foreach (var readarrClient in ArrApplicationFactory.ReadarrInstances)
+            {
+                var result = await readarrClient.FetchAllItemsAsync();
+                items = items.Union(result).ToList();
+            }
+
+            UpdateSearchItems(items);
+            return items?.Any() ?? false;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
+        }
+
+        return false;
+    }
+
+    private void UpdateSearchItems(IEnumerable<SearchItem>? searchItems)
+    {
+        foreach (var searchItem in searchItems ?? [])
             try
             {
-                var success = true;
+                cacheService.CacheSearchItem(searchItem);
-                if (readarrClient.ReadarrOptions.Enabled)
-                {
-                    var syncSuccess = await FetchItemsFromReadarrAsync();
-                    success = success && syncSuccess;
-                }
-                if (sonarrClient.SonarrOptions.Enabled)
-                {
-                    var syncSuccess = await FetchItemsFromSonarrAsync();
-                    success = success && syncSuccess;
-                }
-                if (lidarrClient.LidarrOptions.Enabled)
-                {
-                    var syncSuccess = await FetchItemsFromLidarrAsync();
-                    success = success && syncSuccess;
-                }
-                return success;
             }
             catch (Exception ex)
             {
-                logger.LogError(ex, "An error occurred while fetching items from the Arrs.");
+                logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
             }
-            return false;
-        }
-
-        private async Task<bool> FetchItemsFromSonarrAsync()
-        {
-            try
-            {
-                var items = await sonarrClient.FetchAllItemsAsync();
-                UpdateSearchItems(items);
-                return items?.Any()?? false;
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "An error occurred while updating search item from Sonarr.");
-            }
-            return false;
-        }
-
-        private async Task<bool> FetchItemsFromLidarrAsync()
-        {
-            try
-            {
-                var items = await lidarrClient.FetchAllItemsAsync();
-                UpdateSearchItems(items);
-                return items?.Any() ?? false;
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
-            }
-            return false;
-        }
-
-        private async Task<bool> FetchItemsFromReadarrAsync()
-        {
-            try
-            {
-                var items = await readarrClient.FetchAllItemsAsync();
-                UpdateSearchItems(items);
-                return items?.Any() ?? false;
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
-            }
-            return false;
-        }
-
-        private void UpdateSearchItems(IEnumerable<SearchItem>? searchItems)
-        {
-            foreach (var searchItem in searchItems ?? [])
-            {
-                try
-                {
-                    cacheService.CacheSearchItem(searchItem);
-                }
-                catch (Exception ex)
-                {
-                    logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
-                }
-            }
-        }
     }
 }

UmlautAdaptarr/Services/Factory/ArrApplicationFactory.cs

@@ -0,0 +1,77 @@
+using UmlautAdaptarr.Interfaces;
+using UmlautAdaptarr.Providers;
+
+namespace UmlautAdaptarr.Services.Factory
+{
+    /// <summary>
+    /// Factory for creating RrApplication instances.
+    /// </summary>
+    public class ArrApplicationFactory
+    {
+        private readonly ILogger<ArrApplicationFactory> _logger;
+
+        /// <summary>
+        /// Get all IArrApplication instances.
+        /// </summary>
+        public IDictionary<string, IArrApplication> AllInstances { get; init; }
+
+        /// <summary>
+        /// Get all SonarrClient instances.
+        /// </summary>
+        public IEnumerable<SonarrClient> SonarrInstances { get; init; }
+
+        /// <summary>
+        /// Get all LidarrClient instances.
+        /// </summary>
+        public IEnumerable<LidarrClient> LidarrInstances { get; init; }
+
+        /// <summary>
+        /// Get all ReadarrClient instances.
+        /// </summary>
+        public IEnumerable<ReadarrClient> ReadarrInstances { get; init; }
+
+        /// <summary>
+        /// Constructor for the ArrApplicationFactory.
+        /// </summary>
+        /// <param name="rrArrApplications">A dictionary of IArrApplication instances.</param>
+        /// <param name="logger">Logger Instanz</param>
+        public ArrApplicationFactory(IDictionary<string, IArrApplication> rrArrApplications, ILogger<ArrApplicationFactory> logger)
+        {
+            _logger = logger;
+            try
+            {
+                SonarrInstances = rrArrApplications.Values.OfType<SonarrClient>();
+                LidarrInstances = rrArrApplications.Values.OfType<LidarrClient>();
+                ReadarrInstances = rrArrApplications.Values.OfType<ReadarrClient>();
+                AllInstances = rrArrApplications;
+
+                if (!AllInstances.Values.Any())
+                {
+                    throw new Exception("No RrApplication could be successfully initialized. This could be due to a faulty configuration");
+                }
+            }
+            catch (Exception e)
+            {
+                _logger.LogError("Error while Register ArrFactory. This might be a Config Problem", e.Message);
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Returns an IArrApplication instance that matches the given name.
+        /// </summary>
+        /// <param name="nameOfArrInstance">The name of the IArrApplication instance being sought.</param>
+        /// <returns>The IArrApplication instance that matches the given name.</returns>
+        /// <exception cref="ArgumentException">Thrown when no IArrApplication instance with the given name can be found.</exception>
+        public IArrApplication GetArrInstanceByName(string nameOfArrInstance)
+        {
+            var instance = AllInstances.FirstOrDefault(up => up.Key.Equals(nameOfArrInstance)).Value;
+            if (instance == null)
+            {
+                throw new ArgumentException($"No ArrService with the name {nameOfArrInstance} could be found");
+            }
+
+            return instance;
+        }
+    }
+}

UmlautAdaptarr/Services/SearchItemLookupService.cs

@@ -1,12 +1,11 @@
 using UmlautAdaptarr.Models;
 using UmlautAdaptarr.Providers;
+using UmlautAdaptarr.Services.Factory;
 
 namespace UmlautAdaptarr.Services
 {
     public class SearchItemLookupService(CacheService cacheService,
-                                         SonarrClient sonarrClient,
+        ArrApplicationFactory arrApplicationFactory)
-                                         ReadarrClient readarrClient,
-                                         LidarrClient lidarrClient)
     {
         public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId)
         {
@@ -22,23 +21,40 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    if (sonarrClient.SonarrOptions.Enabled)
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+
+                    if (sonarrInstances.Any())
                     {
-                        fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
+                        foreach (var sonarrClient in sonarrInstances)
+                        {
+                            fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
+                        }
                     }
                     break;
                 case "audio":
-                    if (lidarrClient.LidarrOptions.Enabled)
+
+                    var lidarrInstances = arrApplicationFactory.LidarrInstances;
+
+                    if (lidarrInstances.Any())
                     {
-                        await lidarrClient.FetchItemByExternalIdAsync(externalId);
+                        foreach (var lidarrClient in lidarrInstances)
-                        fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        {
+                            await lidarrClient.FetchItemByExternalIdAsync(externalId);
+                            fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        }
                     }
                     break;
                 case "book":
-                    if (readarrClient.ReadarrOptions.Enabled)
+
+                    var readarrInstances = arrApplicationFactory.ReadarrInstances;
+                    if (readarrInstances.Any())
                     {
-                        await readarrClient.FetchItemByExternalIdAsync(externalId);
+                        foreach (var readarrClient in readarrInstances)
-                        fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        {
+                            await readarrClient.FetchItemByExternalIdAsync(externalId);
+                            fetchedItem = cacheService.GetSearchItemByExternalId(mediaType, externalId);
+                        }
                     }
                     break;
             }
@@ -66,7 +82,9 @@ namespace UmlautAdaptarr.Services
             switch (mediaType)
             {
                 case "tv":
-                    if (sonarrClient.SonarrOptions.Enabled)
+
+                    var sonarrInstances = arrApplicationFactory.SonarrInstances;
+                    foreach (var sonarrClient in sonarrInstances)
                     {
                         fetchedItem = await sonarrClient.FetchItemByTitleAsync(title);
                     }

UmlautAdaptarr/UmlautAdaptarr.csproj

@@ -9,9 +9,12 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="11.9.1" />
+    <PackageReference Include="IL.FluentValidation.Extensions.Options" Version="11.0.2" />
     <PackageReference Include="Microsoft.Extensions.Options" Version="8.0.2" />
     <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="Serilog.AspNetCore" Version="8.0.1" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
   </ItemGroup>
 

UmlautAdaptarr/Utilities/ApiKeyMaskingEnricher.cs

@@ -0,0 +1,69 @@
+using System.Collections;
+using System.Text.RegularExpressions;
+using Serilog.Core;
+using Serilog.Events;
+
+namespace UmlautAdaptarr.Utilities;
+
+public class ApiKeyMaskingEnricher : ILogEventEnricher
+{
+    private readonly List<string> apiKeys = new();
+
+    public ApiKeyMaskingEnricher(string appsetting)
+    {
+        ExtractApiKeysFromAppSettings(appsetting);
+        ExtractApiKeysFromEnvironmentVariables();
+        apiKeys = new List<string>(apiKeys.Distinct());
+    }
+
+    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+    {
+        //if (logEvent.Properties.TryGetValue("apikey", out var value) && value is ScalarValue scalarValue)
+        //{
+            var maskedValue = new ScalarValue("**Hidden Api Key**");
+            foreach (var apikey in apiKeys) logEvent.AddOrUpdateProperty(new LogEventProperty(apikey, maskedValue));
+       // }
+    }
+
+
+    /// <summary>
+    ///     Scan all Env Variabels for known Apikeys
+    /// </summary>
+    /// <returns>List of all Apikeys</returns>
+    public List<string> ExtractApiKeysFromEnvironmentVariables()
+    {
+        var envVariables = Environment.GetEnvironmentVariables();
+
+        foreach (DictionaryEntry envVariable in envVariables)
+            if (envVariable.Key.ToString()!.Contains("ApiKey"))
+                apiKeys.Add(envVariable.Value.ToString());
+
+        return apiKeys;
+    }
+
+
+    public List<string> ExtractApiKeysFromAppSettings(string filePath)
+    {
+        try
+        {
+            if (File.Exists(filePath))
+            {
+                var fileContent = File.ReadAllText(filePath);
+
+                var pattern = "\"ApiKey\": \"(.*?)\"";
+                var regex = new Regex(pattern);
+                var matches = regex.Matches(fileContent);
+
+                foreach (Match match in matches) apiKeys.Add(match.Groups[1].Value);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.Message);
+        }
+
+        return apiKeys;
+    }
+}
+
+

UmlautAdaptarr/Utilities/Helper.cs

@@ -0,0 +1,88 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UmlautAdaptarr.Utilities;
+
+public static class Helper
+{
+    public static void ShowLogo()
+    {
+        Console.WriteLine(
+            "\r\n _   _           _             _    ___      _             _                  \r\n| | | |         | |           | |  / _ \\    | |           | |                 \r\n| | | |_ __ ___ | | __ _ _   _| |_/ /_\\ \\ __| | __ _ _ __ | |_ __ _ _ __ _ __ \r\n| | | | '_ ` _ \\| |/ _` | | | | __|  _  |/ _` |/ _` | '_ \\| __/ _` | '__| '__|\r\n| |_| | | | | | | | (_| | |_| | |_| | | | (_| | (_| | |_) | || (_| | |  | |   \r\n \\___/|_| |_| |_|_|\\__,_|\\__,_|\\__\\_| |_/\\__,_|\\__,_| .__/ \\__\\__,_|_|  |_|   \r\n                                                    | |                       \r\n                                                    |_|                       \r\n");
+    }
+
+    public static void ShowInformation()
+    {
+        Console.WriteLine("--------------------------[IP Leak Test]-----------------------------");
+        var ipInfo = GetPublicIpAddressInfoAsync().GetAwaiter().GetResult();
+
+        if (ipInfo != null)
+        {
+            Console.WriteLine($"Your Public IP Address is '{ipInfo.Ip}'");
+            Console.WriteLine($"Hostname: {ipInfo.Hostname}");
+            Console.WriteLine($"City: {ipInfo.City}");
+            Console.WriteLine($"Region: {ipInfo.Region}");
+            Console.WriteLine($"Country: {ipInfo.Country}");
+            Console.WriteLine($"Provider: {ipInfo.Org}");
+        }
+        else
+        {
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine("Error: Could not retrieve public IP information.");
+            Console.ResetColor();
+        }
+
+        Console.WriteLine("--------------------------------------------------------------------");
+    }
+
+
+    private static async Task<IpInfo?> GetPublicIpAddressInfoAsync()
+    {
+        using (var client = new HttpClient())
+        {
+            client.Timeout = TimeSpan.FromSeconds(10);
+
+            try
+            {
+                var response = await client.GetAsync("https://ipinfo.io/json");
+                response.EnsureSuccessStatusCode();
+                var content = await response.Content.ReadAsStringAsync();
+                return JsonSerializer.Deserialize<IpInfo>(content);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+    }
+}
+
+public class IpInfo
+{
+    [JsonPropertyName("ip")]
+    public string Ip { get; set; }
+
+    [JsonPropertyName("hostname")]
+    public string Hostname { get; set; }
+
+    [JsonPropertyName("city")]
+    public string City { get; set; }
+
+    [JsonPropertyName("region")]
+    public string Region { get; set; }
+
+    [JsonPropertyName("country")]
+    public string Country { get; set; }
+
+    [JsonPropertyName("loc")]
+    public string Loc { get; set; }
+
+    [JsonPropertyName("org")]
+    public string Org { get; set; }
+
+    [JsonPropertyName("postal")]
+    public string Postal { get; set; }
+
+    [JsonPropertyName("timezone")]
+    public string Timezone { get; set; }
+}

UmlautAdaptarr/Utilities/KeyedServiceExtensions.cs

@@ -0,0 +1,74 @@
+using System.Collections;
+using System.Collections.ObjectModel;
+
+namespace UmlautAdaptarr.Utilities
+{
+    // License: This code is published under the MIT license.
+    // Source: https://stackoverflow.com/questions/77559201/
+    public static class KeyedServiceExtensions
+    {
+        public static void AllowResolvingKeyedServicesAsDictionary(
+            this IServiceCollection sc)
+        {
+            // KeyedServiceCache caches all the keys of a given type for a
+            // specific service type. By making it a singleton we only have
+            // determine the keys once, which makes resolving the dict very fast.
+            sc.AddSingleton(typeof(KeyedServiceCache<,>));
+
+            // KeyedServiceCache depends on the IServiceCollection to get
+            // the list of keys. That's why we register that here as well, as it
+            // is not registered by default in MS.DI.
+            sc.AddSingleton(sc);
+
+            // Last we make the registration for the dictionary itself, which maps
+            // to our custom type below. This registration must be  transient, as
+            // the containing services could have any lifetime and this registration
+            // should by itself not cause Captive Dependencies.
+            sc.AddTransient(typeof(IDictionary<,>), typeof(KeyedServiceDictionary<,>));
+
+            // For completeness, let's also allow IReadOnlyDictionary to be resolved.
+            sc.AddTransient(
+                typeof(IReadOnlyDictionary<,>), typeof(KeyedServiceDictionary<,>));
+        }
+
+        // We inherit from ReadOnlyDictionary, to disallow consumers from changing
+        // the wrapped dependencies while reusing all its functionality. This way
+        // we don't have to implement IDictionary<T,V> ourselves; too much work.
+        private sealed class KeyedServiceDictionary<TKey, TService>(
+            KeyedServiceCache<TKey, TService> keys, IServiceProvider provider)
+            : ReadOnlyDictionary<TKey, TService>(Create(keys, provider))
+            where TKey : notnull
+            where TService : notnull
+        {
+            private static Dictionary<TKey, TService> Create(
+                KeyedServiceCache<TKey, TService> keys, IServiceProvider provider)
+            {
+                var dict = new Dictionary<TKey, TService>(capacity: keys.Keys.Length);
+
+                foreach (TKey key in keys.Keys)
+                {
+                    dict[key] = provider.GetRequiredKeyedService<TService>(key);
+                }
+
+                return dict;
+            }
+        }
+
+        private sealed class KeyedServiceCache<TKey, TService>(IServiceCollection sc)
+            where TKey : notnull
+            where TService : notnull
+        {
+            // Once this class is resolved, all registrations are guaranteed to be
+            // made, so we can, at that point, safely iterate the collection to get
+            // the keys for the service type.
+            public TKey[] Keys { get; } = (
+                from service in sc
+                where service.ServiceKey != null
+                where service.ServiceKey!.GetType() == typeof(TKey)
+                where service.ServiceType == typeof(TService)
+                select (TKey)service.ServiceKey!)
+                .ToArray();
+        }
+
+    }
+}

UmlautAdaptarr/Utilities/ServicesExtensions.cs

@@ -1,92 +1,197 @@
-using UmlautAdaptarr.Options;
+using FluentValidation;
-using UmlautAdaptarr.Options.ArrOptions;
+using System.Linq.Expressions;
+using UmlautAdaptarr.Interfaces;
+using UmlautAdaptarr.Options;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
 using UmlautAdaptarr.Providers;
 using UmlautAdaptarr.Services;
+using UmlautAdaptarr.Validator;
 
-namespace UmlautAdaptarr.Utilities
+namespace UmlautAdaptarr.Utilities;
+
+/// <summary>
+///     Extension methods for configuring services related to ARR Applications
+/// </summary>
+public static class ServicesExtensions
 {
+
     /// <summary>
-    /// Extension methods for configuring services related to ARR Applications
+    /// Logger instance for logging proxy configurations.
     /// </summary>
-    public static class ServicesExtensions
+    private static ILogger Logger = GlobalStaticLogger.Logger;
+
+    /// <summary>
+    ///     Adds a service with specified options and service to the service collection.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type for the service.</typeparam>
+    /// <typeparam name="TService">The service type for the service.</typeparam>
+    /// <typeparam name="TInterface">The Interface of the service type</typeparam>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <param name="sectionName">The name of the configuration section containing service options.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    private static WebApplicationBuilder AddServicesWithOptions<TOptions, TService, TInterface>(
+        this WebApplicationBuilder builder, string sectionName)
+        where TOptions : class, new()
+        where TService : class, TInterface
+        where TInterface : class
     {
 
-        /// <summary>
+        try
-        /// Adds a service with specified options and service to the service collection.
-        /// </summary>
-        /// <typeparam name="TOptions">The options type for the service.</typeparam>
-        /// <typeparam name="TService">The service type for the service.</typeparam>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
-        /// <param name="sectionName">The name of the configuration section containing service options.</param>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        private static WebApplicationBuilder AddServiceWithOptions<TOptions, TService>(this WebApplicationBuilder builder, string sectionName)
-            where TOptions : class
-            where TService : class
         {
-            if (builder.Services == null)
+            if (builder.Services == null) throw new ArgumentNullException(nameof(builder), "Service collection is null.");
+
+
+            var singleInstance = builder.Configuration.GetSection(sectionName).Get<TOptions>();
+
+            var singleHost = (string?)typeof(TOptions).GetProperty("Host")?.GetValue(singleInstance, null);
+
+            // If we have no Single Instance , we try to parse for a Array
+            var optionsArray = singleHost == null
+                ? builder.Configuration.GetSection(sectionName).Get<TOptions[]>()
+                :
+                [
+                    singleInstance
+                ];
+
+            if (optionsArray == null || !optionsArray.Any())
+                throw new InvalidOperationException(
+                    $"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
+
+            foreach (var option in optionsArray)
             {
-                throw new ArgumentNullException(nameof(builder), "Service collection is null.");
+
+                GlobalInstanceOptionsValidator validator = new GlobalInstanceOptionsValidator();
+
+              var results =  validator.Validate(option as GlobalInstanceOptions);
+
+                if (!results.IsValid)
+                {
+                    foreach (var failure in results.Errors)
+                    {
+                        Console.WriteLine(($"Property {failure.PropertyName } failed validation. Error was: {failure.ErrorMessage}"));
+                    }
+
+                    throw new Exception("Please fix first you config and then Start UmlautAdaptarr again");
+                }
+
+                var instanceState = (bool)(typeof(TOptions).GetProperty("Enabled")?.GetValue(option, null) ?? false);
+
+                // We only want to create instances that are enabled in the Configs
+                if (instanceState)
+                {
+                    // User can give the Instance a readable Name otherwise we use the Host Property
+                    var instanceName = (string)(typeof(TOptions).GetProperty("Name")?.GetValue(option, null) ??
+                                                (string)typeof(TOptions).GetProperty("Host")?.GetValue(option, null)!);
+
+                    // Dark Magic , we don't know the Property's of TOptions , and we won't cast them for each Options
+                    // Todo eventuell schönere Lösung finden
+                    var paraexpression = Expression.Parameter(Type.GetType(option.GetType().FullName), "x");
+
+                    foreach (var prop in option.GetType().GetProperties())
+                    {
+                        var val = Expression.Constant(prop.GetValue(option));
+                        var memberexpression = Expression.PropertyOrField(paraexpression, prop.Name);
+
+                        if (prop.PropertyType == typeof(int) || prop.PropertyType == typeof(string) || prop.PropertyType == typeof(bool))
+                        {
+                            var assign = Expression.Assign(memberexpression, Expression.Convert(val, prop.PropertyType));
+                            var exp = Expression.Lambda<Action<TOptions>>(assign, paraexpression);
+                            builder.Services.Configure(instanceName, exp.Compile());
+                        }
+                        else
+                        {
+                            Logger.LogWarning((prop.PropertyType + "No Support"));
+                        }
+                    }
+
+                    builder.Services.AddKeyedSingleton<TInterface, TService>(instanceName);
+                }
             }
 
-            var options = builder.Configuration.GetSection(sectionName).Get<TOptions>();
-            if (options == null)
-            {
-                throw new InvalidOperationException($"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
-            }
-
-            builder.Services.Configure<TOptions>(builder.Configuration.GetSection(sectionName));
-            builder.Services.AddSingleton<TService>();
             return builder;
         }
-
+        catch (Exception e)
-        /// <summary>
-        /// Adds support for Sonarr with default options and client.
-        /// </summary>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        public static WebApplicationBuilder AddSonarrSupport(this WebApplicationBuilder builder)
         {
-            return builder.AddServiceWithOptions<SonarrInstanceOptions, SonarrClient>("Sonarr");
+            Console.WriteLine("Error while Init UmlautAdaptrr");
+            throw;
         }
 
-        /// <summary>
+    }
-        /// Adds support for Lidarr with default options and client.
-        /// </summary>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        public static WebApplicationBuilder AddLidarrSupport(this WebApplicationBuilder builder)
-        {
-            return builder.AddServiceWithOptions<LidarrInstanceOptions, LidarrClient>("Lidarr");
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Adds support for Readarr with default options and client.
+    ///     Adds a service with specified options and service to the service collection.
-        /// </summary>
+    /// </summary>
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
+    /// <typeparam name="TOptions">The options type for the service.</typeparam>
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
+    /// <typeparam name="TService">The service type for the service.</typeparam>
-        public static WebApplicationBuilder AddReadarrSupport(this WebApplicationBuilder builder)
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
-        {
+    /// <param name="sectionName">The name of the configuration section containing service options.</param>
-            return builder.AddServiceWithOptions<ReadarrInstanceOptions, ReadarrClient>("Readarr");
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
-        }
+    private static WebApplicationBuilder AddServiceWithOptions<TOptions, TService>(this WebApplicationBuilder builder,
+        string sectionName)
+        where TOptions : class
+        where TService : class
+    {
+        if (builder.Services == null) throw new ArgumentNullException(nameof(builder), "Service collection is null.");
 
-        /// <summary>
+        var options = builder.Configuration.GetSection(sectionName).Get<TOptions>();
-        /// Adds a title lookup service to the service collection.
+        if (options == null)
-        /// </summary>
+            throw new InvalidOperationException(
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
+                $"{typeof(TService).Name} options could not be loaded from Configuration or ENV Variable.");
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
-        public static WebApplicationBuilder AddTitleLookupService(this WebApplicationBuilder builder)
-        {
-            return builder.AddServiceWithOptions<GlobalOptions, TitleApiService>("Settings");
-        }
 
-        /// <summary>
+        builder.Services.Configure<TOptions>(builder.Configuration.GetSection(sectionName));
-        /// Adds a proxy request service to the service collection.
+        builder.Services.AddSingleton<TService>();
-        /// </summary>
+
-        /// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param>
+        return builder;
-        /// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns>
+    }
-        public static WebApplicationBuilder AddProxyRequestService(this WebApplicationBuilder builder)
+
-        {
+    /// <summary>
-            return builder.AddServiceWithOptions<GlobalOptions, ProxyRequestService>("Settings");
+    ///     Adds support for Sonarr with default options and client.
-        }
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static WebApplicationBuilder AddSonarrSupport(this WebApplicationBuilder builder)
+    {
+        //  builder.Serviceses.AddSingleton<IOptionsMonitoSonarrInstanceOptionsns>, OptionsMonitoSonarrInstanceOptionsns>>();
+        return builder.AddServicesWithOptions<SonarrInstanceOptions, SonarrClient, IArrApplication>("Sonarr");
+    }
+
+    /// <summary>
+    ///     Adds support for Lidarr with default options and client.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static WebApplicationBuilder AddLidarrSupport(this WebApplicationBuilder builder)
+    {
+        return builder.AddServicesWithOptions<LidarrInstanceOptions, LidarrClient, IArrApplication>("Lidarr");
+    }
+
+    /// <summary>
+    ///     Adds support for Readarr with default options and client.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static WebApplicationBuilder AddReadarrSupport(this WebApplicationBuilder builder)
+    {
+        return builder.AddServicesWithOptions<ReadarrInstanceOptions, ReadarrClient, IArrApplication>("Readarr");
+    }
+
+    /// <summary>
+    ///     Adds a title lookup service to the service collection.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static WebApplicationBuilder AddTitleLookupService(this WebApplicationBuilder builder)
+    {
+        return builder.AddServiceWithOptions<GlobalOptions, TitleApiService>("Settings");
+    }
+
+    /// <summary>
+    ///     Adds a proxy request service to the service collection.
+    /// </summary>
+    /// <param name="builder">The <see cref="WebApplicationBuilder" /> to configure the service collection.</param>
+    /// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
+    public static WebApplicationBuilder AddProxyRequestService(this WebApplicationBuilder builder)
+    {
+        return builder.AddServiceWithOptions<GlobalOptions, ProxyRequestService>("Settings");
     }
 }

UmlautAdaptarr/Validator/GlobalInstanceOptionsValidator.cs

@@ -0,0 +1,61 @@
+using System.Net;
+using FluentValidation;
+using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
+
+namespace UmlautAdaptarr.Validator;
+
+public class GlobalInstanceOptionsValidator : AbstractValidator<GlobalInstanceOptions>
+{
+    public GlobalInstanceOptionsValidator()
+    {
+        RuleFor(x => x.Enabled).NotNull();
+
+        When(x => x.Enabled, () =>
+        {
+            RuleFor(x => x.Host)
+                .NotEmpty().WithMessage("Host is required when Enabled is true.")
+                .Must(BeAValidUrl).WithMessage("Host/Url must start with http:// or https:// and be a valid address.")
+                .Must(BeReachable)
+                .WithMessage("Host/Url is not reachable. Please check your Host or your UmlautAdaptrr Settings");
+
+            RuleFor(x => x.ApiKey)
+                .NotEmpty().WithMessage("ApiKey is required when Enabled is true.");
+        });
+    }
+
+    private bool BeAValidUrl(string url)
+    {
+        return Uri.TryCreate(url, UriKind.Absolute, out var uriResult)
+               && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
+    }
+
+    private static bool BeReachable(string url)
+    {
+        var endTime = DateTime.Now.AddMinutes(3);
+        var reachable = false;
+
+        while (DateTime.Now < endTime)
+        {
+            try
+            {
+                var request = WebRequest.Create(url);
+                request.Timeout = 3000;
+                using var response = (HttpWebResponse)request.GetResponse();
+                reachable = response.StatusCode == HttpStatusCode.OK;
+                if (reachable)
+                    break;
+            }
+            catch
+            {
+              
+            }
+
+            // Wait for 15 seconds for next try
+            Console.WriteLine($"The URL \"{url}\" is not reachable. Next attempt in 15 seconds...");
+            Thread.Sleep(15000);
+        }
+
+        return reachable;
+    }
+
+}

UmlautAdaptarr/appsettings.json

@@ -22,20 +22,36 @@
     "UserAgent": "UmlautAdaptarr/1.0",
     "UmlautAdaptarrApiHost": "https://umlautadaptarr.pcjones.de/api/v1"
   },
-  "Sonarr": {
+  "Sonarr": [
-    // Docker Environment Variables:
+    {
-    // - Sonarr__Enabled: true (set to false to disable)
+      // Docker Environment Variables:
-    // - Sonarr__Host: your_sonarr_host_url
+      // - Sonarr__0__Enabled: true (set to false to disable)
-    // - Sonarr__ApiKey: your_sonarr_api_key
+      // - Sonarr__0__Name: Name of the Instance (Optional)
-    "Enabled": false,
+      // - Sonarr__0__Host: your_sonarr_host_url
-    "Host": "your_sonarr_host_url",
+      // - Sonarr__0__ApiKey: your_sonarr_api_key
-    "ApiKey": "your_sonarr_api_key"
+      "Enabled": false,
-  },
+      "Name": "Sonarr",
-  "Lidarr": {
+      "Host": "your_sonarr_host_url",
-    // Docker Environment Variables:
+      "ApiKey": "your_sonarr_api_key"
-    // - Lidarr__Enabled: true (set to false to disable)
+    },
-    // - Lidarr__Host: your_lidarr_host_url
+    {
-    // - Lidarr__ApiKey: your_lidarr_api_key
+      // Docker Environment Variables:
+      // - Sonarr__1__Enabled: true (set to false to disable)
+      // - Sonarr__0__Name: Name of the Instance (Optional)
+      // - Sonarr__1__Host: your_sonarr_host_url
+      // - Sonarr__1__ApiKey: your_sonarr_api_key
+      "Enabled": false,
+      "Name": "Sonarr 4k",
+      "Host": "your_other_sonarr_host_url",
+      "ApiKey": "your_other_sonarr_api_key"
+    }
+  ],
+  "Lidarr":
+  // Docker Environment Variables:
+  // - Lidarr__Enabled: true (set to false to disable)
+  // - Lidarr__Host: your_lidarr_host_url
+  // - Lidarr__ApiKey: your_lidarr_api_key
+  {
     "Enabled": false,
     "Host": "your_lidarr_host_url",
     "ApiKey": "your_lidarr_api_key"