2017-08-09 21:56:38 +02:00
using Emby.Common.Implementations ;
using Emby.Common.Implementations.Serialization ;
using Emby.Dlna ;
using Emby.Dlna.ConnectionManager ;
using Emby.Dlna.ContentDirectory ;
using Emby.Dlna.Main ;
using Emby.Dlna.MediaReceiverRegistrar ;
using Emby.Dlna.Ssdp ;
using Emby.Drawing ;
using Emby.Photos ;
using Emby.Server.Implementations.Activity ;
using Emby.Server.Implementations.Channels ;
using Emby.Server.Implementations.Collections ;
using Emby.Server.Implementations.Configuration ;
using Emby.Server.Implementations.Data ;
using Emby.Server.Implementations.Devices ;
using Emby.Server.Implementations.Dto ;
using Emby.Server.Implementations.FFMpeg ;
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 ;
using Emby.Server.Implementations.MediaEncoder ;
using Emby.Server.Implementations.Migrations ;
using Emby.Server.Implementations.Notifications ;
using Emby.Server.Implementations.Playlists ;
using Emby.Server.Implementations.Security ;
using Emby.Server.Implementations.Session ;
using Emby.Server.Implementations.Social ;
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 ;
2015-01-19 07:42:31 +01:00
using MediaBrowser.Common.Extensions ;
2013-03-07 06:34:00 +01:00
using MediaBrowser.Common.Net ;
2017-08-09 21:56:38 +02:00
using MediaBrowser.Common.Plugins ;
2013-12-13 16:48:35 +01:00
using MediaBrowser.Common.Progress ;
2017-08-09 21:56:38 +02:00
using MediaBrowser.Common.Security ;
using MediaBrowser.Common.Updates ;
2013-02-24 22:53:54 +01:00
using MediaBrowser.Controller ;
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-08-25 05:54:45 +02:00
using MediaBrowser.Controller.Connect ;
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 ;
2017-08-09 21:56:38 +02:00
using MediaBrowser.Controller.Entities.Audio ;
using MediaBrowser.Controller.Entities.Movies ;
using MediaBrowser.Controller.Entities.TV ;
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 ;
2014-07-18 00:21:35 +02:00
using MediaBrowser.Controller.Sync ;
2014-09-01 22:10:54 +02:00
using MediaBrowser.Controller.TV ;
2015-05-31 20:22:51 +02:00
using MediaBrowser.LocalMetadata.Savers ;
2017-08-09 21:56:38 +02:00
using MediaBrowser.Model.Activity ;
using MediaBrowser.Model.Configuration ;
using MediaBrowser.Model.Diagnostics ;
using MediaBrowser.Model.Dlna ;
using MediaBrowser.Model.Globalization ;
using MediaBrowser.Model.IO ;
2013-09-21 03:04:14 +02:00
using MediaBrowser.Model.Logging ;
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.News ;
using MediaBrowser.Model.Reflection ;
using MediaBrowser.Model.Serialization ;
using MediaBrowser.Model.Services ;
using MediaBrowser.Model.Social ;
2013-02-24 22:53:54 +01:00
using MediaBrowser.Model.System ;
2017-08-09 21:56:38 +02:00
using MediaBrowser.Model.Text ;
2013-09-14 03:56:03 +02:00
using MediaBrowser.Model.Updates ;
2017-08-09 21:56:38 +02:00
using MediaBrowser.Model.Xml ;
2014-06-09 21:16:14 +02:00
using MediaBrowser.Providers.Chapters ;
2014-01-28 19:37:01 +01:00
using MediaBrowser.Providers.Manager ;
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 ;
2017-08-09 21:56:38 +02:00
using OpenSubtitlesHandler ;
using ServiceStack ;
using SocketHttpListener.Primitives ;
2013-02-24 22:53:54 +01:00
using System ;
2015-12-29 04:39:38 +01:00
using System.Collections.Concurrent ;
2013-02-24 22:53:54 +01:00
using System.Collections.Generic ;
2014-01-06 02:59:21 +01:00
using System.Globalization ;
2013-02-24 22:53:54 +01:00
using System.IO ;
using System.Linq ;
2017-08-16 08:43:41 +02:00
using System.Net ;
2013-02-24 22:53:54 +01:00
using System.Reflection ;
2017-08-16 08:43:41 +02:00
using System.Runtime.InteropServices ;
2016-11-11 04:29:51 +01:00
using System.Security.Cryptography.X509Certificates ;
2017-08-16 08:43:41 +02:00
using System.Text ;
2013-09-13 17:02:40 +02:00
using System.Threading ;
2013-02-24 22:53:54 +01:00
using System.Threading.Tasks ;
2017-08-16 08:43:41 +02:00
using Emby.Server.Implementations.Archiving ;
using Emby.Server.Implementations.Cryptography ;
using Emby.Server.Implementations.Diagnostics ;
using Emby.Server.Implementations.Net ;
using Emby.Server.Implementations.Reflection ;
using Emby.Server.Implementations.ScheduledTasks ;
using Emby.Server.Implementations.Serialization ;
using Emby.Server.Implementations.Threading ;
using Emby.Server.Implementations.Xml ;
2017-08-09 21:56:38 +02:00
using Emby.Server.MediaEncoding.Subtitles ;
using MediaBrowser.MediaEncoding.BdInfo ;
2017-08-16 08:43:41 +02:00
using MediaBrowser.Model.Cryptography ;
using MediaBrowser.Model.Events ;
using MediaBrowser.Model.Tasks ;
using MediaBrowser.Model.Threading ;
2016-10-29 06:10:11 +02:00
using StringExtensions = MediaBrowser . Controller . Extensions . StringExtensions ;
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>
/// Class CompositionRoot
/// </summary>
2017-08-16 08:43:41 +02:00
public abstract class ApplicationHost : IServerApplicationHost , IDependencyContainer
2013-02-24 22:53:54 +01:00
{
2017-08-16 08:43:41 +02:00
/// <summary>
/// Gets a value indicating whether this instance can self restart.
/// </summary>
/// <value><c>true</c> if this instance can self restart; otherwise, <c>false</c>.</value>
public abstract bool CanSelfRestart { get ; }
/// <summary>
/// Gets or sets a value indicating whether this instance can self update.
/// </summary>
/// <value><c>true</c> if this instance can self update; otherwise, <c>false</c>.</value>
public virtual bool CanSelfUpdate
{
get
{
return false ;
}
}
/// <summary>
/// Occurs when [has pending restart changed].
/// </summary>
public event EventHandler HasPendingRestartChanged ;
/// <summary>
/// Occurs when [application updated].
/// </summary>
public event EventHandler < GenericEventArgs < PackageVersionInfo > > ApplicationUpdated ;
/// <summary>
/// Gets or sets a value indicating whether this instance has changes that require the entire application to restart.
/// </summary>
/// <value><c>true</c> if this instance has pending application restart; otherwise, <c>false</c>.</value>
public bool HasPendingRestart { get ; private set ; }
/// <summary>
/// Gets or sets the logger.
/// </summary>
/// <value>The logger.</value>
protected ILogger Logger { get ; set ; }
/// <summary>
/// Gets or sets the plugins.
/// </summary>
/// <value>The plugins.</value>
public IPlugin [ ] Plugins { get ; protected set ; }
/// <summary>
/// Gets or sets the log manager.
/// </summary>
/// <value>The log manager.</value>
public ILogManager LogManager { get ; protected set ; }
/// <summary>
/// Gets the application paths.
/// </summary>
/// <value>The application paths.</value>
protected ServerApplicationPaths ApplicationPaths { get ; set ; }
/// <summary>
/// Gets assemblies that failed to load
/// </summary>
/// <value>The failed assemblies.</value>
public List < string > FailedAssemblies { get ; protected set ; }
/// <summary>
/// Gets all concrete types.
/// </summary>
/// <value>All concrete types.</value>
public Type [ ] AllConcreteTypes { get ; protected set ; }
/// <summary>
/// The disposable parts
/// </summary>
protected readonly List < IDisposable > DisposableParts = new List < IDisposable > ( ) ;
/// <summary>
/// Gets a value indicating whether this instance is first run.
/// </summary>
/// <value><c>true</c> if this instance is first run; otherwise, <c>false</c>.</value>
public bool IsFirstRun { get ; private set ; }
/// <summary>
/// Gets the configuration manager.
/// </summary>
/// <value>The configuration manager.</value>
protected IConfigurationManager ConfigurationManager { get ; set ; }
public IFileSystem FileSystemManager { get ; set ; }
protected IEnvironmentInfo EnvironmentInfo { get ; set ; }
public PackageVersionClass SystemUpdateLevel
{
get
{
#if BETA
return PackageVersionClass . Beta ;
#endif
return PackageVersionClass . Release ;
}
}
public virtual string OperatingSystemDisplayName
{
get { return EnvironmentInfo . OperatingSystemName ; }
}
/// <summary>
/// The container
/// </summary>
protected readonly SimpleInjector . Container Container = new SimpleInjector . Container ( ) ;
protected ISystemEvents SystemEvents { get ; set ; }
protected IMemoryStreamFactory MemoryStreamFactory { get ; 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>
public IServerConfigurationManager ServerConfigurationManager
2013-02-24 22:53:54 +01:00
{
2013-03-04 06:43:06 +01:00
get { return ( IServerConfigurationManager ) ConfigurationManager ; }
2013-03-03 08:27:40 +01:00
}
2013-02-26 18:21:18 +01:00
/// <summary>
2013-03-04 06:43:06 +01:00
/// Gets the configuration manager.
2013-02-26 18:21:18 +01:00
/// </summary>
2013-03-04 06:43:06 +01:00
/// <returns>IConfigurationManager.</returns>
2017-08-16 08:43:41 +02:00
protected IConfigurationManager GetConfigurationManager ( )
2013-02-26 18:21:18 +01:00
{
2015-09-14 01:07:54 +02:00
return new ServerConfigurationManager ( ApplicationPaths , LogManager , XmlSerializer , FileSystemManager ) ;
2013-02-26 18:21:18 +01:00
}
2013-03-08 06:08:27 +01:00
/// <summary>
/// Gets or sets the server manager.
/// </summary>
/// <value>The server manager.</value>
2013-03-07 06:34:00 +01:00
private IServerManager ServerManager { get ; set ; }
2013-03-08 06:08:27 +01:00
/// <summary>
/// Gets or sets the user manager.
/// </summary>
/// <value>The user manager.</value>
public IUserManager UserManager { get ; set ; }
/// <summary>
/// Gets or sets the library manager.
/// </summary>
/// <value>The library manager.</value>
internal ILibraryManager LibraryManager { get ; set ; }
/// <summary>
/// Gets or sets the directory watchers.
/// </summary>
/// <value>The directory watchers.</value>
2014-01-28 22:25:10 +01:00
private ILibraryMonitor LibraryMonitor { get ; set ; }
2013-03-08 06:08:27 +01:00
/// <summary>
/// Gets or sets the provider manager.
/// </summary>
/// <value>The provider manager.</value>
private IProviderManager ProviderManager { get ; set ; }
/// <summary>
/// Gets or sets the HTTP server.
/// </summary>
/// <value>The HTTP server.</value>
private IHttpServer HttpServer { get ; set ; }
2013-09-04 19:02:19 +02:00
private IDtoService DtoService { get ; set ; }
2017-05-12 20:09:42 +02:00
public IImageProcessor ImageProcessor { get ; set ; }
2013-03-10 07:45:16 +01:00
2013-04-08 17:55:53 +02:00
/// <summary>
/// Gets or sets the media encoder.
/// </summary>
/// <value>The media encoder.</value>
2013-04-07 22:55:05 +02:00
private IMediaEncoder MediaEncoder { get ; set ; }
2015-01-02 07:12:58 +01:00
private ISubtitleEncoder SubtitleEncoder { get ; set ; }
2013-04-08 17:55:53 +02:00
2014-08-25 05:54:45 +02:00
private IConnectManager ConnectManager { get ; set ; }
2013-09-24 17:42:30 +02:00
private ISessionManager SessionManager { get ; set ; }
2013-08-10 03:40:52 +02:00
2013-09-26 17:48:14 +02:00
private ILiveTvManager LiveTvManager { get ; set ; }
2013-09-26 23:20:26 +02:00
2014-11-09 19:24:57 +01:00
public ILocalizationManager LocalizationManager { get ; set ; }
2013-06-10 19:46:11 +02:00
2014-02-20 17:37:41 +01:00
private IEncodingManager EncodingManager { get ; set ; }
2014-03-18 18:05:57 +01:00
private IChannelManager ChannelManager { get ; set ; }
2014-07-22 03:29:06 +02:00
private ISyncManager SyncManager { get ; set ; }
2014-02-28 05:49:02 +01:00
2013-04-13 20:02:30 +02:00
/// <summary>
/// Gets or sets the user data repository.
/// </summary>
/// <value>The user data repository.</value>
2013-10-02 18:08:58 +02:00
private IUserDataManager UserDataManager { get ; set ; }
2013-04-19 22:27:02 +02:00
private IUserRepository UserRepository { get ; set ; }
2013-06-18 21:16:27 +02:00
internal IDisplayPreferencesRepository DisplayPreferencesRepository { get ; set ; }
2013-12-16 23:46:40 +01:00
internal IItemRepository ItemRepository { get ; set ; }
2013-07-06 23:23:32 +02:00
private INotificationsRepository NotificationsRepository { get ; set ; }
2013-04-13 20:02:30 +02:00
2014-04-25 22:15:50 +02:00
private INotificationManager NotificationManager { get ; set ; }
2014-05-07 04:28:19 +02:00
private ISubtitleManager SubtitleManager { get ; set ; }
2014-06-09 21:16:14 +02:00
private IChapterManager ChapterManager { get ; set ; }
2014-10-11 22:38:13 +02:00
private IDeviceManager DeviceManager { get ; set ; }
2014-04-25 22:15:50 +02:00
2014-09-01 22:10:54 +02:00
internal IUserViewManager UserViewManager { get ; set ; }
2014-06-07 21:46:24 +02:00
2014-07-08 03:41:03 +02:00
private IAuthenticationRepository AuthenticationRepository { get ; set ; }
2014-09-01 22:10:54 +02:00
private ITVSeriesManager TVSeriesManager { get ; set ; }
2014-10-08 03:37:45 +02:00
private ICollectionManager CollectionManager { get ; set ; }
2015-02-07 22:03:09 +01:00
private IMediaSourceManager MediaSourceManager { get ; set ; }
2015-03-14 05:50:23 +01:00
private IPlaylistManager PlaylistManager { get ; set ; }
2014-07-20 06:46:29 +02:00
2016-10-29 07:40:15 +02:00
/// <summary>
/// Gets or sets the installation manager.
/// </summary>
/// <value>The installation manager.</value>
protected IInstallationManager InstallationManager { get ; private set ; }
/// <summary>
/// Gets the security manager.
/// </summary>
/// <value>The security manager.</value>
protected ISecurityManager SecurityManager { get ; private set ; }
2016-10-28 20:35:17 +02:00
/// <summary>
/// Gets or sets the zip client.
/// </summary>
/// <value>The zip client.</value>
protected IZipClient ZipClient { get ; private set ; }
2016-11-08 19:44:23 +01:00
protected IAuthService AuthService { get ; private set ; }
2016-11-13 05:33:51 +01:00
protected readonly StartupOptions StartupOptions ;
2016-01-03 20:01:05 +01:00
private readonly string _releaseAssetFilename ;
2014-09-14 17:26:33 +02:00
2016-11-09 05:58:58 +01:00
internal IPowerManagement PowerManagement { get ; private set ; }
2016-11-11 18:33:10 +01:00
internal IImageEncoder ImageEncoder { get ; private set ; }
2017-05-01 04:22:13 +02:00
private readonly Action < string , string , string > _certificateGenerator ;
2016-11-11 18:33:10 +01:00
private readonly Func < string > _defaultUserNameFactory ;
2017-08-16 08:43:41 +02:00
protected IProcessFactory ProcessFactory { get ; private set ; }
protected ITimerFactory TimerFactory { get ; private set ; }
protected ICryptoProvider CryptographyProvider = new CryptographyProvider ( ) ;
protected readonly IXmlSerializer XmlSerializer ;
protected ISocketFactory SocketFactory { get ; private set ; }
protected ITaskManager TaskManager { get ; private set ; }
public IHttpClient HttpClient { get ; private set ; }
protected INetworkManager NetworkManager { get ; set ; }
public IJsonSerializer JsonSerializer { get ; private set ; }
protected IIsoManager IsoManager { get ; private set ; }
2016-11-09 05:58:58 +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>
2014-12-22 02:02:15 +01:00
public ApplicationHost ( ServerApplicationPaths applicationPaths ,
ILogManager logManager ,
StartupOptions options ,
2014-10-07 01:58:46 +02:00
IFileSystem fileSystem ,
2016-11-09 05:58:58 +01:00
IPowerManagement powerManagement ,
2016-11-11 09:13:11 +01:00
string releaseAssetFilename ,
2016-11-11 18:33:10 +01:00
IEnvironmentInfo environmentInfo ,
IImageEncoder imageEncoder ,
ISystemEvents systemEvents ,
IMemoryStreamFactory memoryStreamFactory ,
INetworkManager networkManager ,
2017-05-01 04:22:13 +02:00
Action < string , string , string > certificateGenerator ,
2016-11-11 18:33:10 +01:00
Func < string > defaultUsernameFactory )
2013-09-20 19:32:10 +02:00
{
2017-08-16 08:43:41 +02:00
// hack alert, until common can target .net core
BaseExtensions . CryptographyProvider = CryptographyProvider ;
XmlSerializer = new MyXmlSerializer ( fileSystem , logManager . GetLogger ( "XmlSerializer" ) ) ;
NetworkManager = networkManager ;
EnvironmentInfo = environmentInfo ;
SystemEvents = systemEvents ;
MemoryStreamFactory = memoryStreamFactory ;
FailedAssemblies = new List < string > ( ) ;
ApplicationPaths = applicationPaths ;
LogManager = logManager ;
FileSystemManager = fileSystem ;
ConfigurationManager = GetConfigurationManager ( ) ;
// Initialize this early in case the -v command line option is used
Logger = LogManager . GetLogger ( "App" ) ;
2016-11-13 05:33:51 +01:00
StartupOptions = options ;
2016-11-11 18:33:10 +01:00
_certificateGenerator = certificateGenerator ;
2016-01-03 20:01:05 +01:00
_releaseAssetFilename = releaseAssetFilename ;
2016-11-11 18:33:10 +01:00
_defaultUserNameFactory = defaultUsernameFactory ;
2016-11-09 05:58:58 +01:00
PowerManagement = powerManagement ;
2014-12-17 23:39:17 +01:00
2016-11-11 18:33:10 +01:00
ImageEncoder = imageEncoder ;
2014-12-17 23:39:17 +01:00
SetBaseExceptionMessage ( ) ;
2017-03-10 20:51:29 +01:00
if ( environmentInfo . OperatingSystem = = MediaBrowser . Model . System . OperatingSystem . Windows )
{
fileSystem . AddShortcutHandler ( new LnkShortcutHandler ( ) ) ;
}
fileSystem . AddShortcutHandler ( new MbLinkShortcutHandler ( fileSystem ) ) ;
2014-01-30 01:18:05 +01:00
}
2013-09-21 03:04:14 +02:00
2014-11-14 07:27:10 +01:00
private Version _version ;
/// <summary>
/// Gets the current application version
/// </summary>
/// <value>The application version.</value>
2017-08-16 08:43:41 +02:00
public Version ApplicationVersion
2014-11-14 07:27:10 +01:00
{
get
{
2016-11-13 05:33:51 +01:00
return _version ? ? ( _version = GetAssembly ( GetType ( ) ) . GetName ( ) . Version ) ;
2014-11-14 07:27:10 +01:00
}
}
2017-02-19 04:46:09 +01:00
public virtual bool SupportsRunningAsService
{
get
{
return false ;
}
}
2014-09-09 03:15:31 +02:00
2017-08-16 08:43:41 +02:00
private DeviceId _deviceId ;
public string SystemId
{
get
{
if ( _deviceId = = null )
{
_deviceId = new DeviceId ( ApplicationPaths , LogManager . GetLogger ( "SystemId" ) , FileSystemManager ) ;
}
return _deviceId . Value ;
}
}
2014-01-25 22:07:19 +01:00
/// <summary>
/// Gets the name.
/// </summary>
/// <value>The name.</value>
2017-08-16 08:43:41 +02:00
public string Name
2014-01-25 22:07:19 +01:00
{
get
{
2016-07-14 04:36:42 +02:00
return "Emby Server" ;
2014-01-25 22:07:19 +01:00
}
}
2017-02-19 04:46:09 +01:00
public virtual bool IsRunningAsService
{
get
{
return false ;
}
}
2017-01-21 21:27:07 +01:00
2016-11-11 18:33:10 +01:00
private Assembly GetAssembly ( Type type )
{
return type . GetTypeInfo ( ) . Assembly ;
}
2017-02-19 04:46:09 +01:00
public virtual bool SupportsAutoRunAtStartup
{
get
{
return EnvironmentInfo . OperatingSystem = = MediaBrowser . Model . System . OperatingSystem . Windows ;
}
}
2014-01-06 02:59:21 +01:00
2017-08-16 08:43:41 +02:00
/// <summary>
/// Creates an instance of type and resolves all constructor dependancies
/// </summary>
/// <param name="type">The type.</param>
/// <returns>System.Object.</returns>
public object CreateInstance ( Type type )
{
try
{
return Container . GetInstance ( type ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error creating {0}" , ex , type . FullName ) ;
throw ;
}
}
/// <summary>
/// Creates the instance safe.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>System.Object.</returns>
protected object CreateInstanceSafe ( Type type )
{
try
{
return Container . GetInstance ( type ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error creating {0}" , ex , type . FullName ) ;
// Don't blow up in release mode
return null ;
}
}
/// <summary>
/// Registers the specified obj.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj">The obj.</param>
/// <param name="manageLifetime">if set to <c>true</c> [manage lifetime].</param>
protected void RegisterSingleInstance < T > ( T obj , bool manageLifetime = true )
where T : class
{
Container . RegisterSingleton ( obj ) ;
if ( manageLifetime )
{
var disposable = obj as IDisposable ;
if ( disposable ! = null )
{
DisposableParts . Add ( disposable ) ;
}
}
}
/// <summary>
/// Registers the single instance.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="func">The func.</param>
protected void RegisterSingleInstance < T > ( Func < T > func )
where T : class
{
Container . RegisterSingleton ( func ) ;
}
/// <summary>
/// Resolves this instance.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>``0.</returns>
public T Resolve < T > ( )
{
return ( T ) Container . GetRegistration ( typeof ( T ) , true ) . GetInstance ( ) ;
}
/// <summary>
/// Resolves this instance.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>``0.</returns>
public T TryResolve < T > ( )
{
var result = Container . GetRegistration ( typeof ( T ) , false ) ;
if ( result = = null )
{
return default ( T ) ;
}
return ( T ) result . GetInstance ( ) ;
}
/// <summary>
/// Loads the assembly.
/// </summary>
/// <param name="file">The file.</param>
/// <returns>Assembly.</returns>
protected Assembly LoadAssembly ( string file )
{
try
{
return Assembly . Load ( File . ReadAllBytes ( file ) ) ;
}
catch ( Exception ex )
{
FailedAssemblies . Add ( file ) ;
Logger . ErrorException ( "Error loading assembly {0}" , ex , file ) ;
return null ;
}
}
/// <summary>
/// Gets the export types.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>IEnumerable{Type}.</returns>
public IEnumerable < Type > GetExportTypes < T > ( )
{
var currentType = typeof ( T ) ;
return AllConcreteTypes . Where ( currentType . IsAssignableFrom ) ;
}
/// <summary>
/// Gets the exports.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="manageLiftime">if set to <c>true</c> [manage liftime].</param>
/// <returns>IEnumerable{``0}.</returns>
public IEnumerable < T > GetExports < T > ( bool manageLiftime = true )
{
var parts = GetExportTypes < T > ( )
. Select ( CreateInstanceSafe )
. Where ( i = > i ! = null )
. Cast < T > ( )
. ToList ( ) ;
if ( manageLiftime )
{
lock ( DisposableParts )
{
DisposableParts . AddRange ( parts . OfType < IDisposable > ( ) ) ;
}
}
return parts ;
}
2014-12-17 23:39:17 +01:00
private void SetBaseExceptionMessage ( )
{
var builder = GetBaseExceptionMessage ( ApplicationPaths ) ;
builder . Insert ( 0 , string . Format ( "Version: {0}{1}" , ApplicationVersion , Environment . NewLine ) ) ;
builder . Insert ( 0 , "*** Error Report ***" + Environment . NewLine ) ;
LogManager . ExceptionMessagePrefix = builder . ToString ( ) ;
}
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>
2017-08-16 08:43:41 +02:00
public async Task RunStartupTasks ( )
2013-03-07 06:34:00 +01:00
{
2017-08-16 08:43:41 +02:00
Resolve < ITaskManager > ( ) . AddTasks ( GetExports < IScheduledTask > ( false ) ) ;
ConfigureAutorun ( ) ;
ConfigurationManager . ConfigurationUpdated + = OnConfigurationUpdated ;
2013-03-08 06:08:27 +01:00
2016-06-30 06:23:52 +02:00
await MediaEncoder . Init ( ) . ConfigureAwait ( false ) ;
2016-06-20 08:19:28 +02:00
2016-09-09 18:58:08 +02:00
if ( string . IsNullOrWhiteSpace ( MediaEncoder . EncoderPath ) )
{
if ( ServerConfigurationManager . Configuration . IsStartupWizardCompleted )
{
ServerConfigurationManager . Configuration . IsStartupWizardCompleted = false ;
ServerConfigurationManager . SaveConfiguration ( ) ;
}
}
2015-12-30 08:11:58 +01:00
Logger . Info ( "ServerId: {0}" , SystemId ) ;
2013-04-08 17:55:53 +02:00
Logger . Info ( "Core startup complete" ) ;
2015-09-14 01:07:54 +02:00
HttpServer . GlobalResponse = null ;
2013-04-08 17:55:53 +02:00
2016-06-30 00:01:35 +02:00
Logger . Info ( "Post-init migrations complete" ) ;
2016-02-03 23:42:33 +01:00
2016-06-30 00:01:35 +02:00
foreach ( var entryPoint in GetExports < IServerEntryPoint > ( ) . ToList ( ) )
2013-06-22 01:38:19 +02:00
{
2016-06-30 00:01:35 +02:00
var name = entryPoint . GetType ( ) . FullName ;
2016-06-30 03:23:58 +02:00
Logger . Info ( "Starting entry point {0}" , name ) ;
2016-09-11 19:09:10 +02:00
var now = DateTime . UtcNow ;
2013-06-22 01:38:19 +02:00
try
{
entryPoint . Run ( ) ;
}
catch ( Exception ex )
{
2016-06-30 00:01:35 +02:00
Logger . ErrorException ( "Error in {0}" , ex , name ) ;
2013-06-22 01:38:19 +02:00
}
2017-08-07 01:01:00 +02:00
Logger . Info ( "Entry point completed: {0}. Duration: {1} seconds" , name , ( DateTime . UtcNow - now ) . TotalSeconds . ToString ( CultureInfo . InvariantCulture ) , "ImageInfos" ) ;
2016-06-30 00:01:35 +02:00
}
2016-06-30 03:23:58 +02:00
Logger . Info ( "All entry points have started" ) ;
2014-01-09 05:44:51 +01:00
LogManager . RemoveConsoleOutput ( ) ;
2013-03-07 06:34:00 +01:00
}
2017-08-16 08:43:41 +02:00
/// <summary>
/// Configures the autorun.
/// </summary>
private void ConfigureAutorun ( )
{
try
{
ConfigureAutoRunAtStartup ( ConfigurationManager . CommonConfiguration . RunAtStartup ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error configuring autorun" , ex ) ;
}
}
private IJsonSerializer CreateJsonSerializer ( )
2016-10-08 07:57:38 +02:00
{
2016-10-29 06:10:11 +02:00
try
{
// https://github.com/ServiceStack/ServiceStack/blob/master/tests/ServiceStack.WebHost.IntegrationTests/Web.config#L4
Licensing . RegisterLicense ( "1001-e1JlZjoxMDAxLE5hbWU6VGVzdCBCdXNpbmVzcyxUeXBlOkJ1c2luZXNzLEhhc2g6UHVNTVRPclhvT2ZIbjQ5MG5LZE1mUTd5RUMzQnBucTFEbTE3TDczVEF4QUNMT1FhNXJMOWkzVjFGL2ZkVTE3Q2pDNENqTkQyUktRWmhvUVBhYTBiekJGUUZ3ZE5aZHFDYm9hL3lydGlwUHI5K1JsaTBYbzNsUC85cjVJNHE5QVhldDN6QkE4aTlvdldrdTgyTk1relY2eis2dFFqTThYN2lmc0JveHgycFdjPSxFeHBpcnk6MjAxMy0wMS0wMX0=" ) ;
}
catch
{
// Failing under mono
}
2017-08-16 05:40:36 +02:00
return new JsonSerializer ( FileSystemManager , LogManager . GetLogger ( "JsonSerializer" ) ) ;
2016-10-08 07:57:38 +02:00
}
2017-08-16 08:43:41 +02:00
public async Task Init ( IProgress < double > progress )
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
progress . Report ( 1 ) ;
JsonSerializer = CreateJsonSerializer ( ) ;
OnLoggerLoaded ( true ) ;
LogManager . LoggerLoaded + = ( s , e ) = > OnLoggerLoaded ( false ) ;
IsFirstRun = ! ConfigurationManager . CommonConfiguration . IsStartupWizardCompleted ;
progress . Report ( 2 ) ;
LogManager . LogSeverity = ConfigurationManager . CommonConfiguration . EnableDebugLevelLogging
? LogSeverity . Debug
: LogSeverity . Info ;
progress . Report ( 3 ) ;
DiscoverTypes ( ) ;
progress . Report ( 14 ) ;
SetHttpLimit ( ) ;
progress . Report ( 15 ) ;
var innerProgress = new ActionableProgress < double > ( ) ;
innerProgress . RegisterAction ( p = > progress . Report ( . 8 * p + 15 ) ) ;
await RegisterResources ( innerProgress ) . ConfigureAwait ( false ) ;
FindParts ( ) ;
progress . Report ( 95 ) ;
await InstallIsoMounters ( CancellationToken . None ) . ConfigureAwait ( false ) ;
progress . Report ( 100 ) ;
}
protected virtual void OnLoggerLoaded ( bool isFirstLoad )
{
Logger . Info ( "Application version: {0}" , ApplicationVersion ) ;
if ( ! isFirstLoad )
{
LogEnvironmentInfo ( Logger , ApplicationPaths , false ) ;
}
// Put the app config in the log for troubleshooting purposes
Logger . LogMultiline ( "Application configuration:" , LogSeverity . Info , new StringBuilder ( JsonSerializer . SerializeToString ( ConfigurationManager . CommonConfiguration ) ) ) ;
if ( Plugins ! = null )
{
var pluginBuilder = new StringBuilder ( ) ;
foreach ( var plugin in Plugins )
{
pluginBuilder . AppendLine ( string . Format ( "{0} {1}" , plugin . Name , plugin . Version ) ) ;
}
Logger . LogMultiline ( "Plugins:" , LogSeverity . Info , pluginBuilder ) ;
}
2014-02-13 06:11:54 +01:00
}
2017-02-20 21:50:58 +01:00
protected abstract IConnectManager CreateConnectManager ( ) ;
2017-02-23 20:13:07 +01:00
protected abstract ISyncManager CreateSyncManager ( ) ;
2017-02-20 21:50:58 +01:00
2013-02-24 22:53:54 +01:00
/// <summary>
/// Registers resources that classes will depend on
/// </summary>
2017-08-16 08:43:41 +02:00
protected async Task RegisterResources ( IProgress < double > progress )
2013-02-24 22:53:54 +01:00
{
2017-08-16 08:43:41 +02:00
RegisterSingleInstance ( ConfigurationManager ) ;
RegisterSingleInstance < IApplicationHost > ( this ) ;
RegisterSingleInstance < IApplicationPaths > ( ApplicationPaths ) ;
RegisterSingleInstance ( JsonSerializer ) ;
RegisterSingleInstance ( MemoryStreamFactory ) ;
RegisterSingleInstance ( SystemEvents ) ;
RegisterSingleInstance ( LogManager ) ;
RegisterSingleInstance ( Logger ) ;
RegisterSingleInstance ( EnvironmentInfo ) ;
RegisterSingleInstance ( FileSystemManager ) ;
HttpClient = new HttpClientManager . HttpClientManager ( ApplicationPaths , LogManager . GetLogger ( "HttpClient" ) , FileSystemManager , MemoryStreamFactory , GetDefaultUserAgent ) ;
RegisterSingleInstance ( HttpClient ) ;
RegisterSingleInstance ( NetworkManager ) ;
IsoManager = new IsoManager ( ) ;
RegisterSingleInstance ( IsoManager ) ;
TaskManager = new TaskManager ( ApplicationPaths , JsonSerializer , LogManager . GetLogger ( "TaskManager" ) , FileSystemManager , SystemEvents ) ;
RegisterSingleInstance ( TaskManager ) ;
RegisterSingleInstance ( XmlSerializer ) ;
ProcessFactory = new ProcessFactory ( ) ;
RegisterSingleInstance ( ProcessFactory ) ;
TimerFactory = new TimerFactory ( ) ;
RegisterSingleInstance ( TimerFactory ) ;
RegisterSingleInstance ( CryptographyProvider ) ;
SocketFactory = new SocketFactory ( LogManager . GetLogger ( "SocketFactory" ) ) ;
RegisterSingleInstance ( SocketFactory ) ;
2013-02-26 04:43:04 +01:00
2016-11-09 05:58:58 +01:00
RegisterSingleInstance ( PowerManagement ) ;
2016-11-04 09:43:59 +01:00
SecurityManager = new PluginSecurityManager ( this , HttpClient , JsonSerializer , ApplicationPaths , LogManager , FileSystemManager , CryptographyProvider ) ;
2016-10-29 07:40:15 +02:00
RegisterSingleInstance ( SecurityManager ) ;
2016-11-02 21:53:50 +01:00
InstallationManager = new InstallationManager ( LogManager . GetLogger ( "InstallationManager" ) , this , ApplicationPaths , HttpClient , JsonSerializer , SecurityManager , ConfigurationManager , FileSystemManager , CryptographyProvider ) ;
2016-10-29 07:40:15 +02:00
RegisterSingleInstance ( InstallationManager ) ;
2016-10-28 20:35:17 +02:00
ZipClient = new ZipClient ( FileSystemManager ) ;
RegisterSingleInstance ( ZipClient ) ;
2016-11-12 07:58:50 +01:00
RegisterSingleInstance < IHttpResultFactory > ( new HttpResultFactory ( LogManager , FileSystemManager , JsonSerializer , MemoryStreamFactory ) ) ;
2013-03-15 05:23:07 +01:00
2013-03-07 06:34:00 +01:00
RegisterSingleInstance < IServerApplicationHost > ( this ) ;
2013-03-04 06:43:06 +01:00
RegisterSingleInstance < IServerApplicationPaths > ( ApplicationPaths ) ;
2013-03-07 06:34:00 +01:00
2013-03-04 06:43:06 +01:00
RegisterSingleInstance ( ServerConfigurationManager ) ;
2015-02-28 19:47:05 +01:00
2016-11-05 03:17:18 +01:00
IAssemblyInfo assemblyInfo = new AssemblyInfo ( ) ;
RegisterSingleInstance < IAssemblyInfo > ( assemblyInfo ) ;
LocalizationManager = new LocalizationManager ( ServerConfigurationManager , FileSystemManager , JsonSerializer , LogManager . GetLogger ( "LocalizationManager" ) , assemblyInfo , new TextLocalizer ( ) ) ;
2016-10-25 21:02:04 +02:00
StringExtensions . LocalizationManager = LocalizationManager ;
2014-03-31 03:00:47 +02:00
RegisterSingleInstance ( LocalizationManager ) ;
2017-08-16 08:43:41 +02:00
ITextEncoding textEncoding = new TextEncoding . TextEncoding ( FileSystemManager , LogManager . GetLogger ( "TextEncoding" ) , JsonSerializer ) ;
2016-10-30 08:11:37 +01:00
RegisterSingleInstance ( textEncoding ) ;
Utilities . EncodingHelper = textEncoding ;
RegisterSingleInstance < IBlurayExaminer > ( ( ) = > new BdInfoExaminer ( FileSystemManager , textEncoding ) ) ;
2013-03-08 06:08:27 +01:00
2016-10-26 04:53:47 +02:00
RegisterSingleInstance < IXmlReaderSettingsFactory > ( new XmlReaderSettingsFactory ( ) ) ;
2014-12-26 18:45:06 +01:00
UserDataManager = new UserDataManager ( LogManager , ServerConfigurationManager ) ;
2013-10-02 18:08:58 +02:00
RegisterSingleInstance ( UserDataManager ) ;
2013-04-13 20:02:30 +02:00
2016-11-18 19:28:45 +01:00
UserRepository = GetUserRepository ( ) ;
2016-12-17 09:27:41 +01:00
// This is only needed for disposal purposes. If removing this, make sure to have the manager handle disposing it
RegisterSingleInstance ( UserRepository ) ;
2016-10-08 07:57:38 +02:00
2016-11-18 10:28:39 +01:00
var displayPreferencesRepo = new SqliteDisplayPreferencesRepository ( LogManager . GetLogger ( "SqliteDisplayPreferencesRepository" ) , JsonSerializer , ApplicationPaths , MemoryStreamFactory ) ;
2016-05-01 23:48:37 +02:00
DisplayPreferencesRepository = displayPreferencesRepo ;
2013-04-19 22:27:02 +02:00
RegisterSingleInstance ( DisplayPreferencesRepository ) ;
2016-11-27 20:36:56 +01:00
var itemRepo = new SqliteItemRepository ( ServerConfigurationManager , JsonSerializer , LogManager . GetLogger ( "SqliteItemRepository" ) , MemoryStreamFactory , assemblyInfo , FileSystemManager , EnvironmentInfo , TimerFactory ) ;
2016-05-01 23:48:37 +02:00
ItemRepository = itemRepo ;
2013-04-19 22:27:02 +02:00
RegisterSingleInstance ( ItemRepository ) ;
2017-05-26 08:48:54 +02:00
AuthenticationRepository = GetAuthenticationRepository ( ) ;
2014-07-08 03:41:03 +02:00
RegisterSingleInstance ( AuthenticationRepository ) ;
2016-11-11 18:33:10 +01:00
UserManager = new UserManager ( LogManager . GetLogger ( "UserManager" ) , ServerConfigurationManager , UserRepository , XmlSerializer , NetworkManager , ( ) = > ImageProcessor , ( ) = > DtoService , ( ) = > ConnectManager , this , JsonSerializer , FileSystemManager , CryptographyProvider , _defaultUserNameFactory ( ) ) ;
2013-04-14 05:05:19 +02:00
RegisterSingleInstance ( UserManager ) ;
2015-12-29 04:45:56 +01:00
LibraryManager = new LibraryManager ( Logger , TaskManager , UserManager , ServerConfigurationManager , UserDataManager , ( ) = > LibraryMonitor , FileSystemManager , ( ) = > ProviderManager , ( ) = > UserViewManager ) ;
2013-03-08 06:08:27 +01:00
RegisterSingleInstance ( LibraryManager ) ;
2013-03-05 05:25:27 +01:00
2014-04-02 23:55:19 +02:00
var musicManager = new MusicManager ( LibraryManager ) ;
2014-03-30 18:49:40 +02:00
RegisterSingleInstance < IMusicManager > ( new MusicManager ( LibraryManager ) ) ;
2016-11-04 20:51:59 +01:00
LibraryMonitor = new LibraryMonitor ( LogManager , TaskManager , LibraryManager , ServerConfigurationManager , FileSystemManager , TimerFactory , SystemEvents , EnvironmentInfo ) ;
2014-01-28 22:25:10 +01:00
RegisterSingleInstance ( LibraryMonitor ) ;
2013-03-08 06:08:27 +01:00
2016-11-11 18:33:10 +01:00
ProviderManager = new ProviderManager ( HttpClient , ServerConfigurationManager , LibraryMonitor , LogManager , FileSystemManager , ApplicationPaths , ( ) = > LibraryManager , JsonSerializer , MemoryStreamFactory ) ;
2013-03-08 06:08:27 +01:00
RegisterSingleInstance ( ProviderManager ) ;
2014-01-07 21:12:39 +01:00
RegisterSingleInstance < ISearchEngine > ( ( ) = > new SearchEngine ( LogManager , LibraryManager , UserManager ) ) ;
2013-04-05 21:34:33 +02:00
2017-05-01 04:22:13 +02:00
CertificateInfo = GetCertificateInfo ( true ) ;
Certificate = GetCertificate ( CertificateInfo ) ;
2016-11-12 07:58:50 +01:00
2017-03-12 20:27:26 +01:00
HttpServer = HttpServerFactory . CreateServer ( this , LogManager , ServerConfigurationManager , NetworkManager , MemoryStreamFactory , "Emby" , "web/index.html" , textEncoding , SocketFactory , CryptographyProvider , JsonSerializer , XmlSerializer , EnvironmentInfo , Certificate , FileSystemManager , SupportsDualModeSockets ) ;
2015-09-14 01:07:54 +02:00
HttpServer . GlobalResponse = LocalizationManager . GetLocalizedString ( "StartupEmbyServerIsLoading" ) ;
2013-04-08 18:45:40 +02:00
RegisterSingleInstance ( HttpServer , false ) ;
2013-12-13 16:48:35 +01:00
progress . Report ( 10 ) ;
2013-04-08 18:45:40 +02:00
2017-08-09 21:56:38 +02:00
ServerManager = new ServerManager . ServerManager ( this , JsonSerializer , LogManager . GetLogger ( "ServerManager" ) , ServerConfigurationManager , MemoryStreamFactory , textEncoding ) ;
2013-04-08 17:55:53 +02:00
RegisterSingleInstance ( ServerManager ) ;
2014-03-28 04:32:43 +01:00
var innerProgress = new ActionableProgress < double > ( ) ;
innerProgress . RegisterAction ( p = > progress . Report ( ( . 75 * p ) + 15 ) ) ;
2015-04-29 19:39:23 +02:00
ImageProcessor = GetImageProcessor ( ) ;
2013-09-18 20:49:06 +02:00
RegisterSingleInstance ( ImageProcessor ) ;
2016-07-01 17:51:35 +02:00
TVSeriesManager = new TVSeriesManager ( UserManager , UserDataManager , LibraryManager , ServerConfigurationManager ) ;
2014-12-30 17:36:49 +01:00
RegisterSingleInstance ( TVSeriesManager ) ;
2017-02-23 20:13:07 +01:00
SyncManager = CreateSyncManager ( ) ;
2014-07-22 18:36:34 +02:00
RegisterSingleInstance ( SyncManager ) ;
2015-05-31 20:22:51 +02:00
DtoService = new DtoService ( LogManager . GetLogger ( "DtoService" ) , LibraryManager , UserDataManager , ItemRepository , ImageProcessor , ServerConfigurationManager , FileSystemManager , ProviderManager , ( ) = > ChannelManager , SyncManager , this , ( ) = > DeviceManager , ( ) = > MediaSourceManager , ( ) = > LiveTvManager ) ;
2013-09-04 19:02:19 +02:00
RegisterSingleInstance ( DtoService ) ;
2014-01-18 22:52:01 +01:00
2014-08-25 05:54:45 +02:00
var encryptionManager = new EncryptionManager ( ) ;
RegisterSingleInstance < IEncryptionManager > ( encryptionManager ) ;
2017-02-20 21:50:58 +01:00
ConnectManager = CreateConnectManager ( ) ;
2014-08-25 05:54:45 +02:00
RegisterSingleInstance ( ConnectManager ) ;
2015-12-29 04:45:56 +01:00
DeviceManager = new DeviceManager ( new DeviceRepository ( ApplicationPaths , JsonSerializer , LogManager . GetLogger ( "DeviceManager" ) , FileSystemManager ) , UserManager , FileSystemManager , LibraryMonitor , ServerConfigurationManager , LogManager . GetLogger ( "DeviceManager" ) , NetworkManager ) ;
2014-10-11 22:38:13 +02:00
RegisterSingleInstance ( DeviceManager ) ;
2016-11-02 21:53:50 +01:00
var newsService = new Emby . Server . Implementations . News . NewsService ( ApplicationPaths , JsonSerializer ) ;
2014-01-18 22:52:01 +01:00
RegisterSingleInstance < INewsService > ( newsService ) ;
2013-12-13 16:48:35 +01:00
progress . Report ( 15 ) ;
2015-10-17 17:05:12 +02:00
ChannelManager = new ChannelManager ( UserManager , DtoService , LibraryManager , LogManager . GetLogger ( "ChannelManager" ) , ServerConfigurationManager , FileSystemManager , UserDataManager , JsonSerializer , LocalizationManager , HttpClient , ProviderManager ) ;
2014-03-18 18:05:57 +01:00
RegisterSingleInstance ( ChannelManager ) ;
2014-03-18 02:45:41 +01:00
2016-11-03 07:37:52 +01:00
MediaSourceManager = new MediaSourceManager ( ItemRepository , UserManager , LibraryManager , LogManager . GetLogger ( "MediaSourceManager" ) , JsonSerializer , FileSystemManager , UserDataManager , TimerFactory ) ;
2015-03-07 23:43:53 +01:00
RegisterSingleInstance ( MediaSourceManager ) ;
2016-11-04 00:35:19 +01:00
SessionManager = new SessionManager ( UserDataManager , LogManager . GetLogger ( "SessionManager" ) , LibraryManager , UserManager , musicManager , DtoService , ImageProcessor , JsonSerializer , this , HttpClient , AuthenticationRepository , DeviceManager , MediaSourceManager , TimerFactory ) ;
2015-03-08 19:11:53 +01:00
RegisterSingleInstance ( SessionManager ) ;
2016-11-04 09:31:05 +01:00
var dlnaManager = new DlnaManager ( XmlSerializer , FileSystemManager , ApplicationPaths , LogManager . GetLogger ( "Dlna" ) , JsonSerializer , this , assemblyInfo ) ;
2014-03-13 20:08:02 +01:00
RegisterSingleInstance < IDlnaManager > ( dlnaManager ) ;
2016-11-04 09:31:05 +01:00
var connectionManager = new ConnectionManager ( dlnaManager , ServerConfigurationManager , LogManager . GetLogger ( "UpnpConnectionManager" ) , HttpClient , new XmlReaderSettingsFactory ( ) ) ;
2014-05-21 02:56:24 +02:00
RegisterSingleInstance < IConnectionManager > ( connectionManager ) ;
2015-09-29 18:29:06 +02:00
CollectionManager = new CollectionManager ( LibraryManager , FileSystemManager , LibraryMonitor , LogManager . GetLogger ( "CollectionManager" ) , ProviderManager ) ;
2014-10-08 03:37:45 +02:00
RegisterSingleInstance ( CollectionManager ) ;
2014-03-07 16:53:23 +01:00
2015-07-24 17:20:11 +02:00
PlaylistManager = new PlaylistManager ( LibraryManager , FileSystemManager , LibraryMonitor , LogManager . GetLogger ( "PlaylistManager" ) , UserManager , ProviderManager ) ;
2015-03-14 05:50:23 +01:00
RegisterSingleInstance < IPlaylistManager > ( PlaylistManager ) ;
2014-08-02 04:34:45 +02:00
2016-09-06 07:02:05 +02:00
LiveTvManager = new LiveTvManager ( this , ServerConfigurationManager , Logger , ItemRepository , ImageProcessor , UserDataManager , DtoService , UserManager , LibraryManager , TaskManager , LocalizationManager , JsonSerializer , ProviderManager , FileSystemManager , SecurityManager ) ;
2014-01-12 07:31:21 +01:00
RegisterSingleInstance ( LiveTvManager ) ;
2015-10-05 00:04:56 +02:00
UserViewManager = new UserViewManager ( LibraryManager , LocalizationManager , UserManager , ChannelManager , LiveTvManager , ServerConfigurationManager ) ;
2014-06-07 21:46:24 +02:00
RegisterSingleInstance ( UserViewManager ) ;
2017-08-02 09:30:17 +02:00
var contentDirectory = new ContentDirectory ( dlnaManager , UserDataManager , ImageProcessor , LibraryManager , ServerConfigurationManager , UserManager , LogManager . GetLogger ( "UpnpContentDirectory" ) , HttpClient , LocalizationManager , ChannelManager , MediaSourceManager , UserViewManager , ( ) = > MediaEncoder , new XmlReaderSettingsFactory ( ) , TVSeriesManager ) ;
2014-07-30 05:31:35 +02:00
RegisterSingleInstance < IContentDirectory > ( contentDirectory ) ;
2016-11-04 09:31:05 +01:00
var mediaRegistrar = new MediaReceiverRegistrar ( LogManager . GetLogger ( "MediaReceiverRegistrar" ) , HttpClient , ServerConfigurationManager , new XmlReaderSettingsFactory ( ) ) ;
2015-01-30 18:58:38 +01:00
RegisterSingleInstance < IMediaReceiverRegistrar > ( mediaRegistrar ) ;
2014-04-27 05:42:05 +02:00
NotificationManager = new NotificationManager ( LogManager , UserManager , ServerConfigurationManager ) ;
2014-04-25 22:15:50 +02:00
RegisterSingleInstance ( NotificationManager ) ;
2015-02-07 22:03:09 +01:00
SubtitleManager = new SubtitleManager ( LogManager . GetLogger ( "SubtitleManager" ) , FileSystemManager , LibraryMonitor , LibraryManager , MediaSourceManager ) ;
2014-05-07 04:28:19 +02:00
RegisterSingleInstance ( SubtitleManager ) ;
2016-11-04 09:31:05 +01:00
RegisterSingleInstance < IDeviceDiscovery > ( new DeviceDiscovery ( LogManager . GetLogger ( "IDeviceDiscovery" ) , ServerConfigurationManager , SocketFactory , TimerFactory ) ) ;
2015-07-23 18:32:34 +02:00
2014-06-10 19:36:06 +02:00
ChapterManager = new ChapterManager ( LibraryManager , LogManager . GetLogger ( "ChapterManager" ) , ServerConfigurationManager , ItemRepository ) ;
2014-06-09 21:16:14 +02:00
RegisterSingleInstance ( ChapterManager ) ;
2015-01-02 06:36:27 +01:00
await RegisterMediaEncoder ( innerProgress ) . ConfigureAwait ( false ) ;
progress . Report ( 90 ) ;
2016-08-30 08:06:24 +02:00
EncodingManager = new EncodingManager ( FileSystemManager , Logger , MediaEncoder , ChapterManager , LibraryManager ) ;
2014-06-10 19:36:06 +02:00
RegisterSingleInstance ( EncodingManager ) ;
2016-11-18 09:39:20 +01:00
var sharingRepo = new SharingRepository ( LogManager . GetLogger ( "SharingRepository" ) , ApplicationPaths ) ;
sharingRepo . Initialize ( ) ;
2016-12-17 09:27:41 +01:00
// This is only needed for disposal purposes. If removing this, make sure to have the manager handle disposing it
RegisterSingleInstance < ISharingRepository > ( sharingRepo ) ;
2015-07-01 01:59:45 +02:00
RegisterSingleInstance < ISharingManager > ( new SharingManager ( sharingRepo , ServerConfigurationManager , LibraryManager , this ) ) ;
2015-08-10 19:37:50 +02:00
2016-11-18 09:39:20 +01:00
var activityLogRepo = GetActivityLogRepository ( ) ;
2014-08-11 00:13:17 +02:00
RegisterSingleInstance ( activityLogRepo ) ;
2014-10-02 02:28:16 +02:00
RegisterSingleInstance < IActivityManager > ( new ActivityManager ( LogManager . GetLogger ( "ActivityManager" ) , activityLogRepo , UserManager ) ) ;
2014-08-11 00:13:17 +02:00
2015-04-04 02:41:16 +02:00
var authContext = new AuthorizationContext ( AuthenticationRepository , ConnectManager ) ;
2014-07-02 06:57:18 +02:00
RegisterSingleInstance < IAuthorizationContext > ( authContext ) ;
RegisterSingleInstance < ISessionContext > ( new SessionContext ( UserManager , authContext , SessionManager ) ) ;
2016-11-08 19:44:23 +01:00
AuthService = new AuthService ( UserManager , authContext , ServerConfigurationManager , ConnectManager , SessionManager , DeviceManager ) ;
RegisterSingleInstance < IAuthService > ( AuthService ) ;
2014-07-02 06:57:18 +02:00
2016-11-11 18:33:10 +01:00
SubtitleEncoder = new SubtitleEncoder ( LibraryManager , LogManager . GetLogger ( "SubtitleEncoder" ) , ApplicationPaths , FileSystemManager , MediaEncoder , JsonSerializer , HttpClient , MediaSourceManager , MemoryStreamFactory , ProcessFactory , textEncoding ) ;
2015-01-02 07:12:58 +01:00
RegisterSingleInstance ( SubtitleEncoder ) ;
2016-06-04 07:51:33 +02:00
2016-11-18 10:28:39 +01:00
displayPreferencesRepo . Initialize ( ) ;
2016-06-24 08:32:51 +02:00
2016-11-21 21:22:43 +01:00
var userDataRepo = new SqliteUserDataRepository ( LogManager . GetLogger ( "SqliteUserDataRepository" ) , ApplicationPaths , FileSystemManager ) ;
2016-06-24 08:32:51 +02:00
( ( UserDataManager ) UserDataManager ) . Repository = userDataRepo ;
2016-11-20 10:46:07 +01:00
itemRepo . Initialize ( userDataRepo ) ;
2016-05-01 23:48:37 +02:00
( ( LibraryManager ) LibraryManager ) . ItemRepository = ItemRepository ;
2016-11-18 09:39:20 +01:00
ConfigureNotificationsRepository ( ) ;
2013-12-13 16:48:35 +01:00
progress . Report ( 100 ) ;
2013-04-08 17:55:53 +02:00
2014-02-22 22:05:56 +01:00
SetStaticProperties ( ) ;
2015-01-20 22:32:48 +01:00
await ( ( UserManager ) UserManager ) . Initialize ( ) . ConfigureAwait ( false ) ;
2013-03-08 06:08:27 +01:00
}
2017-08-16 08:43:41 +02:00
public static void LogEnvironmentInfo ( ILogger logger , IApplicationPaths appPaths , bool isStartup )
{
logger . LogMultiline ( "Emby" , LogSeverity . Info , GetBaseExceptionMessage ( appPaths ) ) ;
}
protected static StringBuilder GetBaseExceptionMessage ( IApplicationPaths appPaths )
{
var builder = new StringBuilder ( ) ;
builder . AppendLine ( string . Format ( "Command line: {0}" , string . Join ( " " , Environment . GetCommandLineArgs ( ) ) ) ) ;
builder . AppendLine ( string . Format ( "Operating system: {0}" , Environment . OSVersion ) ) ;
builder . AppendLine ( string . Format ( "64-Bit OS: {0}" , Environment . Is64BitOperatingSystem ) ) ;
builder . AppendLine ( string . Format ( "64-Bit Process: {0}" , Environment . Is64BitProcess ) ) ;
Type type = Type . GetType ( "Mono.Runtime" ) ;
if ( type ! = null )
{
MethodInfo displayName = type . GetMethod ( "GetDisplayName" , BindingFlags . NonPublic | BindingFlags . Static ) ;
if ( displayName ! = null )
{
builder . AppendLine ( "Mono: " + displayName . Invoke ( null , null ) ) ;
}
}
builder . AppendLine ( string . Format ( "Processor count: {0}" , Environment . ProcessorCount ) ) ;
builder . AppendLine ( string . Format ( "Program data path: {0}" , appPaths . ProgramDataPath ) ) ;
builder . AppendLine ( string . Format ( "Application directory: {0}" , appPaths . ProgramSystemPath ) ) ;
return builder ;
}
private void SetHttpLimit ( )
{
try
{
// Increase the max http request limit
ServicePointManager . DefaultConnectionLimit = Math . Max ( 96 , ServicePointManager . DefaultConnectionLimit ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error setting http limit" , ex ) ;
}
}
/// <summary>
/// Installs the iso mounters.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
private async Task InstallIsoMounters ( CancellationToken cancellationToken )
{
var list = new List < IIsoMounter > ( ) ;
foreach ( var isoMounter in GetExports < IIsoMounter > ( ) )
{
try
{
if ( isoMounter . RequiresInstallation & & ! isoMounter . IsInstalled )
{
Logger . Info ( "Installing {0}" , isoMounter . Name ) ;
await isoMounter . Install ( cancellationToken ) . ConfigureAwait ( false ) ;
}
list . Add ( isoMounter ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "{0} failed to load." , ex , isoMounter . Name ) ;
}
}
IsoManager . AddParts ( list ) ;
}
private string GetDefaultUserAgent ( )
{
var name = FormatAttribute ( Name ) ;
return name + "/" + ApplicationVersion ;
}
private string FormatAttribute ( string str )
{
var arr = str . ToCharArray ( ) ;
arr = Array . FindAll < char > ( arr , ( c = > ( char . IsLetterOrDigit ( c )
| | char . IsWhiteSpace ( c ) ) ) ) ;
var result = new string ( arr ) ;
if ( string . IsNullOrWhiteSpace ( result ) )
{
result = "Emby" ;
}
return result ;
}
2017-02-19 04:46:09 +01:00
protected virtual bool SupportsDualModeSockets
{
get
{
return true ;
}
}
2016-11-19 06:52:49 +01:00
2017-05-01 04:22:13 +02:00
private ICertificate GetCertificate ( CertificateInfo info )
2016-11-11 04:29:51 +01:00
{
2017-05-01 04:22:13 +02:00
var certificateLocation = info = = null ? null : info . Path ;
2016-11-11 04:29:51 +01:00
if ( string . IsNullOrWhiteSpace ( certificateLocation ) )
{
return null ;
}
try
{
2016-11-13 22:04:21 +01:00
if ( ! FileSystemManager . FileExists ( certificateLocation ) )
{
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 ;
X509Certificate2 localCert = new X509Certificate2 ( certificateLocation , password ) ;
2016-11-11 04:29:51 +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
{
//throw new FileNotFoundException("Secure requested, no private key included", certificateLocation);
return null ;
}
return new Certificate ( localCert ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error loading cert from {0}" , ex , certificateLocation ) ;
return null ;
}
}
2015-04-29 19:39:23 +02:00
private IImageProcessor GetImageProcessor ( )
{
2017-05-12 20:09:42 +02:00
return new ImageProcessor ( LogManager . GetLogger ( "ImageProcessor" ) , ServerConfigurationManager . ApplicationPaths , FileSystemManager , JsonSerializer , ImageEncoder , ( ) = > LibraryManager , TimerFactory ) ;
2013-10-05 19:13:32 +02:00
}
2017-02-19 04:46:09 +01:00
protected virtual FFMpegInstallInfo GetFfmpegInstallInfo ( )
{
var info = new FFMpegInstallInfo ( ) ;
// Windows builds: http://ffmpeg.zeranoe.com/builds/
// Linux builds: http://johnvansickle.com/ffmpeg/
// OS X builds: http://ffmpegmac.net/
// OS X x64: http://www.evermeet.cx/ffmpeg/
if ( EnvironmentInfo . OperatingSystem = = MediaBrowser . Model . System . OperatingSystem . Linux )
{
info . FFMpegFilename = "ffmpeg" ;
info . FFProbeFilename = "ffprobe" ;
info . ArchiveType = "7z" ;
2017-03-10 19:33:17 +01:00
info . Version = "20170308" ;
2017-02-19 04:46:09 +01:00
info . DownloadUrls = GetLinuxDownloadUrls ( ) ;
}
else if ( EnvironmentInfo . OperatingSystem = = MediaBrowser . Model . System . OperatingSystem . Windows )
{
info . FFMpegFilename = "ffmpeg.exe" ;
info . FFProbeFilename = "ffprobe.exe" ;
2017-03-10 19:33:17 +01:00
info . Version = "20170308" ;
2017-02-19 04:46:09 +01:00
info . ArchiveType = "7z" ;
info . DownloadUrls = GetWindowsDownloadUrls ( ) ;
}
2017-03-10 19:33:17 +01:00
else if ( EnvironmentInfo . OperatingSystem = = MediaBrowser . Model . System . OperatingSystem . OSX )
{
info . FFMpegFilename = "ffmpeg" ;
info . FFProbeFilename = "ffprobe" ;
info . ArchiveType = "7z" ;
info . Version = "20170308" ;
info . DownloadUrls = GetMacDownloadUrls ( ) ;
}
2017-02-20 22:00:36 +01:00
else
{
// No version available - user requirement
info . DownloadUrls = new string [ ] { } ;
}
2017-02-19 04:46:09 +01:00
return info ;
}
2017-03-10 19:33:17 +01:00
private string [ ] GetMacDownloadUrls ( )
{
switch ( EnvironmentInfo . SystemArchitecture )
{
case Architecture . X64 :
return new [ ]
{
"https://embydata.com/downloads/ffmpeg/osx/ffmpeg-x64-20170308.7z"
} ;
}
return new string [ ] { } ;
}
2017-02-19 04:46:09 +01:00
private string [ ] GetWindowsDownloadUrls ( )
{
switch ( EnvironmentInfo . SystemArchitecture )
{
case Architecture . X64 :
return new [ ]
{
2017-03-10 19:33:17 +01:00
"https://embydata.com/downloads/ffmpeg/windows/ffmpeg-20170308-win64.7z"
2017-02-19 04:46:09 +01:00
} ;
case Architecture . X86 :
return new [ ]
{
2017-03-10 19:33:17 +01:00
"https://embydata.com/downloads/ffmpeg/windows/ffmpeg-20170308-win32.7z"
2017-02-19 04:46:09 +01:00
} ;
}
return new string [ ] { } ;
}
private string [ ] GetLinuxDownloadUrls ( )
{
switch ( EnvironmentInfo . SystemArchitecture )
{
case Architecture . X64 :
return new [ ]
{
2017-03-10 19:33:17 +01:00
"https://embydata.com/downloads/ffmpeg/linux/ffmpeg-git-20170301-64bit-static.7z"
2017-02-19 04:46:09 +01:00
} ;
case Architecture . X86 :
return new [ ]
{
2017-03-10 19:33:17 +01:00
"https://embydata.com/downloads/ffmpeg/linux/ffmpeg-git-20170301-32bit-static.7z"
2017-02-19 04:46:09 +01:00
} ;
}
return new string [ ] { } ;
}
2016-11-13 05:33:51 +01:00
2013-09-23 17:37:50 +02:00
/// <summary>
/// Registers the media encoder.
/// </summary>
/// <returns>Task.</returns>
2013-12-13 16:48:35 +01:00
private async Task RegisterMediaEncoder ( IProgress < double > progress )
2013-09-23 17:37:50 +02:00
{
2016-06-23 19:04:18 +02:00
string encoderPath = null ;
string probePath = null ;
2016-11-13 05:33:51 +01:00
var info = await new FFMpegLoader ( Logger , ApplicationPaths , HttpClient , ZipClient , FileSystemManager , GetFfmpegInstallInfo ( ) )
. GetFFMpegInfo ( StartupOptions , progress ) . ConfigureAwait ( false ) ;
2013-09-23 17:37:50 +02:00
2016-06-23 19:04:18 +02:00
encoderPath = info . EncoderPath ;
probePath = info . ProbePath ;
2016-06-29 07:49:31 +02:00
var hasExternalEncoder = string . Equals ( info . Version , "external" , StringComparison . OrdinalIgnoreCase ) ;
2016-06-20 08:19:28 +02:00
2017-08-09 21:56:38 +02:00
var mediaEncoder = new MediaEncoding . Encoder . MediaEncoder ( LogManager . GetLogger ( "MediaEncoder" ) ,
2015-01-19 05:29:57 +01:00
JsonSerializer ,
2016-06-23 19:04:18 +02:00
encoderPath ,
probePath ,
2016-06-29 07:49:31 +02:00
hasExternalEncoder ,
2015-01-02 06:36:27 +01:00
ServerConfigurationManager ,
FileSystemManager ,
LiveTvManager ,
IsoManager ,
LibraryManager ,
ChannelManager ,
2015-01-02 07:12:58 +01:00
SessionManager ,
2015-03-08 05:44:31 +01:00
( ) = > SubtitleEncoder ,
2016-07-03 04:47:39 +02:00
( ) = > MediaSourceManager ,
HttpClient ,
2016-11-18 09:39:20 +01:00
ZipClient ,
2016-11-11 18:33:10 +01:00
MemoryStreamFactory ,
2016-11-01 05:07:12 +01:00
ProcessFactory ,
2016-11-11 18:33:10 +01:00
( Environment . ProcessorCount > 2 ? 14000 : 40000 ) ,
2016-11-29 20:13:20 +01:00
EnvironmentInfo . OperatingSystem = = MediaBrowser . Model . System . OperatingSystem . Windows ,
EnvironmentInfo ) ;
2015-09-18 05:08:45 +02:00
MediaEncoder = mediaEncoder ;
2013-09-23 17:37:50 +02:00
RegisterSingleInstance ( MediaEncoder ) ;
}
2013-10-01 00:18:44 +02:00
/// <summary>
/// Gets the user repository.
/// </summary>
/// <returns>Task{IUserRepository}.</returns>
2016-11-18 19:28:45 +01:00
private IUserRepository GetUserRepository ( )
2013-08-10 02:46:34 +02:00
{
2016-11-18 19:28:45 +01:00
var repo = new SqliteUserRepository ( LogManager . GetLogger ( "SqliteUserRepository" ) , ApplicationPaths , JsonSerializer , MemoryStreamFactory ) ;
2013-08-10 02:46:34 +02:00
2016-11-18 19:28:45 +01:00
repo . Initialize ( ) ;
2013-08-18 21:44:38 +02:00
2016-10-07 17:08:13 +02:00
return repo ;
2014-01-20 17:09:53 +01:00
}
2017-05-26 08:48:54 +02:00
private IAuthenticationRepository GetAuthenticationRepository ( )
2014-07-08 03:41:03 +02:00
{
2016-11-18 10:28:39 +01:00
var repo = new AuthenticationRepository ( LogManager . GetLogger ( "AuthenticationRepository" ) , ServerConfigurationManager . ApplicationPaths ) ;
2014-07-08 03:41:03 +02:00
2016-11-18 10:28:39 +01:00
repo . Initialize ( ) ;
2014-07-08 03:41:03 +02:00
return repo ;
}
2016-11-18 09:39:20 +01:00
private IActivityRepository GetActivityLogRepository ( )
2014-08-11 00:13:17 +02:00
{
2016-11-18 09:39:20 +01:00
var repo = new ActivityRepository ( LogManager . GetLogger ( "ActivityRepository" ) , ServerConfigurationManager . ApplicationPaths ) ;
2014-08-11 00:13:17 +02:00
2016-11-18 09:39:20 +01:00
repo . Initialize ( ) ;
2014-08-11 00:13:17 +02:00
return repo ;
}
2013-07-06 23:23:32 +02:00
/// <summary>
/// Configures the repositories.
/// </summary>
2016-11-18 09:39:20 +01:00
private void ConfigureNotificationsRepository ( )
2013-07-06 23:23:32 +02:00
{
2017-02-17 22:11:13 +01:00
var repo = new SqliteNotificationsRepository ( LogManager . GetLogger ( "SqliteNotificationsRepository" ) , ServerConfigurationManager . ApplicationPaths , FileSystemManager ) ;
2013-07-06 23:23:32 +02:00
2016-11-18 09:39:20 +01:00
repo . Initialize ( ) ;
2013-07-06 23:23:32 +02:00
NotificationsRepository = repo ;
RegisterSingleInstance ( NotificationsRepository ) ;
}
2013-09-05 19:26:03 +02:00
2013-03-08 06:08:27 +01:00
/// <summary>
/// Dirty hacks
/// </summary>
private void SetStaticProperties ( )
{
// For now there's no real way to inject these properly
BaseItem . Logger = LogManager . GetLogger ( "BaseItem" ) ;
BaseItem . ConfigurationManager = ServerConfigurationManager ;
BaseItem . LibraryManager = LibraryManager ;
BaseItem . ProviderManager = ProviderManager ;
2013-06-10 19:46:11 +02:00
BaseItem . LocalizationManager = LocalizationManager ;
2013-06-20 18:44:24 +02:00
BaseItem . ItemRepository = ItemRepository ;
2013-03-08 06:08:27 +01:00
User . XmlSerializer = XmlSerializer ;
User . UserManager = UserManager ;
2013-10-06 03:04:41 +02:00
Folder . UserManager = UserManager ;
2013-10-30 16:07:30 +01:00
BaseItem . FileSystem = FileSystemManager ;
2014-01-16 18:23:30 +01:00
BaseItem . UserDataManager = UserDataManager ;
2014-09-01 22:10:54 +02:00
BaseItem . ChannelManager = ChannelManager ;
2014-08-14 15:24:30 +02:00
BaseItem . LiveTvManager = LiveTvManager ;
2014-09-01 22:10:54 +02:00
Folder . UserViewManager = UserViewManager ;
UserView . TVSeriesManager = TVSeriesManager ;
2015-03-14 05:50:23 +01:00
UserView . PlaylistManager = PlaylistManager ;
2014-10-08 03:37:45 +02:00
BaseItem . CollectionManager = CollectionManager ;
2015-02-07 22:03:09 +01:00
BaseItem . MediaSourceManager = MediaSourceManager ;
2016-08-13 07:49:00 +02:00
CollectionFolder . XmlSerializer = XmlSerializer ;
2016-10-28 00:54:56 +02:00
Utilities . CryptographyProvider = CryptographyProvider ;
2016-11-08 19:44:23 +01:00
AuthenticatedAttribute . AuthService = AuthService ;
2013-02-24 22:53:54 +01:00
}
2013-03-01 22:22:34 +01:00
/// <summary>
/// Finds the parts.
/// </summary>
2017-08-16 08:43:41 +02:00
protected 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
{
RegisterServerWithAdministratorAccess ( ) ;
2015-01-12 06:07:19 +01:00
ServerConfigurationManager . Configuration . IsPortAuthorized = true ;
ConfigurationManager . SaveConfiguration ( ) ;
2013-03-27 23:13:46 +01:00
}
2016-10-29 06:10:11 +02:00
RegisterModules ( ) ;
2017-08-16 08:43:41 +02:00
ConfigurationManager . AddParts ( GetExports < IConfigurationFactory > ( ) ) ;
Plugins = GetExports < IPlugin > ( ) . Select ( LoadPlugin ) . Where ( i = > i ! = null ) . ToArray ( ) ;
2013-03-15 05:23:07 +01:00
2016-10-26 08:01:42 +02:00
HttpServer . Init ( GetExports < IService > ( false ) ) ;
2013-04-08 17:55:53 +02:00
2013-05-17 17:29:22 +02:00
ServerManager . AddWebSocketListeners ( GetExports < IWebSocketListener > ( false ) ) ;
2013-03-08 06:08:27 +01:00
2014-12-27 23:52:41 +01:00
StartServer ( ) ;
2013-03-07 06:34:00 +01:00
2013-06-03 20:15:35 +02:00
LibraryManager . AddParts ( GetExports < IResolverIgnoreRule > ( ) ,
GetExports < IVirtualFolderCreator > ( ) ,
GetExports < IItemResolver > ( ) ,
GetExports < IIntroProvider > ( ) ,
GetExports < IBaseItemComparer > ( ) ,
2014-02-10 00:08:01 +01:00
GetExports < ILibraryPostScanTask > ( ) ) ;
2013-06-25 03:22:21 +02:00
2014-05-05 21:53:05 +02:00
ProviderManager . AddParts ( GetExports < IImageProvider > ( ) ,
GetExports < IMetadataService > ( ) ,
GetExports < IMetadataProvider > ( ) ,
GetExports < IMetadataSaver > ( ) ,
GetExports < IExternalId > ( ) ) ;
2013-08-10 03:40:52 +02:00
2013-09-20 02:53:18 +02:00
ImageProcessor . AddParts ( GetExports < IImageEnhancer > ( ) ) ;
2013-09-26 18:17:36 +02:00
2015-07-23 15:23:22 +02:00
LiveTvManager . AddParts ( GetExports < ILiveTvService > ( ) , GetExports < ITunerHost > ( ) , GetExports < IListingsProvider > ( ) ) ;
2013-12-25 15:39:46 +01:00
2014-05-07 04:28:19 +02:00
SubtitleManager . AddParts ( GetExports < ISubtitleProvider > ( ) ) ;
2014-06-11 16:42:03 +02:00
2013-12-25 15:39:46 +01:00
SessionManager . AddParts ( GetExports < ISessionControllerFactory > ( ) ) ;
2014-03-18 18:05:57 +01:00
2015-09-16 05:55:26 +02:00
ChannelManager . AddParts ( GetExports < IChannel > ( ) ) ;
2014-04-25 22:15:50 +02:00
2015-03-07 23:43:53 +01:00
MediaSourceManager . AddParts ( GetExports < IMediaSourceProvider > ( ) ) ;
2015-04-04 02:41:16 +02:00
2014-04-27 05:42:05 +02:00
NotificationManager . AddParts ( GetExports < INotificationService > ( ) , GetExports < INotificationTypeFactory > ( ) ) ;
2014-07-22 03:29:06 +02:00
SyncManager . AddParts ( GetExports < ISyncProvider > ( ) ) ;
2013-03-01 22:22:34 +01:00
}
2017-08-16 08:43:41 +02:00
private IPlugin LoadPlugin ( IPlugin plugin )
{
try
{
var assemblyPlugin = plugin as IPluginAssembly ;
if ( assemblyPlugin ! = null )
{
var assembly = plugin . GetType ( ) . Assembly ;
var assemblyName = assembly . GetName ( ) ;
var attribute = ( GuidAttribute ) assembly . GetCustomAttributes ( typeof ( GuidAttribute ) , true ) [ 0 ] ;
var assemblyId = new Guid ( attribute . Value ) ;
var assemblyFileName = assemblyName . Name + ".dll" ;
var assemblyFilePath = Path . Combine ( ApplicationPaths . PluginsPath , assemblyFileName ) ;
assemblyPlugin . SetAttributes ( assemblyFilePath , assemblyFileName , assemblyName . Version , assemblyId ) ;
}
var isFirstRun = ! File . Exists ( plugin . ConfigurationFilePath ) ;
plugin . SetStartupInfo ( isFirstRun , File . GetLastWriteTimeUtc , s = > Directory . CreateDirectory ( s ) ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error loading plugin {0}" , ex , plugin . GetType ( ) . FullName ) ;
return null ;
}
return plugin ;
}
/// <summary>
/// Discovers the types.
/// </summary>
protected void DiscoverTypes ( )
{
FailedAssemblies . Clear ( ) ;
var assemblies = GetComposablePartAssemblies ( ) . ToList ( ) ;
foreach ( var assembly in assemblies )
{
Logger . Info ( "Loading {0}" , assembly . FullName ) ;
}
AllConcreteTypes = assemblies
. SelectMany ( GetTypes )
. Where ( t = > t . IsClass & & ! t . IsAbstract & & ! t . IsInterface & & ! t . IsGenericType )
. ToArray ( ) ;
}
/// <summary>
/// Gets a list of types within an assembly
/// This will handle situations that would normally throw an exception - such as a type within the assembly that depends on some other non-existant reference
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <returns>IEnumerable{Type}.</returns>
/// <exception cref="System.ArgumentNullException">assembly</exception>
protected List < Type > GetTypes ( Assembly assembly )
{
if ( assembly = = null )
{
return new List < Type > ( ) ;
}
try
{
// This null checking really shouldn't be needed but adding it due to some
// unhandled exceptions in mono 5.0 that are a little hard to hunt down
var types = assembly . GetTypes ( ) ? ? new Type [ ] { } ;
return types . Where ( t = > t ! = null ) . ToList ( ) ;
}
catch ( ReflectionTypeLoadException ex )
{
if ( ex . LoaderExceptions ! = null )
{
foreach ( var loaderException in ex . LoaderExceptions )
{
if ( loaderException ! = null )
{
Logger . Error ( "LoaderException: " + loaderException . Message ) ;
}
}
}
// If it fails we can still get a list of the Types it was able to resolve
var types = ex . Types ? ? new Type [ ] { } ;
return types . Where ( t = > t ! = null ) . ToList ( ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error loading types from assembly" , ex ) ;
return new List < Type > ( ) ;
}
}
2017-05-01 04:22:13 +02:00
private CertificateInfo CertificateInfo { get ; set ; }
2016-11-11 04:29:51 +01:00
private ICertificate Certificate { get ; set ; }
2015-01-19 07:42:31 +01:00
2015-01-19 05:29:57 +01:00
private IEnumerable < string > GetUrlPrefixes ( )
{
2016-08-18 08:26:47 +02:00
var hosts = new List < string > ( ) ;
2016-06-07 18:21:46 +02:00
2016-08-18 08:26:47 +02:00
hosts . Add ( "+" ) ;
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 >
{
2016-09-21 20:28:33 +02: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 20:49:42 +02:00
/// <summary>
/// Starts the server.
/// </summary>
2014-12-27 23:52:41 +01:00
private void StartServer ( )
2015-01-19 08:12:01 +01:00
{
2016-09-21 19:07:18 +02:00
try
{
2016-11-11 04:29:51 +01:00
ServerManager . Start ( GetUrlPrefixes ( ) ) ;
2016-09-21 19:07:18 +02:00
return ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error starting http server" , ex ) ;
2016-11-09 05:58:58 +01:00
if ( HttpPort = = ServerConfiguration . DefaultHttpPort )
2016-09-21 19:07:18 +02:00
{
throw ;
}
}
2016-11-09 05:58:58 +01:00
HttpPort = ServerConfiguration . DefaultHttpPort ;
2016-09-21 19:07:18 +02:00
2015-01-19 08:12:01 +01:00
try
{
2016-11-11 04:29:51 +01:00
ServerManager . Start ( GetUrlPrefixes ( ) ) ;
2015-01-19 08:12:01 +01:00
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error starting http server" , ex ) ;
throw ;
}
}
2017-05-01 04:22:13 +02:00
private CertificateInfo GetCertificateInfo ( bool generateCertificate )
2013-05-07 20:49:42 +02:00
{
2015-01-23 07:15:15 +01:00
if ( ! string . IsNullOrWhiteSpace ( ServerConfigurationManager . Configuration . CertificatePath ) )
2013-05-07 20:49:42 +02:00
{
2015-01-23 07:15:15 +01:00
// Custom cert
2017-05-01 04:22:13 +02:00
return new CertificateInfo
{
2017-05-09 20:51:26 +02:00
Path = ServerConfigurationManager . Configuration . CertificatePath ,
Password = ServerConfigurationManager . Configuration . CertificatePassword
2017-05-01 04:22:13 +02:00
} ;
2015-01-23 07:15:15 +01:00
}
// Generate self-signed cert
var certHost = GetHostnameFromExternalDns ( ServerConfigurationManager . Configuration . WanDdns ) ;
2017-05-01 22:03:27 +02:00
var certPath = Path . Combine ( ServerConfigurationManager . ApplicationPaths . ProgramDataPath , "ssl" , "cert_" + ( certHost + "2" ) . GetMD5 ( ) . ToString ( "N" ) + ".pfx" ) ;
2017-05-01 04:22:13 +02:00
var password = "embycert" ;
2015-01-19 07:42:31 +01:00
2015-01-23 07:15:15 +01:00
if ( generateCertificate )
{
2015-09-13 23:32:02 +02:00
if ( ! FileSystemManager . FileExists ( certPath ) )
2015-01-18 22:44:35 +01:00
{
2017-05-04 20:14:45 +02:00
FileSystemManager . CreateDirectory ( FileSystemManager . GetDirectoryName ( certPath ) ) ;
2015-01-23 07:15:15 +01:00
try
2015-01-19 07:42:31 +01:00
{
2017-05-01 04:22:13 +02:00
_certificateGenerator ( certPath , certHost , password ) ;
2015-01-23 07:15:15 +01:00
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error creating ssl cert" , ex ) ;
return null ;
2015-01-19 07:42:31 +01:00
}
2015-01-18 22:44:35 +01:00
}
2013-05-07 20:49:42 +02:00
}
2013-10-18 18:09:47 +02:00
2017-05-01 04:22:13 +02:00
return new CertificateInfo
{
Path = certPath ,
Password = password
} ;
2013-05-07 20:49:42 +02: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
{
2017-08-16 08:43:41 +02:00
ConfigureAutorun ( ) ;
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
}
}
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
2017-05-01 04:22:13 +02:00
var currentCertPath = CertificateInfo = = null ? null : CertificateInfo . Path ;
var newCertInfo = GetCertificateInfo ( false ) ;
var newCertPath = newCertInfo = = null ? null : newCertInfo . Path ;
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 )
{
2016-12-26 18:38:12 +01:00
Logger . Info ( "App needs to be restarted due to configuration change." ) ;
2013-05-07 21:07:51 +02:00
NotifyPendingRestart ( ) ;
}
}
2017-08-16 08:43:41 +02:00
/// <summary>
/// Notifies that the kernel that a change has been made that requires a restart
/// </summary>
public void NotifyPendingRestart ( )
{
Logger . Info ( "App needs to be restarted." ) ;
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-08-16 08:43:41 +02:00
public async Task 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
}
2013-09-05 19:26:03 +02:00
try
{
2013-10-03 20:02:23 +02:00
await SessionManager . SendServerRestartNotification ( CancellationToken . None ) . ConfigureAwait ( false ) ;
2013-09-05 19:26:03 +02:00
}
catch ( Exception ex )
{
2013-10-03 20:02:23 +02:00
Logger . ErrorException ( "Error sending server restart notification" , ex ) ;
2013-09-05 19:26:03 +02:00
}
2016-11-13 05:33:51 +01:00
Logger . Info ( "Calling RestartInternal" ) ;
2014-06-04 18:15:44 +02:00
2016-11-13 05:33:51 +01: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>
2017-08-16 08:43:41 +02:00
protected IEnumerable < Assembly > GetComposablePartAssemblies ( )
2013-02-24 22:53:54 +01:00
{
2013-12-29 15:12:29 +01:00
var list = GetPluginAssemblies ( )
2013-09-25 02:54:51 +02:00
. ToList ( ) ;
2013-09-26 23:20:26 +02:00
2013-02-24 22:53:54 +01:00
// 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
2013-02-28 20:32:41 +01:00
// Include composable parts in the Api assembly
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( ApiEntryPoint ) ) ) ;
2013-02-24 22:53:54 +01:00
2013-02-28 20:32:41 +01:00
// Include composable parts in the Dashboard assembly
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( DashboardService ) ) ) ;
2013-02-24 22:53:54 +01:00
// Include composable parts in the Model assembly
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( SystemInfo ) ) ) ;
2013-02-24 22:53:54 +01:00
// Include composable parts in the Common assembly
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( IApplicationHost ) ) ) ;
2013-02-24 22:53:54 +01:00
// Include composable parts in the Controller assembly
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( IServerApplicationHost ) ) ) ;
2013-02-24 22:53:54 +01:00
2013-06-09 18:47:28 +02:00
// Include composable parts in the Providers assembly
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( ProviderUtils ) ) ) ;
2013-06-20 18:44:24 +02:00
2016-10-26 20:25:03 +02:00
// Include composable parts in the Photos assembly
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( PhotoProvider ) ) ) ;
2016-10-26 20:25:03 +02:00
2013-02-24 22:53:54 +01:00
// Common implementations
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( TaskManager ) ) ) ;
2013-02-24 22:53:54 +01:00
2016-11-02 21:53:50 +01:00
// Emby.Server implementations
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( InstallationManager ) ) ) ;
2016-11-02 21:53:50 +01:00
2014-03-27 20:30:21 +01:00
// MediaEncoding
2017-08-09 21:56:38 +02:00
list . Add ( GetAssembly ( typeof ( MediaEncoding . Encoder . MediaEncoder ) ) ) ;
2014-03-27 20:30:21 +01:00
// Dlna
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( DlnaEntryPoint ) ) ) ;
2014-02-28 05:49:02 +01:00
2014-06-30 05:04:50 +02:00
// Local metadata
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( BoxSetXmlSaver ) ) ) ;
2014-06-30 05:04:50 +02:00
// Xbmc
2016-11-11 18:33:10 +01:00
list . Add ( GetAssembly ( typeof ( ArtistNfoProvider ) ) ) ;
2014-06-30 05:04:50 +02:00
2016-11-13 05:33:51 +01:00
list . AddRange ( GetAssembliesWithPartsInternal ( ) ) ;
2013-09-05 19:26:03 +02:00
2017-08-09 21:56:38 +02:00
return list . ToList ( ) ;
2013-02-24 22:53:54 +01:00
}
2013-02-26 17:10:55 +01:00
2016-11-13 05:33:51 +01:00
protected abstract List < Assembly > GetAssembliesWithPartsInternal ( ) ;
2013-12-29 15:12:29 +01:00
/// <summary>
/// Gets the plugin assemblies.
/// </summary>
/// <returns>IEnumerable{Assembly}.</returns>
private IEnumerable < Assembly > GetPluginAssemblies ( )
{
try
{
return Directory . EnumerateFiles ( ApplicationPaths . PluginsPath , "*.dll" , SearchOption . TopDirectoryOnly )
2016-10-28 05:16:38 +02:00
. Where ( EnablePlugin )
2013-12-29 15:12:29 +01:00
. Select ( LoadAssembly )
2013-12-29 18:07:29 +01:00
. Where ( a = > a ! = null )
. ToList ( ) ;
2013-12-29 15:12:29 +01:00
}
catch ( DirectoryNotFoundException )
{
return new List < Assembly > ( ) ;
}
}
2016-10-28 05:16:38 +02:00
private bool EnablePlugin ( string path )
{
var filename = Path . GetFileName ( path ) ;
var exclude = new [ ]
{
"mbplus.dll" ,
2016-12-26 18:38:12 +01:00
"mbintros.dll" ,
"embytv.dll"
2016-10-28 05:16:38 +02:00
} ;
return ! exclude . Contains ( filename ? ? string . Empty , StringComparer . OrdinalIgnoreCase ) ;
}
2013-03-07 06:34:00 +01:00
/// <summary>
/// Gets the system status.
/// </summary>
/// <returns>SystemInfo.</returns>
2016-06-19 18:53:43 +02:00
public async Task < SystemInfo > GetSystemInfo ( )
2013-03-07 06:34:00 +01:00
{
2016-06-19 18:53:43 +02:00
var localAddress = await GetLocalApiUrl ( ) . ConfigureAwait ( false ) ;
2013-03-07 06:34:00 +01:00
return new SystemInfo
{
HasPendingRestart = HasPendingRestart ,
Version = ApplicationVersion . ToString ( ) ,
2015-01-19 05:29:57 +01:00
WebSocketPortNumber = HttpPort ,
2013-09-20 02:53:18 +02:00
FailedPluginAssemblies = FailedAssemblies . ToList ( ) ,
InProgressInstallations = InstallationManager . CurrentInstallations . Select ( i = > i . Item1 ) . ToList ( ) ,
CompletedInstallations = InstallationManager . CompletedInstallations . ToList ( ) ,
2014-09-06 19:46:09 +02:00
Id = SystemId ,
2013-08-16 16:18:09 +02:00
ProgramDataPath = ApplicationPaths . ProgramDataPath ,
2013-11-30 19:32:39 +01:00
LogPath = ApplicationPaths . LogDirectoryPath ,
ItemsByNamePath = ApplicationPaths . ItemsByNamePath ,
2014-03-31 23:04:22 +02:00
InternalMetadataPath = ApplicationPaths . InternalMetadataPath ,
2013-12-15 02:17:57 +01:00
CachePath = ApplicationPaths . CachePath ,
2013-09-07 17:58:47 +02:00
MacAddress = GetMacAddress ( ) ,
2015-01-19 05:29:57 +01:00
HttpServerPortNumber = HttpPort ,
2015-01-19 22:08:58 +01:00
SupportsHttps = SupportsHttps ,
2015-01-19 05:29:57 +01:00
HttpsPortNumber = HttpsPort ,
2016-11-11 09:13:11 +01:00
OperatingSystem = EnvironmentInfo . OperatingSystem . ToString ( ) ,
2015-07-27 18:21:18 +02:00
OperatingSystemDisplayName = OperatingSystemDisplayName ,
2013-10-07 18:22:19 +02:00
CanSelfRestart = CanSelfRestart ,
2013-12-08 20:39:39 +01:00
CanSelfUpdate = CanSelfUpdate ,
2014-08-25 05:54:45 +02:00
WanAddress = ConnectManager . WanApiAddress ,
2014-04-26 04:55:07 +02:00
HasUpdateAvailable = HasUpdateAvailable ,
2014-01-18 20:25:20 +01:00
SupportsAutoRunAtStartup = SupportsAutoRunAtStartup ,
2014-01-30 01:18:05 +01:00
TranscodingTempPath = ApplicationPaths . TranscodingTempPath ,
2014-09-09 03:15:31 +02:00
SupportsRunningAsService = SupportsRunningAsService ,
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 ,
2016-06-29 07:49:31 +02:00
EncoderLocationType = MediaEncoder . EncoderLocationType ,
2016-11-11 09:13:11 +01:00
SystemArchitecture = EnvironmentInfo . SystemArchitecture ,
2017-04-10 03:51:36 +02:00
SystemUpdateLevel = SystemUpdateLevel ,
2016-11-13 05:33:51 +01:00
PackageName = StartupOptions . GetOption ( "-package" )
2013-03-07 06:34:00 +01:00
} ;
}
2015-01-19 05:29:57 +01:00
public bool EnableHttps
{
get
{
return SupportsHttps & & ServerConfigurationManager . Configuration . EnableHttps ;
}
}
public bool SupportsHttps
{
2016-11-11 04:29:51 +01:00
get { return Certificate ! = null ; }
2015-01-19 05:29:57 +01:00
}
2016-06-19 08:18:29 +02:00
public async Task < string > GetLocalApiUrl ( )
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
2016-11-08 19:44:23 +01:00
var address = ( await GetLocalIpAddresses ( ) . ConfigureAwait ( false ) ) . FirstOrDefault ( i = > ! i . Equals ( IpAddressInfo . Loopback ) & & ! i . Equals ( IpAddressInfo . IPv6Loopback ) ) ;
2015-01-24 20:03:55 +01:00
2016-06-19 08:18:29 +02:00
if ( address ! = null )
2015-01-24 20:03:55 +01:00
{
2016-06-19 08:18:29 +02:00
return GetLocalApiUrl ( address ) ;
2015-01-24 20:03:55 +01:00
}
2015-08-10 19:37:50 +02:00
return null ;
2014-08-20 00:28:35 +02:00
}
2016-06-19 08:18:29 +02:00
catch ( Exception ex )
{
Logger . ErrorException ( "Error getting local Ip address information" , ex ) ;
}
return null ;
2015-01-24 20:03:55 +01:00
}
2014-08-20 00:28:35 +02:00
2016-11-08 19:44:23 +01:00
public string GetLocalApiUrl ( IpAddressInfo ipAddress )
2016-10-26 03:57:58 +02:00
{
2016-11-08 19:44:23 +01:00
if ( ipAddress . AddressFamily = = IpAddressFamily . InterNetworkV6 )
2016-03-09 18:40:29 +01:00
{
2016-11-08 19:44:23 +01:00
return GetLocalApiUrl ( "[" + ipAddress . Address + "]" ) ;
2016-03-09 18:40:29 +01:00
}
2016-11-08 19:44:23 +01:00
return GetLocalApiUrl ( ipAddress . Address ) ;
2016-03-09 18:40:29 +01:00
}
2015-02-10 06:54:58 +01:00
public string GetLocalApiUrl ( string host )
{
return string . Format ( "http://{0}:{1}" ,
host ,
HttpPort . ToString ( CultureInfo . InvariantCulture ) ) ;
}
2016-10-26 03:57:58 +02:00
public async Task < List < IpAddressInfo > > GetLocalIpAddresses ( )
{
2016-12-07 21:02:34 +01:00
var addresses = ServerConfigurationManager
. Configuration
. LocalNetworkAddresses
. Select ( NormalizeConfiguredLocalAddress )
. 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
{
2016-12-07 21:02:34 +01:00
addresses . AddRange ( NetworkManager . GetLocalIpAddresses ( ) ) ;
var list = new List < IpAddressInfo > ( ) ;
foreach ( var address in addresses )
2016-09-12 21:38:38 +02:00
{
2016-12-07 21:02:34 +01:00
var valid = await IsIpAddressValidAsync ( address ) . ConfigureAwait ( false ) ;
if ( valid )
{
list . Add ( address ) ;
}
2016-09-12 21:38:38 +02:00
}
2016-12-07 21:02:34 +01:00
addresses = list ;
2016-09-12 21:38:38 +02:00
}
2016-12-07 21:02:34 +01:00
return addresses ;
}
private IpAddressInfo NormalizeConfiguredLocalAddress ( string address )
{
var index = address . Trim ( '/' ) . IndexOf ( '/' ) ;
if ( index ! = - 1 )
{
address = address . Substring ( index + 1 ) ;
}
IpAddressInfo result ;
if ( NetworkManager . TryParseIpAddress ( address . Trim ( '/' ) , out result ) )
{
return result ;
}
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 ) ;
2016-01-28 07:38:35 +01:00
private DateTime _lastAddressCacheClear ;
2016-11-08 19:44:23 +01:00
private async Task < bool > IsIpAddressValidAsync ( IpAddressInfo address )
2014-09-17 05:04:10 +02:00
{
2016-11-08 19:44:23 +01:00
if ( address . Equals ( IpAddressInfo . Loopback ) | |
address . Equals ( IpAddressInfo . 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
2016-03-09 18:40:29 +01:00
var apiUrl = GetLocalApiUrl ( address ) ;
2015-12-29 04:39:38 +01:00
apiUrl + = "/system/ping" ;
2014-09-17 05:04:10 +02:00
2016-10-25 21:02:04 +02:00
if ( ( DateTime . UtcNow - _lastAddressCacheClear ) . TotalMinutes > = 15 )
2016-01-28 07:38:35 +01:00
{
_lastAddressCacheClear = DateTime . UtcNow ;
_validAddressResults . Clear ( ) ;
}
2015-12-29 04:39:38 +01:00
bool cachedResult ;
if ( _validAddressResults . TryGetValue ( apiUrl , out cachedResult ) )
{
return cachedResult ;
}
2014-09-17 05:04:10 +02:00
2015-12-29 04:39:38 +01:00
try
{
2016-01-28 07:38:35 +01:00
using ( var response = await HttpClient . SendAsync ( new HttpRequestOptions
2014-09-17 05:04:10 +02:00
{
2015-12-29 04:39:38 +01:00
Url = apiUrl ,
LogErrorResponseBody = false ,
2015-12-29 20:06:32 +01:00
LogErrors = false ,
2016-01-28 07:38:35 +01:00
LogRequest = false ,
2016-10-06 20:55:01 +02:00
TimeoutMs = 30000 ,
BufferContent = false
2014-09-17 05:04:10 +02:00
2016-01-28 07:38:35 +01:00
} , "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 ) )
{
var result = reader . ReadToEnd ( ) ;
var valid = string . Equals ( Name , result , StringComparison . OrdinalIgnoreCase ) ;
_validAddressResults . AddOrUpdate ( apiUrl , valid , ( k , v ) = > valid ) ;
2016-01-28 07:38:35 +01:00
//Logger.Debug("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
}
2015-12-29 04:39:38 +01:00
catch
{
2016-01-28 07:38:35 +01:00
//Logger.Debug("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 ;
}
}
2014-08-06 01:59:24 +02:00
public string FriendlyName
{
get
{
return string . IsNullOrWhiteSpace ( ServerConfigurationManager . Configuration . ServerName )
? Environment . MachineName
: ServerConfigurationManager . Configuration . ServerName ;
}
}
2015-01-19 05:29:57 +01:00
public int HttpPort { get ; private set ; }
2014-03-17 05:25:11 +01:00
2015-01-19 05:29:57 +01:00
public int HttpsPort { get ; private set ; }
2015-01-07 04:36:42 +01:00
2013-08-16 16:18:09 +02:00
/// <summary>
/// Gets the mac address.
/// </summary>
/// <returns>System.String.</returns>
private string GetMacAddress ( )
{
try
{
return NetworkManager . GetMacAddress ( ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error getting mac address" , ex ) ;
return null ;
}
}
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
{
2013-09-05 19:26:03 +02:00
try
{
2013-10-03 20:02:23 +02:00
await SessionManager . SendServerShutdownNotification ( CancellationToken . None ) . ConfigureAwait ( false ) ;
2013-09-05 19:26:03 +02:00
}
catch ( Exception ex )
{
2013-10-03 20:02:23 +02:00
Logger . ErrorException ( "Error sending server shutdown notification" , ex ) ;
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 ( ) ;
2013-03-27 23:13:46 +01:00
/// <summary>
/// Registers the server with administrator access.
/// </summary>
private void RegisterServerWithAdministratorAccess ( )
{
Logger . Info ( "Requesting administrative access to authorize http server" ) ;
2013-09-25 02:54:51 +02:00
try
2013-03-27 23:13:46 +01:00
{
2016-11-13 22:04:21 +01:00
AuthorizeServer ( ) ;
2017-01-17 19:00:19 +01:00
}
catch ( NotImplementedException )
{
2017-04-10 03:51:36 +02:00
2013-03-27 23:13:46 +01:00
}
2013-09-25 02:54:51 +02:00
catch ( Exception ex )
2013-03-27 23:13:46 +01:00
{
2013-09-25 02:54:51 +02:00
Logger . ErrorException ( "Error authorizing server" , ex ) ;
2013-03-27 23:13:46 +01:00
}
2013-02-26 17:10:55 +01:00
}
2013-07-08 19:13:18 +02:00
2017-02-19 04:46:09 +01:00
protected virtual void AuthorizeServer ( )
{
throw new NotImplementedException ( ) ;
}
2016-11-13 05:33:51 +01:00
2014-04-26 04:55:07 +02:00
public event EventHandler HasUpdateAvailableChanged ;
2014-01-05 07:50:48 +01:00
private bool _hasUpdateAvailable ;
2014-04-26 04:55:07 +02:00
public bool HasUpdateAvailable
{
get { return _hasUpdateAvailable ; }
set
{
var fireEvent = value & & ! _hasUpdateAvailable ;
_hasUpdateAvailable = value ;
if ( fireEvent )
{
EventHelper . FireEventIfNotNull ( HasUpdateAvailableChanged , this , EventArgs . Empty , Logger ) ;
}
}
}
2017-08-16 08:43:41 +02:00
/// <summary>
/// Removes the plugin.
/// </summary>
/// <param name="plugin">The plugin.</param>
public void RemovePlugin ( IPlugin plugin )
{
var list = Plugins . ToList ( ) ;
list . Remove ( plugin ) ;
Plugins = list . ToArray ( ) ;
}
2013-09-14 03:56:03 +02:00
/// <summary>
/// Checks for update.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress.</param>
/// <returns>Task{CheckForUpdateResult}.</returns>
2017-08-16 08:43:41 +02:00
public async Task < CheckForUpdateResult > CheckForApplicationUpdate ( CancellationToken cancellationToken , IProgress < double > progress )
2013-07-08 19:13:18 +02:00
{
2017-08-12 21:09:13 +02:00
var cacheLength = TimeSpan . FromHours ( 1 ) ;
2017-04-10 03:51:36 +02:00
var updateLevel = SystemUpdateLevel ;
2016-01-03 02:23:09 +01:00
2017-08-12 21:09:13 +02:00
if ( updateLevel ! = PackageVersionClass . Release )
2014-07-09 16:39:04 +02:00
{
2016-01-03 20:01:05 +01:00
cacheLength = TimeSpan . FromMinutes ( 5 ) ;
2014-07-09 16:39:04 +02:00
}
2016-09-09 08:59:23 +02:00
var result = await new GithubUpdater ( HttpClient , JsonSerializer ) . CheckForUpdateResult ( "MediaBrowser" , "Emby" , ApplicationVersion , updateLevel , _releaseAssetFilename ,
"MBServer" , "Mbserver.zip" , cacheLength , cancellationToken ) . ConfigureAwait ( false ) ;
2016-01-09 18:17:35 +01:00
HasUpdateAvailable = result . IsUpdateAvailable ;
return result ;
2013-07-08 19:13:18 +02:00
}
2013-08-28 22:12:58 +02:00
2013-09-14 03:56:03 +02:00
/// <summary>
/// Updates the application.
/// </summary>
/// <param name="package">The package that contains the update</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress.</param>
2017-08-16 08:43:41 +02:00
public async Task UpdateApplication ( PackageVersionInfo package , CancellationToken cancellationToken , IProgress < double > progress )
2013-09-14 03:56:03 +02:00
{
2016-01-03 02:23:09 +01:00
await InstallationManager . InstallPackage ( package , false , progress , cancellationToken ) . ConfigureAwait ( false ) ;
2013-09-14 03:56:03 +02:00
2014-04-26 04:55:07 +02:00
HasUpdateAvailable = false ;
2014-01-05 07:50:48 +01:00
2014-04-30 17:07:02 +02:00
OnApplicationUpdated ( package ) ;
2013-09-14 03:56:03 +02:00
}
2014-01-06 02:59:21 +01:00
/// <summary>
/// Configures the automatic run at startup.
/// </summary>
/// <param name="autorun">if set to <c>true</c> [autorun].</param>
2017-08-16 08:43:41 +02:00
protected void ConfigureAutoRunAtStartup ( bool autorun )
2013-09-25 02:54:51 +02:00
{
2014-01-06 02:59:21 +01:00
if ( SupportsAutoRunAtStartup )
{
2016-11-13 05:33:51 +01:00
ConfigureAutoRunInternal ( autorun ) ;
2014-01-06 02:59:21 +01:00
}
2013-08-28 22:12:58 +02:00
}
2015-01-18 22:44:35 +01:00
2017-02-19 04:46:09 +01:00
protected virtual void ConfigureAutoRunInternal ( bool autorun )
{
throw new NotImplementedException ( ) ;
}
2016-11-13 05:33:51 +01:00
2015-01-18 22:44:35 +01:00
/// <summary>
/// This returns localhost in the case of no external dns, and the hostname if the
/// dns is prefixed with a valid Uri prefix.
/// </summary>
/// <param name="externalDns">The external dns prefix to get the hostname of.</param>
/// <returns>The hostname in <paramref name="externalDns"/></returns>
private static string GetHostnameFromExternalDns ( string externalDns )
{
if ( string . IsNullOrWhiteSpace ( externalDns ) )
{
return "localhost" ;
}
try
{
2015-01-19 07:42:31 +01:00
return new Uri ( externalDns ) . Host ;
2015-01-18 22:44:35 +01:00
}
2016-08-05 23:15:48 +02:00
catch
2015-01-18 22:44:35 +01:00
{
return externalDns ;
}
}
2016-04-24 05:03:49 +02:00
2016-11-21 00:48:52 +01:00
public void LaunchUrl ( string url )
{
2016-12-22 05:11:23 +01:00
if ( EnvironmentInfo . OperatingSystem ! = MediaBrowser . Model . System . OperatingSystem . Windows & &
EnvironmentInfo . OperatingSystem ! = MediaBrowser . Model . System . OperatingSystem . OSX )
2016-11-21 00:48:52 +01:00
{
throw new NotImplementedException ( ) ;
}
2016-12-07 21:02:34 +01:00
var process = ProcessFactory . Create ( new ProcessOptions
{
2016-11-21 00:48:52 +01:00
FileName = url ,
2016-12-22 05:28:00 +01:00
//EnableRaisingEvents = true,
2016-11-21 00:48:52 +01:00
UseShellExecute = true ,
ErrorDialog = false
} ) ;
process . Exited + = ProcessExited ;
try
{
process . Start ( ) ;
}
catch ( Exception ex )
{
Console . WriteLine ( "Error launching url: {0}" , url ) ;
Logger . ErrorException ( "Error launching url: {0}" , ex , url ) ;
throw ;
}
}
private static void ProcessExited ( object sender , EventArgs e )
{
( ( IProcess ) sender ) . Dispose ( ) ;
}
2016-09-03 19:16:36 +02:00
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
2016-10-29 06:10:11 +02:00
private void RegisterModules ( )
{
var moduleTypes = GetExportTypes < IDependencyModule > ( ) ;
foreach ( var type in moduleTypes )
{
try
{
var instance = Activator . CreateInstance ( type ) as IDependencyModule ;
if ( instance ! = null )
instance . BindDependencies ( this ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error setting up dependency bindings for " + type . Name , ex ) ;
}
}
}
2017-08-16 08:43:41 +02:00
/// <summary>
/// Called when [application updated].
/// </summary>
/// <param name="package">The package.</param>
protected void OnApplicationUpdated ( PackageVersionInfo package )
{
Logger . Info ( "Application has been updated to version {0}" , package . versionStr ) ;
EventHelper . FireEventIfNotNull ( ApplicationUpdated , this , new GenericEventArgs < PackageVersionInfo >
{
Argument = package
} , Logger ) ;
NotifyPendingRestart ( ) ;
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose ( )
{
Dispose ( true ) ;
}
/// <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 )
{
if ( dispose )
{
var type = GetType ( ) ;
Logger . Info ( "Disposing " + type . Name ) ;
var parts = DisposableParts . Distinct ( ) . Where ( i = > i . GetType ( ) ! = type ) . ToList ( ) ;
DisposableParts . Clear ( ) ;
foreach ( var part in parts )
{
Logger . Info ( "Disposing " + part . GetType ( ) . Name ) ;
try
{
part . Dispose ( ) ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error disposing {0}" , ex , part . GetType ( ) . Name ) ;
}
}
}
}
2016-10-29 06:10:11 +02:00
void IDependencyContainer . RegisterSingleInstance < T > ( T obj , bool manageLifetime )
{
RegisterSingleInstance ( obj , manageLifetime ) ;
}
void IDependencyContainer . RegisterSingleInstance < T > ( Func < T > func )
{
RegisterSingleInstance ( func ) ;
}
void IDependencyContainer . Register ( Type typeInterface , Type typeImplementation )
{
Container . Register ( typeInterface , typeImplementation ) ;
}
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 ; }
public string Password { get ; set ; }
2013-02-24 22:53:54 +01:00
}
}