taiqane/UmlautAdaptarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add Multi Instance Support , Serilog , little Hotfixes

Browse Source
This commit is contained in:
Felix Glang
2024-04-27 18:48:43 +02:00
parent 176b0a74a6
commit f06a866a2f
23 changed files with 1132 additions and 755 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
UmlautAdaptarr/Interfaces/IArrApplication.cs Normal file
View File

@@ -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);
}

7
UmlautAdaptarr/Options/ArrOptions/ArrApplicationBaseOptions.cs → UmlautAdaptarr/Options/ArrOptions/InstanceOptions/GlobalInstanceOptions.cs
View File

@@ -1,9 +1,6 @@
namespace UmlautAdaptarr.Options.ArrOptions
namespace UmlautAdaptarr.Options.ArrOptions.InstanceOptions
{
/// <summary>
/// Base Options for ARR applications
/// </summary>
public class ArrApplicationBaseOptions
public class GlobalInstanceOptions
{
/// <summary>
/// Indicates whether the Arr application is enabled.

6
UmlautAdaptarr/Options/ArrOptions/InstanceOptions/LidarrInstanceOptions.cs Normal file
View File

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

6
UmlautAdaptarr/Options/ArrOptions/InstanceOptions/ReadarrInstanceOptions.cs Normal file
View File

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

6
UmlautAdaptarr/Options/ArrOptions/InstanceOptions/SonarrInstanceOptions.cs Normal file
View File

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

9
UmlautAdaptarr/Options/ArrOptions/LidarrInstanceOptions.cs
View File

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

9
UmlautAdaptarr/Options/ArrOptions/ReadarrInstanceOptions.cs
View File

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

9
UmlautAdaptarr/Options/ArrOptions/SonarrInstanceOptions.cs
View File

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

89
UmlautAdaptarr/Program.cs
View File

@@ -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();
// TODO:
// add option to sort by nzb age
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>();
@@ -36,19 +54,7 @@ internal class Program
});
// 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<RrApplicationFactory>();
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",
pattern: "{options}/{*domain}",
defaults: new { controller = "Caps", action = "Caps" },
constraints: new { t = new TRouteConstraint("caps") });
app.MapControllerRoute("caps",
"{options}/{*domain}",
new { controller = "Caps", action = "Caps" },
new { t = new TRouteConstraint("caps") });
app.MapControllerRoute(name: "movie-search",
pattern: "{options}/{*domain}",
defaults: new { controller = "Search", action = "MovieSearch" },
constraints: new { t = new TRouteConstraint("movie") });
app.MapControllerRoute("movie-search",
"{options}/{*domain}",
new { controller = "Search", action = "MovieSearch" },
new { t = new TRouteConstraint("movie") });
app.MapControllerRoute(name: "tv-search",
pattern: "{options}/{*domain}",
defaults: new { controller = "Search", action = "TVSearch" },
constraints: new { t = new TRouteConstraint("tvsearch") });
app.MapControllerRoute("tv-search",
"{options}/{*domain}",
new { controller = "Search", action = "TVSearch" },
new { t = new TRouteConstraint("tvsearch") });
app.MapControllerRoute(name: "music-search",
pattern: "{options}/{*domain}",
defaults: new { controller = "Search", action = "MusicSearch" },
constraints: new { t = new TRouteConstraint("music") });
app.MapControllerRoute("music-search",
"{options}/{*domain}",
new { controller = "Search", action = "MusicSearch" },
new { t = new TRouteConstraint("music") });
app.MapControllerRoute(name: "book-search",
pattern: "{options}/{*domain}",
defaults: new { controller = "Search", action = "BookSearch" },
constraints: 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("book-search",
"{options}/{*domain}",
new { controller = "Search", action = "BookSearch" },
new { t = new TRouteConstraint("book") });
app.MapControllerRoute("generic-search",
"{options}/{*domain}",
new { controller = "Search", action = "GenericSearch" },
new { t = new TRouteConstraint("search") });
app.Run();
}
}

