BaseApplicationHost.cs 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860
  1. using MediaBrowser.Common.Configuration;
  2. using MediaBrowser.Common.Events;
  3. using MediaBrowser.Common.Implementations.Archiving;
  4. using MediaBrowser.Common.Implementations.Devices;
  5. using MediaBrowser.Common.Implementations.IO;
  6. using MediaBrowser.Common.Implementations.ScheduledTasks;
  7. using MediaBrowser.Common.Implementations.Security;
  8. using MediaBrowser.Common.Implementations.Serialization;
  9. using MediaBrowser.Common.Implementations.Updates;
  10. using MediaBrowser.Common.Net;
  11. using MediaBrowser.Common.Plugins;
  12. using MediaBrowser.Common.Progress;
  13. using MediaBrowser.Common.ScheduledTasks;
  14. using MediaBrowser.Common.Security;
  15. using MediaBrowser.Common.Updates;
  16. using MediaBrowser.Model.Events;
  17. using MediaBrowser.Model.IO;
  18. using MediaBrowser.Model.Logging;
  19. using MediaBrowser.Model.Serialization;
  20. using MediaBrowser.Model.Updates;
  21. using ServiceStack;
  22. using SimpleInjector;
  23. using System;
  24. using System.Collections.Generic;
  25. using System.IO;
  26. using System.Linq;
  27. using System.Net;
  28. using System.Reflection;
  29. using System.Text;
  30. using System.Threading;
  31. using System.Threading.Tasks;
  32. using CommonIO;
  33. namespace MediaBrowser.Common.Implementations
  34. {
  35. /// <summary>
  36. /// Class BaseApplicationHost
  37. /// </summary>
  38. /// <typeparam name="TApplicationPathsType">The type of the T application paths type.</typeparam>
  39. public abstract class BaseApplicationHost<TApplicationPathsType> : IApplicationHost, IDependencyContainer
  40. where TApplicationPathsType : class, IApplicationPaths
  41. {
  42. /// <summary>
  43. /// Occurs when [has pending restart changed].
  44. /// </summary>
  45. public event EventHandler HasPendingRestartChanged;
  46. /// <summary>
  47. /// Occurs when [application updated].
  48. /// </summary>
  49. public event EventHandler<GenericEventArgs<PackageVersionInfo>> ApplicationUpdated;
  50. /// <summary>
  51. /// Gets or sets a value indicating whether this instance has changes that require the entire application to restart.
  52. /// </summary>
  53. /// <value><c>true</c> if this instance has pending application restart; otherwise, <c>false</c>.</value>
  54. public bool HasPendingRestart { get; private set; }
  55. /// <summary>
  56. /// Gets or sets the logger.
  57. /// </summary>
  58. /// <value>The logger.</value>
  59. protected ILogger Logger { get; private set; }
  60. /// <summary>
  61. /// Gets or sets the plugins.
  62. /// </summary>
  63. /// <value>The plugins.</value>
  64. public IEnumerable<IPlugin> Plugins { get; protected set; }
  65. /// <summary>
  66. /// Gets or sets the log manager.
  67. /// </summary>
  68. /// <value>The log manager.</value>
  69. public ILogManager LogManager { get; protected set; }
  70. /// <summary>
  71. /// Gets the application paths.
  72. /// </summary>
  73. /// <value>The application paths.</value>
  74. protected TApplicationPathsType ApplicationPaths { get; private set; }
  75. /// <summary>
  76. /// The container
  77. /// </summary>
  78. protected readonly Container Container = new Container();
  79. /// <summary>
  80. /// The json serializer
  81. /// </summary>
  82. public IJsonSerializer JsonSerializer { get; private set; }
  83. /// <summary>
  84. /// The _XML serializer
  85. /// </summary>
  86. protected readonly IXmlSerializer XmlSerializer;
  87. /// <summary>
  88. /// Gets assemblies that failed to load
  89. /// </summary>
  90. /// <value>The failed assemblies.</value>
  91. public List<string> FailedAssemblies { get; protected set; }
  92. /// <summary>
  93. /// Gets all concrete types.
  94. /// </summary>
  95. /// <value>All concrete types.</value>
  96. public Type[] AllConcreteTypes { get; protected set; }
  97. /// <summary>
  98. /// The disposable parts
  99. /// </summary>
  100. protected readonly List<IDisposable> DisposableParts = new List<IDisposable>();
  101. /// <summary>
  102. /// Gets a value indicating whether this instance is first run.
  103. /// </summary>
  104. /// <value><c>true</c> if this instance is first run; otherwise, <c>false</c>.</value>
  105. public bool IsFirstRun { get; private set; }
  106. /// <summary>
  107. /// Gets the kernel.
  108. /// </summary>
  109. /// <value>The kernel.</value>
  110. protected ITaskManager TaskManager { get; private set; }
  111. /// <summary>
  112. /// Gets the security manager.
  113. /// </summary>
  114. /// <value>The security manager.</value>
  115. protected ISecurityManager SecurityManager { get; private set; }
  116. /// <summary>
  117. /// Gets the HTTP client.
  118. /// </summary>
  119. /// <value>The HTTP client.</value>
  120. public IHttpClient HttpClient { get; private set; }
  121. /// <summary>
  122. /// Gets the network manager.
  123. /// </summary>
  124. /// <value>The network manager.</value>
  125. protected INetworkManager NetworkManager { get; private set; }
  126. /// <summary>
  127. /// Gets the configuration manager.
  128. /// </summary>
  129. /// <value>The configuration manager.</value>
  130. protected IConfigurationManager ConfigurationManager { get; private set; }
  131. /// <summary>
  132. /// Gets or sets the installation manager.
  133. /// </summary>
  134. /// <value>The installation manager.</value>
  135. protected IInstallationManager InstallationManager { get; private set; }
  136. protected IFileSystem FileSystemManager { get; private set; }
  137. /// <summary>
  138. /// Gets or sets the zip client.
  139. /// </summary>
  140. /// <value>The zip client.</value>
  141. protected IZipClient ZipClient { get; private set; }
  142. protected IIsoManager IsoManager { get; private set; }
  143. /// <summary>
  144. /// Gets the name.
  145. /// </summary>
  146. /// <value>The name.</value>
  147. public abstract string Name { get; }
  148. /// <summary>
  149. /// Gets a value indicating whether this instance is running as service.
  150. /// </summary>
  151. /// <value><c>true</c> if this instance is running as service; otherwise, <c>false</c>.</value>
  152. public abstract bool IsRunningAsService { get; }
  153. private DeviceId _deviceId;
  154. public string SystemId
  155. {
  156. get
  157. {
  158. if (_deviceId == null)
  159. {
  160. _deviceId = new DeviceId(ApplicationPaths, LogManager.GetLogger("SystemId"), FileSystemManager);
  161. }
  162. return _deviceId.Value;
  163. }
  164. }
  165. public virtual string OperatingSystemDisplayName
  166. {
  167. get { return Environment.OSVersion.VersionString; }
  168. }
  169. /// <summary>
  170. /// Initializes a new instance of the <see cref="BaseApplicationHost{TApplicationPathsType}"/> class.
  171. /// </summary>
  172. protected BaseApplicationHost(TApplicationPathsType applicationPaths,
  173. ILogManager logManager,
  174. IFileSystem fileSystem)
  175. {
  176. XmlSerializer = new MediaBrowser.Common.Implementations.Serialization.XmlSerializer (fileSystem);
  177. FailedAssemblies = new List<string>();
  178. ApplicationPaths = applicationPaths;
  179. LogManager = logManager;
  180. FileSystemManager = fileSystem;
  181. ConfigurationManager = GetConfigurationManager();
  182. // Initialize this early in case the -v command line option is used
  183. Logger = LogManager.GetLogger("App");
  184. }
  185. /// <summary>
  186. /// Inits this instance.
  187. /// </summary>
  188. /// <returns>Task.</returns>
  189. public virtual async Task Init(IProgress<double> progress)
  190. {
  191. try
  192. {
  193. // https://github.com/ServiceStack/ServiceStack/blob/master/tests/ServiceStack.WebHost.IntegrationTests/Web.config#L4
  194. Licensing.RegisterLicense("1001-e1JlZjoxMDAxLE5hbWU6VGVzdCBCdXNpbmVzcyxUeXBlOkJ1c2luZXNzLEhhc2g6UHVNTVRPclhvT2ZIbjQ5MG5LZE1mUTd5RUMzQnBucTFEbTE3TDczVEF4QUNMT1FhNXJMOWkzVjFGL2ZkVTE3Q2pDNENqTkQyUktRWmhvUVBhYTBiekJGUUZ3ZE5aZHFDYm9hL3lydGlwUHI5K1JsaTBYbzNsUC85cjVJNHE5QVhldDN6QkE4aTlvdldrdTgyTk1relY2eis2dFFqTThYN2lmc0JveHgycFdjPSxFeHBpcnk6MjAxMy0wMS0wMX0=");
  195. }
  196. catch
  197. {
  198. // Failing under mono
  199. }
  200. progress.Report(1);
  201. JsonSerializer = CreateJsonSerializer();
  202. OnLoggerLoaded(true);
  203. LogManager.LoggerLoaded += (s, e) => OnLoggerLoaded(false);
  204. IsFirstRun = !ConfigurationManager.CommonConfiguration.IsStartupWizardCompleted;
  205. progress.Report(2);
  206. LogManager.LogSeverity = ConfigurationManager.CommonConfiguration.EnableDebugLevelLogging
  207. ? LogSeverity.Debug
  208. : LogSeverity.Info;
  209. progress.Report(3);
  210. DiscoverTypes();
  211. progress.Report(14);
  212. SetHttpLimit();
  213. progress.Report(15);
  214. var innerProgress = new ActionableProgress<double>();
  215. innerProgress.RegisterAction(p => progress.Report(.8 * p + 15));
  216. try
  217. {
  218. await RegisterResources(innerProgress).ConfigureAwait(false);
  219. }
  220. catch (Exception ex)
  221. {
  222. Logger.ErrorException("Error in RegisterResource", ex);
  223. throw;
  224. }
  225. FindParts();
  226. progress.Report(95);
  227. await InstallIsoMounters(CancellationToken.None).ConfigureAwait(false);
  228. progress.Report(100);
  229. }
  230. protected virtual void OnLoggerLoaded(bool isFirstLoad)
  231. {
  232. Logger.Info("Application version: {0}", ApplicationVersion);
  233. if (!isFirstLoad)
  234. {
  235. LogEnvironmentInfo(Logger, ApplicationPaths, false);
  236. }
  237. // Put the app config in the log for troubleshooting purposes
  238. Logger.LogMultiline("Application configuration:", LogSeverity.Info, new StringBuilder(JsonSerializer.SerializeToString(ConfigurationManager.CommonConfiguration)));
  239. if (Plugins != null)
  240. {
  241. var pluginBuilder = new StringBuilder();
  242. foreach (var plugin in Plugins)
  243. {
  244. pluginBuilder.AppendLine(string.Format("{0} {1}", plugin.Name, plugin.Version));
  245. }
  246. Logger.LogMultiline("Plugins:", LogSeverity.Info, pluginBuilder);
  247. }
  248. }
  249. public static void LogEnvironmentInfo(ILogger logger, IApplicationPaths appPaths, bool isStartup)
  250. {
  251. logger.LogMultiline("Emby", LogSeverity.Info, GetBaseExceptionMessage(appPaths));
  252. }
  253. protected static StringBuilder GetBaseExceptionMessage(IApplicationPaths appPaths)
  254. {
  255. var builder = new StringBuilder();
  256. builder.AppendLine(string.Format("Command line: {0}", string.Join(" ", Environment.GetCommandLineArgs())));
  257. builder.AppendLine(string.Format("Operating system: {0}", Environment.OSVersion));
  258. builder.AppendLine(string.Format("Processor count: {0}", Environment.ProcessorCount));
  259. builder.AppendLine(string.Format("64-Bit OS: {0}", Environment.Is64BitOperatingSystem));
  260. builder.AppendLine(string.Format("64-Bit Process: {0}", Environment.Is64BitProcess));
  261. builder.AppendLine(string.Format("Program data path: {0}", appPaths.ProgramDataPath));
  262. Type type = Type.GetType("Mono.Runtime");
  263. if (type != null)
  264. {
  265. MethodInfo displayName = type.GetMethod("GetDisplayName", BindingFlags.NonPublic | BindingFlags.Static);
  266. if (displayName != null)
  267. {
  268. builder.AppendLine("Mono: " + displayName.Invoke(null, null));
  269. }
  270. }
  271. builder.AppendLine(string.Format("Application Path: {0}", appPaths.ApplicationPath));
  272. return builder;
  273. }
  274. protected virtual IJsonSerializer CreateJsonSerializer()
  275. {
  276. return new JsonSerializer(FileSystemManager);
  277. }
  278. private void SetHttpLimit()
  279. {
  280. try
  281. {
  282. // Increase the max http request limit
  283. ServicePointManager.DefaultConnectionLimit = Math.Max(96, ServicePointManager.DefaultConnectionLimit);
  284. }
  285. catch (Exception ex)
  286. {
  287. Logger.ErrorException("Error setting http limit", ex);
  288. }
  289. }
  290. /// <summary>
  291. /// Installs the iso mounters.
  292. /// </summary>
  293. /// <param name="cancellationToken">The cancellation token.</param>
  294. /// <returns>Task.</returns>
  295. private async Task InstallIsoMounters(CancellationToken cancellationToken)
  296. {
  297. var list = new List<IIsoMounter>();
  298. foreach (var isoMounter in GetExports<IIsoMounter>())
  299. {
  300. try
  301. {
  302. if (isoMounter.RequiresInstallation && !isoMounter.IsInstalled)
  303. {
  304. Logger.Info("Installing {0}", isoMounter.Name);
  305. await isoMounter.Install(cancellationToken).ConfigureAwait(false);
  306. }
  307. list.Add(isoMounter);
  308. }
  309. catch (Exception ex)
  310. {
  311. Logger.ErrorException("{0} failed to load.", ex, isoMounter.Name);
  312. }
  313. }
  314. IsoManager.AddParts(list);
  315. }
  316. /// <summary>
  317. /// Runs the startup tasks.
  318. /// </summary>
  319. /// <returns>Task.</returns>
  320. public virtual Task RunStartupTasks()
  321. {
  322. Resolve<ITaskManager>().AddTasks(GetExports<IScheduledTask>(false));
  323. ConfigureAutorun ();
  324. ConfigurationManager.ConfigurationUpdated += OnConfigurationUpdated;
  325. return Task.FromResult (true);
  326. }
  327. /// <summary>
  328. /// Configures the autorun.
  329. /// </summary>
  330. private void ConfigureAutorun()
  331. {
  332. try
  333. {
  334. ConfigureAutoRunAtStartup(ConfigurationManager.CommonConfiguration.RunAtStartup);
  335. }
  336. catch (Exception ex)
  337. {
  338. Logger.ErrorException("Error configuring autorun", ex);
  339. }
  340. }
  341. /// <summary>
  342. /// Gets the composable part assemblies.
  343. /// </summary>
  344. /// <returns>IEnumerable{Assembly}.</returns>
  345. protected abstract IEnumerable<Assembly> GetComposablePartAssemblies();
  346. /// <summary>
  347. /// Gets the configuration manager.
  348. /// </summary>
  349. /// <returns>IConfigurationManager.</returns>
  350. protected abstract IConfigurationManager GetConfigurationManager();
  351. /// <summary>
  352. /// Finds the parts.
  353. /// </summary>
  354. protected virtual void FindParts()
  355. {
  356. RegisterModules();
  357. ConfigurationManager.AddParts(GetExports<IConfigurationFactory>());
  358. Plugins = GetExports<IPlugin>();
  359. }
  360. /// <summary>
  361. /// Discovers the types.
  362. /// </summary>
  363. protected void DiscoverTypes()
  364. {
  365. FailedAssemblies.Clear();
  366. var assemblies = GetComposablePartAssemblies().ToList();
  367. foreach (var assembly in assemblies)
  368. {
  369. Logger.Info("Loading {0}", assembly.FullName);
  370. }
  371. AllConcreteTypes = assemblies
  372. .SelectMany(GetTypes)
  373. .Where(t => t.IsClass && !t.IsAbstract && !t.IsInterface && !t.IsGenericType)
  374. .ToArray();
  375. }
  376. /// <summary>
  377. /// Registers resources that classes will depend on
  378. /// </summary>
  379. /// <returns>Task.</returns>
  380. protected virtual Task RegisterResources(IProgress<double> progress)
  381. {
  382. RegisterSingleInstance(ConfigurationManager);
  383. RegisterSingleInstance<IApplicationHost>(this);
  384. RegisterSingleInstance<IApplicationPaths>(ApplicationPaths);
  385. TaskManager = new TaskManager(ApplicationPaths, JsonSerializer, LogManager.GetLogger("TaskManager"), FileSystemManager);
  386. RegisterSingleInstance(JsonSerializer);
  387. RegisterSingleInstance(XmlSerializer);
  388. RegisterSingleInstance(LogManager);
  389. RegisterSingleInstance(Logger);
  390. RegisterSingleInstance(TaskManager);
  391. RegisterSingleInstance(FileSystemManager);
  392. HttpClient = new HttpClientManager.HttpClientManager(ApplicationPaths, LogManager.GetLogger("HttpClient"), FileSystemManager);
  393. RegisterSingleInstance(HttpClient);
  394. NetworkManager = CreateNetworkManager(LogManager.GetLogger("NetworkManager"));
  395. RegisterSingleInstance(NetworkManager);
  396. SecurityManager = new PluginSecurityManager(this, HttpClient, JsonSerializer, ApplicationPaths, LogManager);
  397. RegisterSingleInstance(SecurityManager);
  398. InstallationManager = new InstallationManager(LogManager.GetLogger("InstallationManager"), this, ApplicationPaths, HttpClient, JsonSerializer, SecurityManager, ConfigurationManager, FileSystemManager);
  399. RegisterSingleInstance(InstallationManager);
  400. ZipClient = new ZipClient(FileSystemManager);
  401. RegisterSingleInstance(ZipClient);
  402. IsoManager = new IsoManager();
  403. RegisterSingleInstance(IsoManager);
  404. return Task.FromResult (true);
  405. }
  406. private void RegisterModules()
  407. {
  408. var moduleTypes = GetExportTypes<IDependencyModule>();
  409. foreach (var type in moduleTypes)
  410. {
  411. try
  412. {
  413. var instance = Activator.CreateInstance(type) as IDependencyModule;
  414. if (instance != null)
  415. instance.BindDependencies(this);
  416. }
  417. catch (Exception ex)
  418. {
  419. Logger.ErrorException("Error setting up dependency bindings for " + type.Name, ex);
  420. }
  421. }
  422. }
  423. /// <summary>
  424. /// Gets a list of types within an assembly
  425. /// 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
  426. /// </summary>
  427. /// <param name="assembly">The assembly.</param>
  428. /// <returns>IEnumerable{Type}.</returns>
  429. /// <exception cref="System.ArgumentNullException">assembly</exception>
  430. protected IEnumerable<Type> GetTypes(Assembly assembly)
  431. {
  432. if (assembly == null)
  433. {
  434. throw new ArgumentNullException("assembly");
  435. }
  436. try
  437. {
  438. return assembly.GetTypes();
  439. }
  440. catch (ReflectionTypeLoadException ex)
  441. {
  442. if (ex.LoaderExceptions != null)
  443. {
  444. foreach (var loaderException in ex.LoaderExceptions)
  445. {
  446. Logger.Error("LoaderException: " + loaderException.Message);
  447. }
  448. }
  449. // If it fails we can still get a list of the Types it was able to resolve
  450. return ex.Types.Where(t => t != null);
  451. }
  452. }
  453. protected abstract INetworkManager CreateNetworkManager(ILogger logger);
  454. /// <summary>
  455. /// Creates an instance of type and resolves all constructor dependancies
  456. /// </summary>
  457. /// <param name="type">The type.</param>
  458. /// <returns>System.Object.</returns>
  459. public object CreateInstance(Type type)
  460. {
  461. try
  462. {
  463. return Container.GetInstance(type);
  464. }
  465. catch (Exception ex)
  466. {
  467. Logger.ErrorException("Error creating {0}", ex, type.Name);
  468. throw;
  469. }
  470. }
  471. /// <summary>
  472. /// Creates the instance safe.
  473. /// </summary>
  474. /// <param name="type">The type.</param>
  475. /// <returns>System.Object.</returns>
  476. protected object CreateInstanceSafe(Type type)
  477. {
  478. try
  479. {
  480. return Container.GetInstance(type);
  481. }
  482. catch (Exception ex)
  483. {
  484. Logger.ErrorException("Error creating {0}", ex, type.Name);
  485. // Don't blow up in release mode
  486. return null;
  487. }
  488. }
  489. void IDependencyContainer.RegisterSingleInstance<T>(T obj, bool manageLifetime)
  490. {
  491. RegisterSingleInstance(obj, manageLifetime);
  492. }
  493. /// <summary>
  494. /// Registers the specified obj.
  495. /// </summary>
  496. /// <typeparam name="T"></typeparam>
  497. /// <param name="obj">The obj.</param>
  498. /// <param name="manageLifetime">if set to <c>true</c> [manage lifetime].</param>
  499. protected void RegisterSingleInstance<T>(T obj, bool manageLifetime = true)
  500. where T : class
  501. {
  502. Container.RegisterSingleton(obj);
  503. if (manageLifetime)
  504. {
  505. var disposable = obj as IDisposable;
  506. if (disposable != null)
  507. {
  508. DisposableParts.Add(disposable);
  509. }
  510. }
  511. }
  512. void IDependencyContainer.RegisterSingleInstance<T>(Func<T> func)
  513. {
  514. RegisterSingleInstance(func);
  515. }
  516. /// <summary>
  517. /// Registers the single instance.
  518. /// </summary>
  519. /// <typeparam name="T"></typeparam>
  520. /// <param name="func">The func.</param>
  521. protected void RegisterSingleInstance<T>(Func<T> func)
  522. where T : class
  523. {
  524. Container.RegisterSingleton(func);
  525. }
  526. void IDependencyContainer.Register(Type typeInterface, Type typeImplementation)
  527. {
  528. Container.Register(typeInterface, typeImplementation);
  529. }
  530. /// <summary>
  531. /// Resolves this instance.
  532. /// </summary>
  533. /// <typeparam name="T"></typeparam>
  534. /// <returns>``0.</returns>
  535. public T Resolve<T>()
  536. {
  537. return (T)Container.GetRegistration(typeof(T), true).GetInstance();
  538. }
  539. /// <summary>
  540. /// Resolves this instance.
  541. /// </summary>
  542. /// <typeparam name="T"></typeparam>
  543. /// <returns>``0.</returns>
  544. public T TryResolve<T>()
  545. {
  546. var result = Container.GetRegistration(typeof(T), false);
  547. if (result == null)
  548. {
  549. return default(T);
  550. }
  551. return (T)result.GetInstance();
  552. }
  553. /// <summary>
  554. /// Loads the assembly.
  555. /// </summary>
  556. /// <param name="file">The file.</param>
  557. /// <returns>Assembly.</returns>
  558. protected Assembly LoadAssembly(string file)
  559. {
  560. try
  561. {
  562. return Assembly.Load(File.ReadAllBytes(file));
  563. }
  564. catch (Exception ex)
  565. {
  566. FailedAssemblies.Add(file);
  567. Logger.ErrorException("Error loading assembly {0}", ex, file);
  568. return null;
  569. }
  570. }
  571. /// <summary>
  572. /// Gets the export types.
  573. /// </summary>
  574. /// <typeparam name="T"></typeparam>
  575. /// <returns>IEnumerable{Type}.</returns>
  576. public IEnumerable<Type> GetExportTypes<T>()
  577. {
  578. var currentType = typeof(T);
  579. return AllConcreteTypes.AsParallel().Where(currentType.IsAssignableFrom);
  580. }
  581. /// <summary>
  582. /// Gets the exports.
  583. /// </summary>
  584. /// <typeparam name="T"></typeparam>
  585. /// <param name="manageLiftime">if set to <c>true</c> [manage liftime].</param>
  586. /// <returns>IEnumerable{``0}.</returns>
  587. public IEnumerable<T> GetExports<T>(bool manageLiftime = true)
  588. {
  589. var parts = GetExportTypes<T>()
  590. .Select(CreateInstanceSafe)
  591. .Where(i => i != null)
  592. .Cast<T>()
  593. .ToList();
  594. if (manageLiftime)
  595. {
  596. lock (DisposableParts)
  597. {
  598. DisposableParts.AddRange(parts.OfType<IDisposable>());
  599. }
  600. }
  601. return parts;
  602. }
  603. /// <summary>
  604. /// Gets the application version.
  605. /// </summary>
  606. /// <value>The application version.</value>
  607. public abstract Version ApplicationVersion { get; }
  608. /// <summary>
  609. /// Handles the ConfigurationUpdated event of the ConfigurationManager control.
  610. /// </summary>
  611. /// <param name="sender">The source of the event.</param>
  612. /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
  613. /// <exception cref="System.NotImplementedException"></exception>
  614. protected virtual void OnConfigurationUpdated(object sender, EventArgs e)
  615. {
  616. ConfigureAutorun();
  617. }
  618. protected abstract void ConfigureAutoRunAtStartup(bool autorun);
  619. /// <summary>
  620. /// Removes the plugin.
  621. /// </summary>
  622. /// <param name="plugin">The plugin.</param>
  623. public void RemovePlugin(IPlugin plugin)
  624. {
  625. var list = Plugins.ToList();
  626. list.Remove(plugin);
  627. Plugins = list;
  628. }
  629. /// <summary>
  630. /// Gets a value indicating whether this instance can self restart.
  631. /// </summary>
  632. /// <value><c>true</c> if this instance can self restart; otherwise, <c>false</c>.</value>
  633. public abstract bool CanSelfRestart { get; }
  634. /// <summary>
  635. /// Notifies that the kernel that a change has been made that requires a restart
  636. /// </summary>
  637. public void NotifyPendingRestart()
  638. {
  639. var changed = !HasPendingRestart;
  640. HasPendingRestart = true;
  641. if (changed)
  642. {
  643. EventHelper.QueueEventIfNotNull(HasPendingRestartChanged, this, EventArgs.Empty, Logger);
  644. }
  645. }
  646. /// <summary>
  647. /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
  648. /// </summary>
  649. public void Dispose()
  650. {
  651. Dispose(true);
  652. }
  653. /// <summary>
  654. /// Releases unmanaged and - optionally - managed resources.
  655. /// </summary>
  656. /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
  657. protected virtual void Dispose(bool dispose)
  658. {
  659. if (dispose)
  660. {
  661. var type = GetType();
  662. Logger.Info("Disposing " + type.Name);
  663. var parts = DisposableParts.Distinct().Where(i => i.GetType() != type).ToList();
  664. DisposableParts.Clear();
  665. foreach (var part in parts)
  666. {
  667. Logger.Info("Disposing " + part.GetType().Name);
  668. try
  669. {
  670. part.Dispose();
  671. }
  672. catch (Exception ex)
  673. {
  674. Logger.ErrorException("Error disposing {0}", ex, part.GetType().Name);
  675. }
  676. }
  677. }
  678. }
  679. /// <summary>
  680. /// Restarts this instance.
  681. /// </summary>
  682. public abstract Task Restart();
  683. /// <summary>
  684. /// Gets or sets a value indicating whether this instance can self update.
  685. /// </summary>
  686. /// <value><c>true</c> if this instance can self update; otherwise, <c>false</c>.</value>
  687. public abstract bool CanSelfUpdate { get; }
  688. /// <summary>
  689. /// Checks for update.
  690. /// </summary>
  691. /// <param name="cancellationToken">The cancellation token.</param>
  692. /// <param name="progress">The progress.</param>
  693. /// <returns>Task{CheckForUpdateResult}.</returns>
  694. public abstract Task<CheckForUpdateResult> CheckForApplicationUpdate(CancellationToken cancellationToken,
  695. IProgress<double> progress);
  696. /// <summary>
  697. /// Updates the application.
  698. /// </summary>
  699. /// <param name="package">The package that contains the update</param>
  700. /// <param name="cancellationToken">The cancellation token.</param>
  701. /// <param name="progress">The progress.</param>
  702. /// <returns>Task.</returns>
  703. public abstract Task UpdateApplication(PackageVersionInfo package, CancellationToken cancellationToken,
  704. IProgress<double> progress);
  705. /// <summary>
  706. /// Shuts down.
  707. /// </summary>
  708. public abstract Task Shutdown();
  709. /// <summary>
  710. /// Called when [application updated].
  711. /// </summary>
  712. /// <param name="package">The package.</param>
  713. protected void OnApplicationUpdated(PackageVersionInfo package)
  714. {
  715. Logger.Info("Application has been updated to version {0}", package.versionStr);
  716. EventHelper.FireEventIfNotNull(ApplicationUpdated, this, new GenericEventArgs<PackageVersionInfo>
  717. {
  718. Argument = package
  719. }, Logger);
  720. NotifyPendingRestart();
  721. }
  722. }
  723. }