joshpatra/allstarr
1
0
Fork 0
mirror of https://github.com/SoPat712/allstarr.git synced 2026-02-09 23:55:10 -05:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

feat: add automatic fallback support for SquidWTF endpoints

Browse Source 
- Decode 6 base64 URLs at startup (1 primary + 5 backups)
- Automatic fallback when endpoint fails
- All services try next endpoint on failure
- Metadata, Download, and Validator all support fallback
- Endpoints: triton.squid.wtf, wolf/hund/maus/vogel/katze.qqdl.site
- Logs which endpoint is being used
- Cycles through all endpoints before giving up
This commit is contained in:
Josh Patra
2026-01-30 13:21:23 -05:00
parent 3487f79b5e
commit 649351f68b
4 changed files with 211 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
allstarr/Program.cs
View File

@@ -16,13 +16,23 @@ using System.Text;
var builder = WebApplication.CreateBuilder(args); var builder = WebApplication.CreateBuilder(args);
// Decode SquidWTF API base URL once at startup // Decode SquidWTF API base URLs once at startup (primary + backups)
var squidWtfApiBase = DecodeSquidWtfUrl(); var squidWtfApiUrls = DecodeSquidWtfUrls();
static string DecodeSquidWtfUrl() static List<string> DecodeSquidWtfUrls()
{ {
var encoded = "aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm"; var encodedUrls = new[]
var bytes = Convert.FromBase64String(encoded); {
return Encoding.UTF8.GetString(bytes); "aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm", // Primary: triton.squid.wtf
"aHR0cHM6Ly93b2xmLnFxZGwuc2l0ZQ==", // Backup 1: wolf.qqdl.site
"aHR0cDovL2h1bmQucXFkbC5zaXRl", // Backup 2: hund.qqdl.site
"aHR0cHM6Ly9tYXVzLnFxZGwuc2l0ZQ==", // Backup 3: maus.qqdl.site
"aHR0cHM6Ly92b2dlbC5xcWRsLnNpdGU=", // Backup 4: vogel.qqdl.site
"aHR0cHM6Ly9rYXR6ZS5xcWRsLnNpdGU=" // Backup 5: katze.qqdl.site
};
return encodedUrls
.Select(encoded => Encoding.UTF8.GetString(Convert.FromBase64String(encoded)))
.ToList();
} }
// Determine backend type FIRST // Determine backend type FIRST
@@ -173,7 +183,7 @@ else if (musicService == MusicService.Deezer)
} }
else if (musicService == MusicService.SquidWTF) else if (musicService == MusicService.SquidWTF)
{ {
// SquidWTF services - pass decoded URL // SquidWTF services - pass decoded URLs with fallback support
builder.Services.AddSingleton<IMusicMetadataService>(sp => builder.Services.AddSingleton<IMusicMetadataService>(sp =>
new SquidWTFMetadataService( new SquidWTFMetadataService(
sp.GetRequiredService<IHttpClientFactory>(), sp.GetRequiredService<IHttpClientFactory>(),
@@ -181,7 +191,7 @@ else if (musicService == MusicService.SquidWTF)
sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(), sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(),
sp.GetRequiredService<ILogger<SquidWTFMetadataService>>(), sp.GetRequiredService<ILogger<SquidWTFMetadataService>>(),
sp.GetRequiredService<RedisCacheService>(), sp.GetRequiredService<RedisCacheService>(),
squidWtfApiBase)); squidWtfApiUrls));
builder.Services.AddSingleton<IDownloadService>(sp => builder.Services.AddSingleton<IDownloadService>(sp =>
new SquidWTFDownloadService( new SquidWTFDownloadService(
sp.GetRequiredService<IHttpClientFactory>(), sp.GetRequiredService<IHttpClientFactory>(),
@@ -192,7 +202,7 @@ else if (musicService == MusicService.SquidWTF)
sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(), sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(),
sp, sp,
sp.GetRequiredService<ILogger<SquidWTFDownloadService>>(), sp.GetRequiredService<ILogger<SquidWTFDownloadService>>(),
squidWtfApiBase)); squidWtfApiUrls));
} }
// Startup validation - register validators based on backend // Startup validation - register validators based on backend
@@ -211,7 +221,7 @@ builder.Services.AddSingleton<IStartupValidator>(sp =>
new SquidWTFStartupValidator( new SquidWTFStartupValidator(
sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(), sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(),
sp.GetRequiredService<IHttpClientFactory>().CreateClient(), sp.GetRequiredService<IHttpClientFactory>().CreateClient(),
squidWtfApiBase)); squidWtfApiUrls));
// Register orchestrator as hosted service // Register orchestrator as hosted service
builder.Services.AddHostedService<StartupValidationOrchestrator>(); builder.Services.AddHostedService<StartupValidationOrchestrator>();

