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

9
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> public class GlobalInstanceOptions
/// Base Options for ARR applications
/// </summary>
public class ArrApplicationBaseOptions
{ {
/// <summary> /// <summary>
/// Indicates whether the Arr application is enabled. /// Indicates whether the Arr application is enabled.
@@ -20,4 +17,4 @@
/// </summary> /// </summary>
public string ApiKey { get; set; } public string ApiKey { get; set; }
} }
} }

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
{
}
}

91
UmlautAdaptarr/Program.cs
View File

@@ -1,27 +1,45 @@
using System.Net; using System.Net;
using Serilog;
using Serilog.Filters;
using UmlautAdaptarr.Options; using UmlautAdaptarr.Options;
using UmlautAdaptarr.Routing; using UmlautAdaptarr.Routing;
using UmlautAdaptarr.Services; using UmlautAdaptarr.Services;
using UmlautAdaptarr.Services.Factory;
using UmlautAdaptarr.Utilities; using UmlautAdaptarr.Utilities;
internal class Program internal class Program
{ {
private static void Main(string[] args) private static void Main(string[] args)
{ {
Helper.ShowLogo();
// TODO: // TODO:
// add option to sort by nzb age // add option to sort by nzb age
var builder = WebApplication.CreateBuilder(args);
var builder = WebApplication.CreateBuilder(args);
var configuration = builder.Configuration; 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. // Add services to the container.
builder.Services.AddHttpClient("HttpClient").ConfigurePrimaryHttpMessageHandler(() => builder.Services.AddHttpClient("HttpClient").ConfigurePrimaryHttpMessageHandler(() =>
{ {
var handler = new HttpClientHandler 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>(); 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.AddControllers();
builder.Services.AddHostedService<ArrSyncBackgroundService>();
builder.AddTitleLookupService(); builder.AddTitleLookupService();
builder.Services.AddSingleton<SearchItemLookupService>(); builder.Services.AddSingleton<SearchItemLookupService>();
builder.Services.AddSingleton<TitleMatchingService>(); builder.Services.AddSingleton<TitleMatchingService>();
@@ -57,6 +63,8 @@ internal class Program
builder.AddReadarrSupport(); builder.AddReadarrSupport();
builder.Services.AddSingleton<CacheService>(); builder.Services.AddSingleton<CacheService>();
builder.Services.AddSingleton<ProxyRequestService>(); builder.Services.AddSingleton<ProxyRequestService>();
builder.Services.AddSingleton<RrApplicationFactory>();
builder.Services.AddHostedService<ArrSyncBackgroundService>();
builder.Services.AddSingleton<IHostedService, HttpProxyService>(); builder.Services.AddSingleton<IHostedService, HttpProxyService>();
var app = builder.Build(); var app = builder.Build();
@@ -65,36 +73,35 @@ internal class Program
app.UseHttpsRedirection(); app.UseHttpsRedirection();
app.UseAuthorization(); 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(); app.Run();
} }
} }

19
UmlautAdaptarr/Providers/ArrClientBase.cs
View File

@@ -1,13 +1,12 @@
using Microsoft.Extensions.Caching.Memory; using UmlautAdaptarr.Interfaces;
using UmlautAdaptarr.Models; 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); }
}
}

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

293
UmlautAdaptarr/Providers/LidarrClient.cs
View File