11
UmlautAdaptarr/Providers/ArrClientBase.cs
View File

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

17
UmlautAdaptarr/Providers/ArrClientFactory.cs
View File

@@ -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());
}
}
}
}

83
UmlautAdaptarr/Providers/LidarrClient.cs
View File

@@ -1,46 +1,64 @@
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,
ILogger<LidarrClient> logger, IOptions<LidarrInstanceOptions> options) : ArrClientBase()
IMemoryCache cache, IOptionsMonitor<LidarrInstanceOptions> options,
ILogger<LidarrClient> logger)
{
public LidarrInstanceOptions LidarrOptions { get; } = options.Value;
private readonly string _mediaType = "audio";
_clientFactory = clientFactory;
_cacheService = cacheService;
_cache = cache;
_logger = logger;
InstanceName = instanceName;
Options = options.Get(InstanceName);
_logger.LogInformation($"Init Lidarr ({InstanceName})");
}
public LidarrInstanceOptions Options { get; init; }
public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
{
var httpClient = clientFactory.CreateClient();
var httpClient = _clientFactory.CreateClient();
var items = new List<SearchItem>();
try
{
var lidarrArtistsUrl = $"{LidarrOptions.Host}/api/v1/artist?apikey={LidarrOptions.ApiKey}";
logger.LogInformation($"Fetching all artists from Lidarr: {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
var lidarrArtistsUrl = $"{Options.Host}/api/v1/artist?apikey={Options.ApiKey}";
_logger.LogInformation(
$"Fetching all artists from Lidarr ({InstanceName}) : {UrlUtilities.RedactApiKey(lidarrArtistsUrl)}");
var artistsApiResponse = await httpClient.GetStringAsync(lidarrArtistsUrl);
var artists = JsonConvert.DeserializeObject<List<dynamic>>(artistsApiResponse);
if (artists == null)
{
logger.LogError($"Lidarr artists API request resulted in null");
_logger.LogError($"Lidarr ({InstanceName}) artists API request resulted in null");
return items;
}
logger.LogInformation($"Successfully fetched {artists.Count} artists from Lidarr.");
_logger.LogInformation($"Successfully fetched {artists.Count} artists from Lidarr ({InstanceName}).");
foreach (var artist in artists)
{
var artistId = (int)artist.id;
var lidarrAlbumUrl = $"{LidarrOptions.Host}/api/v1/album?artistId={artistId}&apikey={LidarrOptions.ApiKey}";
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
@@ -50,21 +68,24 @@ namespace UmlautAdaptarr.Providers
//}
//else
//{
logger.LogInformation($"Fetching all albums from artistId {artistId} from Lidarr: {UrlUtilities.RedactApiKey(lidarrAlbumUrl)}");
_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.LogWarning($"Lidarr album API request for artistId {artistId} resulted in null");
_logger.LogWarning(
$"Lidarr ({InstanceName}) album API request for artistId {artistId} resulted in null");
continue;
}
logger.LogInformation($"Successfully fetched {albums.Count} albums for artistId {artistId} from Lidarr.");
_logger.LogInformation(
$"Successfully fetched {albums.Count} albums for artistId {artistId} from Lidarr ({InstanceName}).");
// Cache albums for 3 minutes
cache.Set(lidarrAlbumUrl, albums, TimeSpan.FromMinutes(3));
_cache.Set(lidarrAlbumUrl, albums, TimeSpan.FromMinutes(3));
foreach (var album in albums)
{
@@ -80,11 +101,11 @@ namespace UmlautAdaptarr.Providers
var searchItem = new SearchItem
(
arrId: artistId,
externalId: externalId,
title: albumTitle,
expectedTitle: albumTitle,
germanTitle: null,
artistId,
externalId,
albumTitle,
albumTitle,
null,
aliases: aliases,
mediaType: _mediaType,
expectedAuthor: artistName
@@ -94,11 +115,11 @@ namespace UmlautAdaptarr.Providers
}
}
logger.LogInformation($"Finished fetching all items from Lidarr");
_logger.LogInformation($"Finished fetching all items from Lidarr ({InstanceName})");
}
catch (Exception ex)
{
logger.LogError($"Error fetching all artists from Lidarr: {ex.Message}");
_logger.LogError($"Error fetching all artists from Lidarr ({InstanceName}) : {ex.Message}");
}
return items;
@@ -112,20 +133,19 @@ namespace UmlautAdaptarr.Providers
// 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);
_cacheService.CacheSearchItem(searchItem);
}
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} in Lidarr ({InstanceName}).");
}
}
catch (Exception ex)
{
logger.LogError($"Error fetching single artist from Lidarr: {ex.Message}");
_logger.LogError($"Error fetching single artist from Lidarr ({InstanceName}) : {ex.Message}");
}
return null;
@@ -140,10 +160,9 @@ namespace UmlautAdaptarr.Providers
}
catch (Exception ex)
{
logger.LogError($"Error fetching single artist from Lidarr: {ex.Message}");
_logger.LogError($"Error fetching single artist from Lidarr ({InstanceName}): {ex.Message}");
}
return null;
}
}
}