145
allstarr/Services/SquidWTF/SquidWTFDownloadService.cs
View File

@@ -26,7 +26,8 @@ public class SquidWTFDownloadService : BaseDownloadService
private DateTime _lastRequestTime = DateTime.MinValue; private DateTime _lastRequestTime = DateTime.MinValue;
private readonly int _minRequestIntervalMs = 200; private readonly int _minRequestIntervalMs = 200;
private readonly string SquidWTFApiBase; private readonly List<string> _apiUrls;
private int _currentUrlIndex = 0;
protected override string ProviderName => "squidwtf"; protected override string ProviderName => "squidwtf";
@@ -39,29 +40,48 @@ public class SquidWTFDownloadService : BaseDownloadService
IOptions<SquidWTFSettings> SquidWTFSettings, IOptions<SquidWTFSettings> SquidWTFSettings,
IServiceProvider serviceProvider, IServiceProvider serviceProvider,
ILogger<SquidWTFDownloadService> logger, ILogger<SquidWTFDownloadService> logger,
string apiBase) List<string> apiUrls)
: base(configuration, localLibraryService, metadataService, subsonicSettings.Value, serviceProvider, logger) : base(configuration, localLibraryService, metadataService, subsonicSettings.Value, serviceProvider, logger)
{ {
_httpClient = httpClientFactory.CreateClient(); _httpClient = httpClientFactory.CreateClient();
_squidwtfSettings = SquidWTFSettings.Value; _squidwtfSettings = SquidWTFSettings.Value;
SquidWTFApiBase = apiBase; _apiUrls = apiUrls;
}
private async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action)
{
for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
{
try
{
var baseUrl = _apiUrls[_currentUrlIndex];
return await action(baseUrl);
}
catch (Exception ex)
{
Logger.LogWarning(ex, "Request failed with endpoint {Endpoint}, trying next...", _apiUrls[_currentUrlIndex]);
_currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
if (attempt == _apiUrls.Count - 1)
{
Logger.LogError("All SquidWTF endpoints failed");
throw;
}
}
}
throw new Exception("All SquidWTF endpoints failed");
} }
#region BaseDownloadService Implementation #region BaseDownloadService Implementation
public override async Task<bool> IsAvailableAsync() public override async Task<bool> IsAvailableAsync()
{ {
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
var response = await _httpClient.GetAsync(SquidWTFApiBase); var response = await _httpClient.GetAsync(baseUrl);
Console.WriteLine($"Response code from is available async: {response.IsSuccessStatusCode}"); Console.WriteLine($"Response code from is available async: {response.IsSuccessStatusCode}");
return response.IsSuccessStatusCode; return response.IsSuccessStatusCode;
} });
catch (Exception ex)
{
Logger.LogWarning(ex, "SquidWTF service not available");
return false;
}
} }
protected override string? ExtractExternalIdFromAlbumId(string albumId) protected override string? ExtractExternalIdFromAlbumId(string albumId)
@@ -137,74 +157,69 @@ public class SquidWTFDownloadService : BaseDownloadService
{ {
return await QueueRequestAsync(async () => return await QueueRequestAsync(async () =>
{ {
// Map quality settings to Tidal's quality levels return await TryWithFallbackAsync(async (baseUrl) =>
var quality = _squidwtfSettings.Quality?.ToUpperInvariant() switch
{ {
"FLAC" => "LOSSLESS", // Map quality settings to Tidal's quality levels
"HI_RES" => "HI_RES_LOSSLESS", var quality = _squidwtfSettings.Quality?.ToUpperInvariant() switch
"LOSSLESS" => "LOSSLESS", {
"HIGH" => "HIGH", "FLAC" => "LOSSLESS",
"LOW" => "LOW", "HI_RES" => "HI_RES_LOSSLESS",
_ => "LOSSLESS" // Default to lossless "LOSSLESS" => "LOSSLESS",
}; "HIGH" => "HIGH",
"LOW" => "LOW",
_ => "LOSSLESS" // Default to lossless
};
var url = $"{SquidWTFApiBase}/track/?id={trackId}&quality={quality}"; var url = $"{baseUrl}/track/?id={trackId}&quality={quality}";
Console.WriteLine($"%%%%%%%%%%%%%%%%%%% URL For downloads??: {url}"); Console.WriteLine($"%%%%%%%%%%%%%%%%%%% URL For downloads??: {url}");
try var response = await _httpClient.GetAsync(url, cancellationToken);
{ response.EnsureSuccessStatusCode();
var response = await _httpClient.GetAsync(url, cancellationToken);
response.EnsureSuccessStatusCode();
var json = await response.Content.ReadAsStringAsync(cancellationToken); var json = await response.Content.ReadAsStringAsync(cancellationToken);
var doc = JsonDocument.Parse(json); var doc = JsonDocument.Parse(json);
if (!doc.RootElement.TryGetProperty("data", out var data)) if (!doc.RootElement.TryGetProperty("data", out var data))
{ {
throw new Exception("Invalid response from API"); throw new Exception("Invalid response from API");
} }
// Get the manifest (base64 encoded JSON containing the actual CDN URL) // Get the manifest (base64 encoded JSON containing the actual CDN URL)
var manifestBase64 = data.GetProperty("manifest").GetString() var manifestBase64 = data.GetProperty("manifest").GetString()
?? throw new Exception("No manifest in response"); ?? throw new Exception("No manifest in response");
// Decode the manifest // Decode the manifest
var manifestJson = Encoding.UTF8.GetString(Convert.FromBase64String(manifestBase64)); var manifestJson = Encoding.UTF8.GetString(Convert.FromBase64String(manifestBase64));
var manifest = JsonDocument.Parse(manifestJson); var manifest = JsonDocument.Parse(manifestJson);
// Extract the download URL from the manifest // Extract the download URL from the manifest
if (!manifest.RootElement.TryGetProperty("urls", out var urls) || urls.GetArrayLength() == 0) if (!manifest.RootElement.TryGetProperty("urls", out var urls) || urls.GetArrayLength() == 0)
{ {
throw new Exception("No download URLs in manifest"); throw new Exception("No download URLs in manifest");
} }
var downloadUrl = urls[0].GetString() var downloadUrl = urls[0].GetString()
?? throw new Exception("Download URL is null"); ?? throw new Exception("Download URL is null");
var mimeType = manifest.RootElement.TryGetProperty("mimeType", out var mimeTypeEl) var mimeType = manifest.RootElement.TryGetProperty("mimeType", out var mimeTypeEl)
? mimeTypeEl.GetString() ? mimeTypeEl.GetString()
: "audio/flac"; : "audio/flac";
var audioQuality = data.TryGetProperty("audioQuality", out var audioQualityEl) var audioQuality = data.TryGetProperty("audioQuality", out var audioQualityEl)
? audioQualityEl.GetString() ? audioQualityEl.GetString()
: "LOSSLESS"; : "LOSSLESS";
Logger.LogDebug("Decoded manifest - URL: {Url}, MIME: {MimeType}, Quality: {Quality}", Logger.LogDebug("Decoded manifest - URL: {Url}, MIME: {MimeType}, Quality: {Quality}",
downloadUrl, mimeType, audioQuality); downloadUrl, mimeType, audioQuality);
return new DownloadResult return new DownloadResult
{ {
DownloadUrl = downloadUrl, DownloadUrl = downloadUrl,
MimeType = mimeType ?? "audio/flac", MimeType = mimeType ?? "audio/flac",
AudioQuality = audioQuality ?? "LOSSLESS" AudioQuality = audioQuality ?? "LOSSLESS"
}; };
} });
catch (Exception ex)
{
Logger.LogWarning(ex, "Failed to get track info");
throw;
}
}); });
} }

