Files
jellyfin-ha-src/Jellyfin.Server/Extensions/SessionDirectoryServiceCollectionExtensions.cs
T
unkin-agent 00d0765152
ci/woodpecker/pr/ci Pipeline failed
ci/woodpecker/push/ci Pipeline failed
feat(session): share the session directory between instances
Publish every session to valkey with the instance holding it, and route a
command for a non-local session to its owner over a per-instance pub/sub
channel. Entries expire, so a dead instance leaves the directory.
2026-09-24 22:48:48 +10:00

84 lines
3.6 KiB
C#

using System;
using Emby.Server.Implementations.Session;
using MediaBrowser.Controller.MediaEncoding;
using MediaBrowser.Controller.Session;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using StackExchange.Redis;
namespace Jellyfin.Server.Extensions;
/// <summary>
/// Extensions for registering the session directory and the instance-addressed message bus.
/// </summary>
public static class SessionDirectoryServiceCollectionExtensions
{
/// <summary>
/// Registers the session directory and message bus, Redis-backed when a connection string is
/// configured and no-op otherwise, and reports the selection at <see cref="LogLevel.Information"/>.
/// </summary>
/// <param name="serviceCollection">The service collection.</param>
/// <param name="configuration">The configuration to read <c>Jellyfin:SessionDirectory</c> from.</param>
/// <param name="logger">The logger to report the selection on.</param>
/// <returns>The updated service collection.</returns>
public static IServiceCollection AddSessionDirectory(
this IServiceCollection serviceCollection,
IConfiguration configuration,
ILogger logger)
{
ArgumentNullException.ThrowIfNull(configuration);
ArgumentNullException.ThrowIfNull(logger);
serviceCollection.Configure<SessionDirectoryOptions>(configuration.GetSection(SessionDirectoryOptions.ConfigurationSection));
if (string.IsNullOrEmpty(configuration[TranscodeStoreOptions.RedisConnectionStringKey]))
{
logger.LogInformation(
"Session directory: {Directory}. The session list and remote control only reach the sessions this instance holds; set {Key} to share them.",
nameof(NullSessionDirectory),
TranscodeStoreOptions.RedisConnectionStringKey);
serviceCollection.AddSingleton<ISessionDirectory>(NullSessionDirectory.Instance);
return serviceCollection.AddSingleton<IPodMessageBus>(NullPodMessageBus.Instance);
}
logger.LogInformation(
"Session directory: {Directory}. Sessions are visible to, and controllable from, every instance.",
nameof(RedisSessionDirectory));
serviceCollection.AddSingleton<IPodMessageBus>(sp => Create<IPodMessageBus>(
sp,
() => new RedisPodMessageBus(
sp.GetRequiredService<IConnectionMultiplexer>(),
sp.GetRequiredService<ILogger<RedisPodMessageBus>>()),
NullPodMessageBus.Instance));
return serviceCollection.AddSingleton<ISessionDirectory>(sp => Create<ISessionDirectory>(
sp,
() => new RedisSessionDirectory(
sp.GetRequiredService<IConnectionMultiplexer>(),
sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SessionDirectoryOptions>>(),
sp.GetRequiredService<ILogger<RedisSessionDirectory>>()),
NullSessionDirectory.Instance));
}
// Fail open: an unreachable Redis degrades to the single-instance behaviour rather than aborting startup.
private static T Create<T>(IServiceProvider serviceProvider, Func<T> factory, T fallback)
{
try
{
return factory();
}
catch (Exception ex)
{
serviceProvider.GetRequiredService<ILogger<CoreAppHost>>().LogError(
ex,
"Redis is configured but unavailable, so sessions will not be shared between instances. Check {Key}.",
TranscodeStoreOptions.RedisConnectionStringKey);
return fallback;
}
}
}