@@ -1,149 +1,168 @@
using Microsoft.Extensions.Caching.Memory; using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options; using Microsoft.Extensions.Options;
using Newtonsoft.Json; using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using UmlautAdaptarr.Models; using UmlautAdaptarr.Models;
using UmlautAdaptarr.Options.ArrOptions; using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
using UmlautAdaptarr.Services; using UmlautAdaptarr.Services;
using UmlautAdaptarr.Utilities; 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, IHttpClientFactory clientFactory,
CacheService cacheService, 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;
public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync() _logger = logger;
{ InstanceName = instanceName;
var httpClient = clientFactory.CreateClient(); Options = options.Get(InstanceName);
var items = new List<SearchItem>(); _logger.LogInformation($"Init Lidarr ({InstanceName})");
try
{
var lidarrArtistsUrl = $"{LidarrOptions.Host}/api/v1/artist?apikey={LidarrOptions.ApiKey}";
logger.LogInformation($"Fetching all artists from Lidarr: {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");
return items;
}
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");
}
catch (Exception ex)
{
logger.LogError($"Error fetching all artists from Lidarr: {ex.Message}");
}
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}.");
}
}
}
catch (Exception ex)
{
logger.LogError($"Error fetching single artist from Lidarr: {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: {ex.Message}");
}
return null;
}
} }
}
public LidarrInstanceOptions Options { get; init; }
public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
{
var httpClient = _clientFactory.CreateClient();
var items = new List<SearchItem>();
try
{
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 ({InstanceName}) artists API request resulted in null");
return items;
}
_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.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 ({InstanceName}).");
// 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
(
artistId,
externalId,
albumTitle,
albumTitle,
null,
aliases: aliases,
mediaType: _mediaType,
expectedAuthor: artistName
);
items.Add(searchItem);
}
}
_logger.LogInformation($"Finished fetching all items from Lidarr ({InstanceName})");
}
catch (Exception ex)
{
_logger.LogError($"Error fetching all artists from Lidarr ({InstanceName}) : {ex.Message}");
}
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;
}
}

336
UmlautAdaptarr/Providers/ReadarrClient.cs
View File

@@ -1,174 +1,186 @@
using Microsoft.Extensions.Caching.Memory; using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options; using Microsoft.Extensions.Options;
using Newtonsoft.Json; using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using UmlautAdaptarr.Models; using UmlautAdaptarr.Models;
using UmlautAdaptarr.Options.ArrOptions; using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
using UmlautAdaptarr.Services; using UmlautAdaptarr.Services;
using UmlautAdaptarr.Utilities; 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, CacheService cacheService,
IMemoryCache cache, IMemoryCache cache,
IOptions<ReadarrInstanceOptions> options, IOptionsMonitor<ReadarrInstanceOptions> options,
ILogger<ReadarrClient> logger) : ArrClientBase() ILogger<ReadarrClient> logger)
{ {
_clientFactory = clientFactory;
public ReadarrInstanceOptions ReadarrOptions { get; } = options.Value; _cacheService = cacheService;
private readonly string _mediaType = "book"; _cache = cache;
_logger = logger;
public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync() InstanceName = instanceName;
{ Options = options.Get(InstanceName);
var httpClient = clientFactory.CreateClient(); _logger.LogInformation($"Init ReadarrClient ({InstanceName})");
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 authorApiResponse = await httpClient.GetStringAsync(readarrAuthorUrl);
var authors = JsonConvert.DeserializeObject<List<dynamic>>(authorApiResponse);
if (authors == null)
{
logger.LogError($"Readarr authors API request resulted in null");
return items;
}
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");
}
catch (Exception ex)
{
logger.LogError($"Error fetching all authors from Readarr: {ex.Message}");
}
return items;
}
// 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
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();
}
}
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
{
cacheService.CacheSearchItem(searchItem);
}
catch (Exception ex)
{
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;
}
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: {ex.Message}");
}
return null;
}
} }
}
public ReadarrInstanceOptions Options { get; init; }
public override async Task<IEnumerable<SearchItem>> FetchAllItemsAsync()
{
var httpClient = _clientFactory.CreateClient();
var items = new List<SearchItem>();
try
{
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 ({InstanceName}) authors API request resulted in null");
return items;
}
_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: {UrlUtilities.RedactApiKey(readarrBookUrl)}");
var bookApiResponse = await httpClient.GetStringAsync(readarrBookUrl);
var books = JsonConvert.DeserializeObject<List<dynamic>>(bookApiResponse);
if (books == 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 ({InstanceName}) .");
// 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
(
authorId,
externalId,
bookTitle,
bookTitle,
null,
aliases: aliases,
mediaType: _mediaType,
expectedAuthor: authorName
);
items.Add(searchItem);
}
}
_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;
}
// 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)
{
var endParenthesisIndex = bookTitle.IndexOf(')', firstParenthesisIndex);
if (endParenthesisIndex > -1 && bookTitle
.Substring(firstParenthesisIndex + 1, endParenthesisIndex - firstParenthesisIndex - 1)
.Contains(' ')) bookTitle = bookTitle[..firstParenthesisIndex].Trim();
}
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
{
_cacheService.CacheSearchItem(searchItem);
}
catch (Exception ex)
{
_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 ({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 author from Readarr ({InstanceName}) : {ex.Message}");
}
return null;
}
}