96
UmlautAdaptarr/Providers/ReadarrClient.cs
View File

@@ -1,64 +1,82 @@
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(
IHttpClientFactory clientFactory,
private readonly IMemoryCache _cache;
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,
ILogger<ReadarrClient> logger) : ArrClientBase()
IOptionsMonitor<ReadarrInstanceOptions> options,
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;
private readonly string _mediaType = "book";
public ReadarrInstanceOptions Options { get; init; }
public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
{
var httpClient = clientFactory.CreateClient();
var httpClient = _clientFactory.CreateClient();
var items = new List<SearchItem>();
try
{
var readarrAuthorUrl = $"{ReadarrOptions.Host}/api/v1/author?apikey={ReadarrOptions.ApiKey}";
logger.LogInformation($"Fetching all authors from Readarr: {UrlUtilities.RedactApiKey(readarrAuthorUrl)}");
var readarrAuthorUrl = $"{Options.Host}/api/v1/author?apikey={Options.ApiKey}";
_logger.LogInformation(
$"Fetching all authors from Readarr ({InstanceName}) : {UrlUtilities.RedactApiKey(readarrAuthorUrl)}");
var authorApiResponse = await httpClient.GetStringAsync(readarrAuthorUrl);
var authors = JsonConvert.DeserializeObject<List<dynamic>>(authorApiResponse);
if (authors == null)
{
logger.LogError($"Readarr authors API request resulted in null");
_logger.LogError($"Readarr ({InstanceName}) authors API request resulted in null");
return items;
}
logger.LogInformation($"Successfully fetched {authors.Count} authors from Readarr.");
_logger.LogInformation($"Successfully fetched {authors.Count} authors from Readarr ({InstanceName}).");
foreach (var author in authors)
{
var authorId = (int)author.id;
var readarrBookUrl = $"{ReadarrOptions.Host}/api/v1/book?authorId={authorId}&apikey={ReadarrOptions.ApiKey}";
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: {UrlUtilities.RedactApiKey(readarrBookUrl)}");
_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");
_logger.LogWarning(
$"Readarr ({InstanceName}) book API request for authorId {authorId} resulted in null");
continue;
}
logger.LogInformation($"Successfully fetched {books.Count} books for authorId {authorId} from Readarr.");
_logger.LogInformation(
$"Successfully fetched {books.Count} books for authorId {authorId} from Readarr ({InstanceName}) .");
// Cache books for 3 minutes
cache.Set(readarrBookUrl, books, TimeSpan.FromMinutes(3));
_cache.Set(readarrBookUrl, books, TimeSpan.FromMinutes(3));
foreach (var book in books)
{
@@ -75,11 +93,11 @@ namespace UmlautAdaptarr.Providers
var searchItem = new SearchItem
(
arrId: authorId,
externalId: externalId,
title: bookTitle,
expectedTitle: bookTitle,
germanTitle: null,
authorId,
externalId,
bookTitle,
bookTitle,
null,
aliases: aliases,
mediaType: _mediaType,
expectedAuthor: authorName
@@ -89,11 +107,11 @@ namespace UmlautAdaptarr.Providers
}
}
logger.LogInformation($"Finished fetching all items from Readarr");
_logger.LogInformation($"Finished fetching all items from Readarr ({InstanceName})");
}
catch (Exception ex)
{
logger.LogError($"Error fetching all authors from Readarr: {ex.Message}");
_logger.LogError($"Error fetching all authors from Readarr ({InstanceName}): {ex.Message}");
}
return items;
@@ -104,21 +122,18 @@ namespace UmlautAdaptarr.Providers
{
// 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(':');
var firstParenthesisIndex = bookTitle.IndexOf('(');
var 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 endParenthesisIndex = bookTitle.IndexOf(')', firstParenthesisIndex);
if (endParenthesisIndex > -1 && bookTitle
.Substring(firstParenthesisIndex + 1, endParenthesisIndex - firstParenthesisIndex - 1)
.Contains(' ')) bookTitle = bookTitle[..firstParenthesisIndex].Trim();
}
else if (firstColonIndex > -1)
{
@@ -137,20 +152,18 @@ namespace UmlautAdaptarr.Providers
// 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);
_cacheService.CacheSearchItem(searchItem);
}
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}");
_logger.LogError($"Error fetching single author from Readarr ({InstanceName}) : {ex.Message}");
}
return null;
@@ -165,10 +178,9 @@ namespace UmlautAdaptarr.Providers
}
catch (Exception ex)
{
logger.LogError($"Error fetching single author from Readarr: {ex.Message}");
_logger.LogError($"Error fetching single author from Readarr ({InstanceName}) : {ex.Message}");
}
return null;
}
}
}

