jellyfin/MediaBrowser.Server.Implementations/Configuration/ServerConfigurationManager.cs

285 lines
10 KiB
C#
Raw Normal View History

2014-12-22 01:02:15 +00:00
using System.Collections.Generic;
using MediaBrowser.Common.Configuration;
2014-05-07 18:38:50 +00:00
using MediaBrowser.Common.Events;
2013-03-04 05:43:06 +00:00
using MediaBrowser.Common.Implementations.Configuration;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Configuration;
2014-10-23 04:26:01 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
2014-07-11 04:27:46 +00:00
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
2013-03-04 05:43:06 +00:00
using MediaBrowser.Model.Configuration;
2014-05-08 20:09:53 +00:00
using MediaBrowser.Model.Events;
2013-03-04 05:43:06 +00:00
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Serialization;
using System;
using System.IO;
2014-07-27 22:01:29 +00:00
using System.Linq;
2015-10-04 04:23:11 +00:00
using CommonIO;
2013-03-04 05:43:06 +00:00
namespace MediaBrowser.Server.Implementations.Configuration
{
/// <summary>
/// Class ServerConfigurationManager
/// </summary>
public class ServerConfigurationManager : BaseConfigurationManager, IServerConfigurationManager
{
2015-09-13 23:07:54 +00:00
2013-03-04 05:43:06 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="ServerConfigurationManager" /> class.
/// </summary>
/// <param name="applicationPaths">The application paths.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="xmlSerializer">The XML serializer.</param>
2015-10-07 21:42:29 +00:00
/// <param name="fileSystem">The file system.</param>
2015-09-13 23:07:54 +00:00
public ServerConfigurationManager(IApplicationPaths applicationPaths, ILogManager logManager, IXmlSerializer xmlSerializer, IFileSystem fileSystem)
2015-10-07 21:42:29 +00:00
: base(applicationPaths, logManager, xmlSerializer, fileSystem)
2013-03-04 05:43:06 +00:00
{
2014-03-25 21:13:55 +00:00
UpdateMetadataPath();
2013-03-04 05:43:06 +00:00
}
2014-05-07 18:38:50 +00:00
public event EventHandler<GenericEventArgs<ServerConfiguration>> ConfigurationUpdating;
2013-03-04 05:43:06 +00:00
/// <summary>
/// Gets the type of the configuration.
/// </summary>
/// <value>The type of the configuration.</value>
protected override Type ConfigurationType
{
get { return typeof(ServerConfiguration); }
}
/// <summary>
/// Gets the application paths.
/// </summary>
/// <value>The application paths.</value>
public IServerApplicationPaths ApplicationPaths
{
get { return (IServerApplicationPaths)CommonApplicationPaths; }
}
/// <summary>
/// Gets the configuration.
/// </summary>
/// <value>The configuration.</value>
public ServerConfiguration Configuration
{
get { return (ServerConfiguration)CommonConfiguration; }
}
2013-04-23 19:17:21 +00:00
/// <summary>
/// Called when [configuration updated].
/// </summary>
protected override void OnConfigurationUpdated()
{
2014-04-03 22:50:04 +00:00
UpdateMetadataPath();
2013-04-23 19:17:21 +00:00
base.OnConfigurationUpdated();
}
2014-12-22 01:02:15 +00:00
public override void AddParts(IEnumerable<IConfigurationFactory> factories)
{
base.AddParts(factories);
UpdateTranscodingTempPath();
}
2014-03-25 21:13:55 +00:00
/// <summary>
/// Updates the metadata path.
/// </summary>
private void UpdateMetadataPath()
{
2015-04-24 02:15:29 +00:00
string metadataPath;
if (string.IsNullOrWhiteSpace(Configuration.MetadataPath))
{
metadataPath = GetInternalMetadataPath();
}
else if (Configuration.EnableCustomPathSubFolders)
{
metadataPath = Path.Combine(Configuration.MetadataPath, "metadata");
}
else
{
metadataPath = Configuration.MetadataPath;
}
((ServerApplicationPaths)ApplicationPaths).InternalMetadataPath = metadataPath;
2016-01-26 18:19:05 +00:00
((ServerApplicationPaths)ApplicationPaths).ItemsByNamePath = ((ServerApplicationPaths)ApplicationPaths).InternalMetadataPath;
2014-03-25 21:13:55 +00:00
}
2015-01-21 03:54:45 +00:00
private string GetInternalMetadataPath()
{
2016-01-26 18:19:05 +00:00
return Path.Combine(ApplicationPaths.ProgramDataPath, "metadata");
2015-01-21 03:54:45 +00:00
}
2014-12-22 01:02:15 +00:00
/// <summary>
/// Updates the transcoding temporary path.
/// </summary>
private void UpdateTranscodingTempPath()
{
var encodingConfig = this.GetConfiguration<EncodingOptions>("encoding");
((ServerApplicationPaths)ApplicationPaths).TranscodingTempPath = string.IsNullOrEmpty(encodingConfig.TranscodingTempPath) ?
null :
2015-04-24 02:15:29 +00:00
Path.Combine(encodingConfig.TranscodingTempPath, "transcoding-temp");
2014-12-22 01:02:15 +00:00
}
protected override void OnNamedConfigurationUpdated(string key, object configuration)
{
base.OnNamedConfigurationUpdated(key, configuration);
if (string.Equals(key, "encoding", StringComparison.OrdinalIgnoreCase))
{
UpdateTranscodingTempPath();
}
}
2013-04-23 19:17:21 +00:00
/// <summary>
/// Replaces the configuration.
/// </summary>
/// <param name="newConfiguration">The new configuration.</param>
/// <exception cref="System.IO.DirectoryNotFoundException"></exception>
public override void ReplaceConfiguration(BaseApplicationConfiguration newConfiguration)
{
2014-05-07 18:38:50 +00:00
var newConfig = (ServerConfiguration)newConfiguration;
2013-04-23 19:17:21 +00:00
2013-12-15 01:17:57 +00:00
ValidateItemByNamePath(newConfig);
ValidatePathSubstitutions(newConfig);
2014-03-25 21:13:55 +00:00
ValidateMetadataPath(newConfig);
ValidateSslCertificate(newConfig);
2013-12-15 01:17:57 +00:00
2014-05-07 18:38:50 +00:00
EventHelper.FireEventIfNotNull(ConfigurationUpdating, this, new GenericEventArgs<ServerConfiguration> { Argument = newConfig }, Logger);
2013-12-15 01:17:57 +00:00
base.ReplaceConfiguration(newConfiguration);
}
/// <summary>
/// Validates the SSL certificate.
/// </summary>
/// <param name="newConfig">The new configuration.</param>
/// <exception cref="System.IO.DirectoryNotFoundException"></exception>
private void ValidateSslCertificate(BaseApplicationConfiguration newConfig)
{
var serverConfig = (ServerConfiguration)newConfig;
2015-12-29 17:15:19 +00:00
var newPath = serverConfig.CertificatePath;
2015-12-29 17:15:19 +00:00
if (!string.IsNullOrWhiteSpace(newPath)
&& !string.Equals(Configuration.CertificatePath ?? string.Empty, newPath))
{
// Validate
2015-12-29 17:15:19 +00:00
if (!FileSystem.FileExists(newPath))
{
2015-12-29 17:15:19 +00:00
throw new FileNotFoundException(string.Format("Certificate file '{0}' does not exist.", newPath));
}
}
}
private void ValidatePathSubstitutions(ServerConfiguration newConfig)
{
foreach (var map in newConfig.PathSubstitutions)
{
if (string.IsNullOrWhiteSpace(map.From) || string.IsNullOrWhiteSpace(map.To))
{
throw new ArgumentException("Invalid path substitution");
}
}
}
2013-12-15 01:17:57 +00:00
/// <summary>
/// Replaces the item by name path.
/// </summary>
/// <param name="newConfig">The new configuration.</param>
/// <exception cref="System.IO.DirectoryNotFoundException"></exception>
private void ValidateItemByNamePath(ServerConfiguration newConfig)
{
var newPath = newConfig.ItemsByNamePath;
2013-04-29 18:00:21 +00:00
2013-12-15 01:17:57 +00:00
if (!string.IsNullOrWhiteSpace(newPath)
&& !string.Equals(Configuration.ItemsByNamePath ?? string.Empty, newPath))
2013-04-23 19:17:21 +00:00
{
// Validate
2015-10-07 21:42:29 +00:00
if (!FileSystem.DirectoryExists(newPath))
2013-04-23 19:17:21 +00:00
{
2013-12-15 01:17:57 +00:00
throw new DirectoryNotFoundException(string.Format("{0} does not exist.", newPath));
2013-04-23 19:17:21 +00:00
}
EnsureWriteAccess(newPath);
2013-04-23 19:17:21 +00:00
}
}
2014-03-25 21:13:55 +00:00
/// <summary>
/// Validates the metadata path.
/// </summary>
/// <param name="newConfig">The new configuration.</param>
/// <exception cref="System.IO.DirectoryNotFoundException"></exception>
private void ValidateMetadataPath(ServerConfiguration newConfig)
{
var newPath = newConfig.MetadataPath;
if (!string.IsNullOrWhiteSpace(newPath)
&& !string.Equals(Configuration.MetadataPath ?? string.Empty, newPath))
{
// Validate
2015-10-07 21:42:29 +00:00
if (!FileSystem.DirectoryExists(newPath))
2014-03-25 21:13:55 +00:00
{
throw new DirectoryNotFoundException(string.Format("{0} does not exist.", newPath));
}
EnsureWriteAccess(newPath);
2014-03-25 21:13:55 +00:00
}
}
2014-07-11 04:27:46 +00:00
2014-07-13 04:55:56 +00:00
public void DisableMetadataService(string service)
2014-07-11 04:27:46 +00:00
{
DisableMetadataService(typeof(Movie), Configuration, service);
DisableMetadataService(typeof(Episode), Configuration, service);
DisableMetadataService(typeof(Series), Configuration, service);
2014-10-23 04:26:01 +00:00
DisableMetadataService(typeof(Season), Configuration, service);
DisableMetadataService(typeof(MusicArtist), Configuration, service);
DisableMetadataService(typeof(MusicAlbum), Configuration, service);
DisableMetadataService(typeof(MusicVideo), Configuration, service);
DisableMetadataService(typeof(Video), Configuration, service);
2014-07-11 04:27:46 +00:00
}
private void DisableMetadataService(Type type, ServerConfiguration config, string service)
{
var options = GetMetadataOptions(type, config);
if (!options.DisabledMetadataSavers.Contains(service, StringComparer.OrdinalIgnoreCase))
{
var list = options.DisabledMetadataSavers.ToList();
list.Add(service);
options.DisabledMetadataSavers = list.ToArray();
}
}
private MetadataOptions GetMetadataOptions(Type type, ServerConfiguration config)
{
var options = config.MetadataOptions
.FirstOrDefault(i => string.Equals(i.ItemType, type.Name, StringComparison.OrdinalIgnoreCase));
if (options == null)
{
var list = config.MetadataOptions.ToList();
options = new MetadataOptions
{
ItemType = type.Name
};
list.Add(options);
config.MetadataOptions = list.ToArray();
}
return options;
}
2013-03-04 05:43:06 +00:00
}
}