259
UmlautAdaptarr/Providers/SonarrClient.cs
View File

@@ -1,171 +1,192 @@
using Microsoft.Extensions.Options; using Microsoft.Extensions.Options;
using Newtonsoft.Json; using Newtonsoft.Json;
using UmlautAdaptarr.Models; using UmlautAdaptarr.Models;
using UmlautAdaptarr.Options.ArrOptions; using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
using UmlautAdaptarr.Services; using UmlautAdaptarr.Services;
using UmlautAdaptarr.Utilities; 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, IHttpClientFactory clientFactory,
TitleApiService titleService, 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; var tvdbId = (string)show.tvdbId;
if (tvdbId == null) 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 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, aliases: aliases,
mediaType: _mediaType 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) if (tvdbId == null)
{ {
_logger.LogWarning($"Sonarr ({InstanceName}) Show {show.id} doesn't have a tvdbId.");
return null; 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 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, aliases: aliases,
mediaType: _mediaType mediaType: _mediaType
); );
logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr."); _logger.LogInformation($"Successfully fetched show {searchItem.Title} from Sonarr ({InstanceName}).");
return searchItem; 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;
} }
} }

287
UmlautAdaptarr/Services/ArrSyncBackgroundService.cs
View File

@@ -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(
RrApplicationFactory rrApplicationFactory,
CacheService cacheService,
ILogger<ArrSyncBackgroundService> logger)
: BackgroundService
{ {
public class ArrSyncBackgroundService( public RrApplicationFactory RrApplicationFactory { get; } = rrApplicationFactory;
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 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()
{
try
{
var success = true;
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.");
}
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}.");
} }
} }
} }
logger.LogInformation("ArrSyncBackgroundService is stopping.");
} }
}
private async Task<bool> FetchAndUpdateDataAsync()
{
try
{
var success = true;
if (RrApplicationFactory.SonarrInstances.Any())
{
var syncSuccess = await FetchItemsFromSonarrAsync();
success = success && syncSuccess;
}
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;
}
private async Task<bool> FetchItemsFromSonarrAsync()
{
try
{
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;
}
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 RrApplicationFactory.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 RrApplicationFactory.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
{
cacheService.CacheSearchItem(searchItem);
}
catch (Exception ex)
{
logger.LogError(ex, $"An error occurred while caching search item with ID {searchItem.ArrId}.");
}
}
}

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

42
UmlautAdaptarr/Services/SearchItemLookupService.cs
View File

