< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.ApplicationHost
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/ApplicationHost.cs
Line coverage
71%
Covered lines: 219
Uncovered lines: 87
Coverable lines: 306
Total lines: 1017
Line coverage: 71.5%
Branch coverage
39%
Covered branches: 41
Total branches: 104
Branch coverage: 39.4%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

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%
GetExports(...)100%66100%
GetExports(...)83.33%6688.88%
RunStartupTasksAsync()50%2290.9%
Init(...)50%4481.25%
RegisterServices(...)100%11100%
GetCertificate(...)12.5%48814.28%
SetStaticProperties()100%11100%
FindParts()100%22100%
DiscoverTypes()100%11100%
OnConfigurationUpdated(...)64.28%341453.33%
ValidateSslCertificate(...)33.33%15636.36%
NotifyPendingRestart()0%620%
GetSmartApiUrl(...)0%620%
GetSmartApiUrl(...)0%210140%
GetSmartApiUrl(...)0%620%
GetApiUrlForLocalAccess(...)0%2040%
GetLocalApiUrl(...)0%110100%
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.Collections;
 19using Emby.Server.Implementations.Configuration;
 20using Emby.Server.Implementations.Cryptography;
 21using Emby.Server.Implementations.Data;
 22using Emby.Server.Implementations.Devices;
 23using Emby.Server.Implementations.Dto;
 24using Emby.Server.Implementations.HttpServer.Security;
 25using Emby.Server.Implementations.IO;
 26using Emby.Server.Implementations.Library;
 27using Emby.Server.Implementations.Localization;
 28using Emby.Server.Implementations.Playlists;
 29using Emby.Server.Implementations.Plugins;
 30using Emby.Server.Implementations.QuickConnect;
 31using Emby.Server.Implementations.ScheduledTasks;
 32using Emby.Server.Implementations.Serialization;
 33using Emby.Server.Implementations.Session;
 34using Emby.Server.Implementations.SyncPlay;
 35using Emby.Server.Implementations.TV;
 36using Emby.Server.Implementations.Updates;
 37using Jellyfin.Api.Helpers;
 38using Jellyfin.Database.Implementations;
 39using Jellyfin.Drawing;
 40using Jellyfin.MediaEncoding.Hls.Playlist;
 41using Jellyfin.Networking.Manager;
 42using Jellyfin.Networking.Udp;
 43using Jellyfin.Server.Implementations.Item;
 44using Jellyfin.Server.Implementations.MediaSegments;
 45using MediaBrowser.Common;
 46using MediaBrowser.Common.Configuration;
 47using MediaBrowser.Common.Events;
 48using MediaBrowser.Common.Net;
 49using MediaBrowser.Common.Plugins;
 50using MediaBrowser.Common.Updates;
 51using MediaBrowser.Controller;
 52using MediaBrowser.Controller.Channels;
 53using MediaBrowser.Controller.Chapters;
 54using MediaBrowser.Controller.ClientEvent;
 55using MediaBrowser.Controller.Collections;
 56using MediaBrowser.Controller.Configuration;
 57using MediaBrowser.Controller.Drawing;
 58using MediaBrowser.Controller.Dto;
 59using MediaBrowser.Controller.Entities;
 60using MediaBrowser.Controller.IO;
 61using MediaBrowser.Controller.Library;
 62using MediaBrowser.Controller.LiveTv;
 63using MediaBrowser.Controller.Lyrics;
 64using MediaBrowser.Controller.MediaEncoding;
 65using MediaBrowser.Controller.Net;
 66using MediaBrowser.Controller.Persistence;
 67using MediaBrowser.Controller.Playlists;
 68using MediaBrowser.Controller.Providers;
 69using MediaBrowser.Controller.QuickConnect;
 70using MediaBrowser.Controller.Resolvers;
 71using MediaBrowser.Controller.Session;
 72using MediaBrowser.Controller.Sorting;
 73using MediaBrowser.Controller.Subtitles;
 74using MediaBrowser.Controller.SyncPlay;
 75using MediaBrowser.Controller.TV;
 76using MediaBrowser.LocalMetadata.Savers;
 77using MediaBrowser.MediaEncoding.BdInfo;
 78using MediaBrowser.MediaEncoding.Subtitles;
 79using MediaBrowser.MediaEncoding.Transcoding;
 80using MediaBrowser.Model.Cryptography;
 81using MediaBrowser.Model.Globalization;
 82using MediaBrowser.Model.IO;
 83using MediaBrowser.Model.MediaInfo;
 84using MediaBrowser.Model.Net;
 85using MediaBrowser.Model.Serialization;
 86using MediaBrowser.Model.System;
 87using MediaBrowser.Model.Tasks;
 88using MediaBrowser.Providers.Lyric;
 89using MediaBrowser.Providers.Manager;
 90using MediaBrowser.Providers.Plugins.Tmdb;
 91using MediaBrowser.Providers.Subtitles;
 92using MediaBrowser.XbmcMetadata.Providers;
 93using Microsoft.AspNetCore.Http;
 94using Microsoft.AspNetCore.Mvc;
 95using Microsoft.EntityFrameworkCore;
 96using Microsoft.Extensions.Configuration;
 97using Microsoft.Extensions.DependencyInjection;
 98using Microsoft.Extensions.Logging;
 99using Prometheus.DotNetRuntime;
 100using static MediaBrowser.Controller.Extensions.ConfigurationExtensions;
 101using IConfigurationManager = MediaBrowser.Common.Configuration.IConfigurationManager;
 102using WebSocketManager = Emby.Server.Implementations.HttpServer.WebSocketManager;
 103
 104namespace Emby.Server.Implementations
 105{
 106    /// <summary>
 107    /// Class CompositionRoot.
 108    /// </summary>
 109    public abstract class ApplicationHost : IServerApplicationHost, IDisposable
 110    {
 111        /// <summary>
 112        /// The disposable parts.
 113        /// </summary>
 21114        private readonly ConcurrentBag<IDisposable> _disposableParts = new();
 115        private readonly DeviceId _deviceId;
 116
 117        private readonly IConfiguration _startupConfig;
 118        private readonly IXmlSerializer _xmlSerializer;
 119        private readonly IStartupOptions _startupOptions;
 120        private readonly PluginManager _pluginManager;
 121
 122        private List<Type> _creatingInstances;
 123
 124        /// <summary>
 125        /// Gets or sets all concrete types.
 126        /// </summary>
 127        /// <value>All concrete types.</value>
 128        private Type[] _allConcreteTypes;
 129
 130        private bool _disposed;
 131
 132        /// <summary>
 133        /// Initializes a new instance of the <see cref="ApplicationHost"/> class.
 134        /// </summary>
 135        /// <param name="applicationPaths">Instance of the <see cref="IServerApplicationPaths"/> interface.</param>
 136        /// <param name="loggerFactory">Instance of the <see cref="ILoggerFactory"/> interface.</param>
 137        /// <param name="options">Instance of the <see cref="IStartupOptions"/> interface.</param>
 138        /// <param name="startupConfig">The <see cref="IConfiguration" /> interface.</param>
 139        protected ApplicationHost(
 140            IServerApplicationPaths applicationPaths,
 141            ILoggerFactory loggerFactory,
 142            IStartupOptions options,
 143            IConfiguration startupConfig)
 144        {
 145            ApplicationPaths = applicationPaths;
 146            LoggerFactory = loggerFactory;
 21147            _startupOptions = options;
 21148            _startupConfig = startupConfig;
 149
 21150            Logger = LoggerFactory.CreateLogger<ApplicationHost>();
 21151            _deviceId = new DeviceId(ApplicationPaths, LoggerFactory.CreateLogger<DeviceId>());
 152
 21153            ApplicationVersion = typeof(ApplicationHost).Assembly.GetName().Version;
 21154            ApplicationVersionString = ApplicationVersion.ToString(3);
 21155            ApplicationUserAgent = Name.Replace(' ', '-') + "/" + ApplicationVersionString;
 156
 21157            _xmlSerializer = new MyXmlSerializer();
 21158            ConfigurationManager = new ServerConfigurationManager(ApplicationPaths, LoggerFactory, _xmlSerializer);
 21159            _pluginManager = new PluginManager(
 21160                LoggerFactory.CreateLogger<PluginManager>(),
 21161                this,
 21162                ConfigurationManager.Configuration,
 21163                ApplicationPaths.PluginsPath,
 21164                ApplicationVersion);
 165
 21166            _disposableParts.Add(_pluginManager);
 21167        }
 168
 169        /// <summary>
 170        /// Occurs when [has pending restart changed].
 171        /// </summary>
 172        public event EventHandler HasPendingRestartChanged;
 173
 174        /// <summary>
 175        /// Gets the value of the PublishedServerUrl setting.
 176        /// </summary>
 0177        private string PublishedServerUrl => _startupConfig[AddressOverrideKey];
 178
 179        public bool CoreStartupHasCompleted { get; private set; }
 180
 181        /// <summary>
 182        /// Gets the <see cref="INetworkManager"/> singleton instance.
 183        /// </summary>
 184        public INetworkManager NetManager { get; private set; }
 185
 186        /// <inheritdoc />
 187        public bool HasPendingRestart { get; private set; }
 188
 189        /// <inheritdoc />
 190        public bool ShouldRestart { get; set; }
 191
 192        /// <summary>
 193        /// Gets the logger.
 194        /// </summary>
 195        protected ILogger<ApplicationHost> Logger { get; }
 196
 197        /// <summary>
 198        /// Gets the logger factory.
 199        /// </summary>
 200        protected ILoggerFactory LoggerFactory { get; }
 201
 202        /// <summary>
 203        /// Gets the application paths.
 204        /// </summary>
 205        /// <value>The application paths.</value>
 206        protected IServerApplicationPaths ApplicationPaths { get; }
 207
 208        /// <summary>
 209        /// Gets the configuration manager.
 210        /// </summary>
 211        /// <value>The configuration manager.</value>
 212        public ServerConfigurationManager ConfigurationManager { get; }
 213
 214        /// <summary>
 215        /// Gets or sets the service provider.
 216        /// </summary>
 217        public IServiceProvider ServiceProvider { get; set; }
 218
 219        /// <summary>
 220        /// Gets the http port for the webhost.
 221        /// </summary>
 222        public int HttpPort { get; private set; }
 223
 224        /// <summary>
 225        /// Gets the https port for the webhost.
 226        /// </summary>
 227        public int HttpsPort { get; private set; }
 228
 229        /// <inheritdoc />
 230        public Version ApplicationVersion { get; }
 231
 232        /// <inheritdoc />
 233        public string ApplicationVersionString { get; }
 234
 235        /// <summary>
 236        /// Gets the current application user agent.
 237        /// </summary>
 238        /// <value>The application user agent.</value>
 239        public string ApplicationUserAgent { get; }
 240
 241        /// <summary>
 242        /// Gets the email address for use within a comment section of a user agent field.
 243        /// Presently used to provide contact information to MusicBrainz service.
 244        /// </summary>
 21245        public string ApplicationUserAgentAddress => "team@jellyfin.org";
 246
 247        /// <summary>
 248        /// Gets the current application name.
 249        /// </summary>
 250        /// <value>The application name.</value>
 21251        public string ApplicationProductName { get; } = FileVersionInfo.GetVersionInfo(Assembly.GetEntryAssembly().Locat
 252
 98253        public string SystemId => _deviceId.Value;
 254
 255        /// <inheritdoc/>
 63256        public string Name => ApplicationProductName;
 257
 258        private string CertificatePath { get; set; }
 259
 260        public X509Certificate2 Certificate { get; private set; }
 261
 262        /// <inheritdoc/>
 0263        public bool ListenWithHttps => Certificate is not null && ConfigurationManager.GetNetworkConfiguration().EnableH
 264
 265        public string FriendlyName =>
 0266            string.IsNullOrEmpty(ConfigurationManager.Configuration.ServerName)
 0267                ? Environment.MachineName
 0268                : ConfigurationManager.Configuration.ServerName;
 269
 270        public string ExpandVirtualPath(string path)
 271        {
 87272            if (path is null)
 273            {
 0274                return null;
 275            }
 276
 87277            var appPaths = ApplicationPaths;
 278
 87279            return path.Replace(appPaths.VirtualDataPath, appPaths.DataPath, StringComparison.OrdinalIgnoreCase)
 87280                .Replace(appPaths.VirtualInternalMetadataPath, appPaths.InternalMetadataPath, StringComparison.OrdinalIg
 281        }
 282
 283        public string ReverseVirtualPath(string path)
 284        {
 80285            var appPaths = ApplicationPaths;
 286
 80287            return path.Replace(appPaths.DataPath, appPaths.VirtualDataPath, StringComparison.OrdinalIgnoreCase)
 80288                .Replace(appPaths.InternalMetadataPath, appPaths.VirtualInternalMetadataPath, StringComparison.OrdinalIg
 289        }
 290
 291        /// <summary>
 292        /// Creates the instance safe.
 293        /// </summary>
 294        /// <param name="type">The type.</param>
 295        /// <returns>System.Object.</returns>
 296        protected object CreateInstanceSafe(Type type)
 297        {
 4116298            _creatingInstances ??= new List<Type>();
 299
 4116300            if (_creatingInstances.Contains(type))
 301            {
 0302                Logger.LogError("DI Loop detected in the attempted creation of {Type}", type.FullName);
 0303                foreach (var entry in _creatingInstances)
 304                {
 0305                    Logger.LogError("Called from: {TypeName}", entry.FullName);
 306                }
 307
 0308                _pluginManager.FailPlugin(type.Assembly);
 309
 0310                throw new TypeLoadException("DI Loop detected");
 311            }
 312
 313            try
 314            {
 4116315                _creatingInstances.Add(type);
 4116316                Logger.LogDebug("Creating instance of {Type}", type);
 4116317                return ServiceProvider is null
 4116318                    ? Activator.CreateInstance(type)
 4116319                    : ActivatorUtilities.CreateInstance(ServiceProvider, type);
 320            }
 0321            catch (Exception ex)
 322            {
 0323                Logger.LogError(ex, "Error creating {Type}", type);
 324                // If this is a plugin fail it.
 0325                _pluginManager.FailPlugin(type.Assembly);
 0326                return null;
 327            }
 328            finally
 329            {
 4116330                _creatingInstances.Remove(type);
 4116331            }
 4116332        }
 333
 334        /// <summary>
 335        /// Resolves this instance.
 336        /// </summary>
 337        /// <typeparam name="T">The type.</typeparam>
 338        /// <returns>``0.</returns>
 483339        public T Resolve<T>() => ServiceProvider.GetService<T>();
 340
 341        /// <inheritdoc/>
 342        public IEnumerable<Type> GetExportTypes<T>()
 343        {
 344            var currentType = typeof(T);
 345            var numberOfConcreteTypes = _allConcreteTypes.Length;
 346            for (var i = 0; i < numberOfConcreteTypes; i++)
 347            {
 348                var type = _allConcreteTypes[i];
 349                if (currentType.IsAssignableFrom(type))
 350                {
 351                    yield return type;
 352                }
 353            }
 354        }
 355
 356        /// <inheritdoc />
 357        public IReadOnlyCollection<T> GetExports<T>(bool manageLifetime = true)
 358        {
 359            // Convert to list so this isn't executed for each iteration
 294360            var parts = GetExportTypes<T>()
 294361                .Select(CreateInstanceSafe)
 294362                .Where(i => i is not null)
 294363                .Cast<T>()
 294364                .ToList();
 365
 294366            if (manageLifetime)
 367            {
 630368                foreach (var part in parts.OfType<IDisposable>())
 369                {
 42370                    _disposableParts.Add(part);
 371                }
 372            }
 373
 294374            return parts;
 375        }
 376
 377        /// <inheritdoc />
 378        public IReadOnlyCollection<T> GetExports<T>(CreationDelegateFactory defaultFunc, bool manageLifetime = true)
 379        {
 380            // Convert to list so this isn't executed for each iteration
 21381            var parts = GetExportTypes<T>()
 21382                .Select(i => defaultFunc(i))
 21383                .Where(i => i is not null)
 21384                .Cast<T>()
 21385                .ToList();
 386
 21387            if (manageLifetime)
 388            {
 42389                foreach (var part in parts.OfType<IDisposable>())
 390                {
 0391                    _disposableParts.Add(part);
 392                }
 393            }
 394
 21395            return parts;
 396        }
 397
 398        /// <summary>
 399        /// Runs the startup tasks.
 400        /// </summary>
 401        /// <returns><see cref="Task" />.</returns>
 402        public Task RunStartupTasksAsync()
 403        {
 21404            Logger.LogInformation("Running startup tasks");
 405
 21406            Resolve<ITaskManager>().AddTasks(GetExports<IScheduledTask>(false));
 407
 21408            ConfigurationManager.ConfigurationUpdated += OnConfigurationUpdated;
 21409            ConfigurationManager.NamedConfigurationUpdated += OnConfigurationUpdated;
 410
 21411            var ffmpegValid = Resolve<IMediaEncoder>().SetFFmpegPath();
 412
 21413            if (!ffmpegValid)
 414            {
 0415                throw new FfmpegException("Failed to find valid ffmpeg");
 416            }
 417
 21418            Logger.LogInformation("ServerId: {ServerId}", SystemId);
 21419            Logger.LogInformation("Core startup complete");
 21420            CoreStartupHasCompleted = true;
 421
 21422            return Task.CompletedTask;
 423        }
 424
 425        /// <inheritdoc/>
 426        public void Init(IServiceCollection serviceCollection)
 427        {
 21428            DiscoverTypes();
 429
 21430            ConfigurationManager.AddParts(GetExports<IConfigurationFactory>());
 431
 21432            NetManager = new NetworkManager(ConfigurationManager, _startupConfig, LoggerFactory.CreateLogger<NetworkMana
 433
 434            // Initialize runtime stat collection
 21435            if (ConfigurationManager.Configuration.EnableMetrics)
 436            {
 0437                _disposableParts.Add(DotNetRuntimeStatsBuilder.Default().StartCollecting());
 438            }
 439
 21440            var networkConfiguration = ConfigurationManager.GetNetworkConfiguration();
 21441            HttpPort = networkConfiguration.InternalHttpPort;
 21442            HttpsPort = networkConfiguration.InternalHttpsPort;
 443
 444            // Safeguard against invalid configuration
 21445            if (HttpPort == HttpsPort)
 446            {
 0447                HttpPort = NetworkConfiguration.DefaultHttpPort;
 0448                HttpsPort = NetworkConfiguration.DefaultHttpsPort;
 449            }
 450
 21451            CertificatePath = networkConfiguration.CertificatePath;
 21452            Certificate = GetCertificate(CertificatePath, networkConfiguration.CertificatePassword);
 453
 21454            RegisterServices(serviceCollection);
 455
 21456            _pluginManager.RegisterServices(serviceCollection);
 21457        }
 458
 459        /// <summary>
 460        /// Registers services/resources with the service collection that will be available via DI.
 461        /// </summary>
 462        /// <param name="serviceCollection">Instance of the <see cref="IServiceCollection"/> interface.</param>
 463        protected virtual void RegisterServices(IServiceCollection serviceCollection)
 464        {
 21465            serviceCollection.AddSingleton(_startupOptions);
 466
 21467            serviceCollection.AddMemoryCache();
 468
 21469            serviceCollection.AddSingleton<IServerConfigurationManager>(ConfigurationManager);
 21470            serviceCollection.AddSingleton<IConfigurationManager>(ConfigurationManager);
 21471            serviceCollection.AddSingleton<IApplicationHost>(this);
 21472            serviceCollection.AddSingleton<IPluginManager>(_pluginManager);
 21473            serviceCollection.AddSingleton<IApplicationPaths>(ApplicationPaths);
 474
 21475            serviceCollection.AddSingleton<IFileSystem, ManagedFileSystem>();
 21476            serviceCollection.AddSingleton<IShortcutHandler, MbLinkShortcutHandler>();
 477
 21478            serviceCollection.AddScoped<ISystemManager, SystemManager>();
 479
 21480            serviceCollection.AddSingleton<TmdbClientManager>();
 481
 21482            serviceCollection.AddSingleton(NetManager);
 483
 21484            serviceCollection.AddSingleton<ITaskManager, TaskManager>();
 485
 21486            serviceCollection.AddSingleton(_xmlSerializer);
 487
 21488            serviceCollection.AddSingleton<ICryptoProvider, CryptographyProvider>();
 489
 21490            serviceCollection.AddSingleton<ISocketFactory, SocketFactory>();
 491
 21492            serviceCollection.AddSingleton<IInstallationManager, InstallationManager>();
 493
 21494            serviceCollection.AddSingleton<IServerApplicationHost>(this);
 21495            serviceCollection.AddSingleton(ApplicationPaths);
 496
 21497            serviceCollection.AddSingleton<ILocalizationManager, LocalizationManager>();
 498
 21499            serviceCollection.AddSingleton<IBlurayExaminer, BdInfoExaminer>();
 500
 21501            serviceCollection.AddSingleton<IUserDataManager, UserDataManager>();
 502
 21503            serviceCollection.AddSingleton<IItemRepository, BaseItemRepository>();
 21504            serviceCollection.AddSingleton<IPeopleRepository, PeopleRepository>();
 21505            serviceCollection.AddSingleton<IChapterRepository, ChapterRepository>();
 21506            serviceCollection.AddSingleton<IMediaAttachmentRepository, MediaAttachmentRepository>();
 21507            serviceCollection.AddSingleton<IMediaStreamRepository, MediaStreamRepository>();
 21508            serviceCollection.AddSingleton<IKeyframeRepository, KeyframeRepository>();
 21509            serviceCollection.AddSingleton<IItemTypeLookup, ItemTypeLookup>();
 510
 21511            serviceCollection.AddSingleton<IMediaEncoder, MediaBrowser.MediaEncoding.Encoder.MediaEncoder>();
 21512            serviceCollection.AddSingleton<EncodingHelper>();
 21513            serviceCollection.AddSingleton<IPathManager, PathManager>();
 514
 515            // TODO: Refactor to eliminate the circular dependencies here so that Lazy<T> isn't required
 21516            serviceCollection.AddTransient(provider => new Lazy<ILibraryMonitor>(provider.GetRequiredService<ILibraryMon
 21517            serviceCollection.AddTransient(provider => new Lazy<IProviderManager>(provider.GetRequiredService<IProviderM
 21518            serviceCollection.AddTransient(provider => new Lazy<IUserViewManager>(provider.GetRequiredService<IUserViewM
 21519            serviceCollection.AddSingleton<ILibraryManager, LibraryManager>();
 21520            serviceCollection.AddSingleton<NamingOptions>();
 521
 21522            serviceCollection.AddSingleton<IMusicManager, MusicManager>();
 523
 21524            serviceCollection.AddSingleton<ILibraryMonitor, LibraryMonitor>();
 525
 21526            serviceCollection.AddSingleton<ISearchEngine, SearchEngine>();
 527
 21528            serviceCollection.AddSingleton<IWebSocketManager, WebSocketManager>();
 529
 21530            serviceCollection.AddSingleton<IImageProcessor, ImageProcessor>();
 531
 21532            serviceCollection.AddSingleton<ITVSeriesManager, TVSeriesManager>();
 533
 21534            serviceCollection.AddSingleton<IMediaSourceManager, MediaSourceManager>();
 535
 21536            serviceCollection.AddSingleton<ISubtitleManager, SubtitleManager>();
 21537            serviceCollection.AddSingleton<ILyricManager, LyricManager>();
 538
 21539            serviceCollection.AddSingleton<IProviderManager, ProviderManager>();
 540
 541            // TODO: Refactor to eliminate the circular dependency here so that Lazy<T> isn't required
 21542            serviceCollection.AddTransient(provider => new Lazy<ILiveTvManager>(provider.GetRequiredService<ILiveTvManag
 21543            serviceCollection.AddSingleton<IDtoService, DtoService>();
 544
 21545            serviceCollection.AddSingleton<ISessionManager, SessionManager>();
 546
 21547            serviceCollection.AddSingleton<ICollectionManager, CollectionManager>();
 548
 21549            serviceCollection.AddSingleton<IPlaylistManager, PlaylistManager>();
 550
 21551            serviceCollection.AddSingleton<ISyncPlayManager, SyncPlayManager>();
 552
 21553            serviceCollection.AddSingleton<IUserViewManager, UserViewManager>();
 554
 21555            serviceCollection.AddSingleton<IEncodingManager, MediaEncoder.EncodingManager>();
 556
 21557            serviceCollection.AddSingleton<IAuthService, AuthService>();
 21558            serviceCollection.AddSingleton<IQuickConnect, QuickConnectManager>();
 559
 21560            serviceCollection.AddSingleton<ISubtitleParser, SubtitleEditParser>();
 21561            serviceCollection.AddSingleton<ISubtitleEncoder, SubtitleEncoder>();
 562
 21563            serviceCollection.AddSingleton<IAttachmentExtractor, MediaBrowser.MediaEncoding.Attachments.AttachmentExtrac
 564
 21565            serviceCollection.AddSingleton<ITranscodeManager, TranscodeManager>();
 21566            serviceCollection.AddScoped<MediaInfoHelper>();
 21567            serviceCollection.AddScoped<AudioHelper>();
 21568            serviceCollection.AddScoped<DynamicHlsHelper>();
 21569            serviceCollection.AddScoped<IClientEventLogger, ClientEventLogger>();
 21570            serviceCollection.AddSingleton<IDirectoryService, DirectoryService>();
 571
 21572            serviceCollection.AddSingleton<IMediaSegmentManager, MediaSegmentManager>();
 21573        }
 574
 575        /// <summary>
 576        /// Create services registered with the service container that need to be initialized at application startup.
 577        /// </summary>
 578        /// <param name="startupConfig">The configuration used to initialise the application.</param>
 579        /// <returns>A task representing the service initialization operation.</returns>
 580        public async Task InitializeServices(IConfiguration startupConfig)
 581        {
 582            var factory = Resolve<IDbContextFactory<JellyfinDbContext>>();
 583            var provider = Resolve<IJellyfinDatabaseProvider>();
 584            provider.DbContextFactory = factory;
 585
 586            var jellyfinDb = await factory.CreateDbContextAsync().ConfigureAwait(false);
 587            await using (jellyfinDb.ConfigureAwait(false))
 588            {
 589                if ((await jellyfinDb.Database.GetPendingMigrationsAsync().ConfigureAwait(false)).Any())
 590                {
 591                    Logger.LogInformation("There are pending EFCore migrations in the database. Applying... (This may ta
 592                    await jellyfinDb.Database.MigrateAsync().ConfigureAwait(false);
 593                    Logger.LogInformation("EFCore migrations applied successfully");
 594                }
 595            }
 596
 597            var localizationManager = (LocalizationManager)Resolve<ILocalizationManager>();
 598            await localizationManager.LoadAll().ConfigureAwait(false);
 599
 600            SetStaticProperties();
 601
 602            FindParts();
 603        }
 604
 605        private X509Certificate2 GetCertificate(string path, string password)
 606        {
 21607            if (string.IsNullOrWhiteSpace(path))
 608            {
 21609                return null;
 610            }
 611
 612            try
 613            {
 0614                if (!File.Exists(path))
 615                {
 0616                    return null;
 617                }
 618
 619                // Don't use an empty string password
 0620                password = string.IsNullOrWhiteSpace(password) ? null : password;
 621
 0622                var localCert = X509CertificateLoader.LoadPkcs12FromFile(path, password, X509KeyStorageFlags.UserKeySet)
 0623                if (!localCert.HasPrivateKey)
 624                {
 0625                    Logger.LogError("No private key included in SSL cert {CertificateLocation}.", path);
 0626                    return null;
 627                }
 628
 0629                return localCert;
 630            }
 0631            catch (Exception ex)
 632            {
 0633                Logger.LogError(ex, "Error loading cert from {CertificateLocation}", path);
 0634                return null;
 635            }
 0636        }
 637
 638        /// <summary>
 639        /// Dirty hacks.
 640        /// </summary>
 641        private void SetStaticProperties()
 642        {
 643            // For now there's no real way to inject these properly
 21644            BaseItem.Logger = Resolve<ILogger<BaseItem>>();
 21645            BaseItem.ConfigurationManager = ConfigurationManager;
 21646            BaseItem.LibraryManager = Resolve<ILibraryManager>();
 21647            BaseItem.ProviderManager = Resolve<IProviderManager>();
 21648            BaseItem.LocalizationManager = Resolve<ILocalizationManager>();
 21649            BaseItem.ItemRepository = Resolve<IItemRepository>();
 21650            BaseItem.ChapterRepository = Resolve<IChapterRepository>();
 21651            BaseItem.FileSystem = Resolve<IFileSystem>();
 21652            BaseItem.UserDataManager = Resolve<IUserDataManager>();
 21653            BaseItem.ChannelManager = Resolve<IChannelManager>();
 21654            Video.RecordingsManager = Resolve<IRecordingsManager>();
 21655            Folder.UserViewManager = Resolve<IUserViewManager>();
 21656            UserView.TVSeriesManager = Resolve<ITVSeriesManager>();
 21657            UserView.CollectionManager = Resolve<ICollectionManager>();
 21658            BaseItem.MediaSourceManager = Resolve<IMediaSourceManager>();
 21659            BaseItem.MediaSegmentManager = Resolve<IMediaSegmentManager>();
 21660            CollectionFolder.XmlSerializer = _xmlSerializer;
 21661            CollectionFolder.ApplicationHost = this;
 21662        }
 663
 664        /// <summary>
 665        /// Finds plugin components and register them with the appropriate services.
 666        /// </summary>
 667        private void FindParts()
 668        {
 21669            if (!ConfigurationManager.Configuration.IsPortAuthorized)
 670            {
 21671                ConfigurationManager.Configuration.IsPortAuthorized = true;
 21672                ConfigurationManager.SaveConfiguration();
 673            }
 674
 21675            _pluginManager.CreatePlugins();
 676
 21677            Resolve<ILibraryManager>().AddParts(
 21678                GetExports<IResolverIgnoreRule>(),
 21679                GetExports<IItemResolver>(),
 21680                GetExports<IIntroProvider>(),
 21681                GetExports<IBaseItemComparer>(),
 21682                GetExports<ILibraryPostScanTask>());
 683
 21684            Resolve<IProviderManager>().AddParts(
 21685                GetExports<IImageProvider>(),
 21686                GetExports<IMetadataService>(),
 21687                GetExports<IMetadataProvider>(),
 21688                GetExports<IMetadataSaver>(),
 21689                GetExports<IExternalId>(),
 21690                GetExports<IExternalUrlProvider>());
 691
 21692            Resolve<IMediaSourceManager>().AddParts(GetExports<IMediaSourceProvider>());
 21693        }
 694
 695        /// <summary>
 696        /// Discovers the types.
 697        /// </summary>
 698        protected void DiscoverTypes()
 699        {
 21700            Logger.LogInformation("Loading assemblies");
 701
 21702            _allConcreteTypes = GetTypes(GetComposablePartAssemblies()).ToArray();
 21703        }
 704
 705        private IEnumerable<Type> GetTypes(IEnumerable<Assembly> assemblies)
 706        {
 707            foreach (var ass in assemblies)
 708            {
 709                Type[] exportedTypes;
 710                try
 711                {
 712                    exportedTypes = ass.GetExportedTypes();
 713                }
 714                catch (FileNotFoundException ex)
 715                {
 716                    Logger.LogError(ex, "Error getting exported types from {Assembly}", ass.FullName);
 717                    _pluginManager.FailPlugin(ass);
 718                    continue;
 719                }
 720                catch (TypeLoadException ex)
 721                {
 722                    Logger.LogError(ex, "Error loading types from {Assembly}.", ass.FullName);
 723                    _pluginManager.FailPlugin(ass);
 724                    continue;
 725                }
 726
 727                foreach (Type type in exportedTypes)
 728                {
 729                    if (type.IsClass && !type.IsAbstract && !type.IsInterface && !type.IsGenericType)
 730                    {
 731                        yield return type;
 732                    }
 733                }
 734            }
 735        }
 736
 737        /// <summary>
 738        /// Called when [configuration updated].
 739        /// </summary>
 740        /// <param name="sender">The sender.</param>
 741        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
 742        private void OnConfigurationUpdated(object sender, EventArgs e)
 743        {
 18744            var requiresRestart = false;
 18745            var networkConfiguration = ConfigurationManager.GetNetworkConfiguration();
 746
 747            // Don't do anything if these haven't been set yet
 18748            if (HttpPort != 0 && HttpsPort != 0)
 749            {
 750                // Need to restart if ports have changed
 18751                if (networkConfiguration.InternalHttpPort != HttpPort
 18752                    || networkConfiguration.InternalHttpsPort != HttpsPort)
 753                {
 0754                    if (ConfigurationManager.Configuration.IsPortAuthorized)
 755                    {
 0756                        ConfigurationManager.Configuration.IsPortAuthorized = false;
 0757                        ConfigurationManager.SaveConfiguration();
 758
 0759                        requiresRestart = true;
 760                    }
 761                }
 762            }
 763
 18764            if (ValidateSslCertificate(networkConfiguration))
 765            {
 0766                requiresRestart = true;
 767            }
 768
 18769            if (requiresRestart)
 770            {
 0771                Logger.LogInformation("App needs to be restarted due to configuration change.");
 772
 0773                NotifyPendingRestart();
 774            }
 18775        }
 776
 777        /// <summary>
 778        /// Validates the SSL certificate.
 779        /// </summary>
 780        /// <param name="networkConfig">The new configuration.</param>
 781        /// <exception cref="FileNotFoundException">The certificate path doesn't exist.</exception>
 782        private bool ValidateSslCertificate(NetworkConfiguration networkConfig)
 783        {
 18784            var newPath = networkConfig.CertificatePath;
 785
 18786            if (!string.IsNullOrWhiteSpace(newPath)
 18787                && !string.Equals(CertificatePath, newPath, StringComparison.Ordinal))
 788            {
 0789                if (File.Exists(newPath))
 790                {
 0791                    return true;
 792                }
 793
 0794                throw new FileNotFoundException(
 0795                    string.Format(
 0796                        CultureInfo.InvariantCulture,
 0797                        "Certificate file '{0}' does not exist.",
 0798                        newPath));
 799            }
 800
 18801            return false;
 802        }
 803
 804        /// <summary>
 805        /// Notifies the kernel that a change has been made that requires a restart.
 806        /// </summary>
 807        public void NotifyPendingRestart()
 808        {
 0809            Logger.LogInformation("App needs to be restarted.");
 810
 0811            var changed = !HasPendingRestart;
 812
 0813            HasPendingRestart = true;
 814
 0815            if (changed)
 816            {
 0817                EventHelper.QueueEventIfNotNull(HasPendingRestartChanged, this, EventArgs.Empty, Logger);
 818            }
 0819        }
 820
 821        /// <summary>
 822        /// Gets the composable part assemblies.
 823        /// </summary>
 824        /// <returns>IEnumerable{Assembly}.</returns>
 825        protected IEnumerable<Assembly> GetComposablePartAssemblies()
 826        {
 827            foreach (var p in _pluginManager.LoadAssemblies())
 828            {
 829                yield return p;
 830            }
 831
 832            // Include composable parts in the Model assembly
 833            yield return typeof(SystemInfo).Assembly;
 834
 835            // Include composable parts in the Common assembly
 836            yield return typeof(IApplicationHost).Assembly;
 837
 838            // Include composable parts in the Controller assembly
 839            yield return typeof(IServerApplicationHost).Assembly;
 840
 841            // Include composable parts in the Providers assembly
 842            yield return typeof(ProviderManager).Assembly;
 843
 844            // Include composable parts in the Photos assembly
 845            yield return typeof(PhotoProvider).Assembly;
 846
 847            // Emby.Server implementations
 848            yield return typeof(InstallationManager).Assembly;
 849
 850            // MediaEncoding
 851            yield return typeof(MediaBrowser.MediaEncoding.Encoder.MediaEncoder).Assembly;
 852
 853            // Local metadata
 854            yield return typeof(BoxSetXmlSaver).Assembly;
 855
 856            // Xbmc
 857            yield return typeof(ArtistNfoProvider).Assembly;
 858
 859            // Network
 860            yield return typeof(NetworkManager).Assembly;
 861
 862            // Hls
 863            yield return typeof(DynamicHlsPlaylistGenerator).Assembly;
 864
 865            foreach (var i in GetAssembliesWithPartsInternal())
 866            {
 867                yield return i;
 868            }
 869        }
 870
 871        protected abstract IEnumerable<Assembly> GetAssembliesWithPartsInternal();
 872
 873        /// <inheritdoc/>
 874        public string GetSmartApiUrl(IPAddress remoteAddr)
 875        {
 876            // Published server ends with a /
 0877            if (!string.IsNullOrEmpty(PublishedServerUrl))
 878            {
 879                // Published server ends with a '/', so we need to remove it.
 0880                return PublishedServerUrl.Trim('/');
 881            }
 882
 0883            string smart = NetManager.GetBindAddress(remoteAddr, out var port);
 0884            return GetLocalApiUrl(smart.Trim('/'), null, port);
 885        }
 886
 887        /// <inheritdoc/>
 888        public string GetSmartApiUrl(HttpRequest request)
 889        {
 890            // Return the host in the HTTP request as the API URL if not configured otherwise
 0891            if (ConfigurationManager.GetNetworkConfiguration().EnablePublishedServerUriByRequest)
 892            {
 0893                int? requestPort = request.Host.Port;
 0894                if (requestPort is null
 0895                    || (requestPort == 80 && string.Equals(request.Scheme, "http", StringComparison.OrdinalIgnoreCase))
 0896                    || (requestPort == 443 && string.Equals(request.Scheme, "https", StringComparison.OrdinalIgnoreCase)
 897                {
 0898                    requestPort = -1;
 899                }
 900
 0901                return GetLocalApiUrl(request.Host.Host, request.Scheme, requestPort);
 902            }
 903
 0904            return GetSmartApiUrl(request.HttpContext.Connection.RemoteIpAddress ?? IPAddress.Loopback);
 905        }
 906
 907        /// <inheritdoc/>
 908        public string GetSmartApiUrl(string hostname)
 909        {
 910            // Published server ends with a /
 0911            if (!string.IsNullOrEmpty(PublishedServerUrl))
 912            {
 913                // Published server ends with a '/', so we need to remove it.
 0914                return PublishedServerUrl.Trim('/');
 915            }
 916
 0917            string smart = NetManager.GetBindAddress(hostname, out var port);
 0918            return GetLocalApiUrl(smart.Trim('/'), null, port);
 919        }
 920
 921        /// <inheritdoc/>
 922        public string GetApiUrlForLocalAccess(IPAddress ipAddress = null, bool allowHttps = true)
 923        {
 924            // With an empty source, the port will be null
 0925            var smart = NetManager.GetBindAddress(ipAddress, out _, false);
 0926            var scheme = !allowHttps ? Uri.UriSchemeHttp : null;
 0927            int? port = !allowHttps ? HttpPort : null;
 0928            return GetLocalApiUrl(smart, scheme, port);
 929        }
 930
 931        /// <inheritdoc/>
 932        public string GetLocalApiUrl(string hostname, string scheme = null, int? port = null)
 933        {
 934            // If the smartAPI doesn't start with http then treat it as a host or ip.
 0935            if (hostname.StartsWith("http", StringComparison.OrdinalIgnoreCase))
 936            {
 0937                return hostname.TrimEnd('/');
 938            }
 939
 940            // NOTE: If no BaseUrl is set then UriBuilder appends a trailing slash, but if there is no BaseUrl it does
 941            // not. For consistency, always trim the trailing slash.
 0942            scheme ??= ListenWithHttps ? Uri.UriSchemeHttps : Uri.UriSchemeHttp;
 0943            var isHttps = string.Equals(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase);
 0944            return new UriBuilder
 0945            {
 0946                Scheme = scheme,
 0947                Host = hostname,
 0948                Port = port ?? (isHttps ? HttpsPort : HttpPort),
 0949                Path = ConfigurationManager.GetNetworkConfiguration().BaseUrl
 0950            }.ToString().TrimEnd('/');
 951        }
 952
 953        public IEnumerable<Assembly> GetApiPluginAssemblies()
 954        {
 955            var assemblies = _allConcreteTypes
 956                .Where(i => typeof(ControllerBase).IsAssignableFrom(i))
 957                .Select(i => i.Assembly)
 958                .Distinct();
 959
 960            foreach (var assembly in assemblies)
 961            {
 962                Logger.LogDebug("Found API endpoints in plugin {Name}", assembly.FullName);
 963                yield return assembly;
 964            }
 965        }
 966
 967        /// <inheritdoc />
 968        public void Dispose()
 969        {
 21970            Dispose(true);
 21971            GC.SuppressFinalize(this);
 21972        }
 973
 974        /// <summary>
 975        /// Releases unmanaged and - optionally - managed resources.
 976        /// </summary>
 977        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release o
 978        protected virtual void Dispose(bool dispose)
 979        {
 21980            if (_disposed)
 981            {
 0982                return;
 983            }
 984
 21985            if (dispose)
 986            {
 21987                var type = GetType();
 988
 21989                Logger.LogInformation("Disposing {Type}", type.Name);
 990
 168991                foreach (var part in _disposableParts.ToArray())
 992                {
 63993                    var partType = part.GetType();
 63994                    if (partType == type)
 995                    {
 996                        continue;
 997                    }
 998
 63999                    Logger.LogInformation("Disposing {Type}", partType.Name);
 1000
 1001                    try
 1002                    {
 631003                        part.Dispose();
 631004                    }
 01005                    catch (Exception ex)
 1006                    {
 01007                        Logger.LogError(ex, "Error disposing {Type}", partType.Name);
 01008                    }
 1009                }
 1010
 211011                _disposableParts.Clear();
 1012            }
 1013
 211014            _disposed = true;
 211015        }
 1016    }
 1017}
Generated by: ReportGenerator 5.4.5.0
4/26/2025 - 12:10:58 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()
GetExports(System.Boolean)
GetExports(MediaBrowser.Common.CreationDelegateFactory,System.Boolean)
RunStartupTasksAsync()
Init(Microsoft.Extensions.DependencyInjection.IServiceCollection)
RegisterServices(Microsoft.Extensions.DependencyInjection.IServiceCollection)
GetCertificate(System.String,System.String)
SetStaticProperties()
FindParts()
DiscoverTypes()
OnConfigurationUpdated(System.Object,System.EventArgs)
ValidateSslCertificate(MediaBrowser.Common.Net.NetworkConfiguration)
NotifyPendingRestart()
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>)
Dispose()
Dispose(System.Boolean)