fix: make transcode leases ownership-checked and cleanup-aware

Cleanup never matched a live session because the controller registered empty
manifest and segment paths, renewal was a read-modify-write that could revert a
takeover, and the takeover script compared an ISO date to a number, so it errored.

- populate the session record's manifest and segment paths from the playlist path
- renew the lease via a Lua compare-and-set on the owning pod
- store the lease expiry as unix milliseconds so the scripts can compare it
- retain the session record past its lease so an orphan can still be taken over
- test the Redis store against a real Redis, including the renew-vs-takeover race
- drop the live stream record nothing ever read back

tests/Jellyfin.Server.Implementations.Tests/ScheduledTasks/DeleteTranscodeFileTaskTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -13,13 +14,9 @@ using Xunit;
 namespace Jellyfin.Server.Implementations.Tests.ScheduledTasks;
 
 /// <summary>
-/// Tests for lease-aware cleanup behavior expected of <c>DeleteTranscodeFileTask</c> once
-/// it is made HA-aware in Phase 5.2.
-/// <para>
-/// The current <c>DeleteTranscodeFileTask</c> implementation uses file-age only and does not
-/// check <see cref="ITranscodeSessionStore"/>, which creates a data-loss risk on shared NFS
-/// storage. These tests document the correct contract by exercising the store directly.
-/// </para>
+/// Tests for the lease-aware cleanup behaviour of <c>DeleteTranscodeFileTask</c>: files belonging
+/// to a session whose lease is still live must survive a cleanup pass, and a store failure must
+/// abort the pass rather than risk deleting files in use.
 /// </summary>
 public class DeleteTranscodeFileTaskTests
 {
@@ -313,6 +310,64 @@ public class DeleteTranscodeFileTaskTests
         Assert.Empty(deletedFiles);
     }
 
+    /// <summary>
+    /// The files of a live session, named exactly as the HLS pipeline writes them and recorded by
+    /// the same production factory the controller uses, survive a cleanup pass while an unrelated
+    /// stale file from a finished session is deleted.
+    /// </summary>
+    [Fact]
+    [Trait("Category", "UnitTest")]
+    public async Task ExecuteAsync_WithLiveSessionRegisteredByProduction_KeepsItsFilesAndDeletesTheRest()
+    {
+        const string TranscodePath = "/transcode";
+        var playlistPath = Path.Combine(TranscodePath, "9e1c6f.m3u8");
+        var session = TranscodeSession.CreateForPlaylist("play-1", "media-1", "pod-a", playlistPath, TimeSpan.FromMinutes(5));
+
+        var sessionFiles = new[]
+        {
+            playlistPath,
+            TranscodeSession.GetSegmentPathPrefix(playlistPath) + "0.ts",
+            TranscodeSession.GetSegmentPathPrefix(playlistPath) + "1.ts",
+            TranscodeSession.GetSegmentPathPrefix(playlistPath) + "-1.mp4",
+        };
+
+        var orphanedFile = Path.Combine(TranscodePath, "abandoned.m3u8");
+
+        var store = new CleanupTestSessionStore();
+        await store.SetAsync(session, TestContext.Current.CancellationToken);
+
+        var deletedFiles = new List<string>();
+        var fileSystemMock = new Mock<IFileSystem>();
+        fileSystemMock
+            .Setup(fs => fs.GetFiles(TranscodePath, true))
+            .Returns(sessionFiles.Append(orphanedFile).Select(path => new FileSystemMetadata { FullName = path, IsDirectory = false }));
+        fileSystemMock
+            .Setup(fs => fs.GetLastWriteTimeUtc(It.IsAny<FileSystemMetadata>()))
+            .Returns(DateTime.UtcNow.AddDays(-2));
+        fileSystemMock
+            .Setup(fs => fs.DeleteFile(It.IsAny<string>()))
+            .Callback<string>(deletedFiles.Add);
+        fileSystemMock
+            .Setup(fs => fs.GetDirectories(It.IsAny<string>(), It.IsAny<bool>()))
+            .Returns(Enumerable.Empty<FileSystemMetadata>());
+
+        var localizationMock = new Mock<MediaBrowser.Model.Globalization.ILocalizationManager>();
+        localizationMock
+            .Setup(l => l.GetLocalizedString(It.IsAny<string>()))
+            .Returns<string>(key => key);
+
+        var task = new Emby.Server.Implementations.ScheduledTasks.Tasks.DeleteTranscodeFileTask(
+            new Mock<Microsoft.Extensions.Logging.ILogger<Emby.Server.Implementations.ScheduledTasks.Tasks.DeleteTranscodeFileTask>>().Object,
+            fileSystemMock.Object,
+            CreateConfigMock(TranscodePath).Object,
+            localizationMock.Object,
+            store);
+
+        await task.ExecuteAsync(new Progress<double>(), CancellationToken.None);
+
+        Assert.Equal(new[] { orphanedFile }, deletedFiles);
+    }
+
     /// <summary>
     /// Minimal in-memory <see cref="ITranscodeSessionStore"/> used within this test class
     /// to avoid a cross-project reference to Jellyfin.MediaEncoding.Tests.
@@ -369,17 +424,19 @@ public class DeleteTranscodeFileTaskTests
             return Task.CompletedTask;
         }
 
-        public Task RenewLeaseAsync(string playSessionId, CancellationToken cancellationToken = default)
+        public Task<bool> RenewLeaseAsync(string playSessionId, string ownerPod, CancellationToken cancellationToken = default)
         {
             lock (_lock)
             {
-                if (_sessions.TryGetValue(playSessionId, out var s))
+                if (!_sessions.TryGetValue(playSessionId, out var s)
+                    || !string.Equals(s.OwnerPod, ownerPod, StringComparison.Ordinal))
                 {
-                    s.LeaseExpiresUtc = DateTime.UtcNow.Add(LeaseDuration);
+                    return Task.FromResult(false);
                 }
-            }
 
-            return Task.CompletedTask;
+                s.LeaseExpiresUtc = DateTime.UtcNow.Add(LeaseDuration);
+                return Task.FromResult(true);
+            }
         }
 
         public Task DeleteAsync(string playSessionId, CancellationToken cancellationToken = default)
@@ -404,15 +461,6 @@ public class DeleteTranscodeFileTaskTests
             }
         }
 
-        public Task SetLiveStreamAsync(LiveStreamSession session, CancellationToken cancellationToken = default)
-            => Task.CompletedTask;
-
-        public Task<LiveStreamSession?> TryGetLiveStreamAsync(string liveStreamId, string sessionIdOrPlaySessionId, CancellationToken cancellationToken = default)
-            => Task.FromResult<LiveStreamSession?>(null);
-
-        public Task DeleteLiveStreamAsync(string liveStreamId, string sessionIdOrPlaySessionId, CancellationToken cancellationToken = default)
-            => Task.CompletedTask;
-
         private static TranscodeSession Clone(TranscodeSession source)
             => new TranscodeSession
             {