2019-10-09 17:10:16 +02:00
|
|
|
#pragma warning disable CS1591
|
|
|
|
|
2019-01-13 20:23:38 +01:00
|
|
|
using System;
|
|
|
|
using System.Collections.Concurrent;
|
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.Diagnostics;
|
|
|
|
using System.Globalization;
|
|
|
|
using System.IO;
|
|
|
|
using System.Linq;
|
|
|
|
using System.Net;
|
2019-03-08 20:32:14 +01:00
|
|
|
using System.Net.Http;
|
2019-07-07 21:03:26 +02:00
|
|
|
using System.Net.Sockets;
|
2019-01-13 20:23:38 +01:00
|
|
|
using System.Reflection;
|
|
|
|
using System.Runtime.InteropServices;
|
|
|
|
using System.Security.Cryptography.X509Certificates;
|
|
|
|
using System.Text;
|
|
|
|
using System.Threading;
|
|
|
|
using System.Threading.Tasks;
|
2017-08-09 21:56:38 +02:00
|
|
|
using Emby.Dlna;
|
|
|
|
using Emby.Dlna.Main;
|
|
|
|
using Emby.Dlna.Ssdp;
|
2019-01-13 20:23:38 +01:00
|
|
|
using Emby.Drawing;
|
|
|
|
using Emby.Notifications;
|
|
|
|
using Emby.Photos;
|
2017-09-09 20:51:24 +02:00
|
|
|
using Emby.Server.Implementations.Archiving;
|
2017-08-09 21:56:38 +02:00
|
|
|
using Emby.Server.Implementations.Channels;
|
|
|
|
using Emby.Server.Implementations.Collections;
|
|
|
|
using Emby.Server.Implementations.Configuration;
|
2017-09-09 20:51:24 +02:00
|
|
|
using Emby.Server.Implementations.Cryptography;
|
2017-08-09 21:56:38 +02:00
|
|
|
using Emby.Server.Implementations.Data;
|
|
|
|
using Emby.Server.Implementations.Devices;
|
|
|
|
using Emby.Server.Implementations.Dto;
|
|
|
|
using Emby.Server.Implementations.HttpServer;
|
|
|
|
using Emby.Server.Implementations.HttpServer.Security;
|
|
|
|
using Emby.Server.Implementations.IO;
|
|
|
|
using Emby.Server.Implementations.Library;
|
|
|
|
using Emby.Server.Implementations.LiveTv;
|
|
|
|
using Emby.Server.Implementations.Localization;
|
2017-09-09 20:51:24 +02:00
|
|
|
using Emby.Server.Implementations.Net;
|
2017-08-09 21:56:38 +02:00
|
|
|
using Emby.Server.Implementations.Playlists;
|
2017-09-09 20:51:24 +02:00
|
|
|
using Emby.Server.Implementations.ScheduledTasks;
|
2017-08-09 21:56:38 +02:00
|
|
|
using Emby.Server.Implementations.Security;
|
2017-09-09 20:51:24 +02:00
|
|
|
using Emby.Server.Implementations.Serialization;
|
2020-03-21 23:28:07 +01:00
|
|
|
using Emby.Server.Implementations.Services;
|
2017-08-09 21:56:38 +02:00
|
|
|
using Emby.Server.Implementations.Session;
|
2020-07-04 22:06:27 +02:00
|
|
|
using Emby.Server.Implementations.SyncPlay;
|
2017-08-09 21:56:38 +02:00
|
|
|
using Emby.Server.Implementations.TV;
|
|
|
|
using Emby.Server.Implementations.Updates;
|
|
|
|
using MediaBrowser.Api;
|
2013-03-04 06:43:06 +01:00
|
|
|
using MediaBrowser.Common;
|
|
|
|
using MediaBrowser.Common.Configuration;
|
2014-04-26 04:55:07 +02:00
|
|
|
using MediaBrowser.Common.Events;
|
2013-03-07 06:34:00 +01:00
|
|
|
using MediaBrowser.Common.Net;
|
2017-08-09 21:56:38 +02:00
|
|
|
using MediaBrowser.Common.Plugins;
|
|
|
|
using MediaBrowser.Common.Updates;
|
2013-02-24 22:53:54 +01:00
|
|
|
using MediaBrowser.Controller;
|
2019-01-13 20:23:38 +01:00
|
|
|
using MediaBrowser.Controller.Authentication;
|
2014-03-18 02:45:41 +01:00
|
|
|
using MediaBrowser.Controller.Channels;
|
2014-06-09 21:16:14 +02:00
|
|
|
using MediaBrowser.Controller.Chapters;
|
2014-03-07 16:53:23 +01:00
|
|
|
using MediaBrowser.Controller.Collections;
|
2013-03-04 06:43:06 +01:00
|
|
|
using MediaBrowser.Controller.Configuration;
|
2014-10-11 22:38:13 +02:00
|
|
|
using MediaBrowser.Controller.Devices;
|
2014-03-13 20:08:02 +01:00
|
|
|
using MediaBrowser.Controller.Dlna;
|
2013-03-08 06:08:27 +01:00
|
|
|
using MediaBrowser.Controller.Drawing;
|
2013-09-04 19:02:19 +02:00
|
|
|
using MediaBrowser.Controller.Dto;
|
2013-03-01 22:22:34 +01:00
|
|
|
using MediaBrowser.Controller.Entities;
|
2013-02-27 21:25:45 +01:00
|
|
|
using MediaBrowser.Controller.Library;
|
2013-09-26 17:48:14 +02:00
|
|
|
using MediaBrowser.Controller.LiveTv;
|
2014-02-20 17:37:41 +01:00
|
|
|
using MediaBrowser.Controller.MediaEncoding;
|
2013-12-07 16:52:38 +01:00
|
|
|
using MediaBrowser.Controller.Net;
|
2013-07-06 23:23:32 +02:00
|
|
|
using MediaBrowser.Controller.Notifications;
|
2013-03-08 06:08:27 +01:00
|
|
|
using MediaBrowser.Controller.Persistence;
|
2014-08-02 04:34:45 +02:00
|
|
|
using MediaBrowser.Controller.Playlists;
|
2013-03-08 06:08:27 +01:00
|
|
|
using MediaBrowser.Controller.Plugins;
|
|
|
|
using MediaBrowser.Controller.Providers;
|
2013-03-03 17:53:58 +01:00
|
|
|
using MediaBrowser.Controller.Resolvers;
|
2014-05-07 20:38:50 +02:00
|
|
|
using MediaBrowser.Controller.Security;
|
2013-05-09 19:38:02 +02:00
|
|
|
using MediaBrowser.Controller.Session;
|
2013-03-10 05:22:36 +01:00
|
|
|
using MediaBrowser.Controller.Sorting;
|
2014-05-07 04:28:19 +02:00
|
|
|
using MediaBrowser.Controller.Subtitles;
|
2020-05-06 23:42:53 +02:00
|
|
|
using MediaBrowser.Controller.SyncPlay;
|
2020-07-04 22:06:27 +02:00
|
|
|
using MediaBrowser.Controller.TV;
|
2015-05-31 20:22:51 +02:00
|
|
|
using MediaBrowser.LocalMetadata.Savers;
|
2017-09-09 20:51:24 +02:00
|
|
|
using MediaBrowser.MediaEncoding.BdInfo;
|
2017-08-09 21:56:38 +02:00
|
|
|
using MediaBrowser.Model.Configuration;
|
2017-09-09 20:51:24 +02:00
|
|
|
using MediaBrowser.Model.Cryptography;
|
2017-08-09 21:56:38 +02:00
|
|
|
using MediaBrowser.Model.Dlna;
|
|
|
|
using MediaBrowser.Model.Globalization;
|
|
|
|
using MediaBrowser.Model.IO;
|
2013-02-24 22:53:54 +01:00
|
|
|
using MediaBrowser.Model.MediaInfo;
|
2017-08-09 21:56:38 +02:00
|
|
|
using MediaBrowser.Model.Net;
|
|
|
|
using MediaBrowser.Model.Serialization;
|
|
|
|
using MediaBrowser.Model.Services;
|
2013-02-24 22:53:54 +01:00
|
|
|
using MediaBrowser.Model.System;
|
2017-09-09 20:51:24 +02:00
|
|
|
using MediaBrowser.Model.Tasks;
|
2014-06-09 21:16:14 +02:00
|
|
|
using MediaBrowser.Providers.Chapters;
|
2014-01-28 19:37:01 +01:00
|
|
|
using MediaBrowser.Providers.Manager;
|
2020-03-09 15:53:07 +01:00
|
|
|
using MediaBrowser.Providers.Plugins.TheTvdb;
|
2014-05-07 04:28:19 +02:00
|
|
|
using MediaBrowser.Providers.Subtitles;
|
2013-02-28 20:32:41 +01:00
|
|
|
using MediaBrowser.WebDashboard.Api;
|
2014-06-30 05:04:50 +02:00
|
|
|
using MediaBrowser.XbmcMetadata.Providers;
|
2019-02-25 23:34:32 +01:00
|
|
|
using Microsoft.AspNetCore.Http;
|
2019-02-03 17:09:12 +01:00
|
|
|
using Microsoft.Extensions.DependencyInjection;
|
2019-08-09 23:16:24 +02:00
|
|
|
using Microsoft.Extensions.Logging;
|
2020-04-26 17:28:17 +02:00
|
|
|
using Prometheus.DotNetRuntime;
|
2019-03-07 17:39:40 +01:00
|
|
|
using OperatingSystem = MediaBrowser.Common.System.OperatingSystem;
|
2013-02-24 22:53:54 +01:00
|
|
|
|
2017-08-09 21:56:38 +02:00
|
|
|
namespace Emby.Server.Implementations
|
2013-02-24 22:53:54 +01:00
|
|
|
{
|
|
|
|
/// <summary>
|
2019-10-09 17:10:16 +02:00
|
|
|
/// Class CompositionRoot.
|
2013-02-24 22:53:54 +01:00
|
|
|
/// </summary>
|
2018-09-12 19:26:21 +02:00
|
|
|
public abstract class ApplicationHost : IServerApplicationHost, IDisposable
|
2013-02-24 22:53:54 +01:00
|
|
|
{
|
2020-03-21 22:45:57 +01:00
|
|
|
/// <summary>
|
|
|
|
/// The environment variable prefixes to log at server startup.
|
|
|
|
/// </summary>
|
2020-04-05 15:05:23 +02:00
|
|
|
private static readonly string[] _relevantEnvVarPrefixes = { "JELLYFIN_", "DOTNET_", "ASPNETCORE_" };
|
2020-03-21 22:45:57 +01:00
|
|
|
|
2020-04-05 05:18:11 +02:00
|
|
|
private readonly IFileSystem _fileSystemManager;
|
|
|
|
private readonly INetworkManager _networkManager;
|
|
|
|
private readonly IXmlSerializer _xmlSerializer;
|
|
|
|
private readonly IStartupOptions _startupOptions;
|
|
|
|
|
2020-04-05 01:01:21 +02:00
|
|
|
private IMediaEncoder _mediaEncoder;
|
2020-04-04 19:56:01 +02:00
|
|
|
private ISessionManager _sessionManager;
|
|
|
|
private IHttpServer _httpServer;
|
2020-04-05 03:18:09 +02:00
|
|
|
private IHttpClient _httpClient;
|
2019-08-14 20:35:36 +02:00
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Gets a value indicating whether this instance can self restart.
|
|
|
|
/// </summary>
|
2020-04-05 05:18:11 +02:00
|
|
|
public bool CanSelfRestart => _startupOptions.RestartPath != null;
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2017-12-03 23:14:35 +01:00
|
|
|
public virtual bool CanLaunchWebBrowser
|
|
|
|
{
|
|
|
|
get
|
|
|
|
{
|
|
|
|
if (!Environment.UserInteractive)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-04-05 05:18:11 +02:00
|
|
|
if (_startupOptions.IsService)
|
2017-12-03 23:14:35 +01:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-03-07 17:39:40 +01:00
|
|
|
if (OperatingSystem.Id == OperatingSystemId.Windows
|
|
|
|
|| OperatingSystem.Id == OperatingSystemId.Darwin)
|
2017-12-03 23:14:35 +01:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Occurs when [has pending restart changed].
|
|
|
|
/// </summary>
|
|
|
|
public event EventHandler HasPendingRestartChanged;
|
|
|
|
|
|
|
|
/// <summary>
|
2019-03-13 22:32:52 +01:00
|
|
|
/// Gets a value indicating whether this instance has changes that require the entire application to restart.
|
2017-08-16 08:43:41 +02:00
|
|
|
/// </summary>
|
|
|
|
/// <value><c>true</c> if this instance has pending application restart; otherwise, <c>false</c>.</value>
|
|
|
|
public bool HasPendingRestart { get; private set; }
|
|
|
|
|
2019-10-09 17:10:16 +02:00
|
|
|
/// <inheritdoc />
|
2017-09-09 20:51:24 +02:00
|
|
|
public bool IsShuttingDown { get; private set; }
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <summary>
|
2020-03-03 23:53:48 +01:00
|
|
|
/// Gets the logger.
|
2017-08-16 08:43:41 +02:00
|
|
|
/// </summary>
|
2020-06-06 02:15:56 +02:00
|
|
|
protected ILogger<ApplicationHost> Logger { get; }
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2019-02-18 22:47:02 +01:00
|
|
|
private IPlugin[] _plugins;
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <summary>
|
2019-03-13 22:32:52 +01:00
|
|
|
/// Gets the plugins.
|
2017-08-16 08:43:41 +02:00
|
|
|
/// </summary>
|
|
|
|
/// <value>The plugins.</value>
|
2019-12-11 00:13:57 +01:00
|
|
|
public IReadOnlyList<IPlugin> Plugins => _plugins;
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
/// <summary>
|
2020-03-03 23:56:47 +01:00
|
|
|
/// Gets the logger factory.
|
2017-08-16 08:43:41 +02:00
|
|
|
/// </summary>
|
2020-03-03 23:56:47 +01:00
|
|
|
protected ILoggerFactory LoggerFactory { get; }
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
/// <summary>
|
2019-03-13 22:32:52 +01:00
|
|
|
/// Gets or sets the application paths.
|
2017-08-16 08:43:41 +02:00
|
|
|
/// </summary>
|
|
|
|
/// <value>The application paths.</value>
|
|
|
|
protected ServerApplicationPaths ApplicationPaths { get; set; }
|
|
|
|
|
|
|
|
/// <summary>
|
2019-03-13 22:32:52 +01:00
|
|
|
/// Gets or sets all concrete types.
|
2017-08-16 08:43:41 +02:00
|
|
|
/// </summary>
|
|
|
|
/// <value>All concrete types.</value>
|
2019-08-29 23:11:55 +02:00
|
|
|
private Type[] _allConcreteTypes;
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
/// <summary>
|
2019-08-29 23:11:55 +02:00
|
|
|
/// The disposable parts.
|
2017-08-16 08:43:41 +02:00
|
|
|
/// </summary>
|
2019-03-25 22:25:32 +01:00
|
|
|
private readonly List<IDisposable> _disposableParts = new List<IDisposable>();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the configuration manager.
|
|
|
|
/// </summary>
|
|
|
|
/// <value>The configuration manager.</value>
|
|
|
|
protected IConfigurationManager ConfigurationManager { get; set; }
|
|
|
|
|
2019-11-24 18:25:43 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets or sets the service provider.
|
|
|
|
/// </summary>
|
|
|
|
public IServiceProvider ServiceProvider { get; set; }
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2019-11-24 19:25:46 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the http port for the webhost.
|
|
|
|
/// </summary>
|
|
|
|
public int HttpPort { get; private set; }
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the https port for the webhost.
|
|
|
|
/// </summary>
|
|
|
|
public int HttpsPort { get; private set; }
|
|
|
|
|
2013-02-24 22:53:54 +01:00
|
|
|
/// <summary>
|
2013-03-04 06:43:06 +01:00
|
|
|
/// Gets the server configuration manager.
|
2013-02-24 22:53:54 +01:00
|
|
|
/// </summary>
|
2013-03-04 06:43:06 +01:00
|
|
|
/// <value>The server configuration manager.</value>
|
2019-01-06 21:50:43 +01:00
|
|
|
public IServerConfigurationManager ServerConfigurationManager => (IServerConfigurationManager)ConfigurationManager;
|
2013-03-03 08:27:40 +01:00
|
|
|
|
2013-09-21 03:04:14 +02:00
|
|
|
/// <summary>
|
2014-07-20 06:46:29 +02:00
|
|
|
/// Initializes a new instance of the <see cref="ApplicationHost" /> class.
|
2013-09-21 03:04:14 +02:00
|
|
|
/// </summary>
|
2019-03-13 22:32:52 +01:00
|
|
|
public ApplicationHost(
|
|
|
|
ServerApplicationPaths applicationPaths,
|
2018-12-13 14:18:25 +01:00
|
|
|
ILoggerFactory loggerFactory,
|
2019-01-28 21:58:47 +01:00
|
|
|
IStartupOptions options,
|
2014-10-07 01:58:46 +02:00
|
|
|
IFileSystem fileSystem,
|
2020-02-28 23:28:15 +01:00
|
|
|
INetworkManager networkManager)
|
2013-09-20 19:32:10 +02:00
|
|
|
{
|
2020-04-05 05:18:11 +02:00
|
|
|
_xmlSerializer = new MyXmlSerializer();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 05:18:11 +02:00
|
|
|
_networkManager = networkManager;
|
2018-09-12 19:26:21 +02:00
|
|
|
networkManager.LocalSubnetsFn = GetConfiguredLocalSubnets;
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
ApplicationPaths = applicationPaths;
|
2018-12-13 14:18:25 +01:00
|
|
|
LoggerFactory = loggerFactory;
|
2020-04-05 05:18:11 +02:00
|
|
|
_fileSystemManager = fileSystem;
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 05:18:11 +02:00
|
|
|
ConfigurationManager = new ServerConfigurationManager(ApplicationPaths, LoggerFactory, _xmlSerializer, _fileSystemManager);
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-21 02:20:39 +02:00
|
|
|
Logger = LoggerFactory.CreateLogger<ApplicationHost>();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 05:18:11 +02:00
|
|
|
_startupOptions = options;
|
2014-12-17 23:39:17 +01:00
|
|
|
|
2020-04-26 17:28:17 +02:00
|
|
|
// Initialize runtime stat collection
|
|
|
|
if (ServerConfigurationManager.Configuration.EnableMetrics)
|
|
|
|
{
|
2020-04-27 14:42:46 +02:00
|
|
|
DotNetRuntimeStatsBuilder.Default().StartCollecting();
|
2020-04-26 17:28:17 +02:00
|
|
|
}
|
|
|
|
|
2017-03-10 20:51:29 +01:00
|
|
|
fileSystem.AddShortcutHandler(new MbLinkShortcutHandler(fileSystem));
|
2017-11-29 21:50:18 +01:00
|
|
|
|
2020-04-05 05:18:11 +02:00
|
|
|
_networkManager.NetworkChanged += OnNetworkChanged;
|
2020-04-04 23:19:16 +02:00
|
|
|
|
|
|
|
CertificateInfo = new CertificateInfo
|
|
|
|
{
|
|
|
|
Path = ServerConfigurationManager.Configuration.CertificatePath,
|
|
|
|
Password = ServerConfigurationManager.Configuration.CertificatePassword
|
|
|
|
};
|
|
|
|
Certificate = GetCertificate(CertificateInfo);
|
2017-11-29 21:50:18 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
public string ExpandVirtualPath(string path)
|
|
|
|
{
|
|
|
|
var appPaths = ApplicationPaths;
|
|
|
|
|
|
|
|
return path.Replace(appPaths.VirtualDataPath, appPaths.DataPath, StringComparison.OrdinalIgnoreCase)
|
|
|
|
.Replace(appPaths.VirtualInternalMetadataPath, appPaths.InternalMetadataPath, StringComparison.OrdinalIgnoreCase);
|
|
|
|
}
|
|
|
|
|
|
|
|
public string ReverseVirtualPath(string path)
|
|
|
|
{
|
|
|
|
var appPaths = ApplicationPaths;
|
|
|
|
|
|
|
|
return path.Replace(appPaths.DataPath, appPaths.VirtualDataPath, StringComparison.OrdinalIgnoreCase)
|
|
|
|
.Replace(appPaths.InternalMetadataPath, appPaths.VirtualInternalMetadataPath, StringComparison.OrdinalIgnoreCase);
|
|
|
|
}
|
|
|
|
|
|
|
|
private string[] GetConfiguredLocalSubnets()
|
|
|
|
{
|
|
|
|
return ServerConfigurationManager.Configuration.LocalNetworkSubnets;
|
|
|
|
}
|
|
|
|
|
2019-08-09 23:16:24 +02:00
|
|
|
private void OnNetworkChanged(object sender, EventArgs e)
|
2017-11-29 21:50:18 +01:00
|
|
|
{
|
|
|
|
_validAddressResults.Clear();
|
2014-01-30 01:18:05 +01:00
|
|
|
}
|
2013-09-21 03:04:14 +02:00
|
|
|
|
2019-10-08 20:51:11 +02:00
|
|
|
/// <inheritdoc />
|
|
|
|
public Version ApplicationVersion { get; } = typeof(ApplicationHost).Assembly.GetName().Version;
|
|
|
|
|
|
|
|
/// <inheritdoc />
|
|
|
|
public string ApplicationVersionString { get; } = typeof(ApplicationHost).Assembly.GetName().Version.ToString(3);
|
2019-01-08 01:57:01 +01:00
|
|
|
|
|
|
|
/// <summary>
|
2019-08-09 23:50:40 +02:00
|
|
|
/// Gets the current application user agent.
|
2019-01-08 01:57:01 +01:00
|
|
|
/// </summary>
|
2019-01-20 03:41:48 +01:00
|
|
|
/// <value>The application user agent.</value>
|
2019-10-08 20:51:11 +02:00
|
|
|
public string ApplicationUserAgent => Name.Replace(' ', '-') + "/" + ApplicationVersionString;
|
2019-01-08 01:57:01 +01:00
|
|
|
|
2019-03-14 22:32:27 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the email address for use within a comment section of a user agent field.
|
|
|
|
/// Presently used to provide contact information to MusicBrainz service.
|
|
|
|
/// </summary>
|
|
|
|
public string ApplicationUserAgentAddress { get; } = "team@jellyfin.org";
|
|
|
|
|
2019-01-08 01:57:01 +01:00
|
|
|
/// <summary>
|
2019-08-09 23:16:24 +02:00
|
|
|
/// Gets the current application name.
|
2019-01-08 01:57:01 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <value>The application name.</value>
|
2019-08-09 23:16:24 +02:00
|
|
|
public string ApplicationProductName { get; } = FileVersionInfo.GetVersionInfo(Assembly.GetEntryAssembly().Location).ProductName;
|
2014-11-14 07:27:10 +01:00
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
private DeviceId _deviceId;
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
public string SystemId
|
|
|
|
{
|
|
|
|
get
|
|
|
|
{
|
|
|
|
if (_deviceId == null)
|
|
|
|
{
|
2019-02-06 20:38:42 +01:00
|
|
|
_deviceId = new DeviceId(ApplicationPaths, LoggerFactory);
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return _deviceId.Value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-05 03:18:09 +02:00
|
|
|
/// <inheritdoc/>
|
2019-01-20 05:52:40 +01:00
|
|
|
public string Name => ApplicationProductName;
|
2014-01-25 22:07:19 +01:00
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <summary>
|
2019-11-10 18:24:05 +01:00
|
|
|
/// Creates an instance of type and resolves all constructor dependencies.
|
2017-08-16 08:43:41 +02:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="type">The type.</param>
|
|
|
|
/// <returns>System.Object.</returns>
|
|
|
|
public object CreateInstance(Type type)
|
2019-11-24 15:27:58 +01:00
|
|
|
=> ActivatorUtilities.CreateInstance(ServiceProvider, type);
|
2019-02-03 17:09:12 +01:00
|
|
|
|
|
|
|
/// <summary>
|
2019-11-10 18:24:05 +01:00
|
|
|
/// Creates an instance of type and resolves all constructor dependencies.
|
2019-02-03 17:09:12 +01:00
|
|
|
/// </summary>
|
2019-08-09 23:50:40 +02:00
|
|
|
/// /// <typeparam name="T">The type.</typeparam>
|
|
|
|
/// <returns>T.</returns>
|
2019-02-03 17:09:12 +01:00
|
|
|
public T CreateInstance<T>()
|
2019-11-24 15:27:58 +01:00
|
|
|
=> ActivatorUtilities.CreateInstance<T>(ServiceProvider);
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Creates the instance safe.
|
|
|
|
/// </summary>
|
2019-03-13 22:32:52 +01:00
|
|
|
/// <param name="type">The type.</param>
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <returns>System.Object.</returns>
|
2019-02-03 17:09:12 +01:00
|
|
|
protected object CreateInstanceSafe(Type type)
|
2017-08-16 08:43:41 +02:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2019-02-16 11:41:48 +01:00
|
|
|
Logger.LogDebug("Creating instance of {Type}", type);
|
2019-11-24 15:27:58 +01:00
|
|
|
return ActivatorUtilities.CreateInstance(ServiceProvider, type);
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2019-02-03 17:09:12 +01:00
|
|
|
Logger.LogError(ex, "Error creating {Type}", type);
|
2017-08-16 08:43:41 +02:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Resolves this instance.
|
|
|
|
/// </summary>
|
2019-03-13 22:32:52 +01:00
|
|
|
/// <typeparam name="T">The type</typeparam>
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <returns>``0.</returns>
|
2019-11-24 15:27:58 +01:00
|
|
|
public T Resolve<T>() => ServiceProvider.GetService<T>();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the export types.
|
|
|
|
/// </summary>
|
2019-10-25 12:47:20 +02:00
|
|
|
/// <typeparam name="T">The type.</typeparam>
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <returns>IEnumerable{Type}.</returns>
|
2019-02-03 17:09:12 +01:00
|
|
|
public IEnumerable<Type> GetExportTypes<T>()
|
2017-08-16 08:43:41 +02:00
|
|
|
{
|
|
|
|
var currentType = typeof(T);
|
|
|
|
|
2019-08-29 23:11:55 +02:00
|
|
|
return _allConcreteTypes.Where(i => currentType.IsAssignableFrom(i));
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
|
2019-08-11 16:52:37 +02:00
|
|
|
/// <inheritdoc />
|
|
|
|
public IReadOnlyCollection<T> GetExports<T>(bool manageLifetime = true)
|
2017-08-16 08:43:41 +02:00
|
|
|
{
|
2019-11-10 18:24:05 +01:00
|
|
|
// Convert to list so this isn't executed for each iteration
|
2017-08-16 08:43:41 +02:00
|
|
|
var parts = GetExportTypes<T>()
|
2019-03-13 22:32:52 +01:00
|
|
|
.Select(CreateInstanceSafe)
|
2017-08-16 08:43:41 +02:00
|
|
|
.Where(i => i != null)
|
2019-02-06 17:41:38 +01:00
|
|
|
.Cast<T>()
|
2019-11-10 18:24:05 +01:00
|
|
|
.ToList();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2018-12-20 13:11:26 +01:00
|
|
|
if (manageLifetime)
|
2017-08-16 08:43:41 +02:00
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
lock (_disposableParts)
|
2017-08-16 08:43:41 +02:00
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
_disposableParts.AddRange(parts.OfType<IDisposable>());
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return parts;
|
|
|
|
}
|
|
|
|
|
2013-03-08 06:08:27 +01:00
|
|
|
/// <summary>
|
2013-03-10 07:45:16 +01:00
|
|
|
/// Runs the startup tasks.
|
2013-03-08 06:08:27 +01:00
|
|
|
/// </summary>
|
2019-08-11 16:52:37 +02:00
|
|
|
/// <returns><see cref="Task" />.</returns>
|
2019-03-07 17:39:40 +01:00
|
|
|
public async Task RunStartupTasksAsync()
|
2013-03-07 06:34:00 +01:00
|
|
|
{
|
2019-01-27 15:40:37 +01:00
|
|
|
Logger.LogInformation("Running startup tasks");
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
Resolve<ITaskManager>().AddTasks(GetExports<IScheduledTask>(false));
|
|
|
|
|
|
|
|
ConfigurationManager.ConfigurationUpdated += OnConfigurationUpdated;
|
2013-03-08 06:08:27 +01:00
|
|
|
|
2020-04-05 01:01:21 +02:00
|
|
|
_mediaEncoder.SetFFmpegPath();
|
2016-09-09 18:58:08 +02:00
|
|
|
|
2018-12-13 14:18:25 +01:00
|
|
|
Logger.LogInformation("ServerId: {0}", SystemId);
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2019-08-11 16:52:37 +02:00
|
|
|
var entryPoints = GetExports<IServerEntryPoint>();
|
2019-01-27 15:40:37 +01:00
|
|
|
|
2019-02-25 18:26:17 +01:00
|
|
|
var stopWatch = new Stopwatch();
|
|
|
|
stopWatch.Start();
|
2019-03-13 22:32:52 +01:00
|
|
|
await Task.WhenAll(StartEntryPoints(entryPoints, true)).ConfigureAwait(false);
|
2019-02-26 19:37:39 +01:00
|
|
|
Logger.LogInformation("Executed all pre-startup entry points in {Elapsed:g}", stopWatch.Elapsed);
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2018-12-13 14:18:25 +01:00
|
|
|
Logger.LogInformation("Core startup complete");
|
2020-04-04 19:56:01 +02:00
|
|
|
_httpServer.GlobalResponse = null;
|
2013-04-08 17:55:53 +02:00
|
|
|
|
2019-02-25 18:26:17 +01:00
|
|
|
stopWatch.Restart();
|
2019-03-13 22:32:52 +01:00
|
|
|
await Task.WhenAll(StartEntryPoints(entryPoints, false)).ConfigureAwait(false);
|
2019-02-26 19:37:39 +01:00
|
|
|
Logger.LogInformation("Executed all post-startup entry points in {Elapsed:g}", stopWatch.Elapsed);
|
2019-02-25 18:26:17 +01:00
|
|
|
stopWatch.Stop();
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
|
|
|
|
2019-01-27 15:40:37 +01:00
|
|
|
private IEnumerable<Task> StartEntryPoints(IEnumerable<IServerEntryPoint> entryPoints, bool isBeforeStartup)
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
foreach (var entryPoint in entryPoints)
|
2013-06-22 01:38:19 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
if (isBeforeStartup != (entryPoint is IRunBeforeStartup))
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-01-27 15:40:37 +01:00
|
|
|
Logger.LogDebug("Starting entry point {Type}", entryPoint.GetType());
|
|
|
|
|
|
|
|
yield return entryPoint.RunAsync();
|
2016-06-30 00:01:35 +02:00
|
|
|
}
|
2013-03-07 06:34:00 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 23:28:15 +01:00
|
|
|
/// <inheritdoc/>
|
2020-04-05 02:40:50 +02:00
|
|
|
public void Init(IServiceCollection serviceCollection)
|
2014-02-13 06:11:54 +01:00
|
|
|
{
|
2015-01-19 05:29:57 +01:00
|
|
|
HttpPort = ServerConfigurationManager.Configuration.HttpServerPortNumber;
|
|
|
|
HttpsPort = ServerConfigurationManager.Configuration.HttpsPortNumber;
|
|
|
|
|
2016-11-09 05:58:58 +01:00
|
|
|
// Safeguard against invalid configuration
|
|
|
|
if (HttpPort == HttpsPort)
|
|
|
|
{
|
|
|
|
HttpPort = ServerConfiguration.DefaultHttpPort;
|
|
|
|
HttpsPort = ServerConfiguration.DefaultHttpsPort;
|
|
|
|
}
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
if (Plugins != null)
|
|
|
|
{
|
|
|
|
var pluginBuilder = new StringBuilder();
|
|
|
|
|
|
|
|
foreach (var plugin in Plugins)
|
|
|
|
{
|
2020-07-04 22:06:27 +02:00
|
|
|
pluginBuilder.Append(plugin.Name)
|
|
|
|
.Append(' ')
|
|
|
|
.Append(plugin.Version)
|
|
|
|
.AppendLine();
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
|
2019-08-09 23:16:24 +02:00
|
|
|
Logger.LogInformation("Plugins: {Plugins}", pluginBuilder.ToString());
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
2019-01-01 18:41:02 +01:00
|
|
|
|
|
|
|
DiscoverTypes();
|
|
|
|
|
2020-04-05 02:40:50 +02:00
|
|
|
RegisterServices(serviceCollection);
|
2019-02-25 23:34:32 +01:00
|
|
|
}
|
|
|
|
|
2019-12-17 23:15:02 +01:00
|
|
|
public Task ExecuteHttpHandlerAsync(HttpContext context, Func<Task> next)
|
2020-05-02 01:09:35 +02:00
|
|
|
=> _httpServer.RequestHandler(context);
|
2014-02-13 06:11:54 +01:00
|
|
|
|
2013-02-24 22:53:54 +01:00
|
|
|
/// <summary>
|
2020-03-15 15:23:50 +01:00
|
|
|
/// Registers services/resources with the service collection that will be available via DI.
|
2013-02-24 22:53:54 +01:00
|
|
|
/// </summary>
|
2020-04-05 16:03:53 +02:00
|
|
|
protected virtual void RegisterServices(IServiceCollection serviceCollection)
|
2013-02-24 22:53:54 +01:00
|
|
|
{
|
2020-04-05 05:14:35 +02:00
|
|
|
serviceCollection.AddSingleton(_startupOptions);
|
|
|
|
|
2019-02-15 22:02:17 +01:00
|
|
|
serviceCollection.AddMemoryCache();
|
2019-02-15 20:11:27 +01:00
|
|
|
|
2019-02-03 17:09:12 +01:00
|
|
|
serviceCollection.AddSingleton(ConfigurationManager);
|
|
|
|
serviceCollection.AddSingleton<IApplicationHost>(this);
|
|
|
|
|
|
|
|
serviceCollection.AddSingleton<IApplicationPaths>(ApplicationPaths);
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 03:33:57 +02:00
|
|
|
serviceCollection.AddSingleton<IJsonSerializer, JsonSerializer>();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 05:18:11 +02:00
|
|
|
serviceCollection.AddSingleton(_fileSystemManager);
|
2020-03-09 15:53:07 +01:00
|
|
|
serviceCollection.AddSingleton<TvdbClientManager>();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 03:18:09 +02:00
|
|
|
serviceCollection.AddSingleton<IHttpClient, HttpClientManager.HttpClientManager>();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 05:18:11 +02:00
|
|
|
serviceCollection.AddSingleton(_networkManager);
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 03:00:11 +02:00
|
|
|
serviceCollection.AddSingleton<IIsoManager, IsoManager>();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 03:00:11 +02:00
|
|
|
serviceCollection.AddSingleton<ITaskManager, TaskManager>();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 05:18:11 +02:00
|
|
|
serviceCollection.AddSingleton(_xmlSerializer);
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 02:00:55 +02:00
|
|
|
serviceCollection.AddSingleton<IStreamHelper, StreamHelper>();
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2020-04-05 02:42:11 +02:00
|
|
|
serviceCollection.AddSingleton<ICryptoProvider, CryptographyProvider>();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2020-04-05 02:42:11 +02:00
|
|
|
serviceCollection.AddSingleton<ISocketFactory, SocketFactory>();
|
2013-02-26 04:43:04 +01:00
|
|
|
|
2020-04-05 02:00:55 +02:00
|
|
|
serviceCollection.AddSingleton<IInstallationManager, InstallationManager>();
|
2016-10-29 07:40:15 +02:00
|
|
|
|
2020-04-05 02:00:55 +02:00
|
|
|
serviceCollection.AddSingleton<IZipClient, ZipClient>();
|
2016-10-28 20:35:17 +02:00
|
|
|
|
2020-04-05 02:00:55 +02:00
|
|
|
serviceCollection.AddSingleton<IHttpResultFactory, HttpResultFactory>();
|
2013-03-15 05:23:07 +01:00
|
|
|
|
2019-02-03 17:09:12 +01:00
|
|
|
serviceCollection.AddSingleton<IServerApplicationHost>(this);
|
|
|
|
serviceCollection.AddSingleton<IServerApplicationPaths>(ApplicationPaths);
|
2013-03-07 06:34:00 +01:00
|
|
|
|
2019-02-03 17:09:12 +01:00
|
|
|
serviceCollection.AddSingleton(ServerConfigurationManager);
|
2015-02-28 19:47:05 +01:00
|
|
|
|
2020-04-05 02:21:48 +02:00
|
|
|
serviceCollection.AddSingleton<ILocalizationManager, LocalizationManager>();
|
2014-03-31 03:00:47 +02:00
|
|
|
|
2020-04-05 02:00:55 +02:00
|
|
|
serviceCollection.AddSingleton<IBlurayExaminer, BdInfoExaminer>();
|
2013-03-08 06:08:27 +01:00
|
|
|
|
2020-04-05 01:57:26 +02:00
|
|
|
serviceCollection.AddSingleton<IUserDataRepository, SqliteUserDataRepository>();
|
|
|
|
serviceCollection.AddSingleton<IUserDataManager, UserDataManager>();
|
2013-04-13 20:02:30 +02:00
|
|
|
|
2020-04-04 23:12:24 +02:00
|
|
|
serviceCollection.AddSingleton<IItemRepository, SqliteItemRepository>();
|
2013-04-19 22:27:02 +02:00
|
|
|
|
2020-04-05 01:36:27 +02:00
|
|
|
serviceCollection.AddSingleton<IAuthenticationRepository, AuthenticationRepository>();
|
2014-07-08 03:41:03 +02:00
|
|
|
|
2020-04-05 01:31:14 +02:00
|
|
|
// TODO: Refactor to eliminate the circular dependency here so that Lazy<T> isn't required
|
|
|
|
serviceCollection.AddTransient(provider => new Lazy<IDtoService>(provider.GetRequiredService<IDtoService>));
|
2013-04-14 05:05:19 +02:00
|
|
|
|
2020-04-11 16:53:13 +02:00
|
|
|
// TODO: Refactor to eliminate the circular dependency here so that Lazy<T> isn't required
|
|
|
|
serviceCollection.AddTransient(provider => new Lazy<EncodingHelper>(provider.GetRequiredService<EncodingHelper>));
|
2020-06-29 18:08:20 +02:00
|
|
|
serviceCollection.AddSingleton<IMediaEncoder, MediaBrowser.MediaEncoding.Encoder.MediaEncoder>();
|
2020-02-19 16:06:30 +01:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
// TODO: Refactor to eliminate the circular dependencies here so that Lazy<T> isn't required
|
|
|
|
serviceCollection.AddTransient(provider => new Lazy<ILibraryMonitor>(provider.GetRequiredService<ILibraryMonitor>));
|
|
|
|
serviceCollection.AddTransient(provider => new Lazy<IProviderManager>(provider.GetRequiredService<IProviderManager>));
|
|
|
|
serviceCollection.AddTransient(provider => new Lazy<IUserViewManager>(provider.GetRequiredService<IUserViewManager>));
|
|
|
|
serviceCollection.AddSingleton<ILibraryManager, LibraryManager>();
|
2013-03-05 05:25:27 +01:00
|
|
|
|
2020-04-05 00:22:29 +02:00
|
|
|
serviceCollection.AddSingleton<IMusicManager, MusicManager>();
|
2014-03-30 18:49:40 +02:00
|
|
|
|
2020-04-04 23:33:00 +02:00
|
|
|
serviceCollection.AddSingleton<ILibraryMonitor, LibraryMonitor>();
|
2013-03-08 06:08:27 +01:00
|
|
|
|
2020-04-05 00:22:29 +02:00
|
|
|
serviceCollection.AddSingleton<ISearchEngine, SearchEngine>();
|
2013-04-05 21:34:33 +02:00
|
|
|
|
2020-03-21 23:28:07 +01:00
|
|
|
serviceCollection.AddSingleton<ServiceController>();
|
2020-03-15 15:23:50 +01:00
|
|
|
serviceCollection.AddSingleton<IHttpServer, HttpListenerHost>();
|
2014-03-28 04:32:43 +01:00
|
|
|
|
2020-04-04 23:12:24 +02:00
|
|
|
serviceCollection.AddSingleton<IImageProcessor, ImageProcessor>();
|
2013-09-18 20:49:06 +02:00
|
|
|
|
2020-04-04 21:44:44 +02:00
|
|
|
serviceCollection.AddSingleton<ITVSeriesManager, TVSeriesManager>();
|
2014-12-30 17:36:49 +01:00
|
|
|
|
2020-04-04 21:40:06 +02:00
|
|
|
serviceCollection.AddSingleton<IDeviceManager, DeviceManager>();
|
2014-10-11 22:38:13 +02:00
|
|
|
|
2020-04-04 21:28:21 +02:00
|
|
|
serviceCollection.AddSingleton<IMediaSourceManager, MediaSourceManager>();
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2020-04-04 21:12:02 +02:00
|
|
|
serviceCollection.AddSingleton<ISubtitleManager, SubtitleManager>();
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2020-04-04 20:56:50 +02:00
|
|
|
serviceCollection.AddSingleton<IProviderManager, ProviderManager>();
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2020-04-04 21:28:21 +02:00
|
|
|
// TODO: Refactor to eliminate the circular dependency here so that Lazy<T> isn't required
|
2020-04-04 20:41:03 +02:00
|
|
|
serviceCollection.AddTransient(provider => new Lazy<ILiveTvManager>(provider.GetRequiredService<ILiveTvManager>));
|
|
|
|
serviceCollection.AddSingleton<IDtoService, DtoService>();
|
2013-12-13 16:48:35 +01:00
|
|
|
|
2020-04-04 20:32:35 +02:00
|
|
|
serviceCollection.AddSingleton<IChannelManager, ChannelManager>();
|
2014-03-18 02:45:41 +01:00
|
|
|
|
2020-04-04 19:56:01 +02:00
|
|
|
serviceCollection.AddSingleton<ISessionManager, SessionManager>();
|
2015-03-08 19:11:53 +01:00
|
|
|
|
2020-04-04 19:56:01 +02:00
|
|
|
serviceCollection.AddSingleton<IDlnaManager, DlnaManager>();
|
2014-03-13 20:08:02 +01:00
|
|
|
|
2020-04-04 19:56:01 +02:00
|
|
|
serviceCollection.AddSingleton<ICollectionManager, CollectionManager>();
|
2014-03-07 16:53:23 +01:00
|
|
|
|
2020-04-04 19:16:41 +02:00
|
|
|
serviceCollection.AddSingleton<IPlaylistManager, PlaylistManager>();
|
2014-08-02 04:34:45 +02:00
|
|
|
|
2020-05-06 23:42:53 +02:00
|
|
|
serviceCollection.AddSingleton<ISyncPlayManager, SyncPlayManager>();
|
2020-04-01 17:52:42 +02:00
|
|
|
|
2020-04-04 20:40:04 +02:00
|
|
|
serviceCollection.AddSingleton<LiveTvDtoService>();
|
2020-04-04 19:16:41 +02:00
|
|
|
serviceCollection.AddSingleton<ILiveTvManager, LiveTvManager>();
|
2014-01-12 07:31:21 +01:00
|
|
|
|
2020-04-04 19:10:39 +02:00
|
|
|
serviceCollection.AddSingleton<IUserViewManager, UserViewManager>();
|
2014-06-07 21:46:24 +02:00
|
|
|
|
2020-04-04 19:03:32 +02:00
|
|
|
serviceCollection.AddSingleton<INotificationManager, NotificationManager>();
|
2014-04-25 22:15:50 +02:00
|
|
|
|
2020-04-04 18:56:36 +02:00
|
|
|
serviceCollection.AddSingleton<IDeviceDiscovery, DeviceDiscovery>();
|
2015-07-23 18:32:34 +02:00
|
|
|
|
2020-04-04 18:56:36 +02:00
|
|
|
serviceCollection.AddSingleton<IChapterManager, ChapterManager>();
|
2014-06-09 21:16:14 +02:00
|
|
|
|
2020-04-04 18:51:56 +02:00
|
|
|
serviceCollection.AddSingleton<IEncodingManager, MediaEncoder.EncodingManager>();
|
2014-06-10 19:36:06 +02:00
|
|
|
|
2020-04-04 18:40:33 +02:00
|
|
|
serviceCollection.AddSingleton<IAuthorizationContext, AuthorizationContext>();
|
2020-04-04 18:38:59 +02:00
|
|
|
serviceCollection.AddSingleton<ISessionContext, SessionContext>();
|
2016-11-08 19:44:23 +01:00
|
|
|
|
2020-04-04 18:34:01 +02:00
|
|
|
serviceCollection.AddSingleton<IAuthService, AuthService>();
|
2014-07-02 06:57:18 +02:00
|
|
|
|
2020-04-04 18:26:24 +02:00
|
|
|
serviceCollection.AddSingleton<ISubtitleEncoder, MediaBrowser.MediaEncoding.Subtitles.SubtitleEncoder>();
|
2016-06-04 07:51:33 +02:00
|
|
|
|
2020-04-04 18:42:21 +02:00
|
|
|
serviceCollection.AddSingleton<IResourceFileManager, ResourceFileManager>();
|
2019-10-26 22:53:53 +02:00
|
|
|
serviceCollection.AddSingleton<EncodingHelper>();
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2020-04-04 18:56:36 +02:00
|
|
|
serviceCollection.AddSingleton<IAttachmentExtractor, MediaBrowser.MediaEncoding.Attachments.AttachmentExtractor>();
|
2020-04-04 18:33:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Create services registered with the service container that need to be initialized at application startup.
|
|
|
|
/// </summary>
|
2020-04-05 02:21:48 +02:00
|
|
|
/// <returns>A task representing the service initialization operation.</returns>
|
|
|
|
public async Task InitializeServices()
|
2020-04-04 18:33:25 +02:00
|
|
|
{
|
2020-04-05 02:21:48 +02:00
|
|
|
var localizationManager = (LocalizationManager)Resolve<ILocalizationManager>();
|
|
|
|
await localizationManager.LoadAll().ConfigureAwait(false);
|
|
|
|
|
2020-04-05 01:01:21 +02:00
|
|
|
_mediaEncoder = Resolve<IMediaEncoder>();
|
2020-04-04 19:56:01 +02:00
|
|
|
_sessionManager = Resolve<ISessionManager>();
|
|
|
|
_httpServer = Resolve<IHttpServer>();
|
2020-04-05 03:18:09 +02:00
|
|
|
_httpClient = Resolve<IHttpClient>();
|
2019-10-18 13:56:53 +02:00
|
|
|
|
2020-04-05 01:36:27 +02:00
|
|
|
((AuthenticationRepository)Resolve<IAuthenticationRepository>()).Initialize();
|
2016-06-24 08:32:51 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
SetStaticProperties();
|
|
|
|
|
2020-04-05 01:57:26 +02:00
|
|
|
var userDataRepo = (SqliteUserDataRepository)Resolve<IUserDataRepository>();
|
2020-05-13 04:25:45 +02:00
|
|
|
((SqliteItemRepository)Resolve<IItemRepository>()).Initialize(userDataRepo, Resolve<IUserManager>());
|
2020-04-04 21:05:50 +02:00
|
|
|
|
|
|
|
FindParts();
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
2013-04-08 17:55:53 +02:00
|
|
|
|
2019-03-07 17:39:40 +01:00
|
|
|
public static void LogEnvironmentInfo(ILogger logger, IApplicationPaths appPaths)
|
2017-08-16 08:43:41 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
// Distinct these to prevent users from reporting problems that aren't actually problems
|
|
|
|
var commandLineArgs = Environment
|
|
|
|
.GetCommandLineArgs()
|
2019-01-01 18:41:02 +01:00
|
|
|
.Distinct();
|
|
|
|
|
2020-03-21 22:45:57 +01:00
|
|
|
// Get all relevant environment variables
|
2020-03-17 14:30:08 +01:00
|
|
|
var allEnvVars = Environment.GetEnvironmentVariables();
|
2020-03-21 22:45:57 +01:00
|
|
|
var relevantEnvVars = new Dictionary<object, object>();
|
2020-03-17 14:30:08 +01:00
|
|
|
foreach (var key in allEnvVars.Keys)
|
|
|
|
{
|
2020-04-05 15:05:23 +02:00
|
|
|
if (_relevantEnvVarPrefixes.Any(prefix => key.ToString().StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))
|
2020-03-17 14:30:08 +01:00
|
|
|
{
|
2020-03-21 22:45:57 +01:00
|
|
|
relevantEnvVars.Add(key, allEnvVars[key]);
|
2020-03-17 14:30:08 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-21 22:45:57 +01:00
|
|
|
logger.LogInformation("Environment Variables: {EnvVars}", relevantEnvVars);
|
2019-01-01 18:41:02 +01:00
|
|
|
logger.LogInformation("Arguments: {Args}", commandLineArgs);
|
2019-03-26 19:20:40 +01:00
|
|
|
logger.LogInformation("Operating system: {OS}", OperatingSystem.Name);
|
2019-03-07 17:39:40 +01:00
|
|
|
logger.LogInformation("Architecture: {Architecture}", RuntimeInformation.OSArchitecture);
|
2019-01-01 18:51:55 +01:00
|
|
|
logger.LogInformation("64-Bit Process: {Is64Bit}", Environment.Is64BitProcess);
|
|
|
|
logger.LogInformation("User Interactive: {IsUserInteractive}", Environment.UserInteractive);
|
|
|
|
logger.LogInformation("Processor count: {ProcessorCount}", Environment.ProcessorCount);
|
|
|
|
logger.LogInformation("Program data path: {ProgramDataPath}", appPaths.ProgramDataPath);
|
2019-03-10 22:04:18 +01:00
|
|
|
logger.LogInformation("Web resources path: {WebPath}", appPaths.WebPath);
|
2019-01-01 18:51:55 +01:00
|
|
|
logger.LogInformation("Application directory: {ApplicationPath}", appPaths.ProgramSystemPath);
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
|
2019-03-03 08:29:23 +01:00
|
|
|
private X509Certificate2 GetCertificate(CertificateInfo info)
|
2016-11-11 04:29:51 +01:00
|
|
|
{
|
2019-03-03 08:29:23 +01:00
|
|
|
var certificateLocation = info?.Path;
|
2017-05-01 04:22:13 +02:00
|
|
|
|
2016-11-11 04:29:51 +01:00
|
|
|
if (string.IsNullOrWhiteSpace(certificateLocation))
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2019-01-26 22:59:53 +01:00
|
|
|
if (!File.Exists(certificateLocation))
|
2016-11-13 22:04:21 +01:00
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2017-05-10 21:12:03 +02:00
|
|
|
// Don't use an empty string password
|
|
|
|
var password = string.IsNullOrWhiteSpace(info.Password) ? null : info.Password;
|
|
|
|
|
2019-01-13 21:37:13 +01:00
|
|
|
var localCert = new X509Certificate2(certificateLocation, password);
|
2019-03-13 22:32:52 +01:00
|
|
|
// localCert.PrivateKey = PrivateKey.CreateFromFile(pvk_file).RSA;
|
2016-11-11 18:33:10 +01:00
|
|
|
if (!localCert.HasPrivateKey)
|
2016-11-11 04:29:51 +01:00
|
|
|
{
|
2019-01-01 18:51:55 +01:00
|
|
|
Logger.LogError("No private key included in SSL cert {CertificateLocation}.", certificateLocation);
|
2016-11-11 04:29:51 +01:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2017-09-03 04:42:13 +02:00
|
|
|
return localCert;
|
2016-11-11 04:29:51 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2019-01-01 18:51:55 +01:00
|
|
|
Logger.LogError(ex, "Error loading cert from {CertificateLocation}", certificateLocation);
|
2016-11-11 04:29:51 +01:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-08 06:08:27 +01:00
|
|
|
/// <summary>
|
2019-10-25 12:47:20 +02:00
|
|
|
/// Dirty hacks.
|
2013-03-08 06:08:27 +01:00
|
|
|
/// </summary>
|
|
|
|
private void SetStaticProperties()
|
|
|
|
{
|
|
|
|
// For now there's no real way to inject these properly
|
2020-04-05 03:33:57 +02:00
|
|
|
BaseItem.Logger = Resolve<ILogger<BaseItem>>();
|
2013-03-08 06:08:27 +01:00
|
|
|
BaseItem.ConfigurationManager = ServerConfigurationManager;
|
2020-04-05 00:28:46 +02:00
|
|
|
BaseItem.LibraryManager = Resolve<ILibraryManager>();
|
2020-04-04 20:56:50 +02:00
|
|
|
BaseItem.ProviderManager = Resolve<IProviderManager>();
|
2020-04-05 02:21:48 +02:00
|
|
|
BaseItem.LocalizationManager = Resolve<ILocalizationManager>();
|
2020-04-04 23:12:24 +02:00
|
|
|
BaseItem.ItemRepository = Resolve<IItemRepository>();
|
2020-04-05 05:18:11 +02:00
|
|
|
BaseItem.FileSystem = _fileSystemManager;
|
2020-04-05 01:57:26 +02:00
|
|
|
BaseItem.UserDataManager = Resolve<IUserDataManager>();
|
2020-04-04 21:05:50 +02:00
|
|
|
BaseItem.ChannelManager = Resolve<IChannelManager>();
|
|
|
|
Video.LiveTvManager = Resolve<ILiveTvManager>();
|
2020-04-04 19:10:39 +02:00
|
|
|
Folder.UserViewManager = Resolve<IUserViewManager>();
|
2020-04-04 21:44:44 +02:00
|
|
|
UserView.TVSeriesManager = Resolve<ITVSeriesManager>();
|
2020-04-04 19:56:01 +02:00
|
|
|
UserView.CollectionManager = Resolve<ICollectionManager>();
|
2020-04-04 21:28:21 +02:00
|
|
|
BaseItem.MediaSourceManager = Resolve<IMediaSourceManager>();
|
2020-04-05 05:18:11 +02:00
|
|
|
CollectionFolder.XmlSerializer = _xmlSerializer;
|
2020-04-05 03:33:57 +02:00
|
|
|
CollectionFolder.JsonSerializer = Resolve<IJsonSerializer>();
|
2018-09-12 19:26:21 +02:00
|
|
|
CollectionFolder.ApplicationHost = this;
|
2020-04-04 19:03:32 +02:00
|
|
|
AuthenticatedAttribute.AuthService = Resolve<IAuthService>();
|
2019-02-18 22:47:02 +01:00
|
|
|
}
|
|
|
|
|
2013-03-01 22:22:34 +01:00
|
|
|
/// <summary>
|
2020-04-04 21:05:50 +02:00
|
|
|
/// Finds plugin components and register them with the appropriate services.
|
2013-03-01 22:22:34 +01:00
|
|
|
/// </summary>
|
2020-04-04 21:05:50 +02:00
|
|
|
private void FindParts()
|
2013-03-01 22:22:34 +01:00
|
|
|
{
|
2016-10-10 20:18:28 +02:00
|
|
|
if (!ServerConfigurationManager.Configuration.IsPortAuthorized)
|
2013-03-27 23:13:46 +01:00
|
|
|
{
|
2015-01-12 06:07:19 +01:00
|
|
|
ServerConfigurationManager.Configuration.IsPortAuthorized = true;
|
|
|
|
ConfigurationManager.SaveConfiguration();
|
2013-03-27 23:13:46 +01:00
|
|
|
}
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
ConfigurationManager.AddParts(GetExports<IConfigurationFactory>());
|
2019-12-11 00:13:57 +01:00
|
|
|
_plugins = GetExports<IPlugin>()
|
2019-02-06 14:04:32 +01:00
|
|
|
.Select(LoadPlugin)
|
|
|
|
.Where(i => i != null)
|
|
|
|
.ToArray();
|
2013-03-15 05:23:07 +01:00
|
|
|
|
2020-04-04 19:56:01 +02:00
|
|
|
_httpServer.Init(GetExportTypes<IService>(), GetExports<IWebSocketListener>(), GetUrlPrefixes());
|
2013-03-08 06:08:27 +01:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
Resolve<ILibraryManager>().AddParts(
|
2019-03-13 22:32:52 +01:00
|
|
|
GetExports<IResolverIgnoreRule>(),
|
2017-08-17 22:19:02 +02:00
|
|
|
GetExports<IItemResolver>(),
|
|
|
|
GetExports<IIntroProvider>(),
|
|
|
|
GetExports<IBaseItemComparer>(),
|
|
|
|
GetExports<ILibraryPostScanTask>());
|
2013-06-25 03:22:21 +02:00
|
|
|
|
2020-04-04 20:56:50 +02:00
|
|
|
Resolve<IProviderManager>().AddParts(
|
2019-03-13 22:32:52 +01:00
|
|
|
GetExports<IImageProvider>(),
|
2017-08-17 22:19:02 +02:00
|
|
|
GetExports<IMetadataService>(),
|
|
|
|
GetExports<IMetadataProvider>(),
|
|
|
|
GetExports<IMetadataSaver>(),
|
|
|
|
GetExports<IExternalId>());
|
2013-08-10 03:40:52 +02:00
|
|
|
|
2020-04-04 21:05:50 +02:00
|
|
|
Resolve<ILiveTvManager>().AddParts(GetExports<ILiveTvService>(), GetExports<ITunerHost>(), GetExports<IListingsProvider>());
|
2013-12-25 15:39:46 +01:00
|
|
|
|
2020-04-04 21:12:02 +02:00
|
|
|
Resolve<ISubtitleManager>().AddParts(GetExports<ISubtitleProvider>());
|
2014-06-11 16:42:03 +02:00
|
|
|
|
2020-04-04 21:05:50 +02:00
|
|
|
Resolve<IChannelManager>().AddParts(GetExports<IChannel>());
|
2014-04-25 22:15:50 +02:00
|
|
|
|
2020-04-04 21:28:21 +02:00
|
|
|
Resolve<IMediaSourceManager>().AddParts(GetExports<IMediaSourceProvider>());
|
2015-04-04 02:41:16 +02:00
|
|
|
|
2020-04-04 21:05:50 +02:00
|
|
|
Resolve<INotificationManager>().AddParts(GetExports<INotificationService>(), GetExports<INotificationTypeFactory>());
|
2020-04-05 01:31:14 +02:00
|
|
|
Resolve<IUserManager>().AddParts(GetExports<IAuthenticationProvider>(), GetExports<IPasswordResetProvider>());
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2020-04-05 03:00:11 +02:00
|
|
|
Resolve<IIsoManager>().AddParts(GetExports<IIsoMounter>());
|
2013-03-01 22:22:34 +01:00
|
|
|
}
|
|
|
|
|
2019-02-06 14:04:32 +01:00
|
|
|
private IPlugin LoadPlugin(IPlugin plugin)
|
2017-08-16 08:43:41 +02:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2019-02-06 14:04:32 +01:00
|
|
|
if (plugin is IPluginAssembly assemblyPlugin)
|
2017-08-16 08:43:41 +02:00
|
|
|
{
|
|
|
|
var assembly = plugin.GetType().Assembly;
|
|
|
|
var assemblyName = assembly.GetName();
|
2019-02-06 14:04:32 +01:00
|
|
|
var assemblyFilePath = assembly.Location;
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var dataFolderPath = Path.Combine(ApplicationPaths.PluginsPath, Path.GetFileNameWithoutExtension(assemblyFilePath));
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
assemblyPlugin.SetAttributes(assemblyFilePath, dataFolderPath, assemblyName.Version);
|
2017-08-28 18:41:32 +02:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
var idAttributes = assembly.GetCustomAttributes(typeof(GuidAttribute), true);
|
|
|
|
if (idAttributes.Length > 0)
|
|
|
|
{
|
|
|
|
var attribute = (GuidAttribute)idAttributes[0];
|
|
|
|
var assemblyId = new Guid(attribute.Value);
|
|
|
|
|
|
|
|
assemblyPlugin.SetId(assemblyId);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2019-01-03 21:25:39 +01:00
|
|
|
Logger.LogError(ex, "Error getting plugin Id from {PluginName}.", plugin.GetType().FullName);
|
2017-08-28 18:41:32 +02:00
|
|
|
}
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
|
2019-01-03 21:25:39 +01:00
|
|
|
if (plugin is IHasPluginConfiguration hasPluginConfiguration)
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
hasPluginConfiguration.SetStartupInfo(s => Directory.CreateDirectory(s));
|
|
|
|
}
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2019-04-20 12:18:44 +02:00
|
|
|
Logger.LogError(ex, "Error loading plugin {PluginName}", plugin.GetType().FullName);
|
2017-08-16 08:43:41 +02:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return plugin;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Discovers the types.
|
|
|
|
/// </summary>
|
|
|
|
protected void DiscoverTypes()
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
Logger.LogInformation("Loading assemblies");
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2019-08-29 23:11:55 +02:00
|
|
|
_allConcreteTypes = GetTypes(GetComposablePartAssemblies()).ToArray();
|
2019-04-20 14:02:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private IEnumerable<Type> GetTypes(IEnumerable<Assembly> assemblies)
|
|
|
|
{
|
|
|
|
foreach (var ass in assemblies)
|
|
|
|
{
|
|
|
|
Type[] exportedTypes;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
exportedTypes = ass.GetExportedTypes();
|
|
|
|
}
|
2020-04-01 14:50:18 +02:00
|
|
|
catch (FileNotFoundException ex)
|
2019-04-20 14:02:00 +02:00
|
|
|
{
|
|
|
|
Logger.LogError(ex, "Error getting exported types from {Assembly}", ass.FullName);
|
|
|
|
continue;
|
|
|
|
}
|
2020-07-05 21:36:29 +02:00
|
|
|
catch (TypeLoadException ex)
|
|
|
|
{
|
|
|
|
Logger.LogError(ex, "Error loading types from {Assembly}.", ass.FullName);
|
|
|
|
continue;
|
|
|
|
}
|
2019-04-20 14:02:00 +02:00
|
|
|
|
|
|
|
foreach (Type type in exportedTypes)
|
|
|
|
{
|
|
|
|
if (type.IsClass && !type.IsAbstract && !type.IsInterface && !type.IsGenericType)
|
|
|
|
{
|
|
|
|
yield return type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
|
2017-05-01 04:22:13 +02:00
|
|
|
private CertificateInfo CertificateInfo { get; set; }
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2019-11-24 15:27:58 +01:00
|
|
|
public X509Certificate2 Certificate { get; private set; }
|
2015-01-19 07:42:31 +01:00
|
|
|
|
2015-01-19 05:29:57 +01:00
|
|
|
private IEnumerable<string> GetUrlPrefixes()
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var hosts = new[] { "+" };
|
2015-01-19 05:29:57 +01:00
|
|
|
|
2016-06-07 18:21:46 +02:00
|
|
|
return hosts.SelectMany(i =>
|
|
|
|
{
|
|
|
|
var prefixes = new List<string>
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
"http://" + i + ":" + HttpPort + "/"
|
2016-06-07 18:21:46 +02:00
|
|
|
};
|
|
|
|
|
2017-05-01 04:22:13 +02:00
|
|
|
if (CertificateInfo != null)
|
2016-06-07 18:21:46 +02:00
|
|
|
{
|
2016-09-21 20:28:33 +02:00
|
|
|
prefixes.Add("https://" + i + ":" + HttpsPort + "/");
|
2016-06-07 18:21:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return prefixes;
|
|
|
|
});
|
2015-01-19 05:29:57 +01:00
|
|
|
}
|
|
|
|
|
2013-05-07 21:07:51 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Called when [configuration updated].
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="sender">The sender.</param>
|
|
|
|
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
|
2017-08-16 08:43:41 +02:00
|
|
|
protected void OnConfigurationUpdated(object sender, EventArgs e)
|
2013-05-07 21:07:51 +02:00
|
|
|
{
|
2015-01-19 05:29:57 +01:00
|
|
|
var requiresRestart = false;
|
|
|
|
|
|
|
|
// Don't do anything if these haven't been set yet
|
|
|
|
if (HttpPort != 0 && HttpsPort != 0)
|
|
|
|
{
|
|
|
|
// Need to restart if ports have changed
|
|
|
|
if (ServerConfigurationManager.Configuration.HttpServerPortNumber != HttpPort ||
|
|
|
|
ServerConfigurationManager.Configuration.HttpsPortNumber != HttpsPort)
|
|
|
|
{
|
2015-02-11 05:05:58 +01:00
|
|
|
if (ServerConfigurationManager.Configuration.IsPortAuthorized)
|
|
|
|
{
|
|
|
|
ServerConfigurationManager.Configuration.IsPortAuthorized = false;
|
|
|
|
ServerConfigurationManager.SaveConfiguration();
|
2015-01-19 05:29:57 +01:00
|
|
|
|
2015-02-11 05:05:58 +01:00
|
|
|
requiresRestart = true;
|
|
|
|
}
|
2015-01-19 05:29:57 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-04 19:56:01 +02:00
|
|
|
if (!_httpServer.UrlPrefixes.SequenceEqual(GetUrlPrefixes(), StringComparer.OrdinalIgnoreCase))
|
2013-05-07 21:07:51 +02:00
|
|
|
{
|
2015-01-19 05:29:57 +01:00
|
|
|
requiresRestart = true;
|
|
|
|
}
|
2015-01-04 06:55:34 +01:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
var currentCertPath = CertificateInfo?.Path;
|
2020-04-04 23:19:16 +02:00
|
|
|
var newCertPath = ServerConfigurationManager.Configuration.CertificatePath;
|
2017-05-01 04:22:13 +02:00
|
|
|
|
|
|
|
if (!string.Equals(currentCertPath, newCertPath, StringComparison.OrdinalIgnoreCase))
|
2015-01-19 07:42:31 +01:00
|
|
|
{
|
|
|
|
requiresRestart = true;
|
|
|
|
}
|
|
|
|
|
2015-01-19 05:29:57 +01:00
|
|
|
if (requiresRestart)
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
Logger.LogInformation("App needs to be restarted due to configuration change.");
|
2016-12-26 18:38:12 +01:00
|
|
|
|
2013-05-07 21:07:51 +02:00
|
|
|
NotifyPendingRestart();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <summary>
|
2020-06-16 00:37:52 +02:00
|
|
|
/// Notifies that the kernel that a change has been made that requires a restart.
|
2017-08-16 08:43:41 +02:00
|
|
|
/// </summary>
|
|
|
|
public void NotifyPendingRestart()
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
Logger.LogInformation("App needs to be restarted.");
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
var changed = !HasPendingRestart;
|
|
|
|
|
|
|
|
HasPendingRestart = true;
|
|
|
|
|
|
|
|
if (changed)
|
|
|
|
{
|
|
|
|
EventHelper.QueueEventIfNotNull(HasPendingRestartChanged, this, EventArgs.Empty, Logger);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-24 22:53:54 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Restarts this instance.
|
|
|
|
/// </summary>
|
2017-09-09 20:51:24 +02:00
|
|
|
public void Restart()
|
2013-02-24 22:53:54 +01:00
|
|
|
{
|
2013-10-07 16:38:31 +02:00
|
|
|
if (!CanSelfRestart)
|
|
|
|
{
|
2016-08-31 21:17:11 +02:00
|
|
|
throw new PlatformNotSupportedException("The server is unable to self-restart. Please restart manually.");
|
2013-10-07 16:38:31 +02:00
|
|
|
}
|
|
|
|
|
2017-09-09 20:51:24 +02:00
|
|
|
if (IsShuttingDown)
|
2013-09-05 19:26:03 +02:00
|
|
|
{
|
2017-09-09 20:51:24 +02:00
|
|
|
return;
|
2013-09-05 19:26:03 +02:00
|
|
|
}
|
2017-09-09 20:51:24 +02:00
|
|
|
|
|
|
|
IsShuttingDown = true;
|
|
|
|
|
|
|
|
Task.Run(async () =>
|
2013-09-05 19:26:03 +02:00
|
|
|
{
|
2017-09-09 20:51:24 +02:00
|
|
|
try
|
|
|
|
{
|
2020-04-04 19:56:01 +02:00
|
|
|
await _sessionManager.SendServerRestartNotification(CancellationToken.None).ConfigureAwait(false);
|
2017-09-09 20:51:24 +02:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
Logger.LogError(ex, "Error sending server restart notification");
|
2017-09-09 20:51:24 +02:00
|
|
|
}
|
2013-09-05 19:26:03 +02:00
|
|
|
|
2018-12-13 14:18:25 +01:00
|
|
|
Logger.LogInformation("Calling RestartInternal");
|
2014-06-04 18:15:44 +02:00
|
|
|
|
2017-09-09 20:51:24 +02:00
|
|
|
RestartInternal();
|
|
|
|
});
|
2013-02-24 22:53:54 +01:00
|
|
|
}
|
|
|
|
|
2016-11-13 05:33:51 +01:00
|
|
|
protected abstract void RestartInternal();
|
2013-02-24 22:53:54 +01:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the composable part assemblies.
|
|
|
|
/// </summary>
|
|
|
|
/// <returns>IEnumerable{Assembly}.</returns>
|
2019-02-03 17:09:12 +01:00
|
|
|
protected IEnumerable<Assembly> GetComposablePartAssemblies()
|
2013-02-24 22:53:54 +01:00
|
|
|
{
|
2019-02-03 17:09:12 +01:00
|
|
|
if (Directory.Exists(ApplicationPaths.PluginsPath))
|
|
|
|
{
|
2019-04-03 00:19:19 +02:00
|
|
|
foreach (var file in Directory.EnumerateFiles(ApplicationPaths.PluginsPath, "*.dll", SearchOption.AllDirectories))
|
2019-02-03 17:09:12 +01:00
|
|
|
{
|
2019-04-20 12:18:44 +02:00
|
|
|
Assembly plugAss;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
plugAss = Assembly.LoadFrom(file);
|
|
|
|
}
|
2019-04-20 14:02:00 +02:00
|
|
|
catch (FileLoadException ex)
|
2019-04-20 12:18:44 +02:00
|
|
|
{
|
|
|
|
Logger.LogError(ex, "Failed to load assembly {Path}", file);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
Logger.LogInformation("Loaded assembly {Assembly} from {Path}", plugAss.FullName, file);
|
|
|
|
yield return plugAss;
|
2019-02-03 17:09:12 +01:00
|
|
|
}
|
|
|
|
}
|
2013-09-26 23:20:26 +02:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Include composable parts in the Api assembly
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(ApiEntryPoint).Assembly;
|
2013-02-24 22:53:54 +01:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Include composable parts in the Dashboard assembly
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(DashboardService).Assembly;
|
2013-02-24 22:53:54 +01:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Include composable parts in the Model assembly
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(SystemInfo).Assembly;
|
2013-02-24 22:53:54 +01:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Include composable parts in the Common assembly
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(IApplicationHost).Assembly;
|
2013-02-24 22:53:54 +01:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Include composable parts in the Controller assembly
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(IServerApplicationHost).Assembly;
|
2013-02-24 22:53:54 +01:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Include composable parts in the Providers assembly
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(ProviderUtils).Assembly;
|
2013-06-20 18:44:24 +02:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Include composable parts in the Photos assembly
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(PhotoProvider).Assembly;
|
2016-10-26 20:25:03 +02:00
|
|
|
|
2016-11-02 21:53:50 +01:00
|
|
|
// Emby.Server implementations
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(InstallationManager).Assembly;
|
2016-11-02 21:53:50 +01:00
|
|
|
|
2014-03-27 20:30:21 +01:00
|
|
|
// MediaEncoding
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(MediaBrowser.MediaEncoding.Encoder.MediaEncoder).Assembly;
|
2014-03-27 20:30:21 +01:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Dlna
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(DlnaEntryPoint).Assembly;
|
2014-02-28 05:49:02 +01:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Local metadata
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(BoxSetXmlSaver).Assembly;
|
2014-06-30 05:04:50 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
// Notifications
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(NotificationManager).Assembly;
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2019-01-08 17:29:34 +01:00
|
|
|
// Xbmc
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return typeof(ArtistNfoProvider).Assembly;
|
2013-09-05 19:26:03 +02:00
|
|
|
|
2019-02-03 17:09:12 +01:00
|
|
|
foreach (var i in GetAssembliesWithPartsInternal())
|
2013-12-29 15:12:29 +01:00
|
|
|
{
|
2019-02-03 17:09:12 +01:00
|
|
|
yield return i;
|
2013-12-29 15:12:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-03 17:09:12 +01:00
|
|
|
protected abstract IEnumerable<Assembly> GetAssembliesWithPartsInternal();
|
2016-10-28 05:16:38 +02:00
|
|
|
|
2013-03-07 06:34:00 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the system status.
|
|
|
|
/// </summary>
|
2019-11-10 18:24:05 +01:00
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
2013-03-07 06:34:00 +01:00
|
|
|
/// <returns>SystemInfo.</returns>
|
2017-11-23 16:46:16 +01:00
|
|
|
public async Task<SystemInfo> GetSystemInfo(CancellationToken cancellationToken)
|
2013-03-07 06:34:00 +01:00
|
|
|
{
|
2017-11-23 16:46:16 +01:00
|
|
|
var localAddress = await GetLocalApiUrl(cancellationToken).ConfigureAwait(false);
|
2019-11-08 12:49:00 +01:00
|
|
|
var transcodingTempPath = ConfigurationManager.GetTranscodePath();
|
2019-04-18 13:19:16 +02:00
|
|
|
|
2013-03-07 06:34:00 +01:00
|
|
|
return new SystemInfo
|
|
|
|
{
|
|
|
|
HasPendingRestart = HasPendingRestart,
|
2017-09-09 20:51:24 +02:00
|
|
|
IsShuttingDown = IsShuttingDown,
|
2019-10-08 20:51:11 +02:00
|
|
|
Version = ApplicationVersionString,
|
2015-01-19 05:29:57 +01:00
|
|
|
WebSocketPortNumber = HttpPort,
|
2020-04-11 16:00:39 +02:00
|
|
|
CompletedInstallations = Resolve<IInstallationManager>().CompletedInstallations.ToArray(),
|
2014-09-06 19:46:09 +02:00
|
|
|
Id = SystemId,
|
2013-08-16 16:18:09 +02:00
|
|
|
ProgramDataPath = ApplicationPaths.ProgramDataPath,
|
2019-03-10 22:04:18 +01:00
|
|
|
WebPath = ApplicationPaths.WebPath,
|
2013-11-30 19:32:39 +01:00
|
|
|
LogPath = ApplicationPaths.LogDirectoryPath,
|
2018-09-12 19:26:21 +02:00
|
|
|
ItemsByNamePath = ApplicationPaths.InternalMetadataPath,
|
2014-03-31 23:04:22 +02:00
|
|
|
InternalMetadataPath = ApplicationPaths.InternalMetadataPath,
|
2013-12-15 02:17:57 +01:00
|
|
|
CachePath = ApplicationPaths.CachePath,
|
2019-03-07 17:39:40 +01:00
|
|
|
OperatingSystem = OperatingSystem.Id.ToString(),
|
|
|
|
OperatingSystemDisplayName = OperatingSystem.Name,
|
2013-10-07 18:22:19 +02:00
|
|
|
CanSelfRestart = CanSelfRestart,
|
2017-12-03 23:14:35 +01:00
|
|
|
CanLaunchWebBrowser = CanLaunchWebBrowser,
|
2014-04-26 04:55:07 +02:00
|
|
|
HasUpdateAvailable = HasUpdateAvailable,
|
2019-11-08 12:49:00 +01:00
|
|
|
TranscodingTempPath = transcodingTempPath,
|
2014-08-20 00:28:35 +02:00
|
|
|
ServerName = FriendlyName,
|
2016-06-19 18:53:43 +02:00
|
|
|
LocalAddress = localAddress,
|
2016-11-11 09:13:11 +01:00
|
|
|
SupportsLibraryMonitor = true,
|
2020-04-05 01:01:21 +02:00
|
|
|
EncoderLocation = _mediaEncoder.EncoderLocation,
|
2019-03-07 17:39:40 +01:00
|
|
|
SystemArchitecture = RuntimeInformation.OSArchitecture,
|
2020-04-05 05:18:11 +02:00
|
|
|
PackageName = _startupOptions.PackageName
|
2013-03-07 06:34:00 +01:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-08-09 23:16:24 +02:00
|
|
|
public IEnumerable<WakeOnLanInfo> GetWakeOnLanInfo()
|
2020-04-05 05:18:11 +02:00
|
|
|
=> _networkManager.GetMacAddresses()
|
2019-08-09 23:16:24 +02:00
|
|
|
.Select(i => new WakeOnLanInfo(i))
|
|
|
|
.ToList();
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2017-12-01 18:03:40 +01:00
|
|
|
public async Task<PublicSystemInfo> GetPublicSystemInfo(CancellationToken cancellationToken)
|
|
|
|
{
|
2019-04-18 13:19:16 +02:00
|
|
|
var localAddress = await GetLocalApiUrl(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
2017-12-01 18:03:40 +01:00
|
|
|
return new PublicSystemInfo
|
|
|
|
{
|
2019-10-08 20:51:11 +02:00
|
|
|
Version = ApplicationVersionString,
|
2019-04-16 07:16:02 +02:00
|
|
|
ProductName = ApplicationProductName,
|
2017-12-01 18:03:40 +01:00
|
|
|
Id = SystemId,
|
2019-03-07 17:39:40 +01:00
|
|
|
OperatingSystem = OperatingSystem.Id.ToString(),
|
2017-12-01 18:03:40 +01:00
|
|
|
ServerName = FriendlyName,
|
|
|
|
LocalAddress = localAddress
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2020-04-02 23:45:04 +02:00
|
|
|
/// <inheritdoc/>
|
|
|
|
public bool ListenWithHttps => Certificate != null && ServerConfigurationManager.Configuration.EnableHttps;
|
2015-01-19 05:29:57 +01:00
|
|
|
|
2020-04-06 05:30:57 +02:00
|
|
|
/// <inheritdoc/>
|
2017-11-23 16:46:16 +01:00
|
|
|
public async Task<string> GetLocalApiUrl(CancellationToken cancellationToken)
|
2014-08-20 00:28:35 +02:00
|
|
|
{
|
2016-06-19 08:18:29 +02:00
|
|
|
try
|
2014-08-20 00:28:35 +02:00
|
|
|
{
|
2016-06-19 08:18:29 +02:00
|
|
|
// Return the first matched address, if found, or the first known local address
|
2017-11-29 21:50:18 +01:00
|
|
|
var addresses = await GetLocalIpAddressesInternal(false, 1, cancellationToken).ConfigureAwait(false);
|
2020-04-27 00:04:34 +02:00
|
|
|
if (addresses.Count == 0)
|
2015-01-24 20:03:55 +01:00
|
|
|
{
|
2020-04-27 00:04:34 +02:00
|
|
|
return null;
|
2015-01-24 20:03:55 +01:00
|
|
|
}
|
|
|
|
|
2020-07-04 22:06:27 +02:00
|
|
|
return GetLocalApiUrl(addresses[0]);
|
2014-08-20 00:28:35 +02:00
|
|
|
}
|
2016-06-19 08:18:29 +02:00
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
Logger.LogError(ex, "Error getting local Ip address information");
|
2016-06-19 08:18:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
2015-01-24 20:03:55 +01:00
|
|
|
}
|
2014-08-20 00:28:35 +02:00
|
|
|
|
2019-07-25 00:23:56 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Removes the scope id from IPv6 addresses.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="address">The IPv6 address.</param>
|
|
|
|
/// <returns>The IPv6 address without the scope id.</returns>
|
2020-01-02 21:22:10 +01:00
|
|
|
private ReadOnlySpan<char> RemoveScopeId(ReadOnlySpan<char> address)
|
2019-07-25 00:23:56 +02:00
|
|
|
{
|
|
|
|
var index = address.IndexOf('%');
|
|
|
|
if (index == -1)
|
|
|
|
{
|
|
|
|
return address;
|
|
|
|
}
|
|
|
|
|
2020-01-02 21:22:10 +01:00
|
|
|
return address.Slice(0, index);
|
2019-07-25 00:23:56 +02:00
|
|
|
}
|
|
|
|
|
2020-01-02 21:22:10 +01:00
|
|
|
/// <inheritdoc />
|
2019-07-07 21:03:26 +02:00
|
|
|
public string GetLocalApiUrl(IPAddress ipAddress)
|
2016-10-26 03:57:58 +02:00
|
|
|
{
|
2019-07-07 21:03:26 +02:00
|
|
|
if (ipAddress.AddressFamily == AddressFamily.InterNetworkV6)
|
2016-03-09 18:40:29 +01:00
|
|
|
{
|
2019-07-25 00:23:56 +02:00
|
|
|
var str = RemoveScopeId(ipAddress.ToString());
|
2020-01-02 21:22:10 +01:00
|
|
|
Span<char> span = new char[str.Length + 2];
|
|
|
|
span[0] = '[';
|
|
|
|
str.CopyTo(span.Slice(1));
|
|
|
|
span[^1] = ']';
|
2019-07-07 21:03:26 +02:00
|
|
|
|
2020-01-02 21:22:10 +01:00
|
|
|
return GetLocalApiUrl(span);
|
2016-03-09 18:40:29 +01:00
|
|
|
}
|
|
|
|
|
2019-07-07 21:03:26 +02:00
|
|
|
return GetLocalApiUrl(ipAddress.ToString());
|
2016-03-09 18:40:29 +01:00
|
|
|
}
|
|
|
|
|
2020-04-17 03:46:49 +02:00
|
|
|
/// <inheritdoc/>
|
2020-05-11 00:07:56 +02:00
|
|
|
public string GetLoopbackHttpApiUrl()
|
2015-02-10 06:54:58 +01:00
|
|
|
{
|
2020-05-10 20:36:11 +02:00
|
|
|
return GetLocalApiUrl("127.0.0.1", Uri.UriSchemeHttp, HttpPort);
|
|
|
|
}
|
2019-07-07 21:03:26 +02:00
|
|
|
|
2020-05-10 20:36:11 +02:00
|
|
|
/// <inheritdoc/>
|
2020-05-11 00:07:56 +02:00
|
|
|
public string GetLocalApiUrl(ReadOnlySpan<char> host, string scheme = null, int? port = null)
|
2020-05-10 20:36:11 +02:00
|
|
|
{
|
2020-05-11 00:07:56 +02:00
|
|
|
// NOTE: If no BaseUrl is set then UriBuilder appends a trailing slash, but if there is no BaseUrl it does
|
|
|
|
// not. For consistency, always trim the trailing slash.
|
2020-05-10 20:36:11 +02:00
|
|
|
return new UriBuilder
|
|
|
|
{
|
|
|
|
Scheme = scheme ?? (ListenWithHttps ? Uri.UriSchemeHttps : Uri.UriSchemeHttp),
|
|
|
|
Host = host.ToString(),
|
|
|
|
Port = port ?? (ListenWithHttps ? HttpsPort : HttpPort),
|
|
|
|
Path = ServerConfigurationManager.Configuration.BaseUrl
|
2020-05-11 00:07:56 +02:00
|
|
|
}.ToString().TrimEnd('/');
|
2015-02-10 06:54:58 +01:00
|
|
|
}
|
|
|
|
|
2019-07-07 21:03:26 +02:00
|
|
|
public Task<List<IPAddress>> GetLocalIpAddresses(CancellationToken cancellationToken)
|
2017-11-29 21:50:18 +01:00
|
|
|
{
|
|
|
|
return GetLocalIpAddressesInternal(true, 0, cancellationToken);
|
|
|
|
}
|
|
|
|
|
2019-07-07 21:03:26 +02:00
|
|
|
private async Task<List<IPAddress>> GetLocalIpAddressesInternal(bool allowLoopback, int limit, CancellationToken cancellationToken)
|
2016-10-26 03:57:58 +02:00
|
|
|
{
|
2016-12-07 21:02:34 +01:00
|
|
|
var addresses = ServerConfigurationManager
|
|
|
|
.Configuration
|
|
|
|
.LocalNetworkAddresses
|
2020-07-04 22:06:27 +02:00
|
|
|
.Select(x => NormalizeConfiguredLocalAddress(x))
|
2016-12-07 21:02:34 +01:00
|
|
|
.Where(i => i != null)
|
|
|
|
.ToList();
|
2015-12-29 04:39:38 +01:00
|
|
|
|
2016-12-07 21:02:34 +01:00
|
|
|
if (addresses.Count == 0)
|
2016-09-12 21:38:38 +02:00
|
|
|
{
|
2020-04-28 22:57:39 +02:00
|
|
|
addresses.AddRange(_networkManager.GetLocalIpAddresses());
|
2017-11-29 21:50:18 +01:00
|
|
|
}
|
2016-12-07 21:02:34 +01:00
|
|
|
|
2019-07-07 21:03:26 +02:00
|
|
|
var resultList = new List<IPAddress>();
|
2016-12-07 21:02:34 +01:00
|
|
|
|
2017-11-29 21:50:18 +01:00
|
|
|
foreach (var address in addresses)
|
|
|
|
{
|
|
|
|
if (!allowLoopback)
|
2016-09-12 21:38:38 +02:00
|
|
|
{
|
2019-07-07 21:03:26 +02:00
|
|
|
if (address.Equals(IPAddress.Loopback) || address.Equals(IPAddress.IPv6Loopback))
|
2016-12-07 21:02:34 +01:00
|
|
|
{
|
2017-11-29 21:50:18 +01:00
|
|
|
continue;
|
2016-12-07 21:02:34 +01:00
|
|
|
}
|
2016-09-12 21:38:38 +02:00
|
|
|
}
|
2016-12-07 21:02:34 +01:00
|
|
|
|
2020-07-04 22:06:27 +02:00
|
|
|
if (await IsLocalIpAddressValidAsync(address, cancellationToken).ConfigureAwait(false))
|
2017-11-29 21:50:18 +01:00
|
|
|
{
|
|
|
|
resultList.Add(address);
|
|
|
|
|
|
|
|
if (limit > 0 && resultList.Count >= limit)
|
|
|
|
{
|
|
|
|
return resultList;
|
|
|
|
}
|
|
|
|
}
|
2016-09-12 21:38:38 +02:00
|
|
|
}
|
|
|
|
|
2017-11-29 21:50:18 +01:00
|
|
|
return resultList;
|
2016-12-07 21:02:34 +01:00
|
|
|
}
|
|
|
|
|
2020-07-04 22:06:27 +02:00
|
|
|
public IPAddress NormalizeConfiguredLocalAddress(ReadOnlySpan<char> address)
|
2016-12-07 21:02:34 +01:00
|
|
|
{
|
|
|
|
var index = address.Trim('/').IndexOf('/');
|
|
|
|
if (index != -1)
|
|
|
|
{
|
2020-07-04 22:06:27 +02:00
|
|
|
address = address.Slice(index + 1);
|
2016-12-07 21:02:34 +01:00
|
|
|
}
|
|
|
|
|
2019-07-07 21:03:26 +02:00
|
|
|
if (IPAddress.TryParse(address.Trim('/'), out IPAddress result))
|
2016-12-07 21:02:34 +01:00
|
|
|
{
|
|
|
|
return result;
|
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2016-12-07 21:02:34 +01:00
|
|
|
return null;
|
2014-08-20 00:28:35 +02:00
|
|
|
}
|
|
|
|
|
2015-12-29 04:39:38 +01:00
|
|
|
private readonly ConcurrentDictionary<string, bool> _validAddressResults = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2020-04-17 03:46:49 +02:00
|
|
|
private async Task<bool> IsLocalIpAddressValidAsync(IPAddress address, CancellationToken cancellationToken)
|
2014-09-17 05:04:10 +02:00
|
|
|
{
|
2019-07-29 23:47:25 +02:00
|
|
|
if (address.Equals(IPAddress.Loopback)
|
|
|
|
|| address.Equals(IPAddress.IPv6Loopback))
|
2014-09-17 05:04:10 +02:00
|
|
|
{
|
2015-12-29 04:39:38 +01:00
|
|
|
return true;
|
|
|
|
}
|
2014-09-17 05:04:10 +02:00
|
|
|
|
2020-05-11 00:07:56 +02:00
|
|
|
var apiUrl = GetLocalApiUrl(address) + "/system/ping";
|
2014-09-17 05:04:10 +02:00
|
|
|
|
2019-01-13 21:48:18 +01:00
|
|
|
if (_validAddressResults.TryGetValue(apiUrl, out var cachedResult))
|
2015-12-29 04:39:38 +01:00
|
|
|
{
|
|
|
|
return cachedResult;
|
|
|
|
}
|
2014-09-17 05:04:10 +02:00
|
|
|
|
2015-12-29 04:39:38 +01:00
|
|
|
try
|
|
|
|
{
|
2020-04-05 03:18:09 +02:00
|
|
|
using (var response = await _httpClient.SendAsync(
|
2019-03-13 22:32:52 +01:00
|
|
|
new HttpRequestOptions
|
|
|
|
{
|
|
|
|
Url = apiUrl,
|
|
|
|
LogErrorResponseBody = false,
|
|
|
|
BufferContent = false,
|
|
|
|
CancellationToken = cancellationToken
|
2019-03-08 20:32:14 +01:00
|
|
|
}, HttpMethod.Post).ConfigureAwait(false))
|
2015-12-29 04:39:38 +01:00
|
|
|
{
|
2015-12-29 20:06:32 +01:00
|
|
|
using (var reader = new StreamReader(response.Content))
|
|
|
|
{
|
2019-03-08 20:32:14 +01:00
|
|
|
var result = await reader.ReadToEndAsync().ConfigureAwait(false);
|
2015-12-29 20:06:32 +01:00
|
|
|
var valid = string.Equals(Name, result, StringComparison.OrdinalIgnoreCase);
|
|
|
|
|
|
|
|
_validAddressResults.AddOrUpdate(apiUrl, valid, (k, v) => valid);
|
2018-12-13 14:18:25 +01:00
|
|
|
Logger.LogDebug("Ping test result to {0}. Success: {1}", apiUrl, valid);
|
2015-12-29 20:06:32 +01:00
|
|
|
return valid;
|
|
|
|
}
|
2015-12-29 04:39:38 +01:00
|
|
|
}
|
2014-09-17 05:04:10 +02:00
|
|
|
}
|
2017-11-23 16:46:16 +01:00
|
|
|
catch (OperationCanceledException)
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
Logger.LogDebug("Ping test result to {0}. Success: {1}", apiUrl, "Cancelled");
|
2017-11-23 16:46:16 +01:00
|
|
|
throw;
|
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
catch (Exception ex)
|
2015-12-29 04:39:38 +01:00
|
|
|
{
|
2018-12-20 13:39:58 +01:00
|
|
|
Logger.LogDebug(ex, "Ping test result to {0}. Success: {1}", apiUrl, false);
|
2015-12-29 20:06:32 +01:00
|
|
|
|
|
|
|
_validAddressResults.AddOrUpdate(apiUrl, false, (k, v) => false);
|
2015-12-29 04:39:38 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-06 21:50:43 +01:00
|
|
|
public string FriendlyName =>
|
|
|
|
string.IsNullOrEmpty(ServerConfigurationManager.Configuration.ServerName)
|
|
|
|
? Environment.MachineName
|
|
|
|
: ServerConfigurationManager.Configuration.ServerName;
|
2014-08-06 01:59:24 +02:00
|
|
|
|
2013-02-26 17:10:55 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Shuts down.
|
|
|
|
/// </summary>
|
2017-08-16 08:43:41 +02:00
|
|
|
public async Task Shutdown()
|
2013-02-26 17:10:55 +01:00
|
|
|
{
|
2017-09-09 20:51:24 +02:00
|
|
|
if (IsShuttingDown)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
IsShuttingDown = true;
|
|
|
|
|
2013-09-05 19:26:03 +02:00
|
|
|
try
|
|
|
|
{
|
2020-04-04 19:56:01 +02:00
|
|
|
await _sessionManager.SendServerShutdownNotification(CancellationToken.None).ConfigureAwait(false);
|
2013-09-05 19:26:03 +02:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
Logger.LogError(ex, "Error sending server shutdown notification");
|
2013-09-05 19:26:03 +02:00
|
|
|
}
|
|
|
|
|
2016-11-13 05:33:51 +01:00
|
|
|
ShutdownInternal();
|
2013-04-05 21:34:33 +02:00
|
|
|
}
|
|
|
|
|
2016-11-13 05:33:51 +01:00
|
|
|
protected abstract void ShutdownInternal();
|
|
|
|
|
2014-04-26 04:55:07 +02:00
|
|
|
public event EventHandler HasUpdateAvailableChanged;
|
|
|
|
|
2014-01-05 07:50:48 +01:00
|
|
|
private bool _hasUpdateAvailable;
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2014-04-26 04:55:07 +02:00
|
|
|
public bool HasUpdateAvailable
|
|
|
|
{
|
2019-01-06 21:50:43 +01:00
|
|
|
get => _hasUpdateAvailable;
|
2014-04-26 04:55:07 +02:00
|
|
|
set
|
|
|
|
{
|
|
|
|
var fireEvent = value && !_hasUpdateAvailable;
|
|
|
|
|
|
|
|
_hasUpdateAvailable = value;
|
|
|
|
|
|
|
|
if (fireEvent)
|
|
|
|
{
|
2018-12-28 15:21:02 +01:00
|
|
|
HasUpdateAvailableChanged?.Invoke(this, EventArgs.Empty);
|
2014-04-26 04:55:07 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Removes the plugin.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="plugin">The plugin.</param>
|
|
|
|
public void RemovePlugin(IPlugin plugin)
|
|
|
|
{
|
2019-12-11 00:13:57 +01:00
|
|
|
var list = _plugins.ToList();
|
2017-08-16 08:43:41 +02:00
|
|
|
list.Remove(plugin);
|
2019-12-11 00:13:57 +01:00
|
|
|
_plugins = list.ToArray();
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
2017-08-17 22:19:02 +02:00
|
|
|
|
2017-11-21 23:14:56 +01:00
|
|
|
public virtual void LaunchUrl(string url)
|
2016-11-21 00:48:52 +01:00
|
|
|
{
|
2017-12-03 23:14:35 +01:00
|
|
|
if (!CanLaunchWebBrowser)
|
2017-11-21 23:14:56 +01:00
|
|
|
{
|
|
|
|
throw new NotSupportedException();
|
2016-11-21 00:48:52 +01:00
|
|
|
}
|
|
|
|
|
2020-04-11 19:25:50 +02:00
|
|
|
var process = new Process
|
2016-12-07 21:02:34 +01:00
|
|
|
{
|
2020-04-11 19:25:50 +02:00
|
|
|
StartInfo = new ProcessStartInfo
|
|
|
|
{
|
|
|
|
FileName = url,
|
|
|
|
UseShellExecute = true,
|
|
|
|
ErrorDialog = false
|
|
|
|
},
|
|
|
|
EnableRaisingEvents = true
|
2020-03-27 00:45:48 +01:00
|
|
|
};
|
|
|
|
process.Exited += (sender, args) => ((Process)sender).Dispose();
|
2016-11-21 00:48:52 +01:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
process.Start();
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
Logger.LogError(ex, "Error launching url: {url}", url);
|
2016-11-21 00:48:52 +01:00
|
|
|
throw;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-22 19:37:04 +01:00
|
|
|
public virtual void EnableLoopback(string appName)
|
2016-09-03 19:16:36 +02:00
|
|
|
{
|
2017-02-19 04:46:09 +01:00
|
|
|
}
|
2016-11-13 05:33:51 +01:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
private bool _disposed = false;
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
|
|
|
|
/// </summary>
|
|
|
|
public void Dispose()
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
Dispose(true);
|
|
|
|
GC.SuppressFinalize(this);
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Releases unmanaged and - optionally - managed resources.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
|
|
|
|
protected virtual void Dispose(bool dispose)
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
if (_disposed)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-16 08:43:41 +02:00
|
|
|
if (dispose)
|
|
|
|
{
|
|
|
|
var type = GetType();
|
|
|
|
|
2019-01-03 21:25:39 +01:00
|
|
|
Logger.LogInformation("Disposing {Type}", type.Name);
|
2017-08-16 08:43:41 +02:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
var parts = _disposableParts.Distinct().Where(i => i.GetType() != type).ToList();
|
|
|
|
_disposableParts.Clear();
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
foreach (var part in parts)
|
|
|
|
{
|
2019-01-03 21:25:39 +01:00
|
|
|
Logger.LogInformation("Disposing {Type}", part.GetType().Name);
|
2017-08-16 08:43:41 +02:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
part.Dispose();
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2019-01-03 21:25:39 +01:00
|
|
|
Logger.LogError(ex, "Error disposing {Type}", part.GetType().Name);
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
|
|
|
_disposed = true;
|
2017-08-16 08:43:41 +02:00
|
|
|
}
|
2017-05-01 04:22:13 +02:00
|
|
|
}
|
2016-10-29 06:10:11 +02:00
|
|
|
|
2017-05-01 04:22:13 +02:00
|
|
|
internal class CertificateInfo
|
|
|
|
{
|
|
|
|
public string Path { get; set; }
|
2019-11-10 18:24:05 +01:00
|
|
|
|
2017-05-01 04:22:13 +02:00
|
|
|
public string Password { get; set; }
|
2013-02-24 22:53:54 +01:00
|
|
|
}
|
|
|
|
}
|