more consolidation

2025-12-07 13:29:13 +01:00
parent ed4cc0990c
commit 198fc4c58d
9 changed files with 209 additions and 361 deletions
@@ -10,6 +10,7 @@ using System.Web;
 using Jellyfin.Plugin.SRFPlay.Api;
 using Jellyfin.Plugin.SRFPlay.Configuration;
 using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Common.Net;
 using Microsoft.Extensions.Logging;

 namespace Jellyfin.Plugin.SRFPlay.Services;
@@ -17,14 +18,13 @@ namespace Jellyfin.Plugin.SRFPlay.Services;
 /// <summary>
 /// Service for proxying SRF Play streams and managing authentication.
 /// </summary>
-public class StreamProxyService : IStreamProxyService, IDisposable
+public class StreamProxyService : IStreamProxyService
 {
    private readonly ILogger<StreamProxyService> _logger;
    private readonly IStreamUrlResolver _streamResolver;
    private readonly IMediaCompositionFetcher _compositionFetcher;
-    private readonly HttpClient _httpClient;
+    private readonly IHttpClientFactory _httpClientFactory;
    private readonly ConcurrentDictionary<string, StreamInfo> _streamMappings;
-    private bool _disposed;

    /// <summary>
    /// Initializes a new instance of the <see cref="StreamProxyService"/> class.
@@ -32,18 +32,17 @@ public class StreamProxyService : IStreamProxyService, IDisposable
    /// <param name="logger">The logger.</param>
    /// <param name="streamResolver">The stream URL resolver.</param>
    /// <param name="compositionFetcher">The media composition fetcher.</param>
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
    public StreamProxyService(
        ILogger<StreamProxyService> logger,
        IStreamUrlResolver streamResolver,
-        IMediaCompositionFetcher compositionFetcher)
+        IMediaCompositionFetcher compositionFetcher,
+        IHttpClientFactory httpClientFactory)
    {
        _logger = logger;
        _streamResolver = streamResolver;
        _compositionFetcher = compositionFetcher;
-        _httpClient = new HttpClient
-        {
-            Timeout = TimeSpan.FromSeconds(30)
-        };
+        _httpClientFactory = httpClientFactory;
        _streamMappings = new ConcurrentDictionary<string, StreamInfo>();
    }

@@ -70,29 +69,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
            LastLivestreamFetchAt = isLiveStream ? DateTime.UtcNow : null
        };

-        // Register with the provided item ID
-        _streamMappings.AddOrUpdate(itemId, streamInfo, (key, old) => streamInfo);
-
-        // Also register with alternative GUID formats to handle Jellyfin's ID transformations
-        if (Guid.TryParse(itemId, out var guid))
-        {
-            var formats = new[]
-            {
-                guid.ToString("N"), // Without dashes: 00000000000000000000000000000000
-                guid.ToString("D"), // With dashes: 00000000-0000-0000-0000-000000000000
-                guid.ToString("B"), // With braces: {00000000-0000-0000-0000-000000000000}
-            };
-
-            foreach (var format in formats)
-            {
-                if (format != itemId) // Don't duplicate the original
-                {
-                    _streamMappings.AddOrUpdate(format, streamInfo, (key, old) => streamInfo);
-                }
-            }
-
-            _logger.LogDebug("Registered stream with {Count} GUID format variations", formats.Length);
-        }
+        RegisterWithGuidFormats(itemId, streamInfo);

        if (tokenExpiry.HasValue)
        {
@@ -129,27 +106,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
            NeedsAuthentication = true
        };