@@ -1,12 +1,11 @@
using UmlautAdaptarr.Models; using UmlautAdaptarr.Models;
using UmlautAdaptarr.Providers; using UmlautAdaptarr.Providers;
using UmlautAdaptarr.Services.Factory;
namespace UmlautAdaptarr.Services namespace UmlautAdaptarr.Services
{ {
public class SearchItemLookupService(CacheService cacheService, public class SearchItemLookupService(CacheService cacheService,
SonarrClient sonarrClient, RrApplicationFactory rrApplicationFactory)
ReadarrClient readarrClient,
LidarrClient lidarrClient)
{ {
public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId) public async Task<SearchItem?> GetOrFetchSearchItemByExternalId(string mediaType, string externalId)
{ {
@@ -22,23 +21,40 @@ namespace UmlautAdaptarr.Services
switch (mediaType) switch (mediaType)
{ {
case "tv": case "tv":
if (sonarrClient.SonarrOptions.Enabled)
var sonarrInstances = rrApplicationFactory.SonarrInstances;
if (sonarrInstances.Any())
{ {
fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId); foreach (var sonarrClient in sonarrInstances)
{
fetchedItem = await sonarrClient.FetchItemByExternalIdAsync(externalId);
}
} }
break; break;
case "audio": case "audio":
if (lidarrClient.LidarrOptions.Enabled)
var lidarrInstances = rrApplicationFactory.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; break;
case "book": case "book":
if (readarrClient.ReadarrOptions.Enabled)
var readarrInstances = rrApplicationFactory.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; break;
} }
@@ -66,7 +82,9 @@ namespace UmlautAdaptarr.Services
switch (mediaType) switch (mediaType)
{ {
case "tv": case "tv":
if (sonarrClient.SonarrOptions.Enabled)
var sonarrInstances = rrApplicationFactory.SonarrInstances;
foreach (var sonarrClient in sonarrInstances)
{ {
fetchedItem = await sonarrClient.FetchItemByTitleAsync(title); 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" Version="8.0.2" />
<PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" /> <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
<PackageReference Include="Newtonsoft.Json" Version="13.0.3" /> <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
<PackageReference Include="Serilog.AspNetCore" Version="8.0.1" />
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" /> <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
</ItemGroup> </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();
}
}
}

209
UmlautAdaptarr/Utilities/ServicesExtensions.cs
View File

@@ -1,92 +1,145 @@
using UmlautAdaptarr.Options; using UmlautAdaptarr.Interfaces;
using UmlautAdaptarr.Options.ArrOptions; using UmlautAdaptarr.Options;
using UmlautAdaptarr.Options.ArrOptions.InstanceOptions;
using UmlautAdaptarr.Providers; using UmlautAdaptarr.Providers;
using UmlautAdaptarr.Services; 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> /// <summary>
/// Extension methods for configuring services related to ARR Applications /// Adds a service with specified options and service to the service collection.
/// </summary> /// </summary>
public static class ServicesExtensions /// <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.");
/// <summary>
/// Adds a service with specified options and service to the service collection. var singleInstance = builder.Configuration.GetSection(sectionName).Get<TOptions>();
/// </summary>
/// <typeparam name="TOptions">The options type for the service.</typeparam> var singleHost = (string?)typeof(TOptions).GetProperty("Host")?.GetValue(singleInstance, null);
/// <typeparam name="TService">The service type for the service.</typeparam>
/// <param name="builder">The <see cref="WebApplicationBuilder"/> to configure the service collection.</param> // If we have no Single Instance , we try to parse for a Array
/// <param name="sectionName">The name of the configuration section containing service options.</param> var optionsArray = singleHost == null
/// <returns>The configured <see cref="WebApplicationBuilder"/>.</returns> ? builder.Configuration.GetSection(sectionName).Get<TOptions[]>()
private static WebApplicationBuilder AddServiceWithOptions<TOptions, TService>(this WebApplicationBuilder builder, string sectionName) :
where TOptions : class [
where TService : class 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)
{ {
if (builder.Services == null) 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)
{ {
throw new ArgumentNullException(nameof(builder), "Service collection is null."); // 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);
} }
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;
} }
/// <summary> return builder;
/// 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");
}
/// <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>
/// 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.AddServiceWithOptions<ReadarrInstanceOptions, ReadarrClient>("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");
}
} }
}
/// <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>
/// <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) 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.");
builder.Services.Configure<TOptions>(builder.Configuration.GetSection(sectionName));
builder.Services.AddSingleton<TService>();
return builder;
}
/// <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.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");
}
}

40
UmlautAdaptarr/appsettings.json
View File

@@ -22,20 +22,32 @@
"UserAgent": "UmlautAdaptarr/1.0", "UserAgent": "UmlautAdaptarr/1.0",
"UmlautAdaptarrApiHost": "https://umlautadaptarr.pcjones.de/api/v1" "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__Host: your_sonarr_host_url
"Enabled": false, // - Sonarr__0__ApiKey: your_sonarr_api_key
"Host": "your_sonarr_host_url", "Enabled": false,
"ApiKey": "your_sonarr_api_key" "Host": "your_sonarr_host_url",
}, "ApiKey": "your_sonarr_api_key"
"Lidarr": { },
// Docker Environment Variables: {
// - Lidarr__Enabled: true (set to false to disable) // Docker Environment Variables:
// - Lidarr__Host: your_lidarr_host_url // - Sonarr__1__Enabled: true (set to false to disable)
// - Lidarr__ApiKey: your_lidarr_api_key // - 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, "Enabled": false,
"Host": "your_lidarr_host_url", "Host": "your_lidarr_host_url",
"ApiKey": "your_lidarr_api_key" "ApiKey": "your_lidarr_api_key"