149
allstarr/Services/SquidWTF/SquidWTFMetadataService.cs
View File

@@ -21,7 +21,8 @@ public class SquidWTFMetadataService : IMusicMetadataService
private readonly SubsonicSettings _settings; private readonly SubsonicSettings _settings;
private readonly ILogger<SquidWTFMetadataService> _logger; private readonly ILogger<SquidWTFMetadataService> _logger;
private readonly RedisCacheService _cache; private readonly RedisCacheService _cache;
private readonly string BaseUrl; private readonly List<string> _apiUrls;
private int _currentUrlIndex = 0;
public SquidWTFMetadataService( public SquidWTFMetadataService(
IHttpClientFactory httpClientFactory, IHttpClientFactory httpClientFactory,
@@ -29,24 +30,50 @@ public class SquidWTFMetadataService : IMusicMetadataService
IOptions<SquidWTFSettings> squidwtfSettings, IOptions<SquidWTFSettings> squidwtfSettings,
ILogger<SquidWTFMetadataService> logger, ILogger<SquidWTFMetadataService> logger,
RedisCacheService cache, RedisCacheService cache,
string baseUrl) List<string> apiUrls)
{ {
_httpClient = httpClientFactory.CreateClient(); _httpClient = httpClientFactory.CreateClient();
_settings = settings.Value; _settings = settings.Value;
_logger = logger; _logger = logger;
_cache = cache; _cache = cache;
BaseUrl = baseUrl; _apiUrls = apiUrls;
// Set up default headers // Set up default headers
_httpClient.DefaultRequestHeaders.Add("User-Agent", _httpClient.DefaultRequestHeaders.Add("User-Agent",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0"); "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0");
} }
private string GetCurrentBaseUrl() => _apiUrls[_currentUrlIndex];
private async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action, T defaultValue)
{
for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
{
try
{
var baseUrl = _apiUrls[_currentUrlIndex];
return await action(baseUrl);
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Request failed with endpoint {Endpoint}, trying next...", _apiUrls[_currentUrlIndex]);
_currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
if (attempt == _apiUrls.Count - 1)
{
_logger.LogError("All SquidWTF endpoints failed");
return defaultValue;
}
}
}
return defaultValue;
}
public async Task<List<Song>> SearchSongsAsync(string query, int limit = 20) public async Task<List<Song>> SearchSongsAsync(string query, int limit = 20)
{ {
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
var url = $"{BaseUrl}/search/?s={Uri.EscapeDataString(query)}"; var url = $"{baseUrl}/search/?s={Uri.EscapeDataString(query)}";
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
if (!response.IsSuccessStatusCode) if (!response.IsSuccessStatusCode)
@@ -72,19 +99,14 @@ public class SquidWTFMetadataService : IMusicMetadataService
} }
} }
return songs; return songs;
} }, new List<Song>());
catch (Exception ex)
{
_logger.LogWarning(ex, "Failed to search songs for query: {Query}", query);
return new List<Song>();
}
} }
public async Task<List<Album>> SearchAlbumsAsync(string query, int limit = 20) public async Task<List<Album>> SearchAlbumsAsync(string query, int limit = 20)
{ {
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
var url = $"{BaseUrl}/search/?al={Uri.EscapeDataString(query)}"; var url = $"{baseUrl}/search/?al={Uri.EscapeDataString(query)}";
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
if (!response.IsSuccessStatusCode) if (!response.IsSuccessStatusCode)
@@ -111,19 +133,14 @@ public class SquidWTFMetadataService : IMusicMetadataService
} }
return albums; return albums;
} }, new List<Album>());
catch (Exception ex)
{
_logger.LogWarning(ex, "Failed to search albums for query: {Query}", query);
return new List<Album>();
}
} }
public async Task<List<Artist>> SearchArtistsAsync(string query, int limit = 20) public async Task<List<Artist>> SearchArtistsAsync(string query, int limit = 20)
{ {
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
var url = $"{BaseUrl}/search/?a={Uri.EscapeDataString(query)}"; var url = $"{baseUrl}/search/?a={Uri.EscapeDataString(query)}";
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
if (!response.IsSuccessStatusCode) if (!response.IsSuccessStatusCode)
@@ -150,19 +167,14 @@ public class SquidWTFMetadataService : IMusicMetadataService
} }
return artists; return artists;
} }, new List<Artist>());
catch (Exception ex)
{
_logger.LogWarning(ex, "Failed to search artists for query: {Query}", query);
return new List<Artist>();
}
} }
public async Task<List<ExternalPlaylist>> SearchPlaylistsAsync(string query, int limit = 20) public async Task<List<ExternalPlaylist>> SearchPlaylistsAsync(string query, int limit = 20)
{ {
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
var url = $"{BaseUrl}/search/?p={Uri.EscapeDataString(query)}"; var url = $"{baseUrl}/search/?p={Uri.EscapeDataString(query)}";
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
if (!response.IsSuccessStatusCode) return new List<ExternalPlaylist>(); if (!response.IsSuccessStatusCode) return new List<ExternalPlaylist>();
@@ -180,11 +192,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
} }
} }
return playlists; return playlists;
} }, new List<ExternalPlaylist>());
catch
{
return new List<ExternalPlaylist>();
}
} }
public async Task<SearchResult> SearchAllAsync(string query, int songLimit = 20, int albumLimit = 20, int artistLimit = 20) public async Task<SearchResult> SearchAllAsync(string query, int songLimit = 20, int albumLimit = 20, int artistLimit = 20)
@@ -210,10 +218,9 @@ public class SquidWTFMetadataService : IMusicMetadataService
{ {
if (externalProvider != "squidwtf") return null; if (externalProvider != "squidwtf") return null;
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
// Use the /info endpoint for full track metadata var url = $"{baseUrl}/info/?id={externalId}";
var url = $"{BaseUrl}/info/?id={externalId}";
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
if (!response.IsSuccessStatusCode) return null; if (!response.IsSuccessStatusCode) return null;
@@ -225,12 +232,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
return null; return null;
return ParseTidalTrackFull(track); return ParseTidalTrackFull(track);
} }, (Song?)null);
catch (Exception ex)
{
_logger.LogWarning(ex, "GetSongAsync Exception");
return null;
}
} }
public async Task<Album?> GetAlbumAsync(string externalProvider, string externalId) public async Task<Album?> GetAlbumAsync(string externalProvider, string externalId)
@@ -242,10 +244,9 @@ public class SquidWTFMetadataService : IMusicMetadataService
var cached = await _cache.GetAsync<Album>(cacheKey); var cached = await _cache.GetAsync<Album>(cacheKey);
if (cached != null) return cached; if (cached != null) return cached;
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
// Use the /info endpoint for full track metadata var url = $"{baseUrl}/album/?id={externalId}";
var url = $"{BaseUrl}/album/?id={externalId}";
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
if (!response.IsSuccessStatusCode) return null; if (!response.IsSuccessStatusCode) return null;
@@ -279,12 +280,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
await _cache.SetAsync(cacheKey, album, TimeSpan.FromHours(24)); await _cache.SetAsync(cacheKey, album, TimeSpan.FromHours(24));
return album; return album;
} }, (Album?)null);
catch (Exception ex)
{
_logger.LogWarning(ex, "GetAlbumAsync Exception");
return null;
}
} }
public async Task<Artist?> GetArtistAsync(string externalProvider, string externalId) public async Task<Artist?> GetArtistAsync(string externalProvider, string externalId)
@@ -302,10 +298,9 @@ public class SquidWTFMetadataService : IMusicMetadataService
return cached; return cached;
} }
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
// Use the /info endpoint for full track metadata var url = $"{baseUrl}/artist/?f={externalId}";
var url = $"{BaseUrl}/artist/?f={externalId}";
_logger.LogInformation("Fetching artist from {Url}", url); _logger.LogInformation("Fetching artist from {Url}", url);
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
@@ -366,25 +361,18 @@ public class SquidWTFMetadataService : IMusicMetadataService
await _cache.SetAsync(cacheKey, artist, TimeSpan.FromHours(24)); await _cache.SetAsync(cacheKey, artist, TimeSpan.FromHours(24));
return artist; return artist;
}, (Artist?)null);
}
catch (Exception ex)
{
_logger.LogWarning(ex, "GetArtistAsync Exception.");
return null;
}
} }
public async Task<List<Album>> GetArtistAlbumsAsync(string externalProvider, string externalId) public async Task<List<Album>> GetArtistAlbumsAsync(string externalProvider, string externalId)
{ {
if (externalProvider != "squidwtf") return new List<Album>();
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
if (externalProvider != "squidwtf") return new List<Album>();
_logger.LogInformation("GetArtistAlbumsAsync called for SquidWTF artist {ExternalId}", externalId); _logger.LogInformation("GetArtistAlbumsAsync called for SquidWTF artist {ExternalId}", externalId);
var url = $"{BaseUrl}/artist/?f={externalId}"; var url = $"{baseUrl}/artist/?f={externalId}";
_logger.LogInformation("Fetching artist albums from URL: {Url}", url); _logger.LogInformation("Fetching artist albums from URL: {Url}", url);
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
@@ -418,21 +406,16 @@ public class SquidWTFMetadataService : IMusicMetadataService
} }
return albums; return albums;
} }, new List<Album>());
catch (Exception ex)
{
_logger.LogError(ex, "Failed to get SquidWTF artist albums for {ExternalId}", externalId);
return new List<Album>();
}
} }
public async Task<ExternalPlaylist?> GetPlaylistAsync(string externalProvider, string externalId) public async Task<ExternalPlaylist?> GetPlaylistAsync(string externalProvider, string externalId)
{ {
if (externalProvider != "squidwtf") return null; if (externalProvider != "squidwtf") return null;
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
var url = $"{BaseUrl}/playlist/?id={externalId}"; var url = $"{baseUrl}/playlist/?id={externalId}";
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
if (!response.IsSuccessStatusCode) return null; if (!response.IsSuccessStatusCode) return null;
@@ -442,21 +425,16 @@ public class SquidWTFMetadataService : IMusicMetadataService
if (playlistElement.TryGetProperty("error", out _)) return null; if (playlistElement.TryGetProperty("error", out _)) return null;
return ParseTidalPlaylist(playlistElement); return ParseTidalPlaylist(playlistElement);
} }, (ExternalPlaylist?)null);
catch
{
return null;
}
} }
public async Task<List<Song>> GetPlaylistTracksAsync(string externalProvider, string externalId) public async Task<List<Song>> GetPlaylistTracksAsync(string externalProvider, string externalId)
{ {
if (externalProvider != "squidwtf") return new List<Song>(); if (externalProvider != "squidwtf") return new List<Song>();
try return await TryWithFallbackAsync(async (baseUrl) =>
{ {
var url = $"{BaseUrl}/playlist/?id={externalId}"; var url = $"{baseUrl}/playlist/?id={externalId}";
var response = await _httpClient.GetAsync(url); var response = await _httpClient.GetAsync(url);
if (!response.IsSuccessStatusCode) return new List<Song>(); if (!response.IsSuccessStatusCode) return new List<Song>();
@@ -507,12 +485,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
} }
} }
return songs; return songs;
} }, new List<Song>());
catch
{
return new List<Song>();
}
} }
// --- Parser functions start here --- // --- Parser functions start here ---