-        // Register with the provided item ID
-        _streamMappings.AddOrUpdate(itemId, streamInfo, (key, old) => streamInfo);
-
-        // Also register with alternative GUID formats
-        if (Guid.TryParse(itemId, out var guid))
-        {
-            var formats = new[]
-            {
-                guid.ToString("N"),
-                guid.ToString("D"),
-                guid.ToString("B"),
-            };
-
-            foreach (var format in formats)
-            {
-                if (format != itemId)
-                {
-                    _streamMappings.AddOrUpdate(format, streamInfo, (key, old) => streamInfo);
-                }
-            }
-        }
+        RegisterWithGuidFormats(itemId, streamInfo);

        _logger.LogDebug(
            "Registered deferred stream for item {ItemId} (URN: {Urn}, will authenticate on first access)",
@@ -191,10 +148,11 @@ public class StreamProxyService : IStreamProxyService, IDisposable
    /// Gets the authenticated URL for an item.
    /// </summary>
    /// <param name="itemId">The item ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
    /// <returns>The authenticated URL, or null if not found or expired.</returns>
-    public string? GetAuthenticatedUrl(string itemId)
+    public async Task<string?> GetAuthenticatedUrlAsync(string itemId, CancellationToken cancellationToken = default)
    {
-        _logger.LogInformation("GetAuthenticatedUrl called for itemId: {ItemId}", itemId);
+        _logger.LogInformation("GetAuthenticatedUrlAsync called for itemId: {ItemId}", itemId);

        // Try direct lookup first
        if (_streamMappings.TryGetValue(itemId, out var streamInfo))
@@ -204,7 +162,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
                ? (streamInfo.TokenExpiresAt.Value - DateTime.UtcNow).TotalSeconds
                : -1;
            _logger.LogInformation(
-                "✅ Found stream by direct lookup for itemId: {ItemId} - NeedsAuth={NeedsAuth}, IsLive={IsLive}, Urn={Urn}, TokenLeft={TokenLeft:F0}s, AuthUrl={HasAuth}",
+                "Found stream by direct lookup for itemId: {ItemId} - NeedsAuth={NeedsAuth}, IsLive={IsLive}, Urn={Urn}, TokenLeft={TokenLeft:F0}s, AuthUrl={HasAuth}",
                itemId,
                streamInfo.NeedsAuthentication,
                streamInfo.IsLiveStream,
@@ -225,14 +183,14 @@ public class StreamProxyService : IStreamProxyService, IDisposable
                        itemId,
                        freshStream.Value.Key);
                    _streamMappings.AddOrUpdate(itemId, freshStream.Value.Value, (key, old) => freshStream.Value.Value);
-                    return ValidateAndReturnStream(itemId, freshStream.Value.Value);
+                    return await ValidateAndReturnStreamAsync(itemId, freshStream.Value.Value, cancellationToken).ConfigureAwait(false);
                }
            }

-            return ValidateAndReturnStream(itemId, streamInfo);
+            return await ValidateAndReturnStreamAsync(itemId, streamInfo, cancellationToken).ConfigureAwait(false);
        }

-        _logger.LogWarning("❌ No direct match for itemId: {ItemId}, trying fallbacks... (Registered streams: {Count})", itemId, _streamMappings.Count);
+        _logger.LogWarning("No direct match for itemId: {ItemId}, trying fallbacks... (Registered streams: {Count})", itemId, _streamMappings.Count);

        // Fallback: Try to find by GUID variations (with/without dashes)
        // This handles cases where Jellyfin uses different GUID formats
@@ -248,7 +206,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
                        "Found stream by GUID normalization - Requested: {RequestedId}, Registered: {RegisteredId}",
                        itemId,
                        kvp.Key);
-                    var url = ValidateAndReturnStream(kvp.Key, kvp.Value);
+                    var url = await ValidateAndReturnStreamAsync(kvp.Key, kvp.Value, cancellationToken).ConfigureAwait(false);
                    if (url != null)
                    {
                        return url; // Found valid stream
@@ -282,7 +240,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
            // Register the transcoding session ID as an alias (update if stale alias exists)
            _streamMappings.AddOrUpdate(itemId, activeStreams[0].Value, (key, old) => activeStreams[0].Value);

-            return ValidateAndReturnStream(activeStreams[0].Key, activeStreams[0].Value);
+            return await ValidateAndReturnStreamAsync(activeStreams[0].Key, activeStreams[0].Value, cancellationToken).ConfigureAwait(false);
        }

        // If multiple active streams, use the most recently registered one (likely the one being transcoded)
@@ -305,7 +263,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
                // Register the transcoding session ID as an alias (update if stale alias exists)
                _streamMappings.AddOrUpdate(itemId, mostRecent.Value, (key, old) => mostRecent.Value);

-                return ValidateAndReturnStream(mostRecent.Key, mostRecent.Value);
+                return await ValidateAndReturnStreamAsync(mostRecent.Key, mostRecent.Value, cancellationToken).ConfigureAwait(false);
            }
        }

@@ -320,7 +278,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
    /// <summary>
    /// Validates a stream and returns its URL if valid.
    /// </summary>
-    private string? ValidateAndReturnStream(string itemId, StreamInfo streamInfo)
+    private async Task<string?> ValidateAndReturnStreamAsync(string itemId, StreamInfo streamInfo, CancellationToken cancellationToken)
    {
        // Handle deferred authentication (first playback after browsing)
        if (streamInfo.NeedsAuthentication)
@@ -329,7 +287,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
                "First playback for item {ItemId} - authenticating stream on-demand",
                itemId);

