< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.AppBase.BaseConfigurationManager
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/AppBase/BaseConfigurationManager.cs
Line coverage
65%
Covered lines: 80
Uncovered lines: 43
Coverable lines: 123
Total lines: 382
Line coverage: 65%
Branch coverage
36%
Covered branches: 13
Total branches: 36
Branch coverage: 36.1%
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_CommonConfiguration()75%4483.33%
set_CommonConfiguration(...)100%210%
RegisterConfiguration()0%2040%
AddParts(...)100%11100%
SaveConfiguration()50%22100%
OnConfigurationUpdated()100%11100%
ReplaceConfiguration(...)100%210%
UpdateCachePath()50%4475%
ValidateCachePath(...)0%7280%
EnsureWriteAccess(...)100%210%
GetConfigurationFile(...)100%11100%
GetConfiguration(...)100%11100%
LoadConfiguration(...)50%7444.44%
SaveConfiguration(...)50%9880%
OnNamedConfigurationUpdated(...)50%22100%
GetConfigurationStores()100%11100%
GetConfigurationType(...)100%210%
GetConfigurationStore(...)100%11100%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/AppBase/BaseConfigurationManager.cs

#LineLine coverage
 1using System;
 2using System.Collections.Concurrent;
 3using System.Collections.Generic;
 4using System.Globalization;
 5using System.IO;
 6using System.Linq;
 7using System.Threading;
 8using MediaBrowser.Common.Configuration;
 9using MediaBrowser.Common.Events;
 10using MediaBrowser.Common.Extensions;
 11using MediaBrowser.Model.Configuration;
 12using MediaBrowser.Model.Serialization;
 13using Microsoft.Extensions.Logging;
 14
 15namespace Emby.Server.Implementations.AppBase
 16{
 17    /// <summary>
 18    /// Class BaseConfigurationManager.
 19    /// </summary>
 20    public abstract class BaseConfigurationManager : IConfigurationManager
 21    {
 2122        private readonly ConcurrentDictionary<string, object> _configurations = new();
 2123        private readonly Lock _configurationSyncLock = new();
 24
 2125        private ConfigurationStore[] _configurationStores = Array.Empty<ConfigurationStore>();
 2126        private IConfigurationFactory[] _configurationFactories = Array.Empty<IConfigurationFactory>();
 27
 28        /// <summary>
 29        /// The _configuration.
 30        /// </summary>
 31        private BaseApplicationConfiguration? _configuration;
 32
 33        /// <summary>
 34        /// Initializes a new instance of the <see cref="BaseConfigurationManager" /> class.
 35        /// </summary>
 36        /// <param name="applicationPaths">The application paths.</param>
 37        /// <param name="loggerFactory">The logger factory.</param>
 38        /// <param name="xmlSerializer">The XML serializer.</param>
 39        protected BaseConfigurationManager(
 40            IApplicationPaths applicationPaths,
 41            ILoggerFactory loggerFactory,
 42            IXmlSerializer xmlSerializer)
 43        {
 2144            CommonApplicationPaths = applicationPaths;
 2145            XmlSerializer = xmlSerializer;
 2146            Logger = loggerFactory.CreateLogger<BaseConfigurationManager>();
 47
 2148            UpdateCachePath();
 2149        }
 50
 51        /// <summary>
 52        /// Occurs when [configuration updated].
 53        /// </summary>
 54        public event EventHandler<EventArgs>? ConfigurationUpdated;
 55
 56        /// <summary>
 57        /// Occurs when [configuration updating].
 58        /// </summary>
 59        public event EventHandler<ConfigurationUpdateEventArgs>? NamedConfigurationUpdating;
 60
 61        /// <summary>
 62        /// Occurs when [named configuration updated].
 63        /// </summary>
 64        public event EventHandler<ConfigurationUpdateEventArgs>? NamedConfigurationUpdated;
 65
 66        /// <summary>
 67        /// Gets the type of the configuration.
 68        /// </summary>
 69        /// <value>The type of the configuration.</value>
 70        protected abstract Type ConfigurationType { get; }
 71
 72        /// <summary>
 73        /// Gets the logger.
 74        /// </summary>
 75        /// <value>The logger.</value>
 76        protected ILogger<BaseConfigurationManager> Logger { get; private set; }
 77
 78        /// <summary>
 79        /// Gets the XML serializer.
 80        /// </summary>
 81        /// <value>The XML serializer.</value>
 82        protected IXmlSerializer XmlSerializer { get; private set; }
 83
 84        /// <summary>
 85        /// Gets the application paths.
 86        /// </summary>
 87        /// <value>The application paths.</value>
 88        public IApplicationPaths CommonApplicationPaths { get; private set; }
 89
 90        /// <summary>
 91        /// Gets or sets the system configuration.
 92        /// </summary>
 93        /// <value>The configuration.</value>
 94        public BaseApplicationConfiguration CommonConfiguration
 95        {
 96            get
 97            {
 420898                if (_configuration is not null)
 99                {
 4187100                    return _configuration;
 101                }
 102
 103                lock (_configurationSyncLock)
 104                {
 21105                    if (_configuration is not null)
 106                    {
 0107                        return _configuration;
 108                    }
 109
 21110                    return _configuration = (BaseApplicationConfiguration)ConfigurationHelper.GetXmlConfiguration(Config
 111                }
 21112            }
 113
 114            protected set
 115            {
 0116                _configuration = value;
 0117            }
 118        }
 119
 120        /// <summary>
 121        /// Manually pre-loads a factory so that it is available pre system initialisation.
 122        /// </summary>
 123        /// <typeparam name="T">Class to register.</typeparam>
 124        public virtual void RegisterConfiguration<T>()
 125            where T : IConfigurationFactory
 126        {
 0127            IConfigurationFactory factory = Activator.CreateInstance<T>();
 128
 0129            if (_configurationFactories is null)
 130            {
 0131                _configurationFactories = [factory];
 132            }
 133            else
 134            {
 0135                _configurationFactories = [.._configurationFactories, factory];
 136            }
 137
 0138            _configurationStores = _configurationFactories
 0139                .SelectMany(i => i.GetConfigurations())
 0140                .ToArray();
 0141        }
 142
 143        /// <summary>
 144        /// Adds parts.
 145        /// </summary>
 146        /// <param name="factories">The configuration factories.</param>
 147        public virtual void AddParts(IEnumerable<IConfigurationFactory> factories)
 148        {
 21149            _configurationFactories = factories.ToArray();
 150
 21151            _configurationStores = _configurationFactories
 21152                .SelectMany(i => i.GetConfigurations())
 21153                .ToArray();
 21154        }
 155
 156        /// <summary>
 157        /// Saves the configuration.
 158        /// </summary>
 159        public void SaveConfiguration()
 160        {
 38161            Logger.LogInformation("Saving system configuration");
 38162            var path = CommonApplicationPaths.SystemConfigurationFilePath;
 163
 38164            Directory.CreateDirectory(Path.GetDirectoryName(path) ?? throw new InvalidOperationException("Path can't be 
 165
 166            lock (_configurationSyncLock)
 167            {
 38168                XmlSerializer.SerializeToFile(CommonConfiguration, path);
 38169            }
 170
 38171            OnConfigurationUpdated();
 38172        }
 173
 174        /// <summary>
 175        /// Called when [configuration updated].
 176        /// </summary>
 177        protected virtual void OnConfigurationUpdated()
 178        {
 38179            UpdateCachePath();
 180
 38181            EventHelper.QueueEventIfNotNull(ConfigurationUpdated, this, EventArgs.Empty, Logger);
 38182        }
 183
 184        /// <summary>
 185        /// Replaces the configuration.
 186        /// </summary>
 187        /// <param name="newConfiguration">The new configuration.</param>
 188        /// <exception cref="ArgumentNullException"><c>newConfiguration</c> is <c>null</c>.</exception>
 189        public virtual void ReplaceConfiguration(BaseApplicationConfiguration newConfiguration)
 190        {
 0191            ArgumentNullException.ThrowIfNull(newConfiguration);
 192
 0193            ValidateCachePath(newConfiguration);
 194
 0195            CommonConfiguration = newConfiguration;
 0196            SaveConfiguration();
 0197        }
 198
 199        /// <summary>
 200        /// Updates the items by name path.
 201        /// </summary>
 202        private void UpdateCachePath()
 203        {
 204            string cachePath;
 205
 206            // If the configuration file has no entry (i.e. not set in UI)
 59207            if (string.IsNullOrWhiteSpace(CommonConfiguration.CachePath))
 208            {
 209                // If the current live configuration has no entry (i.e. not set on CLI/envvars, during startup)
 59210                if (string.IsNullOrWhiteSpace(((BaseApplicationPaths)CommonApplicationPaths).CachePath))
 211                {
 212                    // Set cachePath to a default value under ProgramDataPath
 0213                    cachePath = Path.Combine(((BaseApplicationPaths)CommonApplicationPaths).ProgramDataPath, "cache");
 214                }
 215                else
 216                {
 217                    // Set cachePath to the existing live value; will require restart if UI value is removed (but not re
 218                    // TODO: Figure out how to re-grab this from the CLI/envvars while running
 59219                    cachePath = ((BaseApplicationPaths)CommonApplicationPaths).CachePath;
 220                }
 221            }
 222            else
 223            {
 224                // Set cachePath to the new UI-set value
 0225                cachePath = CommonConfiguration.CachePath;
 226            }
 227
 59228            Logger.LogInformation("Setting cache path: {Path}", cachePath);
 59229            ((BaseApplicationPaths)CommonApplicationPaths).CachePath = cachePath;
 59230        }
 231
 232        /// <summary>
 233        /// Replaces the cache path.
 234        /// </summary>
 235        /// <param name="newConfig">The new configuration.</param>
 236        /// <exception cref="DirectoryNotFoundException">The new cache path doesn't exist.</exception>
 237        private void ValidateCachePath(BaseApplicationConfiguration newConfig)
 238        {
 0239            var newPath = newConfig.CachePath;
 240
 0241            if (!string.IsNullOrWhiteSpace(newPath)
 0242                && !string.Equals(CommonConfiguration.CachePath ?? string.Empty, newPath, StringComparison.Ordinal))
 243            {
 244                // Validate
 0245                if (!Directory.Exists(newPath))
 246                {
 0247                    throw new DirectoryNotFoundException(
 0248                        string.Format(
 0249                            CultureInfo.InvariantCulture,
 0250                            "{0} does not exist.",
 0251                            newPath));
 252                }
 253
 0254                EnsureWriteAccess(newPath);
 255            }
 0256        }
 257
 258        /// <summary>
 259        /// Ensures that we have write access to the path.
 260        /// </summary>
 261        /// <param name="path">The path.</param>
 262        protected void EnsureWriteAccess(string path)
 263        {
 0264            var file = Path.Combine(path, Guid.NewGuid().ToString());
 0265            File.WriteAllText(file, string.Empty);
 0266            File.Delete(file);
 0267        }
 268
 269        private string GetConfigurationFile(string key)
 270        {
 110271            return Path.Combine(CommonApplicationPaths.ConfigurationDirectoryPath, key.ToLowerInvariant() + ".xml");
 272        }
 273
 274        /// <inheritdoc />
 275        public object GetConfiguration(string key)
 276        {
 863277            return _configurations.GetOrAdd(
 863278                key,
 863279                static (k, configurationManager) =>
 863280                {
 863281                    var file = configurationManager.GetConfigurationFile(k);
 863282
 863283                    var configurationInfo = Array.Find(
 863284                        configurationManager._configurationStores,
 863285                        i => string.Equals(i.Key, k, StringComparison.OrdinalIgnoreCase));
 863286
 863287                    if (configurationInfo is null)
 863288                    {
 863289                        throw new ResourceNotFoundException("Configuration with key " + k + " not found.");
 863290                    }
 863291
 863292                    var configurationType = configurationInfo.ConfigurationType;
 863293
 863294                    lock (configurationManager._configurationSyncLock)
 863295                    {
 863296                        return configurationManager.LoadConfiguration(file, configurationType);
 863297                    }
 863298                },
 863299                this);
 300        }
 301
 302        private object LoadConfiguration(string path, Type configurationType)
 303        {
 304            try
 305            {
 88306                if (File.Exists(path))
 307                {
 0308                    return XmlSerializer.DeserializeFromFile(configurationType, path);
 309                }
 88310            }
 0311            catch (Exception ex) when (ex is not IOException)
 312            {
 0313                Logger.LogError(ex, "Error loading configuration file: {Path}", path);
 0314            }
 315
 88316            return Activator.CreateInstance(configurationType)
 88317                ?? throw new InvalidOperationException("Configuration type can't be Nullable<T>.");
 0318        }
 319
 320        /// <inheritdoc />
 321        public void SaveConfiguration(string key, object configuration)
 322        {
 22323            var configurationStore = GetConfigurationStore(key);
 22324            var configurationType = configurationStore.ConfigurationType;
 325
 22326            if (configuration.GetType() != configurationType)
 327            {
 0328                throw new ArgumentException("Expected configuration type is " + configurationType.Name);
 329            }
 330
 22331            if (configurationStore is IValidatingConfiguration validatingStore)
 332            {
 0333                var currentConfiguration = GetConfiguration(key);
 334
 0335                validatingStore.Validate(currentConfiguration, configuration);
 336            }
 337
 22338            NamedConfigurationUpdating?.Invoke(this, new ConfigurationUpdateEventArgs(key, configuration));
 339
 22340            _configurations.AddOrUpdate(key, configuration, (_, _) => configuration);
 341
 22342            var path = GetConfigurationFile(key);
 22343            Directory.CreateDirectory(Path.GetDirectoryName(path) ?? throw new InvalidOperationException("Path can't be 
 344
 345            lock (_configurationSyncLock)
 346            {
 22347                XmlSerializer.SerializeToFile(configuration, path);
 22348            }
 349
 22350            OnNamedConfigurationUpdated(key, configuration);
 22351        }
 352
 353        /// <summary>
 354        /// Event handler for when a named configuration has been updated.
 355        /// </summary>
 356        /// <param name="key">The key of the configuration.</param>
 357        /// <param name="configuration">The old configuration.</param>
 358        protected virtual void OnNamedConfigurationUpdated(string key, object configuration)
 359        {
 22360            NamedConfigurationUpdated?.Invoke(this, new ConfigurationUpdateEventArgs(key, configuration));
 22361        }
 362
 363        /// <inheritdoc />
 364        public ConfigurationStore[] GetConfigurationStores()
 365        {
 1366            return _configurationStores;
 367        }
 368
 369        /// <inheritdoc />
 370        public Type GetConfigurationType(string key)
 371        {
 0372            return GetConfigurationStore(key)
 0373                .ConfigurationType;
 374        }
 375
 376        private ConfigurationStore GetConfigurationStore(string key)
 377        {
 22378            return _configurationStores
 22379                .First(i => string.Equals(i.Key, key, StringComparison.OrdinalIgnoreCase));
 380        }
 381    }
 382}
Generated by: ReportGenerator 5.4.5.0
4/26/2025 - 12:10:58 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Common.Configuration.IApplicationPaths,Microsoft.Extensions.Logging.ILoggerFactory,MediaBrowser.Model.Serialization.IXmlSerializer)
get_CommonConfiguration()
set_CommonConfiguration(MediaBrowser.Model.Configuration.BaseApplicationConfiguration)
RegisterConfiguration()
AddParts(System.Collections.Generic.IEnumerable`1<MediaBrowser.Common.Configuration.IConfigurationFactory>)
SaveConfiguration()
OnConfigurationUpdated()
ReplaceConfiguration(MediaBrowser.Model.Configuration.BaseApplicationConfiguration)
UpdateCachePath()
ValidateCachePath(MediaBrowser.Model.Configuration.BaseApplicationConfiguration)
EnsureWriteAccess(System.String)
GetConfigurationFile(System.String)
GetConfiguration(System.String)
LoadConfiguration(System.String,System.Type)
SaveConfiguration(System.String,System.Object)
OnNamedConfigurationUpdated(System.String,System.Object)
GetConfigurationStores()
GetConfigurationType(System.String)
GetConfigurationStore(System.String)