70
allstarr/Services/SquidWTF/SquidWTFStartupValidator.cs
View File

@@ -12,15 +12,39 @@ namespace allstarr.Services.SquidWTF;
public class SquidWTFStartupValidator : BaseStartupValidator public class SquidWTFStartupValidator : BaseStartupValidator
{ {
private readonly SquidWTFSettings _settings; private readonly SquidWTFSettings _settings;
private readonly string _apiBase; private readonly List<string> _apiUrls;
private int _currentUrlIndex = 0;
public override string ServiceName => "SquidWTF"; public override string ServiceName => "SquidWTF";
public SquidWTFStartupValidator(IOptions<SquidWTFSettings> settings, HttpClient httpClient, string apiBase) public SquidWTFStartupValidator(IOptions<SquidWTFSettings> settings, HttpClient httpClient, List<string> apiUrls)
: base(httpClient) : base(httpClient)
{ {
_settings = settings.Value; _settings = settings.Value;
_apiBase = apiBase; _apiUrls = apiUrls;
}
private async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action, T defaultValue)
{
for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
{
try
{
var baseUrl = _apiUrls[_currentUrlIndex];
return await action(baseUrl);
}
catch
{
WriteDetail($"Endpoint {_apiUrls[_currentUrlIndex]} failed, trying next...");
_currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
if (attempt == _apiUrls.Count - 1)
{
return defaultValue;
}
}
}
return defaultValue;
} }
public override async Task<ValidationResult> ValidateAsync(CancellationToken cancellationToken) public override async Task<ValidationResult> ValidateAsync(CancellationToken cancellationToken)
@@ -39,54 +63,36 @@ public class SquidWTFStartupValidator : BaseStartupValidator
WriteStatus("SquidWTF Quality", quality, ConsoleColor.Cyan); WriteStatus("SquidWTF Quality", quality, ConsoleColor.Cyan);
// Test connectivity // Test connectivity with fallback
try var result = await TryWithFallbackAsync(async (baseUrl) =>
{ {
var response = await _httpClient.GetAsync(_apiBase, cancellationToken); var response = await _httpClient.GetAsync(baseUrl, cancellationToken);
if (response.IsSuccessStatusCode) if (response.IsSuccessStatusCode)
{ {
WriteStatus("SquidWTF API", "REACHABLE", ConsoleColor.Green); WriteStatus("SquidWTF API", $"REACHABLE ({baseUrl})", ConsoleColor.Green);
WriteDetail("No authentication required - powered by Tidal"); WriteDetail("No authentication required - powered by Tidal");
// Try a test search to verify functionality // Try a test search to verify functionality
await ValidateSearchFunctionality(cancellationToken); await ValidateSearchFunctionality(baseUrl, cancellationToken);
return ValidationResult.Success("SquidWTF validation completed"); return ValidationResult.Success("SquidWTF validation completed");
} }
else else
{ {
WriteStatus("SquidWTF API", $"HTTP {(int)response.StatusCode}", ConsoleColor.Yellow); throw new HttpRequestException($"HTTP {(int)response.StatusCode}");
WriteDetail("Service may be temporarily unavailable");
return ValidationResult.Failure($"{response.StatusCode}", "SquidWTF returned code");
} }
} }, ValidationResult.Failure("-1", "All SquidWTF endpoints failed"));
catch (TaskCanceledException)
{ return result;
WriteStatus("SquidWTF API", "TIMEOUT", ConsoleColor.Yellow);
WriteDetail("Could not reach service within timeout period");
return ValidationResult.Failure("-1", "SquidWTF connection timeout");
}
catch (HttpRequestException ex)
{
WriteStatus("SquidWTF API", "UNREACHABLE", ConsoleColor.Red);
WriteDetail(ex.Message);
return ValidationResult.Failure("-1", $"Cannot connect to SquidWTF: {ex.Message}");
}
catch (Exception ex)
{
WriteStatus("SquidWTF API", "ERROR", ConsoleColor.Red);
WriteDetail(ex.Message);
return ValidationResult.Failure("-1", $"Validation error: {ex.Message}");
}
} }
private async Task ValidateSearchFunctionality(CancellationToken cancellationToken) private async Task ValidateSearchFunctionality(string baseUrl, CancellationToken cancellationToken)
{ {
try try
{ {
// Test search with a simple query // Test search with a simple query
var searchUrl = $"{_apiBase}/search/?s=Taylor%20Swift"; var searchUrl = $"{baseUrl}/search/?s=Taylor%20Swift";
var searchResponse = await _httpClient.GetAsync(searchUrl, cancellationToken); var searchResponse = await _httpClient.GetAsync(searchUrl, cancellationToken);
if (searchResponse.IsSuccessStatusCode) if (searchResponse.IsSuccessStatusCode)