Phase 5.2.2a: Register HLS sessions in ITranscodeSessionStore + lease renewal (#23)

* Initial plan * Phase 5.2.2a: Register HLS sessions in ITranscodeSessionStore + lease renewal Co-authored-by: ZoltyMat <177592743+ZoltyMat@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: ZoltyMat <177592743+ZoltyMat@users.noreply.github.com>
2026-03-09 23:50:10 -04:00
parent d60ae43b59
commit c2a11f3e68
2 changed files with 289 additions and 1 deletions
@@ -0,0 +1,201 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.MediaEncoding;
+using Xunit;
+
+namespace Jellyfin.Api.Tests.Controllers
+{
+    /// <summary>
+    /// Tests for HLS session registration, lease renewal, and cleanup behaviour wired into
+    /// <see cref="Jellyfin.Api.Controllers.DynamicHlsController"/> in Phase 5.2.2a.
+    /// These tests verify the <see cref="ITranscodeSessionStore"/> contract used by the controller.
+    /// </summary>
+    public class DynamicHlsSessionRegistrationTests
+    {
+        private static TranscodeSession CreateSession(string id, string pod)
+            => new TranscodeSession
+            {
+                PlaySessionId = id,
+                OwnerPod = pod,
+                LeaseExpiresUtc = DateTime.UtcNow.AddSeconds(30),
+                ManifestPath = string.Empty,
+                SegmentPathPrefix = string.Empty,
+                MediaSourceId = "media-source-1",
+                LastCompletedSegmentIndex = 0,
+                LastDurablePlaybackOffset = 0L,
+            };
+
+        /// <summary>
+        /// After registering a session via <see cref="ITranscodeSessionStore.SetAsync"/>,
+        /// <see cref="ITranscodeSessionStore.TryGetAsync"/> must return a non-null result with
+        /// matching <see cref="TranscodeSession.PlaySessionId"/> and <see cref="TranscodeSession.OwnerPod"/>.
+        /// </summary>
+        [Fact]
+        [Trait("Category", "UnitTest")]
+        public async Task SessionRegistration_AfterStreamStart_StoreContainsSession()
+        {
+            var store = new InMemoryTranscodeSessionStore();
+            var session = CreateSession("session-reg-1", "pod-a");
+
+            await store.SetAsync(session);
+
+            var retrieved = await store.TryGetAsync("session-reg-1");
+
+            Assert.NotNull(retrieved);
+            Assert.Equal("session-reg-1", retrieved.PlaySessionId);
+            Assert.Equal("pod-a", retrieved.OwnerPod);
+        }
+
+        /// <summary>
+        /// After calling <see cref="ITranscodeSessionStore.DeleteAsync"/>,
+        /// <see cref="ITranscodeSessionStore.TryGetAsync"/> must return <c>null</c>.
+        /// </summary>
+        [Fact]
+        [Trait("Category", "UnitTest")]
+        public async Task SessionCleanup_AfterStreamEnd_StoreReturnsNull()
+        {
+            var store = new InMemoryTranscodeSessionStore();
+            var session = CreateSession("session-cleanup-1", "pod-b");
+
+            await store.SetAsync(session);
+            await store.DeleteAsync("session-cleanup-1");
+
+            var retrieved = await store.TryGetAsync("session-cleanup-1");
+
+            Assert.Null(retrieved);
+        }
+
+        /// <summary>
+        /// After a session's initial lease window would have expired, calling
+        /// <see cref="ITranscodeSessionStore.RenewLeaseAsync"/> must extend the lease so that
+        /// <see cref="ITranscodeSessionStore.TryGetAsync"/> still returns the session as active.
+        /// </summary>
+        [Fact]
+        [Trait("Category", "UnitTest")]
+        public async Task LeaseRenewal_ExtendsBeyondInitialExpiry()
+        {
+            var store = new InMemoryTranscodeSessionStore();
+
+            // Create the session with a lease that has already expired.
+            var session = new TranscodeSession
+            {
+                PlaySessionId = "session-renewal-1",
+                OwnerPod = "pod-c",
+                LeaseExpiresUtc = DateTime.UtcNow.AddMilliseconds(-1),
+                ManifestPath = string.Empty,
+                SegmentPathPrefix = string.Empty,
+                MediaSourceId = "media-source-1",
+                LastCompletedSegmentIndex = 0,
+                LastDurablePlaybackOffset = 0L,
+            };
+            await store.SetAsync(session);
+
+            // Verify the session is not accessible because the lease has expired.
+            Assert.Null(await store.TryGetAsync("session-renewal-1"));
+
+            // Renew the lease.
+            await store.RenewLeaseAsync("session-renewal-1");
+
+            // After renewal the session must be accessible again.
+            var renewed = await store.TryGetAsync("session-renewal-1");
+            Assert.NotNull(renewed);
+            Assert.Equal("session-renewal-1", renewed.PlaySessionId);
+            Assert.True(renewed.LeaseExpiresUtc > DateTime.UtcNow);
+        }
+
+        /// <summary>
+        /// Minimal thread-safe in-memory implementation of <see cref="ITranscodeSessionStore"/>
+        /// used within this test class to avoid a cross-project reference.
+        /// </summary>
+        private sealed class InMemoryTranscodeSessionStore : ITranscodeSessionStore
+        {
+            private static readonly TimeSpan DefaultLeaseDuration = TimeSpan.FromSeconds(30);
+
+            private readonly Dictionary<string, TranscodeSession> _sessions =
+                new(StringComparer.OrdinalIgnoreCase);
+
+            private readonly Lock _lock = new();
+
+            public Task<TranscodeSession?> TryGetAsync(string playSessionId, CancellationToken cancellationToken = default)
+            {
+                lock (_lock)
+                {
+                    if (_sessions.TryGetValue(playSessionId, out var session) && session.LeaseExpiresUtc > DateTime.UtcNow)
+                    {
+                        return Task.FromResult<TranscodeSession?>(Clone(session));
+                    }
+
+                    return Task.FromResult<TranscodeSession?>(null);
+                }
+            }
+
+            public Task<bool> TryTakeoverAsync(string playSessionId, string claimingPod, CancellationToken cancellationToken = default)
+            {
+                lock (_lock)
+                {
+                    if (!_sessions.TryGetValue(playSessionId, out var session))
+                    {
+                        return Task.FromResult(false);
+                    }
+
+                    if (session.LeaseExpiresUtc > DateTime.UtcNow)
+                    {
+                        return Task.FromResult(false);
+                    }
+
+                    session.OwnerPod = claimingPod;
+                    session.LeaseExpiresUtc = DateTime.UtcNow.Add(DefaultLeaseDuration);
+                    return Task.FromResult(true);
+                }
+            }
+
+            public Task SetAsync(TranscodeSession session, CancellationToken cancellationToken = default)
+            {
+                lock (_lock)
+                {
+                    _sessions[session.PlaySessionId] = session;
+                }
+
+                return Task.CompletedTask;
+            }
+
+            public Task RenewLeaseAsync(string playSessionId, CancellationToken cancellationToken = default)
+            {
+                lock (_lock)
+                {
+                    if (_sessions.TryGetValue(playSessionId, out var session))
+                    {
+                        session.LeaseExpiresUtc = DateTime.UtcNow.Add(DefaultLeaseDuration);
+                    }
+                }
+
+                return Task.CompletedTask;
+            }
+
+            public Task DeleteAsync(string playSessionId, CancellationToken cancellationToken = default)
+            {
+                lock (_lock)
+                {
+                    _sessions.Remove(playSessionId);
+                }
+
+                return Task.CompletedTask;
+            }
+
+            private static TranscodeSession Clone(TranscodeSession source)
+                => new TranscodeSession
+                {
+                    PlaySessionId = source.PlaySessionId,
+                    OwnerPod = source.OwnerPod,
+                    LeaseExpiresUtc = source.LeaseExpiresUtc,
+                    ManifestPath = source.ManifestPath,
+                    SegmentPathPrefix = source.SegmentPathPrefix,
+                    MediaSourceId = source.MediaSourceId,
+                    LastCompletedSegmentIndex = source.LastCompletedSegmentIndex,
+                    LastDurablePlaybackOffset = source.LastDurablePlaybackOffset,
+                };
+        }
+    }
+}