-            var authenticatedUrl = AuthenticateOnDemand(itemId, streamInfo);
+            var authenticatedUrl = await AuthenticateOnDemandAsync(itemId, streamInfo, cancellationToken).ConfigureAwait(false);
            if (authenticatedUrl != null)
            {
                return authenticatedUrl;
@@ -369,7 +327,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
                tokenTimeLeft,
                timeSinceLastFetch);

-            var freshUrl = FetchFreshStreamUrl(itemId, streamInfo);
+            var freshUrl = await FetchFreshStreamUrlAsync(itemId, streamInfo, cancellationToken).ConfigureAwait(false);
            if (freshUrl != null)
            {
                return freshUrl;
@@ -403,7 +361,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
                    now);

                // Try to refresh the token
-                var refreshedUrl = RefreshToken(itemId, streamInfo);
+                var refreshedUrl = await RefreshTokenAsync(itemId, streamInfo, cancellationToken).ConfigureAwait(false);
                if (refreshedUrl != null)
                {
                    _logger.LogInformation("Successfully refreshed token for item {ItemId}", itemId);
@@ -428,7 +386,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
    /// <summary>
    /// Fetches a fresh stream URL from the SRF API for livestreams.
    /// </summary>
-    private string? FetchFreshStreamUrl(string itemId, StreamInfo streamInfo)
+    private async Task<string?> FetchFreshStreamUrlAsync(string itemId, StreamInfo streamInfo, CancellationToken cancellationToken)
    {
        if (string.IsNullOrEmpty(streamInfo.Urn))
        {
@@ -438,8 +396,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
        try
        {
            // Use short cache duration (5 min) for livestreams
-            var mediaComposition = _compositionFetcher.GetMediaCompositionAsync(streamInfo.Urn, CancellationToken.None, 5)
-                .GetAwaiter().GetResult();
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(streamInfo.Urn, cancellationToken, 5).ConfigureAwait(false);

            if (mediaComposition?.ChapterList == null || mediaComposition.ChapterList.Count == 0)
            {
@@ -458,8 +415,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
            }

            // Authenticate the fresh URL
-            var authenticatedUrl = _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, CancellationToken.None)
-                .GetAwaiter().GetResult();
+            var authenticatedUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, cancellationToken).ConfigureAwait(false);

            // Update the stored stream info with the fresh data
            var newTokenExpiry = ExtractTokenExpiry(authenticatedUrl);
@@ -486,7 +442,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
    /// <summary>
    /// Attempts to refresh an expired token.
    /// </summary>
-    private string? RefreshToken(string itemId, StreamInfo streamInfo)
+    private async Task<string?> RefreshTokenAsync(string itemId, StreamInfo streamInfo, CancellationToken cancellationToken)
    {
        if (string.IsNullOrEmpty(streamInfo.UnauthenticatedUrl))
        {
@@ -496,10 +452,10 @@ public class StreamProxyService : IStreamProxyService, IDisposable

        try
        {
-            // Re-authenticate the stream URL synchronously (blocking call)
-            var newAuthenticatedUrl = _streamResolver.GetAuthenticatedStreamUrlAsync(
+            // Re-authenticate the stream URL
+            var newAuthenticatedUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(
                streamInfo.UnauthenticatedUrl,
-                CancellationToken.None).GetAwaiter().GetResult();
+                cancellationToken).ConfigureAwait(false);

            if (string.IsNullOrEmpty(newAuthenticatedUrl))
            {
@@ -528,7 +484,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
    /// <summary>
    /// Authenticates a stream on-demand (first playback after browsing).
    /// </summary>
-    private string? AuthenticateOnDemand(string itemId, StreamInfo streamInfo)
+    private async Task<string?> AuthenticateOnDemandAsync(string itemId, StreamInfo streamInfo, CancellationToken cancellationToken)
    {
        if (string.IsNullOrEmpty(streamInfo.UnauthenticatedUrl))
        {
@@ -539,9 +495,9 @@ public class StreamProxyService : IStreamProxyService, IDisposable
        try
        {
            // Authenticate the stream URL
-            var authenticatedUrl = _streamResolver.GetAuthenticatedStreamUrlAsync(
+            var authenticatedUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(
                streamInfo.UnauthenticatedUrl,
-                CancellationToken.None).GetAwaiter().GetResult();
+                cancellationToken).ConfigureAwait(false);

            if (string.IsNullOrEmpty(authenticatedUrl))
            {
@@ -669,7 +625,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
        string baseProxyUrl,
        CancellationToken cancellationToken = default)
    {
-        var authenticatedUrl = GetAuthenticatedUrl(itemId);
+        var authenticatedUrl = await GetAuthenticatedUrlAsync(itemId, cancellationToken).ConfigureAwait(false);
        if (authenticatedUrl == null)
        {
            return null;
@@ -678,14 +634,15 @@ public class StreamProxyService : IStreamProxyService, IDisposable
        try
        {
            _logger.LogInformation("Fetching manifest from: {Url}", authenticatedUrl);
-            var manifestContent = await _httpClient.GetStringAsync(authenticatedUrl, cancellationToken).ConfigureAwait(false);
+            using var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+            var manifestContent = await httpClient.GetStringAsync(authenticatedUrl, cancellationToken).ConfigureAwait(false);

-            _logger.LogInformation("Original manifest ({Length} bytes):\n{Content}", manifestContent.Length, manifestContent);
+            _logger.LogDebug("Original manifest ({Length} bytes):\n{Content}", manifestContent.Length, manifestContent);

            // Rewrite the manifest to replace Akamai URLs with proxy URLs
            var rewrittenContent = RewriteManifestUrls(manifestContent, authenticatedUrl, baseProxyUrl);

-            _logger.LogInformation("Rewritten manifest for item {ItemId} ({Length} bytes):\n{Content}", itemId, rewrittenContent.Length, rewrittenContent);
+            _logger.LogDebug("Rewritten manifest for item {ItemId} ({Length} bytes):\n{Content}", itemId, rewrittenContent.Length, rewrittenContent);
            return rewrittenContent;
        }
        catch (Exception ex)
@@ -707,7 +664,7 @@ public class StreamProxyService : IStreamProxyService, IDisposable
        string segmentPath,
        CancellationToken cancellationToken = default)
    {
-        var authenticatedUrl = GetAuthenticatedUrl(itemId);
+        var authenticatedUrl = await GetAuthenticatedUrlAsync(itemId, cancellationToken).ConfigureAwait(false);
        if (authenticatedUrl == null)
        {
            return null;
@@ -725,13 +682,14 @@ public class StreamProxyService : IStreamProxyService, IDisposable
            // Build full segment URL
            var segmentUrl = $"{baseUrl}/{segmentPath}{queryParams}";

-            _logger.LogInformation(
+            _logger.LogDebug(
                "Fetching segment - BaseUri: {BaseUri}, BaseUrl: {BaseUrl}, SegmentPath: {SegmentPath}, FullUrl: {FullUrl}",
                authenticatedUrl,
                baseUrl,
                segmentPath,
                segmentUrl);
-            var segmentData = await _httpClient.GetByteArrayAsync(segmentUrl, cancellationToken).ConfigureAwait(false);
+            using var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+            var segmentData = await httpClient.GetByteArrayAsync(segmentUrl, cancellationToken).ConfigureAwait(false);

            _logger.LogDebug("Successfully fetched segment {SegmentPath} ({Size} bytes)", segmentPath, segmentData.Length);
            return segmentData;
@@ -892,31 +850,33 @@ public class StreamProxyService : IStreamProxyService, IDisposable
    }

    /// <summary>
-    /// Disposes the service.
+    /// Registers a stream with multiple GUID format variations to handle Jellyfin's ID transformations.
    /// </summary>
-    public void Dispose()
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="streamInfo">The stream information to register.</param>
+    private void RegisterWithGuidFormats(string itemId, StreamInfo streamInfo)
    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
+        _streamMappings.AddOrUpdate(itemId, streamInfo, (key, old) => streamInfo);

-    /// <summary>
-    /// Disposes the service.
-    /// </summary>
-    /// <param name="disposing">True if disposing.</param>
-    protected virtual void Dispose(bool disposing)
-    {
-        if (_disposed)
+        if (Guid.TryParse(itemId, out var guid))
        {
-            return;
-        }
+            var formats = new[]
+            {
+                guid.ToString("N"), // Without dashes: 00000000000000000000000000000000
+                guid.ToString("D"), // With dashes: 00000000-0000-0000-0000-000000000000
+                guid.ToString("B"), // With braces: {00000000-0000-0000-0000-000000000000}
+            };

-        if (disposing)
-        {
-            _httpClient?.Dispose();
-        }
+            foreach (var format in formats)
+            {
+                if (format != itemId) // Don't duplicate the original
+                {
+                    _streamMappings.AddOrUpdate(format, streamInfo, (key, old) => streamInfo);
+                }
+            }

-        _disposed = true;
+            _logger.LogDebug("Registered stream with {Count} GUID format variations", formats.Length);
+        }
    }

    /// <summary>