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);
}
}
}
}