123
UmlautAdaptarr/Providers/SonarrClient.cs
View File

@@ -1,53 +1,71 @@
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,
ILogger<SonarrClient> logger) : ArrClientBase()
IOptionsMonitor<SonarrInstanceOptions> options,
ILogger<SonarrClient> logger)
{
public SonarrInstanceOptions SonarrOptions { get; } = options.Value;
private readonly string _mediaType = "tv";
_clientFactory = clientFactory;
_titleService = titleService;
_logger = logger;
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 httpClient = _clientFactory.CreateClient();
var items = new List<SearchItem>();
try
{
var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
var sonarrUrl = $"{Options.Host}/api/v3/series?includeSeasonImages=false&apikey={Options.ApiKey}";
_logger.LogInformation($"Fetching all items from Sonarr: {UrlUtilities.RedactApiKey(sonarrUrl)}");
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.");
_logger.LogInformation($"Successfully fetched {shows.Count} items from Sonarr ({InstanceName}).");
foreach (var show in shows)
{
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.");
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,
externalId: tvdbId,
title: (string)show.title,
expectedTitle: (string)show.title,
germanTitle: germanTitle,
(int)show.id,
tvdbId,
(string)show.title,
(string)show.title,
germanTitle,
aliases: aliases,
mediaType: _mediaType
);
@@ -56,11 +74,11 @@ namespace UmlautAdaptarr.Providers
}
}
logger.LogInformation($"Finished fetching all items from Sonarr");
_logger.LogInformation($"Finished fetching all items from Sonarr ({InstanceName})");
}
catch (Exception ex)
{
logger.LogError($"Error fetching all shows from Sonarr: {ex.Message}");
_logger.LogError($"Error fetching all shows from Sonarr ({InstanceName}) : {ex.Message}");
}
return items;
@@ -68,12 +86,14 @@ namespace UmlautAdaptarr.Providers
public override async Task<SearchItem?> FetchItemByExternalIdAsync(string externalId)
{
var httpClient = clientFactory.CreateClient();
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 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];
@@ -83,29 +103,31 @@ namespace UmlautAdaptarr.Providers
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;
}
(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,
externalId: tvdbId,
title: (string)show.title,
expectedTitle: (string)show.title,
germanTitle: germanTitle,
(int)show.id,
tvdbId,
(string)show.title,
(string)show.title,
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)
{
logger.LogError($"Error fetching single show from Sonarr: {ex.Message}");
_logger.LogError($"Error fetching single show from Sonarr ({InstanceName}): {ex.Message}");
}
return null;
@@ -113,59 +135,58 @@ namespace UmlautAdaptarr.Providers
public override async Task<SearchItem?> FetchItemByTitleAsync(string title)
{
var httpClient = clientFactory.CreateClient();
var httpClient = _clientFactory.CreateClient();
try
{
(string? germanTitle, string? tvdbId, string[]? aliases) = await titleService.FetchGermanTitleAndExternalIdAndAliasesByTitle(_mediaType, title);
var (germanTitle, tvdbId, aliases) =
await _titleService.FetchGermanTitleAndExternalIdAndAliasesByTitle(_mediaType, title);
if (tvdbId == null)
{
return null;
}
if (tvdbId == null) return null;
var sonarrUrl = $"{SonarrOptions.Host}/api/v3/series?tvdbId={tvdbId}&includeSeasonImages=false&apikey={SonarrOptions.ApiKey}";
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($"Parsing Sonarr API response for TVDB ID {tvdbId} resulted in null");
_logger.LogError($"Parsing Sonarr ({InstanceName}) API response for TVDB ID {tvdbId} resulted in null");
return null;
}
else if (shows.Count == 0)
if (shows.Count == 0)
{
logger.LogWarning($"No results found for TVDB ID {tvdbId}");
_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");
_logger.LogError($"Sonarr ({InstanceName}) : Title for TVDB ID {tvdbId} is null");
return null;
}
var searchItem = new SearchItem
(
arrId: (int)shows[0].id,
externalId: tvdbId,
title: (string)shows[0].title,
expectedTitle: (string)shows[0].title,
germanTitle: germanTitle,
(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.");
_logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr ({InstanceName}).");
return searchItem;
}
catch (Exception ex)
{
logger.LogError($"Error fetching single show from Sonarr: {ex.Message}");
_logger.LogError($"Error fetching single show from Sonarr ({InstanceName}) : {ex.Message}");
}
return null;
}
}
}

