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 Microsoft.Extensions.Options; using StackExchange.Redis; namespace Jellyfin.Server.Extensions; /// /// Extensions for registering the session directory and the instance-addressed message bus. /// public static class SessionDirectoryServiceCollectionExtensions { /// /// Registers the session directory and message bus, Redis-backed when a connection string is /// configured and no-op otherwise, and reports the selection at . /// /// The service collection. /// The configuration to read Jellyfin:SessionDirectory from. /// The logger to report the selection on. /// The updated service collection. public static IServiceCollection AddSessionDirectory( this IServiceCollection serviceCollection, IConfiguration configuration, ILogger logger) { ArgumentNullException.ThrowIfNull(configuration); ArgumentNullException.ThrowIfNull(logger); serviceCollection.Configure(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); } else { logger.LogInformation( "Session directory: {Directory}. Sessions are visible to, and controllable from, every instance.", nameof(RedisSessionDirectory)); serviceCollection.AddSingleton(SharedSessionServices.Create); } serviceCollection.AddSingleton(sp => sp.GetService()?.Bus ?? NullPodMessageBus.Instance); return serviceCollection.AddSingleton(sp => sp.GetService()?.Directory ?? NullSessionDirectory.Instance); } // A Redis directory paired with a no-op bus would leave every routed command permanently // undeliverable, so the pair is built together and falls back together. private sealed class SharedSessionServices { private SharedSessionServices(ISessionDirectory directory, IPodMessageBus bus) { Directory = directory; Bus = bus; } public ISessionDirectory Directory { get; } public IPodMessageBus Bus { get; } // Fail open: an unreachable Redis degrades to the single-instance behaviour rather than aborting startup. public static SharedSessionServices Create(IServiceProvider serviceProvider) { try { var redis = serviceProvider.GetRequiredService(); var options = serviceProvider.GetRequiredService>(); return new SharedSessionServices( new RedisSessionDirectory(redis, options, serviceProvider.GetRequiredService>()), new RedisPodMessageBus(redis, options, PodIdentity.Current, serviceProvider.GetRequiredService>())); } catch (Exception ex) { serviceProvider.GetRequiredService>().LogError( ex, "Redis is configured but unavailable, so sessions will not be shared between instances. Check {Key}.", TranscodeStoreOptions.RedisConnectionStringKey); return new SharedSessionServices(NullSessionDirectory.Instance, NullPodMessageBus.Instance); } } } }