< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.ApplicationHost
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/ApplicationHost.cs
Line coverage
74%
Covered lines: 275
Uncovered lines: 96
Coverable lines: 371
Total lines: 1022
Line coverage: 74.1%
Branch coverage
49%
Covered branches: 62
Total branches: 126
Branch coverage: 49.2%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 1/23/2026 - 12:11:06 AM Line coverage: 72.1% (225/312) Branch coverage: 39.4% (41/104) Total lines: 10144/19/2026 - 12:14:27 AM Line coverage: 73.5% (267/363) Branch coverage: 49.2% (62/126) Total lines: 10145/4/2026 - 12:15:16 AM Line coverage: 74% (274/370) Branch coverage: 49.2% (62/126) Total lines: 10215/5/2026 - 12:15:44 AM Line coverage: 74.1% (275/371) Branch coverage: 49.2% (62/126) Total lines: 1022 1/23/2026 - 12:11:06 AM Line coverage: 72.1% (225/312) Branch coverage: 39.4% (41/104) Total lines: 10144/19/2026 - 12:14:27 AM Line coverage: 73.5% (267/363) Branch coverage: 49.2% (62/126) Total lines: 10145/4/2026 - 12:15:16 AM Line coverage: 74% (274/370) Branch coverage: 49.2% (62/126) Total lines: 10215/5/2026 - 12:15:44 AM Line coverage: 74.1% (275/371) Branch coverage: 49.2% (62/126) Total lines: 1022

Coverage delta

Coverage delta 10 -10

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_PublishedServerUrl()100%210%
get_ApplicationUserAgentAddress()100%11100%
get_SystemId()100%11100%
get_Name()100%11100%
get_ListenWithHttps()0%620%
get_FriendlyName()0%620%
ExpandVirtualPath(...)50%2280%
ReverseVirtualPath(...)100%11100%
CreateInstanceSafe(...)62.5%15852.63%
Resolve()100%11100%
GetExportTypes()100%44100%
GetExports(...)100%66100%
GetExports(...)83.33%6688.88%
RunStartupTasksAsync()50%2290.9%
Init(...)50%4481.25%
RegisterServices(...)100%11100%
InitializeServices()100%11100%
GetCertificate(...)12.5%48814.28%
SetStaticProperties()100%11100%
FindParts()100%22100%
DiscoverTypes()100%11100%
GetTypes()100%341246.66%
OnConfigurationUpdated(...)64.28%341453.33%
ValidateSslCertificate(...)33.33%15636.36%
NotifyPendingRestart()0%620%
GetComposablePartAssemblies()75%4493.75%
GetSmartApiUrl(...)0%620%
GetSmartApiUrl(...)0%210140%
GetSmartApiUrl(...)0%620%
GetApiUrlForLocalAccess(...)0%2040%
GetLocalApiUrl(...)0%110100%
GetApiPluginAssemblies()100%22100%
Dispose()100%11100%
Dispose(...)87.5%9876.47%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/ApplicationHost.cs