89
UmlautAdaptarr/Services/ArrSyncBackgroundService.cs
View File

@@ -1,27 +1,21 @@
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.DependencyInjection;
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;
using UmlautAdaptarr.Models;
using UmlautAdaptarr.Services.Factory;
namespace UmlautAdaptarr.Services;
namespace UmlautAdaptarr.Services
{
public class ArrSyncBackgroundService(
SonarrClient sonarrClient,
LidarrClient lidarrClient,
ReadarrClient readarrClient,
RrApplicationFactory rrApplicationFactory,
CacheService cacheService,
ILogger<ArrSyncBackgroundService> logger) : BackgroundService
ILogger<ArrSyncBackgroundService> logger)
: BackgroundService
{
public RrApplicationFactory RrApplicationFactory { get; } = rrApplicationFactory;
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
logger.LogInformation("ArrSyncBackgroundService is starting.");
bool lastRunSuccess = true;
var lastRunSuccess = true;
while (!stoppingToken.IsCancellationRequested)
{
@@ -39,12 +33,14 @@ namespace UmlautAdaptarr.Services
if (lastRunSuccess)
{
lastRunSuccess = false;
logger.LogInformation("ArrSyncBackgroundService is trying again in 2 minutes because not all syncs were successful.");
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.");
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);
}
}
@@ -58,27 +54,34 @@ namespace UmlautAdaptarr.Services
try
{
var success = true;
if (readarrClient.ReadarrOptions.Enabled)
{
var syncSuccess = await FetchItemsFromReadarrAsync();
success = success && syncSuccess;
}
if (sonarrClient.SonarrOptions.Enabled)
if (RrApplicationFactory.SonarrInstances.Any())
{
var syncSuccess = await FetchItemsFromSonarrAsync();
success = success && syncSuccess;
}
if (lidarrClient.LidarrOptions.Enabled)
if (RrApplicationFactory.ReadarrInstances.Any())
{
var syncSuccess = await FetchItemsFromReadarrAsync();
success = success && syncSuccess;
}
if (RrApplicationFactory.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;
}
@@ -86,7 +89,15 @@ namespace UmlautAdaptarr.Services
{
try
{
var items = await sonarrClient.FetchAllItemsAsync();
var items = new List<SearchItem>();
foreach (var sonarrClient in RrApplicationFactory.SonarrInstances)
{
var result = await sonarrClient.FetchAllItemsAsync();
items = items.Union(result).ToList();
}
UpdateSearchItems(items);
return items?.Any() ?? false;
}
@@ -94,6 +105,7 @@ namespace UmlautAdaptarr.Services
{
logger.LogError(ex, "An error occurred while updating search item from Sonarr.");
}
return false;
}
@@ -101,7 +113,14 @@ namespace UmlautAdaptarr.Services
{
try
{
var items = await lidarrClient.FetchAllItemsAsync();
var items = new List<SearchItem>();
foreach (var lidarrClient in RrApplicationFactory.LidarrInstances)
{
var result = await lidarrClient.FetchAllItemsAsync();
items = items.Union(result).ToList();
}
UpdateSearchItems(items);
return items?.Any() ?? false;
}
@@ -109,6 +128,7 @@ namespace UmlautAdaptarr.Services
{
logger.LogError(ex, "An error occurred while updating search item from Lidarr.");
}
return false;
}
@@ -116,7 +136,14 @@ namespace UmlautAdaptarr.Services
{
try
{
var items = await readarrClient.FetchAllItemsAsync();
var items = new List<SearchItem>();
foreach (var readarrClient in RrApplicationFactory.ReadarrInstances)
{
var result = await readarrClient.FetchAllItemsAsync();
items = items.Union(result).ToList();
}
UpdateSearchItems(items);
return items?.Any() ?? false;
}
@@ -124,13 +151,13 @@ namespace UmlautAdaptarr.Services
{
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);
@@ -141,5 +168,3 @@ namespace UmlautAdaptarr.Services
}
}
}
}
}

