InstallationManager.cs 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506
  1. #pragma warning disable CS1591
  2. using System;
  3. using System.Collections.Concurrent;
  4. using System.Collections.Generic;
  5. using System.IO;
  6. using System.Linq;
  7. using System.Net.Http;
  8. using System.Runtime.Serialization;
  9. using System.Security.Cryptography;
  10. using System.Threading;
  11. using System.Threading.Tasks;
  12. using MediaBrowser.Common;
  13. using MediaBrowser.Common.Configuration;
  14. using MediaBrowser.Common.Net;
  15. using MediaBrowser.Common.Plugins;
  16. using MediaBrowser.Common.Updates;
  17. using MediaBrowser.Controller.Configuration;
  18. using MediaBrowser.Model.IO;
  19. using MediaBrowser.Model.Net;
  20. using MediaBrowser.Model.Serialization;
  21. using MediaBrowser.Model.Updates;
  22. using Microsoft.Extensions.Logging;
  23. namespace Emby.Server.Implementations.Updates
  24. {
  25. /// <summary>
  26. /// Manages all install, uninstall, and update operations for the system and individual plugins.
  27. /// </summary>
  28. public class InstallationManager : IInstallationManager
  29. {
  30. /// <summary>
  31. /// The logger.
  32. /// </summary>
  33. private readonly ILogger<InstallationManager> _logger;
  34. private readonly IApplicationPaths _appPaths;
  35. private readonly IHttpClient _httpClient;
  36. private readonly IJsonSerializer _jsonSerializer;
  37. private readonly IServerConfigurationManager _config;
  38. private readonly IFileSystem _fileSystem;
  39. /// <summary>
  40. /// Gets the application host.
  41. /// </summary>
  42. /// <value>The application host.</value>
  43. private readonly IApplicationHost _applicationHost;
  44. private readonly IZipClient _zipClient;
  45. private readonly object _currentInstallationsLock = new object();
  46. /// <summary>
  47. /// The current installations.
  48. /// </summary>
  49. private readonly List<(InstallationInfo info, CancellationTokenSource token)> _currentInstallations;
  50. /// <summary>
  51. /// The completed installations.
  52. /// </summary>
  53. private readonly ConcurrentBag<InstallationInfo> _completedInstallationsInternal;
  54. public InstallationManager(
  55. ILogger<InstallationManager> logger,
  56. IApplicationHost appHost,
  57. IApplicationPaths appPaths,
  58. IHttpClient httpClient,
  59. IJsonSerializer jsonSerializer,
  60. IServerConfigurationManager config,
  61. IFileSystem fileSystem,
  62. IZipClient zipClient)
  63. {
  64. if (logger == null)
  65. {
  66. throw new ArgumentNullException(nameof(logger));
  67. }
  68. _currentInstallations = new List<(InstallationInfo, CancellationTokenSource)>();
  69. _completedInstallationsInternal = new ConcurrentBag<InstallationInfo>();
  70. _logger = logger;
  71. _applicationHost = appHost;
  72. _appPaths = appPaths;
  73. _httpClient = httpClient;
  74. _jsonSerializer = jsonSerializer;
  75. _config = config;
  76. _fileSystem = fileSystem;
  77. _zipClient = zipClient;
  78. }
  79. /// <inheritdoc />
  80. public event EventHandler<InstallationInfo> PackageInstalling;
  81. /// <inheritdoc />
  82. public event EventHandler<InstallationInfo> PackageInstallationCompleted;
  83. /// <inheritdoc />
  84. public event EventHandler<InstallationFailedEventArgs> PackageInstallationFailed;
  85. /// <inheritdoc />
  86. public event EventHandler<InstallationInfo> PackageInstallationCancelled;
  87. /// <inheritdoc />
  88. public event EventHandler<IPlugin> PluginUninstalled;
  89. /// <inheritdoc />
  90. public event EventHandler<InstallationInfo> PluginUpdated;
  91. /// <inheritdoc />
  92. public event EventHandler<InstallationInfo> PluginInstalled;
  93. /// <inheritdoc />
  94. public IEnumerable<InstallationInfo> CompletedInstallations => _completedInstallationsInternal;
  95. /// <inheritdoc />
  96. public async Task<IReadOnlyList<PackageInfo>> GetPackages(string manifest, CancellationToken cancellationToken = default)
  97. {
  98. try
  99. {
  100. using (var response = await _httpClient.SendAsync(
  101. new HttpRequestOptions
  102. {
  103. Url = manifest,
  104. CancellationToken = cancellationToken,
  105. CacheMode = CacheMode.Unconditional,
  106. CacheLength = TimeSpan.FromMinutes(3)
  107. },
  108. HttpMethod.Get).ConfigureAwait(false))
  109. using (Stream stream = response.Content)
  110. {
  111. try
  112. {
  113. return await _jsonSerializer.DeserializeFromStreamAsync<IReadOnlyList<PackageInfo>>(stream).ConfigureAwait(false);
  114. }
  115. catch (SerializationException ex)
  116. {
  117. _logger.LogError(ex, "Failed to deserialize the plugin manifest retrieved from {Manifest}", manifest);
  118. return Array.Empty<PackageInfo>();
  119. }
  120. }
  121. }
  122. catch (UriFormatException ex)
  123. {
  124. _logger.LogError(ex, "The URL configured for the plugin repository manifest URL is not valid: {Manifest}", manifest);
  125. return Array.Empty<PackageInfo>();
  126. }
  127. catch (HttpException ex)
  128. {
  129. _logger.LogError(ex, "An error occurred while accessing the plugin manifest: {Manifest}", manifest);
  130. return Array.Empty<PackageInfo>();
  131. }
  132. catch (HttpRequestException ex)
  133. {
  134. _logger.LogError(ex, "An error occurred while accessing the plugin manifest: {Manifest}", manifest);
  135. return Array.Empty<PackageInfo>();
  136. }
  137. }
  138. /// <inheritdoc />
  139. public async Task<IReadOnlyList<PackageInfo>> GetAvailablePackages(CancellationToken cancellationToken = default)
  140. {
  141. var result = new List<PackageInfo>();
  142. foreach (RepositoryInfo repository in _config.Configuration.PluginRepositories)
  143. {
  144. result.AddRange(await GetPackages(repository.Url, cancellationToken).ConfigureAwait(true));
  145. }
  146. return result;
  147. }
  148. /// <inheritdoc />
  149. public IEnumerable<PackageInfo> FilterPackages(
  150. IEnumerable<PackageInfo> availablePackages,
  151. string name = null,
  152. Guid guid = default)
  153. {
  154. if (name != null)
  155. {
  156. availablePackages = availablePackages.Where(x => x.name.Equals(name, StringComparison.OrdinalIgnoreCase));
  157. }
  158. if (guid != Guid.Empty)
  159. {
  160. availablePackages = availablePackages.Where(x => Guid.Parse(x.guid) == guid);
  161. }
  162. return availablePackages;
  163. }
  164. /// <inheritdoc />
  165. public IEnumerable<InstallationInfo> GetCompatibleVersions(
  166. IEnumerable<PackageInfo> availablePackages,
  167. string name = null,
  168. Guid guid = default,
  169. Version minVersion = null)
  170. {
  171. var package = FilterPackages(availablePackages, name, guid).FirstOrDefault();
  172. // Package not found in repository
  173. if (package == null)
  174. {
  175. yield break;
  176. }
  177. var appVer = _applicationHost.ApplicationVersion;
  178. var availableVersions = package.versions
  179. .Where(x => Version.Parse(x.targetAbi) <= appVer);
  180. if (minVersion != null)
  181. {
  182. availableVersions = availableVersions.Where(x => new Version(x.version) >= minVersion);
  183. }
  184. foreach (var v in availableVersions.OrderByDescending(x => x.version))
  185. {
  186. yield return new InstallationInfo
  187. {
  188. Changelog = v.changelog,
  189. Guid = new Guid(package.guid),
  190. Name = package.name,
  191. Version = new Version(v.version),
  192. SourceUrl = v.sourceUrl,
  193. Checksum = v.checksum
  194. };
  195. }
  196. }
  197. /// <inheritdoc />
  198. public async Task<IEnumerable<InstallationInfo>> GetAvailablePluginUpdates(CancellationToken cancellationToken = default)
  199. {
  200. var catalog = await GetAvailablePackages(cancellationToken).ConfigureAwait(false);
  201. return GetAvailablePluginUpdates(catalog);
  202. }
  203. private IEnumerable<InstallationInfo> GetAvailablePluginUpdates(IReadOnlyList<PackageInfo> pluginCatalog)
  204. {
  205. foreach (var plugin in _applicationHost.Plugins)
  206. {
  207. var compatibleversions = GetCompatibleVersions(pluginCatalog, plugin.Name, plugin.Id, plugin.Version);
  208. var version = compatibleversions.FirstOrDefault(y => y.Version > plugin.Version);
  209. if (version != null && CompletedInstallations.All(x => x.Guid != version.Guid))
  210. {
  211. yield return version;
  212. }
  213. }
  214. }
  215. /// <inheritdoc />
  216. public async Task InstallPackage(InstallationInfo package, CancellationToken cancellationToken)
  217. {
  218. if (package == null)
  219. {
  220. throw new ArgumentNullException(nameof(package));
  221. }
  222. var innerCancellationTokenSource = new CancellationTokenSource();
  223. var tuple = (package, innerCancellationTokenSource);
  224. // Add it to the in-progress list
  225. lock (_currentInstallationsLock)
  226. {
  227. _currentInstallations.Add(tuple);
  228. }
  229. var linkedToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, innerCancellationTokenSource.Token).Token;
  230. PackageInstalling?.Invoke(this, package);
  231. try
  232. {
  233. await InstallPackageInternal(package, linkedToken).ConfigureAwait(false);
  234. lock (_currentInstallationsLock)
  235. {
  236. _currentInstallations.Remove(tuple);
  237. }
  238. _completedInstallationsInternal.Add(package);
  239. PackageInstallationCompleted?.Invoke(this, package);
  240. }
  241. catch (OperationCanceledException)
  242. {
  243. lock (_currentInstallationsLock)
  244. {
  245. _currentInstallations.Remove(tuple);
  246. }
  247. _logger.LogInformation("Package installation cancelled: {0} {1}", package.Name, package.Version);
  248. PackageInstallationCancelled?.Invoke(this, package);
  249. throw;
  250. }
  251. catch (Exception ex)
  252. {
  253. _logger.LogError(ex, "Package installation failed");
  254. lock (_currentInstallationsLock)
  255. {
  256. _currentInstallations.Remove(tuple);
  257. }
  258. PackageInstallationFailed?.Invoke(this, new InstallationFailedEventArgs
  259. {
  260. InstallationInfo = package,
  261. Exception = ex
  262. });
  263. throw;
  264. }
  265. finally
  266. {
  267. // Dispose the progress object and remove the installation from the in-progress list
  268. tuple.innerCancellationTokenSource.Dispose();
  269. }
  270. }
  271. /// <summary>
  272. /// Installs the package internal.
  273. /// </summary>
  274. /// <param name="package">The package.</param>
  275. /// <param name="cancellationToken">The cancellation token.</param>
  276. /// <returns><see cref="Task" />.</returns>
  277. private async Task InstallPackageInternal(InstallationInfo package, CancellationToken cancellationToken)
  278. {
  279. // Set last update time if we were installed before
  280. IPlugin plugin = _applicationHost.Plugins.FirstOrDefault(p => p.Id == package.Guid)
  281. ?? _applicationHost.Plugins.FirstOrDefault(p => p.Name.Equals(package.Name, StringComparison.OrdinalIgnoreCase));
  282. // Do the install
  283. await PerformPackageInstallation(package, cancellationToken).ConfigureAwait(false);
  284. // Do plugin-specific processing
  285. if (plugin == null)
  286. {
  287. _logger.LogInformation("New plugin installed: {0} {1}", package.Name, package.Version);
  288. PluginInstalled?.Invoke(this, package);
  289. }
  290. else
  291. {
  292. _logger.LogInformation("Plugin updated: {0} {1}", package.Name, package.Version);
  293. PluginUpdated?.Invoke(this, package);
  294. }
  295. _applicationHost.NotifyPendingRestart();
  296. }
  297. private async Task PerformPackageInstallation(InstallationInfo package, CancellationToken cancellationToken)
  298. {
  299. var extension = Path.GetExtension(package.SourceUrl);
  300. if (!string.Equals(extension, ".zip", StringComparison.OrdinalIgnoreCase))
  301. {
  302. _logger.LogError("Only zip packages are supported. {SourceUrl} is not a zip archive.", package.SourceUrl);
  303. return;
  304. }
  305. // Always override the passed-in target (which is a file) and figure it out again
  306. string targetDir = Path.Combine(_appPaths.PluginsPath, package.Name);
  307. // CA5351: Do Not Use Broken Cryptographic Algorithms
  308. #pragma warning disable CA5351
  309. using (var res = await _httpClient.SendAsync(
  310. new HttpRequestOptions
  311. {
  312. Url = package.SourceUrl,
  313. CancellationToken = cancellationToken,
  314. // We need it to be buffered for setting the position
  315. BufferContent = true
  316. },
  317. HttpMethod.Get).ConfigureAwait(false))
  318. using (var stream = res.Content)
  319. using (var md5 = MD5.Create())
  320. {
  321. cancellationToken.ThrowIfCancellationRequested();
  322. var hash = Hex.Encode(md5.ComputeHash(stream));
  323. if (!string.Equals(package.Checksum, hash, StringComparison.OrdinalIgnoreCase))
  324. {
  325. _logger.LogError(
  326. "The checksums didn't match while installing {Package}, expected: {Expected}, got: {Received}",
  327. package.Name,
  328. package.Checksum,
  329. hash);
  330. throw new InvalidDataException("The checksum of the received data doesn't match.");
  331. }
  332. if (Directory.Exists(targetDir))
  333. {
  334. Directory.Delete(targetDir, true);
  335. }
  336. stream.Position = 0;
  337. _zipClient.ExtractAllFromZip(stream, targetDir, true);
  338. }
  339. #pragma warning restore CA5351
  340. }
  341. /// <summary>
  342. /// Uninstalls a plugin.
  343. /// </summary>
  344. /// <param name="plugin">The plugin.</param>
  345. public void UninstallPlugin(IPlugin plugin)
  346. {
  347. if (!plugin.CanUninstall)
  348. {
  349. _logger.LogWarning("Attempt to delete non removable plugin {0}, ignoring request", plugin.Name);
  350. return;
  351. }
  352. plugin.OnUninstalling();
  353. // Remove it the quick way for now
  354. _applicationHost.RemovePlugin(plugin);
  355. var path = plugin.AssemblyFilePath;
  356. bool isDirectory = false;
  357. // Check if we have a plugin directory we should remove too
  358. if (Path.GetDirectoryName(plugin.AssemblyFilePath) != _appPaths.PluginsPath)
  359. {
  360. path = Path.GetDirectoryName(plugin.AssemblyFilePath);
  361. isDirectory = true;
  362. }
  363. // Make this case-insensitive to account for possible incorrect assembly naming
  364. var file = _fileSystem.GetFilePaths(Path.GetDirectoryName(path))
  365. .FirstOrDefault(i => string.Equals(i, path, StringComparison.OrdinalIgnoreCase));
  366. if (!string.IsNullOrWhiteSpace(file))
  367. {
  368. path = file;
  369. }
  370. if (isDirectory)
  371. {
  372. _logger.LogInformation("Deleting plugin directory {0}", path);
  373. Directory.Delete(path, true);
  374. }
  375. else
  376. {
  377. _logger.LogInformation("Deleting plugin file {0}", path);
  378. _fileSystem.DeleteFile(path);
  379. }
  380. var list = _config.Configuration.UninstalledPlugins.ToList();
  381. var filename = Path.GetFileName(path);
  382. if (!list.Contains(filename, StringComparer.OrdinalIgnoreCase))
  383. {
  384. list.Add(filename);
  385. _config.Configuration.UninstalledPlugins = list.ToArray();
  386. _config.SaveConfiguration();
  387. }
  388. PluginUninstalled?.Invoke(this, plugin);
  389. _applicationHost.NotifyPendingRestart();
  390. }
  391. /// <inheritdoc/>
  392. public bool CancelInstallation(Guid id)
  393. {
  394. lock (_currentInstallationsLock)
  395. {
  396. var install = _currentInstallations.Find(x => x.info.Guid == id);
  397. if (install == default((InstallationInfo, CancellationTokenSource)))
  398. {
  399. return false;
  400. }
  401. install.token.Cancel();
  402. _currentInstallations.Remove(install);
  403. return true;
  404. }
  405. }
  406. /// <inheritdoc />
  407. public void Dispose()
  408. {
  409. Dispose(true);
  410. GC.SuppressFinalize(this);
  411. }
  412. /// <summary>
  413. /// Releases unmanaged and optionally managed resources.
  414. /// </summary>
  415. /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources or <c>false</c> to release only unmanaged resources.</param>
  416. protected virtual void Dispose(bool dispose)
  417. {
  418. if (dispose)
  419. {
  420. lock (_currentInstallationsLock)
  421. {
  422. foreach (var tuple in _currentInstallations)
  423. {
  424. tuple.token.Dispose();
  425. }
  426. _currentInstallations.Clear();
  427. }
  428. }
  429. }
  430. }
  431. }