From 767cdc1f6f6a63ce997fc9476911e2c361f9d402 Mon Sep 17 00:00:00 2001 From: LukePulverenti Date: Wed, 20 Feb 2013 20:33:05 -0500 Subject: Pushing missing changes --- MediaBrowser.Common/Kernel/BaseApplicationPaths.cs | 458 +++++--- MediaBrowser.Common/Kernel/BaseKernel.cs | 1116 ++++++++++++++------ MediaBrowser.Common/Kernel/BaseManager.cs | 57 + .../Kernel/BasePeriodicWebSocketListener.cs | 223 ++++ .../Kernel/BaseWebSocketListener.cs | 98 ++ MediaBrowser.Common/Kernel/IKernel.cs | 182 ++++ MediaBrowser.Common/Kernel/KernelContext.cs | 27 +- MediaBrowser.Common/Kernel/RegisterServer.bat | 28 + MediaBrowser.Common/Kernel/TcpManager.cs | 485 +++++++++ 9 files changed, 2166 insertions(+), 508 deletions(-) create mode 100644 MediaBrowser.Common/Kernel/BaseManager.cs create mode 100644 MediaBrowser.Common/Kernel/BasePeriodicWebSocketListener.cs create mode 100644 MediaBrowser.Common/Kernel/BaseWebSocketListener.cs create mode 100644 MediaBrowser.Common/Kernel/IKernel.cs create mode 100644 MediaBrowser.Common/Kernel/RegisterServer.bat create mode 100644 MediaBrowser.Common/Kernel/TcpManager.cs (limited to 'MediaBrowser.Common/Kernel') diff --git a/MediaBrowser.Common/Kernel/BaseApplicationPaths.cs b/MediaBrowser.Common/Kernel/BaseApplicationPaths.cs index fefbd354a1..936c484c8a 100644 --- a/MediaBrowser.Common/Kernel/BaseApplicationPaths.cs +++ b/MediaBrowser.Common/Kernel/BaseApplicationPaths.cs @@ -1,154 +1,304 @@ -using System.Configuration; -using System.IO; -using System.Reflection; - -namespace MediaBrowser.Common.Kernel -{ - /// - /// Provides a base class to hold common application paths used by both the Ui and Server. - /// This can be subclassed to add application-specific paths. - /// - public abstract class BaseApplicationPaths - { - private string _programDataPath; - /// - /// Gets the path to the program data folder - /// - public string ProgramDataPath - { - get - { - if (_programDataPath == null) - { - _programDataPath = GetProgramDataPath(); - } - - return _programDataPath; - } - } - - private string _pluginsPath; - /// - /// Gets the path to the plugin directory - /// - public string PluginsPath - { - get - { - if (_pluginsPath == null) - { - _pluginsPath = Path.Combine(ProgramDataPath, "plugins"); - if (!Directory.Exists(_pluginsPath)) - { - Directory.CreateDirectory(_pluginsPath); - } - } - - return _pluginsPath; - } - } - - private string _pluginConfigurationsPath; - /// - /// Gets the path to the plugin configurations directory - /// - public string PluginConfigurationsPath - { - get - { - if (_pluginConfigurationsPath == null) - { - _pluginConfigurationsPath = Path.Combine(PluginsPath, "configurations"); - if (!Directory.Exists(_pluginConfigurationsPath)) - { - Directory.CreateDirectory(_pluginConfigurationsPath); - } - } - - return _pluginConfigurationsPath; - } - } - - private string _logDirectoryPath; - /// - /// Gets the path to the log directory - /// - public string LogDirectoryPath - { - get - { - if (_logDirectoryPath == null) - { - _logDirectoryPath = Path.Combine(ProgramDataPath, "logs"); - if (!Directory.Exists(_logDirectoryPath)) - { - Directory.CreateDirectory(_logDirectoryPath); - } - } - return _logDirectoryPath; - } - } - - private string _configurationDirectoryPath; - /// - /// Gets the path to the application configuration root directory - /// - public string ConfigurationDirectoryPath - { - get - { - if (_configurationDirectoryPath == null) - { - _configurationDirectoryPath = Path.Combine(ProgramDataPath, "config"); - if (!Directory.Exists(_configurationDirectoryPath)) - { - Directory.CreateDirectory(_configurationDirectoryPath); - } - } - return _configurationDirectoryPath; - } - } - - private string _systemConfigurationFilePath; - /// - /// Gets the path to the system configuration file - /// - public string SystemConfigurationFilePath - { - get - { - if (_systemConfigurationFilePath == null) - { - _systemConfigurationFilePath = Path.Combine(ConfigurationDirectoryPath, "system.xml"); - } - return _systemConfigurationFilePath; - } - } - - /// - /// Gets the path to the application's ProgramDataFolder - /// - private static string GetProgramDataPath() - { - string programDataPath = ConfigurationManager.AppSettings["ProgramDataPath"]; - - // If it's a relative path, e.g. "..\" - if (!Path.IsPathRooted(programDataPath)) - { - string path = Assembly.GetExecutingAssembly().Location; - path = Path.GetDirectoryName(path); - - programDataPath = Path.Combine(path, programDataPath); - - programDataPath = Path.GetFullPath(programDataPath); - } - - if (!Directory.Exists(programDataPath)) - { - Directory.CreateDirectory(programDataPath); - } - - return programDataPath; - } - } -} +using System; +using System.Configuration; +using System.IO; +using System.Reflection; + +namespace MediaBrowser.Common.Kernel +{ + /// + /// Provides a base class to hold common application paths used by both the Ui and Server. + /// This can be subclassed to add application-specific paths. + /// + public abstract class BaseApplicationPaths + { + /// + /// The _program data path + /// + private string _programDataPath; + /// + /// Gets the path to the program data folder + /// + /// The program data path. + public string ProgramDataPath + { + get + { + return _programDataPath ?? (_programDataPath = GetProgramDataPath()); + } + } + + /// + /// The _data directory + /// + private string _dataDirectory; + /// + /// Gets the folder path to the data directory + /// + /// The data directory. + public string DataPath + { + get + { + if (_dataDirectory == null) + { + _dataDirectory = Path.Combine(ProgramDataPath, "data"); + + if (!Directory.Exists(_dataDirectory)) + { + Directory.CreateDirectory(_dataDirectory); + } + } + + return _dataDirectory; + } + } + + /// + /// The _image cache path + /// + private string _imageCachePath; + /// + /// Gets the image cache path. + /// + /// The image cache path. + public string ImageCachePath + { + get + { + if (_imageCachePath == null) + { + _imageCachePath = Path.Combine(CachePath, "images"); + + if (!Directory.Exists(_imageCachePath)) + { + Directory.CreateDirectory(_imageCachePath); + } + } + + return _imageCachePath; + } + } + + /// + /// The _plugins path + /// + private string _pluginsPath; + /// + /// Gets the path to the plugin directory + /// + /// The plugins path. + public string PluginsPath + { + get + { + if (_pluginsPath == null) + { + _pluginsPath = Path.Combine(ProgramDataPath, "plugins"); + if (!Directory.Exists(_pluginsPath)) + { + Directory.CreateDirectory(_pluginsPath); + } + } + + return _pluginsPath; + } + } + + /// + /// The _plugin configurations path + /// + private string _pluginConfigurationsPath; + /// + /// Gets the path to the plugin configurations directory + /// + /// The plugin configurations path. + public string PluginConfigurationsPath + { + get + { + if (_pluginConfigurationsPath == null) + { + _pluginConfigurationsPath = Path.Combine(PluginsPath, "configurations"); + if (!Directory.Exists(_pluginConfigurationsPath)) + { + Directory.CreateDirectory(_pluginConfigurationsPath); + } + } + + return _pluginConfigurationsPath; + } + } + + private string _tempUpdatePath; + /// + /// Gets the path to where temporary update files will be stored + /// + /// The plugin configurations path. + public string TempUpdatePath + { + get + { + if (_tempUpdatePath == null) + { + _tempUpdatePath = Path.Combine(ProgramDataPath, "Updates"); + if (!Directory.Exists(_tempUpdatePath)) + { + Directory.CreateDirectory(_tempUpdatePath); + } + } + + return _tempUpdatePath; + } + } + + /// + /// The _log directory path + /// + private string _logDirectoryPath; + /// + /// Gets the path to the log directory + /// + /// The log directory path. + public string LogDirectoryPath + { + get + { + if (_logDirectoryPath == null) + { + _logDirectoryPath = Path.Combine(ProgramDataPath, "logs"); + if (!Directory.Exists(_logDirectoryPath)) + { + Directory.CreateDirectory(_logDirectoryPath); + } + } + return _logDirectoryPath; + } + } + + /// + /// The _configuration directory path + /// + private string _configurationDirectoryPath; + /// + /// Gets the path to the application configuration root directory + /// + /// The configuration directory path. + public string ConfigurationDirectoryPath + { + get + { + if (_configurationDirectoryPath == null) + { + _configurationDirectoryPath = Path.Combine(ProgramDataPath, "config"); + if (!Directory.Exists(_configurationDirectoryPath)) + { + Directory.CreateDirectory(_configurationDirectoryPath); + } + } + return _configurationDirectoryPath; + } + } + + /// + /// The _system configuration file path + /// + private string _systemConfigurationFilePath; + /// + /// Gets the path to the system configuration file + /// + /// The system configuration file path. + public string SystemConfigurationFilePath + { + get + { + return _systemConfigurationFilePath ?? (_systemConfigurationFilePath = Path.Combine(ConfigurationDirectoryPath, "system.xml")); + } + } + + /// + /// The _cache directory + /// + private string _cachePath; + /// + /// Gets the folder path to the cache directory + /// + /// The cache directory. + public string CachePath + { + get + { + if (_cachePath == null) + { + _cachePath = Path.Combine(ProgramDataPath, "cache"); + + if (!Directory.Exists(_cachePath)) + { + Directory.CreateDirectory(_cachePath); + } + } + + return _cachePath; + } + } + + /// + /// The _temp directory + /// + private string _tempDirectory; + /// + /// Gets the folder path to the temp directory within the cache folder + /// + /// The temp directory. + public string TempDirectory + { + get + { + if (_tempDirectory == null) + { + _tempDirectory = Path.Combine(CachePath, "temp"); + + if (!Directory.Exists(_tempDirectory)) + { + Directory.CreateDirectory(_tempDirectory); + } + } + + return _tempDirectory; + } + } + + /// + /// Gets the path to the application's ProgramDataFolder + /// + /// System.String. + public static string GetProgramDataPath() + { +#if DEBUG + string programDataPath = ConfigurationManager.AppSettings["DebugProgramDataPath"]; + +#else + string programDataPath = Path.Combine(ConfigurationManager.AppSettings["ReleaseProgramDataPath"], ConfigurationManager.AppSettings["ProgramDataFolderName"]); +#endif + + programDataPath = programDataPath.Replace("%CommonApplicationData%", Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData)); + + // If it's a relative path, e.g. "..\" + if (!Path.IsPathRooted(programDataPath)) + { + var path = Assembly.GetExecutingAssembly().Location; + path = Path.GetDirectoryName(path); + + programDataPath = Path.Combine(path, programDataPath); + + programDataPath = Path.GetFullPath(programDataPath); + } + + if (!Directory.Exists(programDataPath)) + { + Directory.CreateDirectory(programDataPath); + } + + return programDataPath; + } + } +} diff --git a/MediaBrowser.Common/Kernel/BaseKernel.cs b/MediaBrowser.Common/Kernel/BaseKernel.cs index a6081a6881..a4cd81665c 100644 --- a/MediaBrowser.Common/Kernel/BaseKernel.cs +++ b/MediaBrowser.Common/Kernel/BaseKernel.cs @@ -1,345 +1,771 @@ -using MediaBrowser.Common.Events; -using MediaBrowser.Common.Logging; -using MediaBrowser.Common.Mef; -using MediaBrowser.Common.Net; -using MediaBrowser.Common.Net.Handlers; -using MediaBrowser.Common.Plugins; -using MediaBrowser.Common.Serialization; -using MediaBrowser.Model.Configuration; -using MediaBrowser.Model.Progress; -using System; -using System.Collections.Generic; -using System.ComponentModel.Composition; -using System.ComponentModel.Composition.Hosting; -using System.ComponentModel.Composition.Primitives; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Threading.Tasks; - -namespace MediaBrowser.Common.Kernel -{ - /// - /// Represents a shared base kernel for both the Ui and server apps - /// - public abstract class BaseKernel : IDisposable, IKernel - where TConfigurationType : BaseApplicationConfiguration, new() - where TApplicationPathsType : BaseApplicationPaths, new() - { - #region ReloadBeginning Event - /// - /// Fires whenever the kernel begins reloading - /// - public event EventHandler>> ReloadBeginning; - private void OnReloadBeginning(IProgress progress) - { - if (ReloadBeginning != null) - { - ReloadBeginning(this, new GenericEventArgs> { Argument = progress }); - } - } - #endregion - - #region ReloadCompleted Event - /// - /// Fires whenever the kernel completes reloading - /// - public event EventHandler>> ReloadCompleted; - private void OnReloadCompleted(IProgress progress) - { - if (ReloadCompleted != null) - { - ReloadCompleted(this, new GenericEventArgs> { Argument = progress }); - } - } - #endregion - - /// - /// Gets the current configuration - /// - public TConfigurationType Configuration { get; private set; } - - public TApplicationPathsType ApplicationPaths { get; private set; } - - /// - /// Gets the list of currently loaded plugins - /// - [ImportMany(typeof(BasePlugin))] - public IEnumerable Plugins { get; private set; } - - /// - /// Gets the list of currently registered http handlers - /// - [ImportMany(typeof(BaseHandler))] - private IEnumerable HttpHandlers { get; set; } - - /// - /// Gets the list of currently registered Loggers - /// - [ImportMany(typeof(BaseLogger))] - public IEnumerable Loggers { get; set; } - - /// - /// Both the Ui and server will have a built-in HttpServer. - /// People will inevitably want remote control apps so it's needed in the Ui too. - /// - public HttpServer HttpServer { get; private set; } - - /// - /// This subscribes to HttpListener requests and finds the appropate BaseHandler to process it - /// - private IDisposable HttpListener { get; set; } - - /// - /// Gets the MEF CompositionContainer - /// - private CompositionContainer CompositionContainer { get; set; } - - protected virtual string HttpServerUrlPrefix - { - get - { - return "http://+:" + Configuration.HttpServerPortNumber + "/mediabrowser/"; - } - } - - /// - /// Gets the kernel context. Subclasses will have to override. - /// - public abstract KernelContext KernelContext { get; } - - /// - /// Initializes the Kernel - /// - public async Task Init(IProgress progress) - { - Logger.Kernel = this; - - // Performs initializations that only occur once - InitializeInternal(progress); - - // Performs initializations that can be reloaded at anytime - await Reload(progress).ConfigureAwait(false); - } - - /// - /// Performs initializations that only occur once - /// - protected virtual void InitializeInternal(IProgress progress) - { - ApplicationPaths = new TApplicationPathsType(); - - ReportProgress(progress, "Loading Configuration"); - ReloadConfiguration(); - - ReportProgress(progress, "Loading Http Server"); - ReloadHttpServer(); - } - - /// - /// Performs initializations that can be reloaded at anytime - /// - public async Task Reload(IProgress progress) - { - OnReloadBeginning(progress); - - await ReloadInternal(progress).ConfigureAwait(false); - - OnReloadCompleted(progress); - - ReportProgress(progress, "Kernel.Reload Complete"); - } - - /// - /// Performs initializations that can be reloaded at anytime - /// - protected virtual async Task ReloadInternal(IProgress progress) - { - await Task.Run(() => - { - ReportProgress(progress, "Loading Plugins"); - ReloadComposableParts(); - - }).ConfigureAwait(false); - } - - /// - /// Uses MEF to locate plugins - /// Subclasses can use this to locate types within plugins - /// - private void ReloadComposableParts() - { - DisposeComposableParts(); - - CompositionContainer = GetCompositionContainer(includeCurrentAssembly: true); - - CompositionContainer.ComposeParts(this); - - OnComposablePartsLoaded(); - - CompositionContainer.Catalog.Dispose(); - } - - /// - /// Constructs an MEF CompositionContainer based on the current running assembly and all plugin assemblies - /// - public CompositionContainer GetCompositionContainer(bool includeCurrentAssembly = false) - { - // Gets all plugin assemblies by first reading all bytes of the .dll and calling Assembly.Load against that - // This will prevent the .dll file from getting locked, and allow us to replace it when needed - IEnumerable pluginAssemblies = Directory.GetFiles(ApplicationPaths.PluginsPath, "*.dll", SearchOption.TopDirectoryOnly).Select(f => Assembly.Load(File.ReadAllBytes((f)))); - - var catalogs = new List(); - - catalogs.AddRange(pluginAssemblies.Select(a => new AssemblyCatalog(a))); - - // Include composable parts in the Common assembly - catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly())); - - if (includeCurrentAssembly) - { - // Include composable parts in the subclass assembly - catalogs.Add(new AssemblyCatalog(GetType().Assembly)); - } - - return MefUtils.GetSafeCompositionContainer(catalogs); - } - - /// - /// Fires after MEF finishes finding composable parts within plugin assemblies - /// - protected virtual void OnComposablePartsLoaded() - { - foreach (var logger in Loggers) - { - logger.Initialize(this); - } - - // Start-up each plugin - foreach (var plugin in Plugins) - { - plugin.Initialize(this); - } - } - - /// - /// Reloads application configuration from the config file - /// - private void ReloadConfiguration() - { - //Configuration information for anything other than server-specific configuration will have to come via the API... -ebr - - // Deserialize config - // Use try/catch to avoid the extra file system lookup using File.Exists - try - { - Configuration = XmlSerializer.DeserializeFromFile(ApplicationPaths.SystemConfigurationFilePath); - } - catch (FileNotFoundException) - { - Configuration = new TConfigurationType(); - XmlSerializer.SerializeToFile(Configuration, ApplicationPaths.SystemConfigurationFilePath); - } - } - - /// - /// Restarts the Http Server, or starts it if not currently running - /// - private void ReloadHttpServer() - { - DisposeHttpServer(); - - HttpServer = new HttpServer(HttpServerUrlPrefix); - - HttpListener = HttpServer.Subscribe(ctx => - { - BaseHandler handler = HttpHandlers.FirstOrDefault(h => h.HandlesRequest(ctx.Request)); - - // Find the appropiate http handler - if (handler != null) - { - // Need to create a new instance because handlers are currently stateful - handler = Activator.CreateInstance(handler.GetType()) as BaseHandler; - - // No need to await this, despite the compiler warning - handler.ProcessRequest(ctx); - } - }); - } - - /// - /// Disposes all resources currently in use. - /// - public virtual void Dispose() - { - Logger.LogInfo("Beginning Kernel.Dispose"); - - DisposeHttpServer(); - - DisposeComposableParts(); - } - - /// - /// Disposes all objects gathered through MEF composable parts - /// - protected virtual void DisposeComposableParts() - { - if (CompositionContainer != null) - { - CompositionContainer.Dispose(); - } - } - - /// - /// Disposes the current HttpServer - /// - private void DisposeHttpServer() - { - if (HttpServer != null) - { - Logger.LogInfo("Disposing Http Server"); - - HttpServer.Dispose(); - } - - if (HttpListener != null) - { - HttpListener.Dispose(); - } - } - - /// - /// Gets the current application version - /// - public Version ApplicationVersion - { - get - { - return GetType().Assembly.GetName().Version; - } - } - - protected void ReportProgress(IProgress progress, string message) - { - progress.Report(new TaskProgress { Description = message }); - - Logger.LogInfo(message); - } - - BaseApplicationPaths IKernel.ApplicationPaths - { - get { return ApplicationPaths; } - } - } - - public interface IKernel - { - BaseApplicationPaths ApplicationPaths { get; } - KernelContext KernelContext { get; } - - Task Init(IProgress progress); - Task Reload(IProgress progress); - IEnumerable Loggers { get; } - void Dispose(); - } -} +using MediaBrowser.Common.Events; +using MediaBrowser.Common.IO; +using MediaBrowser.Common.Localization; +using MediaBrowser.Common.Mef; +using MediaBrowser.Common.Net; +using MediaBrowser.Common.Net.Handlers; +using MediaBrowser.Common.Plugins; +using MediaBrowser.Common.ScheduledTasks; +using MediaBrowser.Common.Serialization; +using MediaBrowser.Model.Configuration; +using MediaBrowser.Model.Logging; +using MediaBrowser.Model.System; +using NLog; +using NLog.Config; +using NLog.Targets; +using System; +using System.Collections.Generic; +using System.ComponentModel.Composition; +using System.ComponentModel.Composition.Hosting; +using System.ComponentModel.Composition.Primitives; +using System.Deployment.Application; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Threading; +using System.Threading.Tasks; + +namespace MediaBrowser.Common.Kernel +{ + /// + /// Represents a shared base kernel for both the Ui and server apps + /// + /// The type of the T configuration type. + /// The type of the T application paths type. + public abstract class BaseKernel : IDisposable, IKernel + where TConfigurationType : BaseApplicationConfiguration, new() + where TApplicationPathsType : BaseApplicationPaths, new() + { + /// + /// Occurs when [has pending restart changed]. + /// + public event EventHandler HasPendingRestartChanged; + + /// + /// Notifiies the containing application that a restart has been requested + /// + public event EventHandler ApplicationRestartRequested; + + #region ConfigurationUpdated Event + /// + /// Occurs when [configuration updated]. + /// + public event EventHandler ConfigurationUpdated; + + /// + /// Called when [configuration updated]. + /// + internal void OnConfigurationUpdated() + { + EventHelper.QueueEventIfNotNull(ConfigurationUpdated, this, EventArgs.Empty); + + // Notify connected clients + TcpManager.SendWebSocketMessage("ConfigurationUpdated", Configuration); + } + #endregion + + #region LoggerLoaded Event + /// + /// Fires whenever the logger is loaded + /// + public event EventHandler LoggerLoaded; + /// + /// Called when [logger loaded]. + /// + private void OnLoggerLoaded() + { + EventHelper.QueueEventIfNotNull(LoggerLoaded, this, EventArgs.Empty); + } + #endregion + + #region ReloadBeginning Event + /// + /// Fires whenever the kernel begins reloading + /// + public event EventHandler ReloadBeginning; + /// + /// Called when [reload beginning]. + /// + private void OnReloadBeginning() + { + EventHelper.QueueEventIfNotNull(ReloadBeginning, this, EventArgs.Empty); + } + #endregion + + #region ReloadCompleted Event + /// + /// Fires whenever the kernel completes reloading + /// + public event EventHandler ReloadCompleted; + /// + /// Called when [reload completed]. + /// + private void OnReloadCompleted() + { + EventHelper.QueueEventIfNotNull(ReloadCompleted, this, EventArgs.Empty); + } + #endregion + + #region ApplicationUpdated Event + /// + /// Occurs when [application updated]. + /// + public event EventHandler> ApplicationUpdated; + /// + /// Called when [application updated]. + /// + /// The new version. + public void OnApplicationUpdated(Version newVersion) + { + EventHelper.QueueEventIfNotNull(ApplicationUpdated, this, new GenericEventArgs {Argument = newVersion}); + + NotifyPendingRestart(); + } + #endregion + + /// + /// The _configuration loaded + /// + private bool _configurationLoaded; + /// + /// The _configuration sync lock + /// + private object _configurationSyncLock = new object(); + /// + /// The _configuration + /// + private TConfigurationType _configuration; + /// + /// Gets the system configuration + /// + /// The configuration. + public TConfigurationType Configuration + { + get + { + // Lazy load + LazyInitializer.EnsureInitialized(ref _configuration, ref _configurationLoaded, ref _configurationSyncLock, () => XmlSerializer.GetXmlConfiguration(ApplicationPaths.SystemConfigurationFilePath)); + return _configuration; + } + protected set + { + _configuration = value; + + if (value == null) + { + _configurationLoaded = false; + } + } + } + + /// + /// Gets a value indicating whether this instance is first run. + /// + /// true if this instance is first run; otherwise, false. + public bool IsFirstRun { get; private set; } + + /// + /// The version of the application to display + /// + /// The display version. + public string DisplayVersion { get { return ApplicationVersion.ToString(); } } + + /// + /// Gets or sets a value indicating whether this instance has changes that require the entire application to restart. + /// + /// true if this instance has pending application restart; otherwise, false. + public bool HasPendingRestart { get; private set; } + + /// + /// Gets the application paths. + /// + /// The application paths. + public TApplicationPathsType ApplicationPaths { get; private set; } + + /// + /// The _failed assembly loads + /// + private readonly List _failedPluginAssemblies = new List(); + /// + /// Gets the plugin assemblies that failed to load. + /// + /// The failed assembly loads. + public IEnumerable FailedPluginAssemblies + { + get { return _failedPluginAssemblies; } + } + + /// + /// Gets the list of currently loaded plugins + /// + /// The plugins. + [ImportMany(typeof(IPlugin))] + public IEnumerable Plugins { get; protected set; } + + /// + /// Gets the list of Scheduled Tasks + /// + /// The scheduled tasks. + [ImportMany(typeof(IScheduledTask))] + public IEnumerable ScheduledTasks { get; private set; } + + /// + /// Gets the web socket listeners. + /// + /// The web socket listeners. + [ImportMany(typeof(IWebSocketListener))] + public IEnumerable WebSocketListeners { get; private set; } + + /// + /// Gets the list of Localized string files + /// + /// The string files. + [ImportMany(typeof(LocalizedStringData))] + public IEnumerable StringFiles { get; private set; } + + /// + /// Gets the MEF CompositionContainer + /// + /// The composition container. + private CompositionContainer CompositionContainer { get; set; } + + /// + /// The _HTTP manager + /// + /// The HTTP manager. + public HttpManager HttpManager { get; private set; } + + /// + /// Gets or sets the TCP manager. + /// + /// The TCP manager. + public TcpManager TcpManager { get; private set; } + + /// + /// Gets the task manager. + /// + /// The task manager. + public TaskManager TaskManager { get; private set; } + + /// + /// Gets the iso manager. + /// + /// The iso manager. + public IIsoManager IsoManager { get; private set; } + + /// + /// Gets the rest services. + /// + /// The rest services. + [ImportMany(typeof(IRestfulService))] + public IEnumerable RestServices { get; private set; } + + /// + /// The _protobuf serializer initialized + /// + private bool _protobufSerializerInitialized; + /// + /// The _protobuf serializer sync lock + /// + private object _protobufSerializerSyncLock = new object(); + /// + /// Gets a dynamically compiled generated serializer that can serialize protocontracts without reflection + /// + private DynamicProtobufSerializer _protobufSerializer; + /// + /// Gets the protobuf serializer. + /// + /// The protobuf serializer. + public DynamicProtobufSerializer ProtobufSerializer + { + get + { + // Lazy load + LazyInitializer.EnsureInitialized(ref _protobufSerializer, ref _protobufSerializerInitialized, ref _protobufSerializerSyncLock, () => DynamicProtobufSerializer.Create(Assemblies)); + return _protobufSerializer; + } + private set + { + _protobufSerializer = value; + + if (value == null) + { + _protobufSerializerInitialized = false; + } + } + } + + /// + /// Gets the UDP server port number. + /// This can't be configurable because then the user would have to configure their client to discover the server. + /// + /// The UDP server port number. + public abstract int UdpServerPortNumber { get; } + + /// + /// Gets the name of the web application that can be used for url building. + /// All api urls will be of the form {protocol}://{host}:{port}/{appname}/... + /// + /// The name of the web application. + public string WebApplicationName + { + get { return "mediabrowser"; } + } + + /// + /// Gets the HTTP server URL prefix. + /// + /// The HTTP server URL prefix. + public virtual string HttpServerUrlPrefix + { + get + { + return "http://+:" + Configuration.HttpServerPortNumber + "/" + WebApplicationName + "/"; + } + } + + /// + /// Gets the kernel context. Subclasses will have to override. + /// + /// The kernel context. + public abstract KernelContext KernelContext { get; } + + /// + /// Gets the log file path. + /// + /// The log file path. + public string LogFilePath { get; private set; } + + /// + /// Gets the logger. + /// + /// The logger. + protected ILogger Logger { get; private set; } + + /// + /// Gets the assemblies. + /// + /// The assemblies. + public Assembly[] Assemblies { get; private set; } + + /// + /// Initializes the Kernel + /// + /// The iso manager. + /// Task. + public async Task Init(IIsoManager isoManager) + { + IsoManager = isoManager; + + Logger = Logging.LogManager.GetLogger(GetType().Name); + + ApplicationPaths = new TApplicationPathsType(); + + IsFirstRun = !File.Exists(ApplicationPaths.SystemConfigurationFilePath); + + // Performs initializations that can be reloaded at anytime + await Reload().ConfigureAwait(false); + } + + /// + /// Performs initializations that can be reloaded at anytime + /// + /// Task. + public async Task Reload() + { + OnReloadBeginning(); + + await ReloadInternal().ConfigureAwait(false); + + OnReloadCompleted(); + + Logger.Info("Kernel.Reload Complete"); + } + + /// + /// Performs initializations that can be reloaded at anytime + /// + /// Task. + protected virtual async Task ReloadInternal() + { + // Set these to null so that they can be lazy loaded again + Configuration = null; + ProtobufSerializer = null; + + ReloadLogger(); + + Logger.Info("Version {0} initializing", ApplicationVersion); + + DisposeHttpManager(); + HttpManager = new HttpManager(this); + + await OnConfigurationLoaded().ConfigureAwait(false); + + DisposeTaskManager(); + TaskManager = new TaskManager(this); + + Logger.Info("Loading Plugins"); + await ReloadComposableParts().ConfigureAwait(false); + + DisposeTcpManager(); + TcpManager = new TcpManager(this); + } + + /// + /// Called when [configuration loaded]. + /// + /// Task. + protected virtual Task OnConfigurationLoaded() + { + return Task.FromResult(null); + } + + /// + /// Disposes and reloads all loggers + /// + public void ReloadLogger() + { + DisposeLogger(); + + LogFilePath = Path.Combine(ApplicationPaths.LogDirectoryPath, KernelContext + "-" + DateTime.Now.Ticks + ".log"); + + var logFile = new FileTarget(); + + logFile.FileName = LogFilePath; + logFile.Layout = "${longdate}, ${level}, ${logger}, ${message}"; + + AddLogTarget(logFile, "ApplicationLogFile"); + + Logging.Logger.LoggerInstance = Logging.LogManager.GetLogger("Global"); + + OnLoggerLoaded(); + } + + /// + /// Adds the log target. + /// + /// The target. + /// The name. + private void AddLogTarget(Target target, string name) + { + var config = LogManager.Configuration; + + config.RemoveTarget(name); + + target.Name = name; + config.AddTarget(name, target); + + var level = Configuration.EnableDebugLevelLogging ? LogLevel.Debug : LogLevel.Info; + + var rule = new LoggingRule("*", level, target); + config.LoggingRules.Add(rule); + + LogManager.Configuration = config; + } + + /// + /// Uses MEF to locate plugins + /// Subclasses can use this to locate types within plugins + /// + /// Task. + private async Task ReloadComposableParts() + { + _failedPluginAssemblies.Clear(); + + DisposeComposableParts(); + + Assemblies = GetComposablePartAssemblies().ToArray(); + + CompositionContainer = MefUtils.GetSafeCompositionContainer(Assemblies.Select(i => new AssemblyCatalog(i))); + + CompositionContainer.ComposeExportedValue("kernel", this); + + CompositionContainer.ComposeParts(this); + + await OnComposablePartsLoaded().ConfigureAwait(false); + + CompositionContainer.Catalog.Dispose(); + } + + /// + /// Gets the composable part assemblies. + /// + /// IEnumerable{Assembly}. + protected virtual IEnumerable GetComposablePartAssemblies() + { + // Gets all plugin assemblies by first reading all bytes of the .dll and calling Assembly.Load against that + // This will prevent the .dll file from getting locked, and allow us to replace it when needed + var pluginAssemblies = Directory.EnumerateFiles(ApplicationPaths.PluginsPath, "*.dll", SearchOption.TopDirectoryOnly) + .Select(file => + { + try + { + return Assembly.Load(File.ReadAllBytes((file))); + } + catch (Exception ex) + { + _failedPluginAssemblies.Add(file); + Logger.ErrorException("Error loading {0}", ex, file); + return null; + } + + }).Where(a => a != null); + + foreach (var pluginAssembly in pluginAssemblies) + { + yield return pluginAssembly; + } + + // Include composable parts in the Model assembly + yield return typeof (SystemInfo).Assembly; + + // Include composable parts in the Common assembly + yield return Assembly.GetExecutingAssembly(); + + // Include composable parts in the subclass assembly + yield return GetType().Assembly; + } + + /// + /// Fires after MEF finishes finding composable parts within plugin assemblies + /// + /// Task. + protected virtual Task OnComposablePartsLoaded() + { + return Task.Run(() => + { + foreach (var listener in WebSocketListeners) + { + listener.Initialize(this); + } + + foreach (var task in ScheduledTasks) + { + task.Initialize(this); + } + + // Start-up each plugin + Parallel.ForEach(Plugins, plugin => + { + Logger.Info("Initializing {0} {1}", plugin.Name, plugin.Version); + + try + { + plugin.Initialize(this); + + Logger.Info("{0} {1} initialized.", plugin.Name, plugin.Version); + } + catch (Exception ex) + { + Logger.ErrorException("Error initializing {0}", ex, plugin.Name); + } + }); + }); + } + + /// + /// Notifies that the kernel that a change has been made that requires a restart + /// + public void NotifyPendingRestart() + { + HasPendingRestart = true; + + TcpManager.SendWebSocketMessage("HasPendingRestartChanged", GetSystemInfo()); + + EventHelper.QueueEventIfNotNull(HasPendingRestartChanged, this, EventArgs.Empty); + } + + /// + /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// + /// Releases unmanaged and - optionally - managed resources. + /// + /// true to release both managed and unmanaged resources; false to release only unmanaged resources. + protected virtual void Dispose(bool dispose) + { + if (dispose) + { + DisposeTcpManager(); + DisposeTaskManager(); + DisposeIsoManager(); + DisposeHttpManager(); + + DisposeComposableParts(); + } + } + + /// + /// Disposes the iso manager. + /// + private void DisposeIsoManager() + { + if (IsoManager != null) + { + IsoManager.Dispose(); + IsoManager = null; + } + } + + /// + /// Disposes the TCP manager. + /// + private void DisposeTcpManager() + { + if (TcpManager != null) + { + TcpManager.Dispose(); + TcpManager = null; + } + } + + /// + /// Disposes the task manager. + /// + private void DisposeTaskManager() + { + if (TaskManager != null) + { + TaskManager.Dispose(); + TaskManager = null; + } + } + + /// + /// Disposes the HTTP manager. + /// + private void DisposeHttpManager() + { + if (HttpManager != null) + { + HttpManager.Dispose(); + HttpManager = null; + } + } + + /// + /// Disposes all objects gathered through MEF composable parts + /// + protected virtual void DisposeComposableParts() + { + if (CompositionContainer != null) + { + CompositionContainer.Dispose(); + } + } + + /// + /// Disposes all logger resources + /// + private void DisposeLogger() + { + // Dispose all current loggers + var listeners = Trace.Listeners.OfType().ToList(); + + Trace.Listeners.Clear(); + + foreach (var listener in listeners) + { + listener.Dispose(); + } + + } + + /// + /// Gets the current application version + /// + /// The application version. + public Version ApplicationVersion + { + get + { + return GetType().Assembly.GetName().Version; + } + } + + /// + /// Performs the pending restart. + /// + /// Task. + public void PerformPendingRestart() + { + if (HasPendingRestart) + { + RestartApplication(); + } + else + { + Logger.Info("PerformPendingRestart - not needed"); + } + } + + /// + /// Restarts the application. + /// + protected void RestartApplication() + { + Logger.Info("Restarting the application"); + + EventHelper.QueueEventIfNotNull(ApplicationRestartRequested, this, EventArgs.Empty); + } + + /// + /// Gets the system status. + /// + /// SystemInfo. + public virtual SystemInfo GetSystemInfo() + { + return new SystemInfo + { + HasPendingRestart = HasPendingRestart, + Version = DisplayVersion, + IsNetworkDeployed = ApplicationDeployment.IsNetworkDeployed, + WebSocketPortNumber = TcpManager.WebSocketPortNumber, + SupportsNativeWebSocket = TcpManager.SupportsNativeWebSocket, + FailedPluginAssemblies = FailedPluginAssemblies.ToArray() + }; + } + + /// + /// The _save lock + /// + private readonly object _configurationSaveLock = new object(); + + /// + /// Saves the current configuration + /// + public void SaveConfiguration() + { + lock (_configurationSaveLock) + { + XmlSerializer.SerializeToFile(Configuration, ApplicationPaths.SystemConfigurationFilePath); + } + + OnConfigurationUpdated(); + } + + /// + /// Gets the application paths. + /// + /// The application paths. + BaseApplicationPaths IKernel.ApplicationPaths + { + get { return ApplicationPaths; } + } + /// + /// Gets the configuration. + /// + /// The configuration. + BaseApplicationConfiguration IKernel.Configuration + { + get { return Configuration; } + } + } +} diff --git a/MediaBrowser.Common/Kernel/BaseManager.cs b/MediaBrowser.Common/Kernel/BaseManager.cs new file mode 100644 index 0000000000..a9aff4d1cc --- /dev/null +++ b/MediaBrowser.Common/Kernel/BaseManager.cs @@ -0,0 +1,57 @@ +using MediaBrowser.Common.Logging; +using MediaBrowser.Model.Logging; +using System; + +namespace MediaBrowser.Common.Kernel +{ + /// + /// Class BaseManager + /// + /// The type of the T kernel type. + public abstract class BaseManager : IDisposable + where TKernelType : IKernel + { + /// + /// Gets the logger. + /// + /// The logger. + protected ILogger Logger { get; private set; } + + /// + /// The _kernel + /// + protected readonly TKernelType Kernel; + + /// + /// Initializes a new instance of the class. + /// + /// The kernel. + protected BaseManager(TKernelType kernel) + { + Kernel = kernel; + + Logger = LogManager.GetLogger(GetType().Name); + + Logger.Info("Initializing"); + } + + /// + /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + /// + public void Dispose() + { + Logger.Info("Disposing"); + + Dispose(true); + GC.SuppressFinalize(this); + } + + /// + /// Releases unmanaged and - optionally - managed resources. + /// + /// true to release both managed and unmanaged resources; false to release only unmanaged resources. + protected virtual void Dispose(bool dispose) + { + } + } +} diff --git a/MediaBrowser.Common/Kernel/BasePeriodicWebSocketListener.cs b/MediaBrowser.Common/Kernel/BasePeriodicWebSocketListener.cs new file mode 100644 index 0000000000..7db1ca36bb --- /dev/null +++ b/MediaBrowser.Common/Kernel/BasePeriodicWebSocketListener.cs @@ -0,0 +1,223 @@ +using MediaBrowser.Common.Logging; +using MediaBrowser.Common.Net; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net.WebSockets; +using System.Threading; +using System.Threading.Tasks; + +namespace MediaBrowser.Common.Kernel +{ + /// + /// Starts sending data over a web socket periodically when a message is received, and then stops when a corresponding stop message is received + /// + /// The type of the T kernel type. + /// The type of the T return data type. + /// The type of the T state type. + public abstract class BasePeriodicWebSocketListener : BaseWebSocketListener + where TKernelType : IKernel + where TStateType : class, new() + { + /// + /// The _active connections + /// + protected readonly List> ActiveConnections = + new List>(); + + /// + /// Gets the name. + /// + /// The name. + protected abstract string Name { get; } + + /// + /// Gets the data to send. + /// + /// The state. + /// Task{`1}. + protected abstract Task GetDataToSend(TStateType state); + + /// + /// Processes the message internal. + /// + /// The message. + /// Task. + protected override Task ProcessMessageInternal(WebSocketMessageInfo message) + { + if (message.MessageType.Equals(Name + "Start", StringComparison.OrdinalIgnoreCase)) + { + Start(message); + } + + if (message.MessageType.Equals(Name + "Stop", StringComparison.OrdinalIgnoreCase)) + { + Stop(message); + } + + return NullTaskResult; + } + + /// + /// Starts sending messages over a web socket + /// + /// The message. + private void Start(WebSocketMessageInfo message) + { + var vals = message.Data.Split(','); + + var dueTimeMs = long.Parse(vals[0]); + var periodMs = long.Parse(vals[1]); + + var cancellationTokenSource = new CancellationTokenSource(); + + Logger.LogInfo("{1} Begin transmitting over websocket to {0}", message.Connection.RemoteEndPoint, GetType().Name); + + var timer = new Timer(TimerCallback, message.Connection, Timeout.Infinite, Timeout.Infinite); + + var state = new TStateType(); + + var semaphore = new SemaphoreSlim(1, 1); + + lock (ActiveConnections) + { + ActiveConnections.Add(new Tuple(message.Connection, cancellationTokenSource, timer, state, semaphore)); + } + + timer.Change(TimeSpan.FromMilliseconds(dueTimeMs), TimeSpan.FromMilliseconds(periodMs)); + } + + /// + /// Timers the callback. + /// + /// The state. + private async void TimerCallback(object state) + { + var connection = (WebSocketConnection)state; + + Tuple tuple; + + lock (ActiveConnections) + { + tuple = ActiveConnections.FirstOrDefault(c => c.Item1 == connection); + } + + if (tuple == null) + { + return; + } + + if (connection.State != WebSocketState.Open || tuple.Item2.IsCancellationRequested) + { + DisposeConnection(tuple); + return; + } + + try + { + await tuple.Item5.WaitAsync(tuple.Item2.Token).ConfigureAwait(false); + + var data = await GetDataToSend(tuple.Item4).ConfigureAwait(false); + + await connection.SendAsync(new WebSocketMessage + { + MessageType = Name, + Data = data + + }, tuple.Item2.Token).ConfigureAwait(false); + } + catch (OperationCanceledException) + { + if (tuple.Item2.IsCancellationRequested) + { + DisposeConnection(tuple); + } + } + catch (Exception ex) + { + Logger.LogException("Error sending web socket message {0}", ex, Name); + DisposeConnection(tuple); + } + finally + { + tuple.Item5.Release(); + } + } + + /// + /// Stops sending messages over a web socket + /// + /// The message. + private void Stop(WebSocketMessageInfo message) + { + lock (ActiveConnections) + { + var connection = ActiveConnections.FirstOrDefault(c => c.Item1 == message.Connection); + + if (connection != null) + { + DisposeConnection(connection); + } + } + } + + /// + /// Disposes the connection. + /// + /// The connection. + private void DisposeConnection(Tuple connection) + { + Logger.LogInfo("{1} stop transmitting over websocket to {0}", connection.Item1.RemoteEndPoint, GetType().Name); + + try + { + connection.Item3.Dispose(); + } + catch (ObjectDisposedException) + { + + } + + try + { + connection.Item2.Cancel(); + connection.Item2.Dispose(); + } + catch (ObjectDisposedException) + { + + } + + try + { + connection.Item5.Dispose(); + } + catch (ObjectDisposedException) + { + + } + + ActiveConnections.Remove(connection); + } + + /// + /// Releases unmanaged and - optionally - managed resources. + /// + /// true to release both managed and unmanaged resources; false to release only unmanaged resources. + protected override void Dispose(bool dispose) + { + if (dispose) + { + lock (ActiveConnections) + { + foreach (var connection in ActiveConnections.ToList()) + { + DisposeConnection(connection); + } + } + } + + base.Dispose(dispose); + } + } +} diff --git a/MediaBrowser.Common/Kernel/BaseWebSocketListener.cs b/MediaBrowser.Common/Kernel/BaseWebSocketListener.cs new file mode 100644 index 0000000000..2870403b26 --- /dev/null +++ b/MediaBrowser.Common/Kernel/BaseWebSocketListener.cs @@ -0,0 +1,98 @@ +using MediaBrowser.Common.Net; +using System; +using System.Threading.Tasks; + +namespace MediaBrowser.Common.Kernel +{ + /// + /// Represents a class that is notified everytime the server receives a message over a WebSocket + /// + /// The type of the T kernel type. + public abstract class BaseWebSocketListener : IWebSocketListener + where TKernelType : IKernel + { + /// + /// The null task result + /// + protected Task NullTaskResult = Task.FromResult(true); + + /// + /// Gets the kernel. + /// + /// The kernel. + protected TKernelType Kernel { get; private set; } + + /// + /// Initializes the specified kernel. + /// + /// The kernel. + public virtual void Initialize(IKernel kernel) + { + if (kernel == null) + { + throw new ArgumentNullException("kernel"); + } + + Kernel = (TKernelType)kernel; + } + + /// + /// Processes the message. + /// + /// The message. + /// Task. + /// message + public Task ProcessMessage(WebSocketMessageInfo message) + { + if (message == null) + { + throw new ArgumentNullException("message"); + } + + return ProcessMessageInternal(message); + } + + /// + /// Processes the message internal. + /// + /// The message. + /// Task. + protected abstract Task ProcessMessageInternal(WebSocketMessageInfo message); + + /// + /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// + /// Releases unmanaged and - optionally - managed resources. + /// + /// true to release both managed and unmanaged resources; false to release only unmanaged resources. + protected virtual void Dispose(bool dispose) + { + } + } + + /// + /// Interface IWebSocketListener + /// + public interface IWebSocketListener : IDisposable + { + /// + /// Processes the message. + /// + /// The message. + /// Task. + Task ProcessMessage(WebSocketMessageInfo message); + + /// + /// Initializes the specified kernel. + /// + /// The kernel. + void Initialize(IKernel kernel); + } +} diff --git a/MediaBrowser.Common/Kernel/IKernel.cs b/MediaBrowser.Common/Kernel/IKernel.cs new file mode 100644 index 0000000000..1a68dd320a --- /dev/null +++ b/MediaBrowser.Common/Kernel/IKernel.cs @@ -0,0 +1,182 @@ +using MediaBrowser.Common.IO; +using MediaBrowser.Common.Net; +using MediaBrowser.Common.Net.Handlers; +using MediaBrowser.Common.Plugins; +using MediaBrowser.Common.ScheduledTasks; +using MediaBrowser.Common.Serialization; +using MediaBrowser.Model.Configuration; +using MediaBrowser.Model.System; +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Threading.Tasks; + +namespace MediaBrowser.Common.Kernel +{ + /// + /// Interface IKernel + /// + public interface IKernel + { + /// + /// Occurs when [application restart requested]. + /// + event EventHandler ApplicationRestartRequested; + + /// + /// Gets the application paths. + /// + /// The application paths. + BaseApplicationPaths ApplicationPaths { get; } + + /// + /// Gets the configuration. + /// + /// The configuration. + BaseApplicationConfiguration Configuration { get; } + + /// + /// Gets the kernel context. + /// + /// The kernel context. + KernelContext KernelContext { get; } + + /// + /// Gets the protobuf serializer. + /// + /// The protobuf serializer. + DynamicProtobufSerializer ProtobufSerializer { get; } + + /// + /// Inits this instance. + /// + /// Task. + Task Init(IIsoManager isoManager); + + /// + /// Reloads this instance. + /// + /// Task. + Task Reload(); + + /// + /// Gets or sets a value indicating whether this instance has pending kernel reload. + /// + /// true if this instance has pending kernel reload; otherwise, false. + bool HasPendingRestart { get; } + + /// + /// Disposes this instance. + /// + void Dispose(); + + /// + /// Gets the system status. + /// + /// SystemInfo. + SystemInfo GetSystemInfo(); + + /// + /// Gets the scheduled tasks. + /// + /// The scheduled tasks. + IEnumerable ScheduledTasks { get; } + + /// + /// Reloads the logger. + /// + void ReloadLogger(); + + /// + /// Called when [application updated]. + /// + /// The new version. + void OnApplicationUpdated(Version newVersion); + + /// + /// Gets the name of the web application. + /// + /// The name of the web application. + string WebApplicationName { get; } + + /// + /// Gets the log file path. + /// + /// The log file path. + string LogFilePath { get; } + + /// + /// Performs the pending restart. + /// + void PerformPendingRestart(); + + /// + /// Gets the plugins. + /// + /// The plugins. + IEnumerable Plugins { get; } + + /// + /// Gets the UDP server port number. + /// + /// The UDP server port number. + int UdpServerPortNumber { get; } + + /// + /// Gets the HTTP server URL prefix. + /// + /// The HTTP server URL prefix. + string HttpServerUrlPrefix { get; } + + /// + /// Gets a value indicating whether this instance is first run. + /// + /// true if this instance is first run; otherwise, false. + bool IsFirstRun { get; } + + /// + /// Gets the TCP manager. + /// + /// The TCP manager. + TcpManager TcpManager { get; } + + /// + /// Gets the task manager. + /// + /// The task manager. + TaskManager TaskManager { get; } + + /// + /// Gets the web socket listeners. + /// + /// The web socket listeners. + IEnumerable WebSocketListeners { get; } + + /// + /// Occurs when [logger loaded]. + /// + event EventHandler LoggerLoaded; + + /// + /// Occurs when [reload completed]. + /// + event EventHandler ReloadCompleted; + + /// + /// Occurs when [configuration updated]. + /// + event EventHandler ConfigurationUpdated; + + /// + /// Gets the assemblies. + /// + /// The assemblies. + Assembly[] Assemblies { get; } + + /// + /// Gets the rest services. + /// + /// The rest services. + IEnumerable RestServices { get; } + } +} diff --git a/MediaBrowser.Common/Kernel/KernelContext.cs b/MediaBrowser.Common/Kernel/KernelContext.cs index 4d13ebb7b0..1f84c02426 100644 --- a/MediaBrowser.Common/Kernel/KernelContext.cs +++ b/MediaBrowser.Common/Kernel/KernelContext.cs @@ -1,9 +1,18 @@ - -namespace MediaBrowser.Common.Kernel -{ - public enum KernelContext - { - Server, - Ui - } -} + +namespace MediaBrowser.Common.Kernel +{ + /// + /// Enum KernelContext + /// + public enum KernelContext + { + /// + /// The server + /// + Server, + /// + /// The UI + /// + Ui + } +} diff --git a/MediaBrowser.Common/Kernel/RegisterServer.bat b/MediaBrowser.Common/Kernel/RegisterServer.bat new file mode 100644 index 0000000000..d762dfaf76 --- /dev/null +++ b/MediaBrowser.Common/Kernel/RegisterServer.bat @@ -0,0 +1,28 @@ +rem %1 = http server port +rem %2 = http server url +rem %3 = udp server port +rem %4 = tcp server port (web socket) + +if [%1]==[] GOTO DONE + +netsh advfirewall firewall delete rule name="Port %1" protocol=TCP localport=%1 +netsh advfirewall firewall add rule name="Port %1" dir=in action=allow protocol=TCP localport=%1 + +if [%2]==[] GOTO DONE + +netsh http del urlacl url="%2" user="NT AUTHORITY\Authenticated Users" +netsh http add urlacl url="%2" user="NT AUTHORITY\Authenticated Users" + +if [%3]==[] GOTO DONE + +netsh advfirewall firewall delete rule name="Port %3" protocol=UDP localport=%3 +netsh advfirewall firewall add rule name="Port %3" dir=in action=allow protocol=UDP localport=%3 + +if [%4]==[] GOTO DONE + +netsh advfirewall firewall delete rule name="Port %4" protocol=TCP localport=%4 +netsh advfirewall firewall add rule name="Port %4" dir=in action=allow protocol=TCP localport=%4 + + +:DONE +Exit \ No newline at end of file diff --git a/MediaBrowser.Common/Kernel/TcpManager.cs b/MediaBrowser.Common/Kernel/TcpManager.cs new file mode 100644 index 0000000000..02b078c797 --- /dev/null +++ b/MediaBrowser.Common/Kernel/TcpManager.cs @@ -0,0 +1,485 @@ +using Alchemy; +using Alchemy.Classes; +using MediaBrowser.Common.Net; +using MediaBrowser.Common.Serialization; +using MediaBrowser.Model.Configuration; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Net; +using System.Net.Sockets; +using System.Net.WebSockets; +using System.Reflection; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace MediaBrowser.Common.Kernel +{ + /// + /// Manages the Http Server, Udp Server and WebSocket connections + /// + public class TcpManager : BaseManager + { + /// + /// This is the udp server used for server discovery by clients + /// + /// The UDP server. + private UdpServer UdpServer { get; set; } + + /// + /// Gets or sets the UDP listener. + /// + /// The UDP listener. + private IDisposable UdpListener { get; set; } + + /// + /// Both the Ui and server will have a built-in HttpServer. + /// People will inevitably want remote control apps so it's needed in the Ui too. + /// + /// The HTTP server. + public HttpServer HttpServer { get; private set; } + + /// + /// This subscribes to HttpListener requests and finds the appropriate BaseHandler to process it + /// + /// The HTTP listener. + private IDisposable HttpListener { get; set; } + + /// + /// The web socket connections + /// + private readonly List _webSocketConnections = new List(); + + /// + /// Gets or sets the external web socket server. + /// + /// The external web socket server. + private WebSocketServer ExternalWebSocketServer { get; set; } + + /// + /// The _supports native web socket + /// + private bool? _supportsNativeWebSocket; + + /// + /// Gets a value indicating whether [supports web socket]. + /// + /// true if [supports web socket]; otherwise, false. + internal bool SupportsNativeWebSocket + { + get + { + if (!_supportsNativeWebSocket.HasValue) + { + try + { + new ClientWebSocket(); + + _supportsNativeWebSocket = true; + } + catch (PlatformNotSupportedException) + { + _supportsNativeWebSocket = false; + } + } + + return _supportsNativeWebSocket.Value; + } + } + + /// + /// Gets the web socket port number. + /// + /// The web socket port number. + public int WebSocketPortNumber + { + get { return SupportsNativeWebSocket ? Kernel.Configuration.HttpServerPortNumber : Kernel.Configuration.LegacyWebSocketPortNumber; } + } + + /// + /// Initializes a new instance of the class. + /// + /// The kernel. + public TcpManager(IKernel kernel) + : base(kernel) + { + if (kernel.IsFirstRun) + { + RegisterServerWithAdministratorAccess(); + } + + ReloadUdpServer(); + ReloadHttpServer(); + + if (!SupportsNativeWebSocket) + { + ReloadExternalWebSocketServer(); + } + } + + /// + /// Starts the external web socket server. + /// + private void ReloadExternalWebSocketServer() + { + // Avoid windows firewall prompts in the ui + if (Kernel.KernelContext != KernelContext.Server) + { + return; + } + + DisposeExternalWebSocketServer(); + + ExternalWebSocketServer = new WebSocketServer(Kernel.Configuration.LegacyWebSocketPortNumber, IPAddress.Any) + { + OnConnected = OnAlchemyWebSocketClientConnected, + TimeOut = TimeSpan.FromMinutes(60) + }; + + ExternalWebSocketServer.Start(); + + Logger.Info("Alchemy Web Socket Server started"); + } + + /// + /// Called when [alchemy web socket client connected]. + /// + /// The context. + private void OnAlchemyWebSocketClientConnected(UserContext context) + { + var connection = new WebSocketConnection(new AlchemyWebSocket(context), context.ClientAddress, ProcessWebSocketMessageReceived); + + _webSocketConnections.Add(connection); + } + + /// + /// Restarts the Http Server, or starts it if not currently running + /// + /// if set to true [register server on failure]. + public void ReloadHttpServer(bool registerServerOnFailure = true) + { + // Only reload if the port has changed, so that we don't disconnect any active users + if (HttpServer != null && HttpServer.UrlPrefix.Equals(Kernel.HttpServerUrlPrefix, StringComparison.OrdinalIgnoreCase)) + { + return; + } + + DisposeHttpServer(); + + Logger.Info("Loading Http Server"); + + try + { + HttpServer = new HttpServer(Kernel.HttpServerUrlPrefix, "Media Browser", Kernel); + } + catch (HttpListenerException ex) + { + Logger.ErrorException("Error starting Http Server", ex); + + if (registerServerOnFailure) + { + RegisterServerWithAdministratorAccess(); + + // Don't get stuck in a loop + ReloadHttpServer(false); + + return; + } + + throw; + } + + HttpServer.WebSocketConnected += HttpServer_WebSocketConnected; + } + + /// + /// Handles the WebSocketConnected event of the HttpServer control. + /// + /// The source of the event. + /// The instance containing the event data. + void HttpServer_WebSocketConnected(object sender, WebSocketConnectEventArgs e) + { + var connection = new WebSocketConnection(e.WebSocket, e.Endpoint, ProcessWebSocketMessageReceived); + + _webSocketConnections.Add(connection); + } + + /// + /// Processes the web socket message received. + /// + /// The result. + private async void ProcessWebSocketMessageReceived(WebSocketMessageInfo result) + { + var tasks = Kernel.WebSocketListeners.Select(i => Task.Run(async () => + { + try + { + await i.ProcessMessage(result).ConfigureAwait(false); + } + catch (Exception ex) + { + Logger.ErrorException("{0} failed processing WebSocket message {1}", ex, i.GetType().Name, result.MessageType); + } + })); + + await Task.WhenAll(tasks).ConfigureAwait(false); + } + + /// + /// Starts or re-starts the udp server + /// + private void ReloadUdpServer() + { + // For now, there's no reason to keep reloading this over and over + if (UdpServer != null) + { + return; + } + + // Avoid windows firewall prompts in the ui + if (Kernel.KernelContext != KernelContext.Server) + { + return; + } + + DisposeUdpServer(); + + try + { + // The port number can't be in configuration because we don't want it to ever change + UdpServer = new UdpServer(new IPEndPoint(IPAddress.Any, Kernel.UdpServerPortNumber)); + } + catch (SocketException ex) + { + Logger.ErrorException("Failed to start UDP Server", ex); + return; + } + + UdpListener = UdpServer.Subscribe(async res => + { + var expectedMessage = String.Format("who is MediaBrowser{0}?", Kernel.KernelContext); + var expectedMessageBytes = Encoding.UTF8.GetBytes(expectedMessage); + + if (expectedMessageBytes.SequenceEqual(res.Buffer)) + { + Logger.Info("Received UDP server request from " + res.RemoteEndPoint.ToString()); + + // Send a response back with our ip address and port + var response = String.Format("MediaBrowser{0}|{1}:{2}", Kernel.KernelContext, NetUtils.GetLocalIpAddress(), Kernel.UdpServerPortNumber); + + await UdpServer.SendAsync(response, res.RemoteEndPoint); + } + }); + } + + /// + /// Sends a message to all clients currently connected via a web socket + /// + /// + /// Type of the message. + /// The data. + /// Task. + public void SendWebSocketMessage(string messageType, T data) + { + SendWebSocketMessage(messageType, () => data); + } + + /// + /// Sends a message to all clients currently connected via a web socket + /// + /// + /// Type of the message. + /// The function that generates the data to send, if there are any connected clients + public void SendWebSocketMessage(string messageType, Func dataFunction) + { + Task.Run(async () => await SendWebSocketMessageAsync(messageType, dataFunction, CancellationToken.None).ConfigureAwait(false)); + } + + /// + /// Sends a message to all clients currently connected via a web socket + /// + /// + /// Type of the message. + /// The function that generates the data to send, if there are any connected clients + /// The cancellation token. + /// Task. + /// messageType + public async Task SendWebSocketMessageAsync(string messageType, Func dataFunction, CancellationToken cancellationToken) + { + if (string.IsNullOrEmpty(messageType)) + { + throw new ArgumentNullException("messageType"); + } + + if (dataFunction == null) + { + throw new ArgumentNullException("dataFunction"); + } + + if (cancellationToken == null) + { + throw new ArgumentNullException("cancellationToken"); + } + + cancellationToken.ThrowIfCancellationRequested(); + + var connections = _webSocketConnections.Where(s => s.State == WebSocketState.Open).ToList(); + + if (connections.Count > 0) + { + Logger.Info("Sending web socket message {0}", messageType); + + var message = new WebSocketMessage { MessageType = messageType, Data = dataFunction() }; + var bytes = JsonSerializer.SerializeToBytes(message); + + var tasks = connections.Select(s => Task.Run(() => + { + try + { + s.SendAsync(bytes, cancellationToken); + } + catch (OperationCanceledException) + { + throw; + } + catch (Exception ex) + { + Logger.ErrorException("Error sending web socket message {0} to {1}", ex, messageType, s.RemoteEndPoint); + } + })); + + await Task.WhenAll(tasks).ConfigureAwait(false); + } + } + + /// + /// Disposes the udp server + /// + private void DisposeUdpServer() + { + if (UdpServer != null) + { + UdpServer.Dispose(); + } + + if (UdpListener != null) + { + UdpListener.Dispose(); + } + } + + /// + /// Disposes the current HttpServer + /// + private void DisposeHttpServer() + { + foreach (var socket in _webSocketConnections) + { + // Dispose the connection + socket.Dispose(); + } + + _webSocketConnections.Clear(); + + if (HttpServer != null) + { + Logger.Info("Disposing Http Server"); + + HttpServer.WebSocketConnected -= HttpServer_WebSocketConnected; + HttpServer.Dispose(); + } + + if (HttpListener != null) + { + HttpListener.Dispose(); + } + + DisposeExternalWebSocketServer(); + } + + /// + /// Registers the server with administrator access. + /// + private void RegisterServerWithAdministratorAccess() + { + // Create a temp file path to extract the bat file to + var tmpFile = Path.Combine(Kernel.ApplicationPaths.TempDirectory, Guid.NewGuid() + ".bat"); + + // Extract the bat file + using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("MediaBrowser.Common.Kernel.RegisterServer.bat")) + { + using (var fileStream = File.Create(tmpFile)) + { + stream.CopyTo(fileStream); + } + } + + var startInfo = new ProcessStartInfo + { + FileName = tmpFile, + + Arguments = string.Format("{0} {1} {2} {3}", Kernel.Configuration.HttpServerPortNumber, + Kernel.HttpServerUrlPrefix, + Kernel.UdpServerPortNumber, + Kernel.Configuration.LegacyWebSocketPortNumber), + + CreateNoWindow = true, + WindowStyle = ProcessWindowStyle.Hidden, + Verb = "runas", + ErrorDialog = false + }; + + using (var process = Process.Start(startInfo)) + { + process.WaitForExit(); + } + } + + /// + /// Releases unmanaged and - optionally - managed resources. + /// + /// true to release both managed and unmanaged resources; false to release only unmanaged resources. + protected override void Dispose(bool dispose) + { + if (dispose) + { + DisposeUdpServer(); + DisposeHttpServer(); + } + + base.Dispose(dispose); + } + + /// + /// Disposes the external web socket server. + /// + private void DisposeExternalWebSocketServer() + { + if (ExternalWebSocketServer != null) + { + ExternalWebSocketServer.Dispose(); + } + } + + /// + /// Called when [application configuration changed]. + /// + /// The old config. + /// The new config. + public void OnApplicationConfigurationChanged(BaseApplicationConfiguration oldConfig, BaseApplicationConfiguration newConfig) + { + if (oldConfig.HttpServerPortNumber != newConfig.HttpServerPortNumber) + { + ReloadHttpServer(); + } + + if (!SupportsNativeWebSocket && oldConfig.LegacyWebSocketPortNumber != newConfig.LegacyWebSocketPortNumber) + { + ReloadExternalWebSocketServer(); + } + } + } +} -- cgit v1.2.3