76
UmlautAdaptarr/Services/Factory/RrApplicationFactory.cs Normal file
View File

@@ -0,0 +1,76 @@
using UmlautAdaptarr.Interfaces;
using UmlautAdaptarr.Providers;
namespace UmlautAdaptarr.Services.Factory
{
/// <summary>
/// Factory for creating RrApplication instances.
/// </summary>
public class RrApplicationFactory
{
private readonly ILogger<RrApplicationFactory> _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 RrApplicationFactory.
/// </summary>
/// <param name="rrArrApplications">A dictionary of IArrApplication instances.</param>
public RrApplicationFactory(IDictionary<string, IArrApplication> rrArrApplications, ILogger<RrApplicationFactory> 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("Register RrFactory", 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;
}
}
}

32
UmlautAdaptarr/Services/SearchItemLookupService.cs
View File

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

1
UmlautAdaptarr/UmlautAdaptarr.csproj
View File

@@ -12,6 +12,7 @@
<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>

69
UmlautAdaptarr/Utilities/ApiKeyMaskingEnricher.cs Normal file
View File

@@ -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;
}
}

10
UmlautAdaptarr/Utilities/Helper.cs Normal file
View File

@@ -0,0 +1,10 @@
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");
}
}
}

74
UmlautAdaptarr/Utilities/KeyedServiceExtensions.cs Normal file
View File

@@ -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();
}
}
}

85
UmlautAdaptarr/Utilities/ServicesExtensions.cs
View File