#LineLine coverage
 1#nullable disable
 2
 3#pragma warning disable CS1591
 4
 5using System;
 6using System.Collections.Concurrent;
 7using System.Collections.Generic;
 8using System.Diagnostics;
 9using System.Globalization;
 10using System.IO;
 11using System.Linq;
 12using System.Net;
 13using System.Reflection;
 14using System.Security.Cryptography.X509Certificates;
 15using System.Threading.Tasks;
 16using Emby.Naming.Common;
 17using Emby.Photos;
 18using Emby.Server.Implementations.Chapters;
 19using Emby.Server.Implementations.Collections;
 20using Emby.Server.Implementations.Configuration;
 21using Emby.Server.Implementations.Cryptography;
 22using Emby.Server.Implementations.Data;
 23using Emby.Server.Implementations.Devices;
 24using Emby.Server.Implementations.Dto;
 25using Emby.Server.Implementations.HttpServer.Security;
 26using Emby.Server.Implementations.IO;
 27using Emby.Server.Implementations.Library;
 28using Emby.Server.Implementations.Localization;
 29using Emby.Server.Implementations.Playlists;
 30using Emby.Server.Implementations.Plugins;
 31using Emby.Server.Implementations.QuickConnect;
 32using Emby.Server.Implementations.ScheduledTasks;
 33using Emby.Server.Implementations.Serialization;
 34using Emby.Server.Implementations.Session;
 35using Emby.Server.Implementations.SyncPlay;
 36using Emby.Server.Implementations.TV;
 37using Emby.Server.Implementations.Updates;
 38using Jellyfin.Api.Helpers;
 39using Jellyfin.Drawing;
 40using Jellyfin.MediaEncoding.Hls.Playlist;
 41using Jellyfin.Networking.Manager;
 42using Jellyfin.Networking.Udp;
 43using Jellyfin.Server.Implementations.FullSystemBackup;
 44using Jellyfin.Server.Implementations.Item;
 45using Jellyfin.Server.Implementations.MediaSegments;
 46using Jellyfin.Server.Implementations.SystemBackupService;
 47using MediaBrowser.Common;
 48using MediaBrowser.Common.Configuration;
 49using MediaBrowser.Common.Events;
 50using MediaBrowser.Common.Net;
 51using MediaBrowser.Common.Plugins;
 52using MediaBrowser.Common.Updates;
 53using MediaBrowser.Controller;
 54using MediaBrowser.Controller.Channels;
 55using MediaBrowser.Controller.Chapters;
 56using MediaBrowser.Controller.ClientEvent;
 57using MediaBrowser.Controller.Collections;
 58using MediaBrowser.Controller.Configuration;
 59using MediaBrowser.Controller.Drawing;
 60using MediaBrowser.Controller.Dto;
 61using MediaBrowser.Controller.Entities;
 62using MediaBrowser.Controller.Entities.TV;
 63using MediaBrowser.Controller.IO;
 64using MediaBrowser.Controller.Library;
 65using MediaBrowser.Controller.LibraryTaskScheduler;
 66using MediaBrowser.Controller.LiveTv;
 67using MediaBrowser.Controller.Lyrics;
 68using MediaBrowser.Controller.MediaEncoding;
 69using MediaBrowser.Controller.MediaSegments;
 70using MediaBrowser.Controller.Net;
 71using MediaBrowser.Controller.Persistence;
 72using MediaBrowser.Controller.Playlists;
 73using MediaBrowser.Controller.Providers;
 74using MediaBrowser.Controller.QuickConnect;
 75using MediaBrowser.Controller.Resolvers;
 76using MediaBrowser.Controller.Session;
 77using MediaBrowser.Controller.Sorting;
 78using MediaBrowser.Controller.Subtitles;
 79using MediaBrowser.Controller.SyncPlay;
 80using MediaBrowser.Controller.TV;
 81using MediaBrowser.LocalMetadata.Savers;
 82using MediaBrowser.MediaEncoding.BdInfo;
 83using MediaBrowser.MediaEncoding.Subtitles;
 84using MediaBrowser.MediaEncoding.Transcoding;
 85using MediaBrowser.Model.Cryptography;
 86using MediaBrowser.Model.Globalization;
 87using MediaBrowser.Model.IO;
 88using MediaBrowser.Model.MediaInfo;
 89using MediaBrowser.Model.Net;
 90using MediaBrowser.Model.Serialization;
 91using MediaBrowser.Model.System;
 92using MediaBrowser.Model.Tasks;
 93using MediaBrowser.Providers.Lyric;
 94using MediaBrowser.Providers.Manager;
 95using MediaBrowser.Providers.Plugins.Tmdb;
 96using MediaBrowser.Providers.Subtitles;
 97using MediaBrowser.XbmcMetadata.Providers;
 98using Microsoft.AspNetCore.Http;
 99using Microsoft.AspNetCore.Mvc;
 100using Microsoft.Extensions.Configuration;
 101using Microsoft.Extensions.DependencyInjection;
 102using Microsoft.Extensions.Logging;
 103using Prometheus.DotNetRuntime;
 104using static MediaBrowser.Controller.Extensions.ConfigurationExtensions;
 105using IConfigurationManager = MediaBrowser.Common.Configuration.IConfigurationManager;
 106using WebSocketManager = Emby.Server.Implementations.HttpServer.WebSocketManager;
 107
 108namespace Emby.Server.Implementations
 109{
 110    /// <summary>
 111    /// Class CompositionRoot.
 112    /// </summary>
 113    public abstract class ApplicationHost : IServerApplicationHost, IDisposable
 114    {
 115        /// <summary>
 116        /// The disposable parts.
 117        /// </summary>
 21118        private readonly ConcurrentBag<IDisposable> _disposableParts = new();
 119        private readonly DeviceId _deviceId;
 120
 121        private readonly IConfiguration _startupConfig;
 122        private readonly IXmlSerializer _xmlSerializer;
 123        private readonly IStartupOptions _startupOptions;
 124        private readonly PluginManager _pluginManager;
 125
 126        private List<Type> _creatingInstances;
 127
 128        /// <summary>
 129        /// Gets or sets all concrete types.
 130        /// </summary>
 131        /// <value>All concrete types.</value>
 132        private Type[] _allConcreteTypes;
 133
 134        private bool _disposed;
 135
 136        /// <summary>
 137        /// Initializes a new instance of the <see cref="ApplicationHost"/> class.
 138        /// </summary>
 139        /// <param name="applicationPaths">Instance of the <see cref="IServerApplicationPaths"/> interface.</param>
 140        /// <param name="loggerFactory">Instance of the <see cref="ILoggerFactory"/> interface.</param>
 141        /// <param name="options">Instance of the <see cref="IStartupOptions"/> interface.</param>
 142        /// <param name="startupConfig">The <see cref="IConfiguration" /> interface.</param>
 143        protected ApplicationHost(
 144            IServerApplicationPaths applicationPaths,
 145            ILoggerFactory loggerFactory,
 146            IStartupOptions options,
 147            IConfiguration startupConfig)
 148        {
 149            ApplicationPaths = applicationPaths;
 150            LoggerFactory = loggerFactory;
 21151            _startupOptions = options;
 21152            _startupConfig = startupConfig;
 153
 21154            Logger = LoggerFactory.CreateLogger<ApplicationHost>();
 21155            _deviceId = new DeviceId(ApplicationPaths, LoggerFactory.CreateLogger<DeviceId>());
 156
 21157            ApplicationVersion = typeof(ApplicationHost).Assembly.GetName().Version;
 21158            ApplicationVersionString = ApplicationVersion.ToString(3);
 21159            ApplicationUserAgent = Name.Replace(' ', '-') + "/" + ApplicationVersionString;
 160
 21161            _xmlSerializer = new MyXmlSerializer();
 21162            ConfigurationManager = new ServerConfigurationManager(ApplicationPaths, LoggerFactory, _xmlSerializer);
 21163            _pluginManager = new PluginManager(
 21164                LoggerFactory.CreateLogger<PluginManager>(),
 21165                this,
 21166                ConfigurationManager.Configuration,
 21167                ApplicationPaths.PluginsPath,
 21168                ApplicationVersion);
 169
 21170            _disposableParts.Add(_pluginManager);
 21171        }
 172
 173        /// <summary>
 174        /// Occurs when [has pending restart changed].
 175        /// </summary>
 176        public event EventHandler HasPendingRestartChanged;
 177
 178        /// <summary>
 179        /// Gets the value of the PublishedServerUrl setting.
 180        /// </summary>
 0181        private string PublishedServerUrl => _startupConfig[AddressOverrideKey];
 182
 183        public bool CoreStartupHasCompleted { get; private set; }
 184
 185        /// <summary>
 186        /// Gets the <see cref="INetworkManager"/> singleton instance.
 187        /// </summary>
 188        public INetworkManager NetManager { get; private set; }
 189
 190        /// <inheritdoc />
 191        public bool HasPendingRestart { get; private set; }
 192
 193        /// <inheritdoc />
 194        public bool ShouldRestart { get; set; }
 195
 196        /// <summary>
 197        /// Gets the logger.
 198        /// </summary>
 199        protected ILogger<ApplicationHost> Logger { get; }
 200
 201        /// <summary>
 202        /// Gets the logger factory.
 203        /// </summary>
 204        protected ILoggerFactory LoggerFactory { get; }
 205
 206        /// <summary>
 207        /// Gets the application paths.
 208        /// </summary>
 209        /// <value>The application paths.</value>
 210        protected IServerApplicationPaths ApplicationPaths { get; }
 211
 212        /// <summary>
 213        /// Gets the configuration manager.
 214        /// </summary>
 215        /// <value>The configuration manager.</value>
 216        public ServerConfigurationManager ConfigurationManager { get; }
 217
 218        /// <summary>
 219        /// Gets or sets the service provider.
 220        /// </summary>
 221        public IServiceProvider ServiceProvider { get; set; }
 222
 223        /// <summary>
 224        /// Gets the http port for the webhost.
 225        /// </summary>
 226        public int HttpPort { get; private set; }
 227
 228        /// <summary>
 229        /// Gets the https port for the webhost.
 230        /// </summary>
 231        public int HttpsPort { get; private set; }
 232
 233        /// <inheritdoc />
 234        public Version ApplicationVersion { get; }
 235
 236        /// <inheritdoc />
 237        public string ApplicationVersionString { get; }
 238
 239        /// <summary>
 240        /// Gets the current application user agent.
 241        /// </summary>
 242        /// <value>The application user agent.</value>
 243        public string ApplicationUserAgent { get; }
 244
 245        /// <summary>
 246        /// Gets the email address for use within a comment section of a user agent field.
 247        /// Presently used to provide contact information to MusicBrainz service.
 248        /// </summary>
 21249        public string ApplicationUserAgentAddress => "team@jellyfin.org";
 250
 251        /// <summary>
 252        /// Gets the current application name.
 253        /// </summary>
 254        /// <value>The application name.</value>
 21255        public string ApplicationProductName { get; } = FileVersionInfo.GetVersionInfo(Assembly.GetEntryAssembly().Locat
 256
 94257        public string SystemId => _deviceId.Value;
 258
 259        /// <inheritdoc/>
 63260        public string Name => ApplicationProductName;
 261
 262        private string CertificatePath { get; set; }
 263
 264        public X509Certificate2 Certificate { get; private set; }
 265
 266        /// <inheritdoc/>
 0267        public bool ListenWithHttps => Certificate is not null && ConfigurationManager.GetNetworkConfiguration().EnableH
 268
 269        public string FriendlyName =>
 0270            string.IsNullOrEmpty(ConfigurationManager.Configuration.ServerName)
 0271                ? Environment.MachineName
 0272                : ConfigurationManager.Configuration.ServerName;
 273
 274        public string RestoreBackupPath { get; set; }
 275
 276        public string ExpandVirtualPath(string path)
 277        {
 74278            if (path is null)
 279            {
 0280                return null;
 281            }
 282
 74283            var appPaths = ApplicationPaths;
 284
 74285            return path.Replace(appPaths.VirtualDataPath, appPaths.DataPath, StringComparison.OrdinalIgnoreCase)
 74286                .Replace(appPaths.VirtualInternalMetadataPath, appPaths.InternalMetadataPath, StringComparison.OrdinalIg
 287        }
 288
 289        public string ReverseVirtualPath(string path)
 290        {
 111291            var appPaths = ApplicationPaths;
 292
 111293            return path.Replace(appPaths.DataPath, appPaths.VirtualDataPath, StringComparison.OrdinalIgnoreCase)
 111294                .Replace(appPaths.InternalMetadataPath, appPaths.VirtualInternalMetadataPath, StringComparison.OrdinalIg
 295        }
 296
 297        /// <summary>
 298        /// Creates the instance safe.
 299        /// </summary>
 300        /// <param name="type">The type.</param>
 301        /// <returns>System.Object.</returns>
 302        protected object CreateInstanceSafe(Type type)
 303        {
 4305304            _creatingInstances ??= new List<Type>();
 305
 4305306            if (_creatingInstances.Contains(type))
 307            {
 0308                Logger.LogError("DI Loop detected in the attempted creation of {Type}", type.FullName);
 0309                foreach (var entry in _creatingInstances)
 310                {
 0311                    Logger.LogError("Called from: {TypeName}", entry.FullName);
 312                }
 313
 0314                _pluginManager.FailPlugin(type.Assembly);
 315
 0316                throw new TypeLoadException("DI Loop detected");
 317            }
 318
 319            try
 320            {
 4305321                _creatingInstances.Add(type);
 4305322                Logger.LogDebug("Creating instance of {Type}", type);
 4305323                return ServiceProvider is null
 4305324                    ? Activator.CreateInstance(type)
 4305325                    : ActivatorUtilities.CreateInstance(ServiceProvider, type);
 326            }
 0327            catch (Exception ex)
 328            {
 0329                Logger.LogError(ex, "Error creating {Type}", type);
 330                // If this is a plugin fail it.
 0331                _pluginManager.FailPlugin(type.Assembly);
 0332                return null;
 333            }
 334            finally
 335            {
 4305336                _creatingInstances.Remove(type);
 4305337            }
 4305338        }
 339
 340        /// <summary>
 341        /// Resolves this instance.
 342        /// </summary>
 343        /// <typeparam name="T">The type.</typeparam>
 344        /// <returns>``0.</returns>
 504345        public T Resolve<T>() => ServiceProvider.GetService<T>();
 346
 347        /// <inheritdoc/>
 348        public IEnumerable<Type> GetExportTypes<T>()
 349        {
 378350            var currentType = typeof(T);
 378351            var numberOfConcreteTypes = _allConcreteTypes.Length;
 770364352            for (var i = 0; i < numberOfConcreteTypes; i++)
 353            {
 384804354                var type = _allConcreteTypes[i];
 384804355                if (currentType.IsAssignableFrom(type))
 356                {
 4494357                    yield return type;
 358                }
 359            }
 378360        }
 361
 362        /// <inheritdoc />
 363        public IReadOnlyCollection<T> GetExports<T>(bool manageLifetime = true)
 364        {
 365            // Convert to list so this isn't executed for each iteration
 294366            var parts = GetExportTypes<T>()
 294367                .Select(CreateInstanceSafe)
 294368                .Where(i => i is not null)
 294369                .Cast<T>()
 294370                .ToList();
 371
 294372            if (manageLifetime)
 373            {
 630374                foreach (var part in parts.OfType<IDisposable>())
 375                {
 42376                    _disposableParts.Add(part);
 377                }
 378            }
 379
 294380            return parts;
 381        }
 382
 383        /// <inheritdoc />
 384        public IReadOnlyCollection<T> GetExports<T>(CreationDelegateFactory defaultFunc, bool manageLifetime = true)
 385        {
 386            // Convert to list so this isn't executed for each iteration
 21387            var parts = GetExportTypes<T>()
 21388                .Select(i => defaultFunc(i))
 21389                .Where(i => i is not null)
 21390                .Cast<T>()
 21391                .ToList();
 392
 21393            if (manageLifetime)
 394            {
 42395                foreach (var part in parts.OfType<IDisposable>())
 396                {
 0397                    _disposableParts.Add(part);
 398                }
 399            }
 400
 21401            return parts;
 402        }
 403
 404        /// <summary>
 405        /// Runs the startup tasks.
 406        /// </summary>
 407        /// <returns><see cref="Task" />.</returns>
 408        public Task RunStartupTasksAsync()
 409        {
 21410            Logger.LogInformation("Running startup tasks");
 411
 21412            Resolve<ITaskManager>().AddTasks(GetExports<IScheduledTask>(false));
 413
 21414            ConfigurationManager.ConfigurationUpdated += OnConfigurationUpdated;
 21415            ConfigurationManager.NamedConfigurationUpdated += OnConfigurationUpdated;
 416
 21417            var ffmpegValid = Resolve<IMediaEncoder>().SetFFmpegPath();
 418
 21419            if (!ffmpegValid)
 420            {
 0421                throw new FfmpegException("Failed to find valid ffmpeg");
 422            }
 423
 21424            Logger.LogInformation("ServerId: {ServerId}", SystemId);
 21425            Logger.LogInformation("Core startup complete");
 21426            CoreStartupHasCompleted = true;
 427
 21428            return Task.CompletedTask;
 429        }
 430
 431        /// <inheritdoc/>
 432        public void Init(IServiceCollection serviceCollection)
 433        {
 21434            DiscoverTypes();
 435
 21436            ConfigurationManager.AddParts(GetExports<IConfigurationFactory>());
 437
 21438            NetManager = new NetworkManager(ConfigurationManager, _startupConfig, LoggerFactory.CreateLogger<NetworkMana
 439
 440            // Initialize runtime stat collection
 21441            if (ConfigurationManager.Configuration.EnableMetrics)
 442            {
 0443                _disposableParts.Add(DotNetRuntimeStatsBuilder.Default().StartCollecting());
 444            }
 445
 21446            var networkConfiguration = ConfigurationManager.GetNetworkConfiguration();
 21447            HttpPort = networkConfiguration.InternalHttpPort;
 21448            HttpsPort = networkConfiguration.InternalHttpsPort;
 449
 450            // Safeguard against invalid configuration
 21451            if (HttpPort == HttpsPort)
 452            {
 0453                HttpPort = NetworkConfiguration.DefaultHttpPort;
 0454                HttpsPort = NetworkConfiguration.DefaultHttpsPort;
 455            }
 456
 21457            CertificatePath = networkConfiguration.CertificatePath;
 21458            Certificate = GetCertificate(CertificatePath, networkConfiguration.CertificatePassword);
 459
 21460            RegisterServices(serviceCollection);
 461
 21462            _pluginManager.RegisterServices(serviceCollection);
 21463        }
 464
 465        /// <summary>
 466        /// Registers services/resources with the service collection that will be available via DI.
 467        /// </summary>
 468        /// <param name="serviceCollection">Instance of the <see cref="IServiceCollection"/> interface.</param>
 469        protected virtual void RegisterServices(IServiceCollection serviceCollection)
 470        {
 21471            serviceCollection.AddSingleton(_startupOptions);
 472
 21473            serviceCollection.AddMemoryCache();
 474
 21475            serviceCollection.AddSingleton<IServerConfigurationManager>(ConfigurationManager);
 21476            serviceCollection.AddSingleton<IConfigurationManager>(ConfigurationManager);
 21477            serviceCollection.AddSingleton<IApplicationHost>(this);
 21478            serviceCollection.AddSingleton<IPluginManager>(_pluginManager);
 21479            serviceCollection.AddSingleton<IApplicationPaths>(ApplicationPaths);
 21480            serviceCollection.AddSingleton<IBackupService, BackupService>();
 481
 21482            serviceCollection.AddSingleton<IFileSystem, ManagedFileSystem>();
 21483            serviceCollection.AddSingleton<IShortcutHandler, MbLinkShortcutHandler>();
 484
 21485            serviceCollection.AddScoped<ISystemManager, SystemManager>();
 486
 21487            serviceCollection.AddSingleton<TmdbClientManager>();
 488
 21489            serviceCollection.AddSingleton(NetManager);
 490
 21491            serviceCollection.AddSingleton<ITaskManager, TaskManager>();
 492
 21493            serviceCollection.AddSingleton(_xmlSerializer);
 494
 21495            serviceCollection.AddSingleton<ICryptoProvider, CryptographyProvider>();
 496
 21497            serviceCollection.AddSingleton<ISocketFactory, SocketFactory>();
 498
 21499            serviceCollection.AddSingleton<IInstallationManager, InstallationManager>();
 500
 21501            serviceCollection.AddSingleton<IServerApplicationHost>(this);
 21502            serviceCollection.AddSingleton(ApplicationPaths);
 503
 21504            serviceCollection.AddSingleton<ILocalizationManager, LocalizationManager>();
 505
 21506            serviceCollection.AddSingleton<IBlurayExaminer, BdInfoExaminer>();
 507
 21508            serviceCollection.AddSingleton<IUserDataManager, UserDataManager>();
 509
 21510            serviceCollection.AddSingleton<BaseItemRepository>();
 21511            serviceCollection.AddSingleton<IItemRepository>(sp => sp.GetRequiredService<BaseItemRepository>());
 21512            serviceCollection.AddSingleton<IItemQueryHelpers>(sp => sp.GetRequiredService<BaseItemRepository>());
 21513            serviceCollection.AddSingleton<IItemPersistenceService, ItemPersistenceService>();
 21514            serviceCollection.AddSingleton<INextUpService, NextUpService>();
 21515            serviceCollection.AddSingleton<IItemCountService, ItemCountService>();
 21516            serviceCollection.AddSingleton<ILinkedChildrenService, LinkedChildrenService>();
 21517            serviceCollection.AddSingleton<IPeopleRepository, PeopleRepository>();
 21518            serviceCollection.AddSingleton<IChapterRepository, ChapterRepository>();
 21519            serviceCollection.AddSingleton<IMediaAttachmentRepository, MediaAttachmentRepository>();
 21520            serviceCollection.AddSingleton<IMediaStreamRepository, MediaStreamRepository>();
 21521            serviceCollection.AddSingleton<IKeyframeRepository, KeyframeRepository>();
 21522            serviceCollection.AddSingleton<IItemTypeLookup, ItemTypeLookup>();
 523
 21524            serviceCollection.AddSingleton<IMediaEncoder, MediaBrowser.MediaEncoding.Encoder.MediaEncoder>();
 21525            serviceCollection.AddSingleton<EncodingHelper>();
 21526            serviceCollection.AddSingleton<IPathManager, PathManager>();
 21527            serviceCollection.AddSingleton<IExternalDataManager, ExternalDataManager>();
 528
 529            // TODO: Refactor to eliminate the circular dependencies here so that Lazy<T> isn't required
 21530            serviceCollection.AddTransient(provider => new Lazy<ILibraryMonitor>(provider.GetRequiredService<ILibraryMon
 21531            serviceCollection.AddTransient(provider => new Lazy<IProviderManager>(provider.GetRequiredService<IProviderM
 21532            serviceCollection.AddTransient(provider => new Lazy<IUserViewManager>(provider.GetRequiredService<IUserViewM
 21533            serviceCollection.AddSingleton<ILibraryManager, LibraryManager>();
 21534            serviceCollection.AddSingleton<NamingOptions>();
 535
 21536            serviceCollection.AddSingleton<IMusicManager, MusicManager>();
 537
 21538            serviceCollection.AddSingleton<ILibraryMonitor, LibraryMonitor>();
 21539            serviceCollection.AddSingleton<DotIgnoreIgnoreRule>();
 540
 21541            serviceCollection.AddSingleton<ISearchEngine, SearchEngine>();
 542
 21543            serviceCollection.AddSingleton<IWebSocketManager, WebSocketManager>();
 544
 21545            serviceCollection.AddSingleton<IImageProcessor, ImageProcessor>();
 546
 21547            serviceCollection.AddSingleton<ITVSeriesManager, TVSeriesManager>();
 548
 21549            serviceCollection.AddSingleton<IMediaSourceManager, MediaSourceManager>();
 550
 21551            serviceCollection.AddSingleton<ISubtitleManager, SubtitleManager>();
 21552            serviceCollection.AddSingleton<ILyricManager, LyricManager>();
 553
 21554            serviceCollection.AddSingleton<IProviderManager, ProviderManager>();
 555
 556            // TODO: Refactor to eliminate the circular dependency here so that Lazy<T> isn't required
 21557            serviceCollection.AddTransient(provider => new Lazy<ILiveTvManager>(provider.GetRequiredService<ILiveTvManag
 21558            serviceCollection.AddSingleton<IDtoService, DtoService>();
 559
 21560            serviceCollection.AddSingleton<ISessionManager, SessionManager>();
 561
 21562            serviceCollection.AddSingleton<ICollectionManager, CollectionManager>();
 21563            serviceCollection.AddSingleton<ILimitedConcurrencyLibraryScheduler, LimitedConcurrencyLibraryScheduler>();
 564
 21565            serviceCollection.AddSingleton<IPlaylistManager, PlaylistManager>();
 566
 21567            serviceCollection.AddSingleton<ISyncPlayManager, SyncPlayManager>();
 568
 21569            serviceCollection.AddSingleton<IUserViewManager, UserViewManager>();
 570
 21571            serviceCollection.AddSingleton<IChapterManager, ChapterManager>();
 572
 21573            serviceCollection.AddSingleton<IAuthService, AuthService>();
 21574            serviceCollection.AddSingleton<IQuickConnect, QuickConnectManager>();
 575
 21576            serviceCollection.AddSingleton<ISubtitleParser, SubtitleEditParser>();
 21577            serviceCollection.AddSingleton<ISubtitleEncoder, SubtitleEncoder>();
 21578            serviceCollection.AddSingleton<IKeyframeManager, KeyframeManager>();
 579
 21580            serviceCollection.AddSingleton<IAttachmentExtractor, MediaBrowser.MediaEncoding.Attachments.AttachmentExtrac
 581
 21582            serviceCollection.AddSingleton<ITranscodeManager, TranscodeManager>();
 21583            serviceCollection.AddScoped<MediaInfoHelper>();
 21584            serviceCollection.AddScoped<AudioHelper>();
 21585            serviceCollection.AddScoped<DynamicHlsHelper>();
 21586            serviceCollection.AddScoped<IClientEventLogger, ClientEventLogger>();
 21587            serviceCollection.AddSingleton<IDirectoryService, DirectoryService>();
 588
 21589            serviceCollection.AddSingleton<IMediaSegmentManager, MediaSegmentManager>();
 21590        }
 591
 592        /// <summary>
 593        /// Create services registered with the service container that need to be initialized at application startup.
 594        /// </summary>
 595        /// <param name="startupConfig">The configuration used to initialise the application.</param>
 596        /// <returns>A task representing the service initialization operation.</returns>
 597        public async Task InitializeServices(IConfiguration startupConfig)
 598        {
 21599            var localizationManager = (LocalizationManager)Resolve<ILocalizationManager>();
 21600            await localizationManager.LoadAll().ConfigureAwait(false);
 601
 21602            SetStaticProperties();
 603
 21604            FindParts();
 21605        }
 606
 607        private X509Certificate2 GetCertificate(string path, string password)
 608        {
 21609            if (string.IsNullOrWhiteSpace(path))
 610            {
 21611                return null;
 612            }
 613
 614            try
 615            {
 0616                if (!File.Exists(path))
 617                {
 0618                    return null;
 619                }
 620
 621                // Don't use an empty string password
 0622                password = string.IsNullOrWhiteSpace(password) ? null : password;
 623
 0624                var localCert = X509CertificateLoader.LoadPkcs12FromFile(path, password, X509KeyStorageFlags.UserKeySet)
 0625                if (!localCert.HasPrivateKey)
 626                {
 0627                    Logger.LogError("No private key included in SSL cert {CertificateLocation}.", path);
 0628                    return null;
 629                }
 630
 0631                return localCert;
 632            }
 0633            catch (Exception ex)
 634            {
 0635                Logger.LogError(ex, "Error loading cert from {CertificateLocation}", path);
 0636                return null;
 637            }
 0638        }
 639
 640        /// <summary>
 641        /// Dirty hacks.
 642        /// </summary>
 643        private void SetStaticProperties()
 644        {
 645            // For now there's no real way to inject these properly
 21646            BaseItem.ChapterManager = Resolve<IChapterManager>();
 21647            BaseItem.ChannelManager = Resolve<IChannelManager>();
 21648            BaseItem.ConfigurationManager = ConfigurationManager;
 21649            BaseItem.FileSystem = Resolve<IFileSystem>();
 21650            BaseItem.ItemRepository = Resolve<IItemRepository>();
 21651            BaseItem.ItemCountService = Resolve<IItemCountService>();
 21652            BaseItem.LibraryManager = Resolve<ILibraryManager>();
 21653            BaseItem.LocalizationManager = Resolve<ILocalizationManager>();
 21654            BaseItem.Logger = Resolve<ILogger<BaseItem>>();
 21655            BaseItem.MediaSegmentManager = Resolve<IMediaSegmentManager>();
 21656            BaseItem.MediaSourceManager = Resolve<IMediaSourceManager>();
 21657            BaseItem.ProviderManager = Resolve<IProviderManager>();
 21658            BaseItem.UserDataManager = Resolve<IUserDataManager>();
 21659            CollectionFolder.XmlSerializer = _xmlSerializer;
 21660            CollectionFolder.ApplicationHost = this;
 21661            Folder.UserViewManager = Resolve<IUserViewManager>();
 21662            Folder.CollectionManager = Resolve<ICollectionManager>();
 21663            Folder.LimitedConcurrencyLibraryScheduler = Resolve<ILimitedConcurrencyLibraryScheduler>();
 21664            Episode.MediaEncoder = Resolve<IMediaEncoder>();
 21665            UserView.TVSeriesManager = Resolve<ITVSeriesManager>();
 21666            Video.RecordingsManager = Resolve<IRecordingsManager>();
 21667        }
 668
 669        /// <summary>
 670        /// Finds plugin components and register them with the appropriate services.
 671        /// </summary>
 672        private void FindParts()
 673        {
 21674            if (!ConfigurationManager.Configuration.IsPortAuthorized)
 675            {
 21676                ConfigurationManager.Configuration.IsPortAuthorized = true;
 21677                ConfigurationManager.SaveConfiguration();
 678            }
 679
 21680            _pluginManager.CreatePlugins();
 681
 21682            Resolve<ILibraryManager>().AddParts(
 21683                GetExports<IResolverIgnoreRule>(),
 21684                GetExports<IItemResolver>(),
 21685                GetExports<IIntroProvider>(),
 21686                GetExports<IBaseItemComparer>(),
 21687                GetExports<ILibraryPostScanTask>());
 688
 21689            Resolve<IProviderManager>().AddParts(
 21690                GetExports<IImageProvider>(),
 21691                GetExports<IMetadataService>(),
 21692                GetExports<IMetadataProvider>(),
 21693                GetExports<IMetadataSaver>(),
 21694                GetExports<IExternalId>(),
 21695                GetExports<IExternalUrlProvider>());
 696
 21697            Resolve<IMediaSourceManager>().AddParts(GetExports<IMediaSourceProvider>());
 21698        }
 699
 700        /// <summary>
 701        /// Discovers the types.
 702        /// </summary>
 703        protected void DiscoverTypes()
 704        {
 21705            Logger.LogInformation("Loading assemblies");
 706
 21707            _allConcreteTypes = GetTypes(GetComposablePartAssemblies()).ToArray();
 21708        }
 709
 710        private IEnumerable<Type> GetTypes(IEnumerable<Assembly> assemblies)
 711        {
 714712            foreach (var ass in assemblies)
 713            {
 714                Type[] exportedTypes;
 715                try
 716                {
 336717                    exportedTypes = ass.GetExportedTypes();
 336718                }
 0719                catch (FileNotFoundException ex)
 720                {
 0721                    Logger.LogError(ex, "Error getting exported types from {Assembly}", ass.FullName);
 0722                    _pluginManager.FailPlugin(ass);
 0723                    continue;
 724                }
 0725                catch (TypeLoadException ex)
 726                {
 0727                    Logger.LogError(ex, "Error loading types from {Assembly}.", ass.FullName);
 0728                    _pluginManager.FailPlugin(ass);
 0729                    continue;
 730                }
 731
 62034732                foreach (Type type in exportedTypes)
 733                {
 30681734                    if (type.IsClass && !type.IsAbstract && !type.IsInterface && !type.IsGenericType)
 735                    {
 21378736                        yield return type;
 737                    }
 738                }
 739            }
 21740        }
 741
 742        /// <summary>
 743        /// Called when [configuration updated].
 744        /// </summary>
 745        /// <param name="sender">The sender.</param>
 746        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
 747        private void OnConfigurationUpdated(object sender, EventArgs e)
 748        {
 18749            var requiresRestart = false;
 18750            var networkConfiguration = ConfigurationManager.GetNetworkConfiguration();
 751
 752            // Don't do anything if these haven't been set yet
 18753            if (HttpPort != 0 && HttpsPort != 0)
 754            {
 755                // Need to restart if ports have changed
 18756                if (networkConfiguration.InternalHttpPort != HttpPort
 18757                    || networkConfiguration.InternalHttpsPort != HttpsPort)
 758                {
 0759                    if (ConfigurationManager.Configuration.IsPortAuthorized)
 760                    {
 0761                        ConfigurationManager.Configuration.IsPortAuthorized = false;
 0762                        ConfigurationManager.SaveConfiguration();
 763
 0764                        requiresRestart = true;
 765                    }
 766                }
 767            }
 768
 18769            if (ValidateSslCertificate(networkConfiguration))
 770            {
 0771                requiresRestart = true;
 772            }
 773
 18774            if (requiresRestart)
 775            {
 0776                Logger.LogInformation("App needs to be restarted due to configuration change.");
 777
 0778                NotifyPendingRestart();
 779            }
 18780        }
 781
 782        /// <summary>
 783        /// Validates the SSL certificate.
 784        /// </summary>
 785        /// <param name="networkConfig">The new configuration.</param>
 786        /// <exception cref="FileNotFoundException">The certificate path doesn't exist.</exception>
 787        private bool ValidateSslCertificate(NetworkConfiguration networkConfig)
 788        {
 18789            var newPath = networkConfig.CertificatePath;
 790
 18791            if (!string.IsNullOrWhiteSpace(newPath)
 18792                && !string.Equals(CertificatePath, newPath, StringComparison.Ordinal))
 793            {
 0794                if (File.Exists(newPath))
 795                {
 0796                    return true;
 797                }
 798
 0799                throw new FileNotFoundException(
 0800                    string.Format(
 0801                        CultureInfo.InvariantCulture,
 0802                        "Certificate file '{0}' does not exist.",
 0803                        newPath));
 804            }
 805
 18806            return false;
 807        }
 808
 809        /// <summary>
 810        /// Notifies the kernel that a change has been made that requires a restart.
 811        /// </summary>
 812        public void NotifyPendingRestart()
 813        {
 0814            Logger.LogInformation("App needs to be restarted.");
 815
 0816            var changed = !HasPendingRestart;
 817
 0818            HasPendingRestart = true;
 819
 0820            if (changed)
 821            {
 0822                EventHelper.QueueEventIfNotNull(HasPendingRestartChanged, this, EventArgs.Empty, Logger);
 823            }
 0824        }
 825
 826        /// <summary>
 827        /// Gets the composable part assemblies.
 828        /// </summary>
 829        /// <returns>IEnumerable{Assembly}.</returns>
 830        protected IEnumerable<Assembly> GetComposablePartAssemblies()
 831        {
 42832            foreach (var p in _pluginManager.LoadAssemblies())
 833            {
 0834                yield return p;
 835            }
 836
 837            // Include composable parts in the Model assembly
 21838            yield return typeof(SystemInfo).Assembly;
 839
 840            // Include composable parts in the Common assembly
 21841            yield return typeof(IApplicationHost).Assembly;
 842
 843            // Include composable parts in the Controller assembly
 21844            yield return typeof(IServerApplicationHost).Assembly;
 845
 846            // Include composable parts in the Providers assembly
 21847            yield return typeof(ProviderManager).Assembly;
 848
 849            // Include composable parts in the Photos assembly
 21850            yield return typeof(PhotoProvider).Assembly;
 851
 852            // Emby.Server implementations
 21853            yield return typeof(InstallationManager).Assembly;
 854
 855            // MediaEncoding
 21856            yield return typeof(MediaBrowser.MediaEncoding.Encoder.MediaEncoder).Assembly;
 857
 858            // Local metadata
 21859            yield return typeof(BoxSetXmlSaver).Assembly;
 860
 861            // Xbmc
 21862            yield return typeof(ArtistNfoProvider).Assembly;
 863
 864            // Network
 21865            yield return typeof(NetworkManager).Assembly;
 866
 867            // Hls
 21868            yield return typeof(DynamicHlsPlaylistGenerator).Assembly;
 869
 252870            foreach (var i in GetAssembliesWithPartsInternal())
 871            {
 105872                yield return i;
 873            }
 21874        }
 875
 876        protected abstract IEnumerable<Assembly> GetAssembliesWithPartsInternal();
 877
 878        /// <inheritdoc/>
 879        public string GetSmartApiUrl(IPAddress remoteAddr)
 880        {
 881            // Published server ends with a /
 0882            if (!string.IsNullOrEmpty(PublishedServerUrl))
 883            {
 884                // Published server ends with a '/', so we need to remove it.
 0885                return PublishedServerUrl.Trim('/');
 886            }
 887
 0888            string smart = NetManager.GetBindAddress(remoteAddr, out var port);
 0889            return GetLocalApiUrl(smart.Trim('/'), null, port);
 890        }
 891
 892        /// <inheritdoc/>
 893        public string GetSmartApiUrl(HttpRequest request)
 894        {
 895            // Return the host in the HTTP request as the API URL if not configured otherwise
 0896            if (ConfigurationManager.GetNetworkConfiguration().EnablePublishedServerUriByRequest)
 897            {
 0898                int? requestPort = request.Host.Port;
 0899                if (requestPort is null
 0900                    || (requestPort == 80 && string.Equals(request.Scheme, "http", StringComparison.OrdinalIgnoreCase))
 0901                    || (requestPort == 443 && string.Equals(request.Scheme, "https", StringComparison.OrdinalIgnoreCase)
 902                {
 0903                    requestPort = -1;
 904                }
 905
 0906                return GetLocalApiUrl(request.Host.Host, request.Scheme, requestPort);
 907            }
 908
 0909            return GetSmartApiUrl(request.HttpContext.Connection.RemoteIpAddress ?? IPAddress.Loopback);
 910        }
 911
 912        /// <inheritdoc/>
 913        public string GetSmartApiUrl(string hostname)
 914        {
 915            // Published server ends with a /
 0916            if (!string.IsNullOrEmpty(PublishedServerUrl))
 917            {
 918                // Published server ends with a '/', so we need to remove it.
 0919                return PublishedServerUrl.Trim('/');
 920            }
 921
 0922            string smart = NetManager.GetBindAddress(hostname, out var port);
 0923            return GetLocalApiUrl(smart.Trim('/'), null, port);
 924        }
 925
 926        /// <inheritdoc/>
 927        public string GetApiUrlForLocalAccess(IPAddress ipAddress = null, bool allowHttps = true)
 928        {
 929            // With an empty source, the port will be null
 0930            var smart = NetManager.GetBindAddress(ipAddress, out _, false);
 0931            var scheme = !allowHttps ? Uri.UriSchemeHttp : null;
 0932            int? port = !allowHttps ? HttpPort : null;
 0933            return GetLocalApiUrl(smart, scheme, port);
 934        }
 935
 936        /// <inheritdoc/>
 937        public string GetLocalApiUrl(string hostname, string scheme = null, int? port = null)
 938        {
 939            // If the smartAPI doesn't start with http then treat it as a host or ip.
 0940            if (hostname.StartsWith("http", StringComparison.OrdinalIgnoreCase))
 941            {
 0942                return hostname.TrimEnd('/');
 943            }
 944
 945            // NOTE: If no BaseUrl is set then UriBuilder appends a trailing slash, but if there is no BaseUrl it does
 946            // not. For consistency, always trim the trailing slash.
 0947            scheme ??= ListenWithHttps ? Uri.UriSchemeHttps : Uri.UriSchemeHttp;
 0948            var isHttps = string.Equals(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase);
 0949            return new UriBuilder
 0950            {
 0951                Scheme = scheme,
 0952                Host = hostname,
 0953                Port = port ?? (isHttps ? HttpsPort : HttpPort),
 0954                Path = ConfigurationManager.GetNetworkConfiguration().BaseUrl
 0955            }.ToString().TrimEnd('/');
 956        }
 957
 958        public IEnumerable<Assembly> GetApiPluginAssemblies()
 959        {
 21960            var assemblies = _allConcreteTypes
 21961                .Where(i => typeof(ControllerBase).IsAssignableFrom(i))
 21962                .Select(i => i.Assembly)
 21963                .Distinct();
 964
 126965            foreach (var assembly in assemblies)
 966            {
 42967                Logger.LogDebug("Found API endpoints in plugin {Name}", assembly.FullName);
 42968                yield return assembly;
 969            }
 21970        }
 971
 972        /// <inheritdoc />
 973        public void Dispose()
 974        {
 21975            Dispose(true);
 21976            GC.SuppressFinalize(this);
 21977        }
 978
 979        /// <summary>
 980        /// Releases unmanaged and - optionally - managed resources.
 981        /// </summary>
 982        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release o
 983        protected virtual void Dispose(bool dispose)
 984        {
 21985            if (_disposed)
 986            {
 0987                return;
 988            }
 989
 21990            if (dispose)
 991            {
 21992                var type = GetType();
 993
 21994                Logger.LogInformation("Disposing {Type}", type.Name);
 995
 168996                foreach (var part in _disposableParts.ToArray())
 997                {
 63998                    var partType = part.GetType();
 63999                    if (partType == type)
 1000                    {
 1001                        continue;
 1002                    }
 1003
 631004                    Logger.LogInformation("Disposing {Type}", partType.Name);
 1005
 1006                    try
 1007                    {
 631008                        part.Dispose();
 631009                    }
 01010                    catch (Exception ex)
 1011                    {
 01012                        Logger.LogError(ex, "Error disposing {Type}", partType.Name);
 01013                    }
 1014                }
 1015
 211016                _disposableParts.Clear();
 1017            }
 1018
 211019            _disposed = true;
 211020        }
 1021    }
 1022}
Generated by: ReportGenerator 5.5.7.0
5/6/2026 - 12:15:24 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Controller.IServerApplicationPaths,Microsoft.Extensions.Logging.ILoggerFactory,Emby.Server.Implementations.IStartupOptions,Microsoft.Extensions.Configuration.IConfiguration)
get_PublishedServerUrl()
get_ApplicationUserAgentAddress()
get_SystemId()
get_Name()
get_ListenWithHttps()
get_FriendlyName()
ExpandVirtualPath(System.String)
ReverseVirtualPath(System.String)
CreateInstanceSafe(System.Type)
Resolve()
GetExportTypes()
GetExports(System.Boolean)
GetExports(MediaBrowser.Common.CreationDelegateFactory,System.Boolean)
RunStartupTasksAsync()
Init(Microsoft.Extensions.DependencyInjection.IServiceCollection)
RegisterServices(Microsoft.Extensions.DependencyInjection.IServiceCollection)
InitializeServices()
GetCertificate(System.String,System.String)
SetStaticProperties()
FindParts()
DiscoverTypes()
GetTypes()
OnConfigurationUpdated(System.Object,System.EventArgs)
ValidateSslCertificate(MediaBrowser.Common.Net.NetworkConfiguration)
NotifyPendingRestart()
GetComposablePartAssemblies()
GetSmartApiUrl(System.Net.IPAddress)
GetSmartApiUrl(Microsoft.AspNetCore.Http.HttpRequest)
GetSmartApiUrl(System.String)
GetApiUrlForLocalAccess(System.Net.IPAddress,System.Boolean)
GetLocalApiUrl(System.String,System.String,System.Nullable`1<System.Int32>)
GetApiPluginAssemblies()
Dispose()
Dispose(System.Boolean)