@@ -1,15 +1,71 @@
using UmlautAdaptarr.Options;
using UmlautAdaptarr.Options.ArrOptions;
using UmlautAdaptarr.Interfaces;
using UmlautAdaptarr.Options;
using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
using UmlautAdaptarr.Providers;
using UmlautAdaptarr.Services;
namespace UmlautAdaptarr.Utilities
{
namespace UmlautAdaptarr.Utilities;
/// <summary>
/// Extension methods for configuring services related to ARR Applications
/// </summary>
public static class ServicesExtensions
{
/// <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
{
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 options in optionsArray)
{
var instanceState = (bool)(typeof(TOptions).GetProperty("Enabled")?.GetValue(options, 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(options, null) ??
(string)typeof(TOptions).GetProperty("Host")?.GetValue(options, null)!);
instanceName = instanceName.Replace(".", "");
builder.Services.Configure(instanceName,
delegate(TOptions serviceOptions) { serviceOptions = options; });
builder.Services.AllowResolvingKeyedServicesAsDictionary();
builder.Services.AddKeyedSingleton<TInterface, TService>(instanceName);
}
}
return builder;
}
/// <summary>
/// Adds a service with specified options and service to the service collection.
@@ -19,23 +75,21 @@ namespace UmlautAdaptarr.Utilities
/// <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)
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.");
}
if (builder.Services == null) throw new ArgumentNullException(nameof(builder), "Service collection is null.");
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.");
}
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;
}
@@ -46,7 +100,7 @@ namespace UmlautAdaptarr.Utilities
/// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
public static WebApplicationBuilder AddSonarrSupport(this WebApplicationBuilder builder)
{
return builder.AddServiceWithOptions<SonarrInstanceOptions, SonarrClient>("Sonarr");
return builder.AddServicesWithOptions<SonarrInstanceOptions, SonarrClient, IArrApplication>("Sonarr");
}
/// <summary>
@@ -56,7 +110,7 @@ namespace UmlautAdaptarr.Utilities
/// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
public static WebApplicationBuilder AddLidarrSupport(this WebApplicationBuilder builder)
{
return builder.AddServiceWithOptions<LidarrInstanceOptions, LidarrClient>("Lidarr");
return builder.AddServicesWithOptions<LidarrInstanceOptions, LidarrClient, IArrApplication>("Lidarr");
}
/// <summary>
@@ -66,7 +120,7 @@ namespace UmlautAdaptarr.Utilities
/// <returns>The configured <see cref="WebApplicationBuilder" />.</returns>
public static WebApplicationBuilder AddReadarrSupport(this WebApplicationBuilder builder)
{
return builder.AddServiceWithOptions<ReadarrInstanceOptions, ReadarrClient>("Readarr");
return builder.AddServicesWithOptions<ReadarrInstanceOptions, ReadarrClient, IArrApplication>("Readarr");
}
/// <summary>
@@ -89,4 +143,3 @@ namespace UmlautAdaptarr.Utilities
return builder.AddServiceWithOptions<GlobalOptions, ProxyRequestService>("Settings");
}
}
}

22
UmlautAdaptarr/appsettings.json
View File

@@ -22,20 +22,32 @@
"UserAgent": "UmlautAdaptarr/1.0",
"UmlautAdaptarrApiHost": "https://umlautadaptarr.pcjones.de/api/v1"
},
"Sonarr": {
"Sonarr": [
{
// Docker Environment Variables:
// - Sonarr__Enabled: true (set to false to disable)
// - Sonarr__Host: your_sonarr_host_url
// - Sonarr__ApiKey: your_sonarr_api_key
// - Sonarr__0__Enabled: true (set to false to disable)
// - Sonarr__0__Host: your_sonarr_host_url
// - Sonarr__0__ApiKey: your_sonarr_api_key
"Enabled": false,
"Host": "your_sonarr_host_url",
"ApiKey": "your_sonarr_api_key"
},
"Lidarr": {
{
// Docker Environment Variables:
// - Sonarr__1__Enabled: true (set to false to disable)
// - Sonarr__1__Host: your_sonarr_host_url
// - Sonarr__1__ApiKey: your_sonarr_api_key
"Enabled": false,
"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"