using System; using System.Collections.Concurrent; using System.Collections.Generic; using System.Globalization; using System.IO; using System.Linq; using System.Net.Http; using System.Security.Cryptography; using System.Threading; using System.Threading.Tasks; using MediaBrowser.Common; using MediaBrowser.Common.Configuration; using MediaBrowser.Common.Net; using MediaBrowser.Common.Plugins; using MediaBrowser.Common.Updates; using MediaBrowser.Controller.Configuration; using MediaBrowser.Model.Events; using MediaBrowser.Model.IO; using MediaBrowser.Model.Serialization; using MediaBrowser.Model.Updates; using Microsoft.Extensions.Logging; using static MediaBrowser.Common.HexHelper; namespace Emby.Server.Implementations.Updates { /// /// Manages all install, uninstall and update operations (both plugins and system) /// public class InstallationManager : IInstallationManager { public event EventHandler PackageInstalling; public event EventHandler PackageInstallationCompleted; public event EventHandler PackageInstallationFailed; public event EventHandler PackageInstallationCancelled; /// /// The current installations /// private List<(InstallationInfo info, CancellationTokenSource token)> _currentInstallations { get; set; } /// /// The completed installations /// private ConcurrentBag _completedInstallationsInternal; public IEnumerable CompletedInstallations => _completedInstallationsInternal; /// /// Occurs when [plugin uninstalled]. /// public event EventHandler> PluginUninstalled; /// /// Occurs when [plugin updated]. /// public event EventHandler> PluginUpdated; /// /// Occurs when [plugin updated]. /// public event EventHandler> PluginInstalled; /// /// The _logger /// private readonly ILogger _logger; private readonly IApplicationPaths _appPaths; private readonly IHttpClient _httpClient; private readonly IJsonSerializer _jsonSerializer; private readonly IServerConfigurationManager _config; private readonly IFileSystem _fileSystem; /// /// Gets the application host. /// /// The application host. private readonly IApplicationHost _applicationHost; private readonly IZipClient _zipClient; public InstallationManager( ILogger logger, IApplicationHost appHost, IApplicationPaths appPaths, IHttpClient httpClient, IJsonSerializer jsonSerializer, IServerConfigurationManager config, IFileSystem fileSystem, IZipClient zipClient) { if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _currentInstallations = new List<(InstallationInfo, CancellationTokenSource)>(); _completedInstallationsInternal = new ConcurrentBag(); _logger = logger; _applicationHost = appHost; _appPaths = appPaths; _httpClient = httpClient; _jsonSerializer = jsonSerializer; _config = config; _fileSystem = fileSystem; _zipClient = zipClient; } /// /// Gets all available packages. /// /// Task{List{PackageInfo}}. public async Task> GetAvailablePackages( CancellationToken cancellationToken, bool withRegistration = true, string packageType = null, Version applicationVersion = null) { var packages = await GetAvailablePackagesWithoutRegistrationInfo(cancellationToken).ConfigureAwait(false); return FilterPackages(packages, packageType, applicationVersion); } /// /// Gets all available packages. /// /// The cancellation token. /// Task{List{PackageInfo}}. public async Task> GetAvailablePackagesWithoutRegistrationInfo(CancellationToken cancellationToken) { using (var response = await _httpClient.SendAsync( new HttpRequestOptions { Url = "https://repo.jellyfin.org/releases/plugin/manifest.json", CancellationToken = cancellationToken, CacheMode = CacheMode.Unconditional, CacheLength = GetCacheLength() }, HttpMethod.Get).ConfigureAwait(false)) using (Stream stream = response.Content) { return FilterPackages(await _jsonSerializer.DeserializeFromStreamAsync(stream).ConfigureAwait(false)); } } private static TimeSpan GetCacheLength() { return TimeSpan.FromMinutes(3); } protected List FilterPackages(IEnumerable packages) { var list = new List(); foreach (var package in packages) { var versions = new List(); foreach (var version in package.versions) { if (string.IsNullOrEmpty(version.sourceUrl)) { continue; } versions.Add(version); } package.versions = versions .OrderByDescending(x => x.Version) .ToArray(); if (package.versions.Length == 0) { continue; } list.Add(package); } // Remove packages with no versions return list; } protected List FilterPackages(IEnumerable packages, string packageType, Version applicationVersion) { var packagesList = FilterPackages(packages); var returnList = new List(); var filterOnPackageType = !string.IsNullOrEmpty(packageType); foreach (var p in packagesList) { if (filterOnPackageType && !string.Equals(p.type, packageType, StringComparison.OrdinalIgnoreCase)) { continue; } // If an app version was supplied, filter the versions for each package to only include supported versions if (applicationVersion != null) { p.versions = p.versions.Where(v => IsPackageVersionUpToDate(v, applicationVersion)).ToArray(); } if (p.versions.Length == 0) { continue; } returnList.Add(p); } return returnList; } /// /// Determines whether [is package version up to date] [the specified package version info]. /// /// The package version info. /// The current server version. /// true if [is package version up to date] [the specified package version info]; otherwise, false. private static bool IsPackageVersionUpToDate(PackageVersionInfo packageVersionInfo, Version currentServerVersion) { if (string.IsNullOrEmpty(packageVersionInfo.requiredVersionStr)) { return true; } return Version.TryParse(packageVersionInfo.requiredVersionStr, out var requiredVersion) && currentServerVersion >= requiredVersion; } /// /// Gets the package. /// /// The name. /// The assembly guid /// The classification. /// The version. /// Task{PackageVersionInfo}. public async Task GetPackage(string name, string guid, PackageVersionClass classification, Version version) { var packages = await GetAvailablePackages(CancellationToken.None, false).ConfigureAwait(false); var package = packages.FirstOrDefault(p => string.Equals(p.guid, guid ?? "none", StringComparison.OrdinalIgnoreCase)) ?? packages.FirstOrDefault(p => p.name.Equals(name, StringComparison.OrdinalIgnoreCase)); if (package == null) { return null; } return package.versions.FirstOrDefault(v => v.Version == version && v.classification == classification); } /// /// Gets the latest compatible version. /// /// The name. /// The assembly guid if this is a plug-in /// The current server version. /// The classification. /// Task{PackageVersionInfo}. public async Task GetLatestCompatibleVersion(string name, string guid, Version currentServerVersion, PackageVersionClass classification = PackageVersionClass.Release) { var packages = await GetAvailablePackages(CancellationToken.None, false).ConfigureAwait(false); return GetLatestCompatibleVersion(packages, name, guid, currentServerVersion, classification); } /// /// Gets the latest compatible version. /// /// The available packages. /// The name. /// The current server version. /// The classification. /// PackageVersionInfo. public PackageVersionInfo GetLatestCompatibleVersion(IEnumerable availablePackages, string name, string guid, Version currentServerVersion, PackageVersionClass classification = PackageVersionClass.Release) { var package = availablePackages.FirstOrDefault(p => string.Equals(p.guid, guid ?? "none", StringComparison.OrdinalIgnoreCase)) ?? availablePackages.FirstOrDefault(p => p.name.Equals(name, StringComparison.OrdinalIgnoreCase)); return package?.versions .OrderByDescending(x => x.Version) .FirstOrDefault(v => v.classification <= classification && IsPackageVersionUpToDate(v, currentServerVersion)); } /// /// Gets the available plugin updates. /// /// The current server version. /// if set to true [with auto update enabled]. /// The cancellation token. /// Task{IEnumerable{PackageVersionInfo}}. public async Task> GetAvailablePluginUpdates(Version applicationVersion, bool withAutoUpdateEnabled, CancellationToken cancellationToken) { var catalog = await GetAvailablePackagesWithoutRegistrationInfo(cancellationToken).ConfigureAwait(false); var systemUpdateLevel = _applicationHost.SystemUpdateLevel; // Figure out what needs to be installed return _applicationHost.Plugins.Select(p => { var latestPluginInfo = GetLatestCompatibleVersion(catalog, p.Name, p.Id.ToString(), applicationVersion, systemUpdateLevel); return latestPluginInfo != null && latestPluginInfo.Version > p.Version ? latestPluginInfo : null; }).Where(i => i != null) .Where(p => !string.IsNullOrEmpty(p.sourceUrl) && !CompletedInstallations.Any(i => string.Equals(i.AssemblyGuid, p.guid, StringComparison.OrdinalIgnoreCase))); } /// public async Task InstallPackage(PackageVersionInfo package, CancellationToken cancellationToken) { if (package == null) { throw new ArgumentNullException(nameof(package)); } var installationInfo = new InstallationInfo { Id = Guid.NewGuid(), Name = package.name, AssemblyGuid = package.guid, UpdateClass = package.classification, Version = package.versionStr }; var innerCancellationTokenSource = new CancellationTokenSource(); var tuple = (installationInfo, innerCancellationTokenSource); // Add it to the in-progress list lock (_currentInstallations) { _currentInstallations.Add(tuple); } var linkedToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, innerCancellationTokenSource.Token).Token; var installationEventArgs = new InstallationEventArgs { InstallationInfo = installationInfo, PackageVersionInfo = package }; PackageInstalling?.Invoke(this, installationEventArgs); try { await InstallPackageInternal(package, linkedToken).ConfigureAwait(false); lock (_currentInstallations) { _currentInstallations.Remove(tuple); } _completedInstallationsInternal.Add(installationInfo); PackageInstallationCompleted?.Invoke(this, installationEventArgs); } catch (OperationCanceledException) { lock (_currentInstallations) { _currentInstallations.Remove(tuple); } _logger.LogInformation("Package installation cancelled: {0} {1}", package.name, package.versionStr); PackageInstallationCancelled?.Invoke(this, installationEventArgs); throw; } catch (Exception ex) { _logger.LogError(ex, "Package installation failed"); lock (_currentInstallations) { _currentInstallations.Remove(tuple); } PackageInstallationFailed?.Invoke(this, new InstallationFailedEventArgs { InstallationInfo = installationInfo, Exception = ex }); throw; } finally { // Dispose the progress object and remove the installation from the in-progress list tuple.Item2.Dispose(); } } /// /// Installs the package internal. /// /// The package. /// The cancellation token. /// . private async Task InstallPackageInternal(PackageVersionInfo package, CancellationToken cancellationToken) { // Set last update time if we were installed before IPlugin plugin = _applicationHost.Plugins.FirstOrDefault(p => string.Equals(p.Id.ToString(), package.guid, StringComparison.OrdinalIgnoreCase)) ?? _applicationHost.Plugins.FirstOrDefault(p => p.Name.Equals(package.name, StringComparison.OrdinalIgnoreCase)); // Do the install await PerformPackageInstallation(package, cancellationToken).ConfigureAwait(false); // Do plugin-specific processing if (plugin == null) { _logger.LogInformation("New plugin installed: {0} {1} {2}", package.name, package.versionStr ?? string.Empty, package.classification); PluginInstalled?.Invoke(this, new GenericEventArgs(package)); } else { _logger.LogInformation("Plugin updated: {0} {1} {2}", package.name, package.versionStr ?? string.Empty, package.classification); PluginUpdated?.Invoke(this, new GenericEventArgs<(IPlugin, PackageVersionInfo)>((plugin, package))); } _applicationHost.NotifyPendingRestart(); } private async Task PerformPackageInstallation(PackageVersionInfo package, CancellationToken cancellationToken) { var extension = Path.GetExtension(package.targetFilename); if (!string.Equals(extension, ".zip", StringComparison.OrdinalIgnoreCase)) { _logger.LogError("Only zip packages are supported. {Filename} is not a zip archive.", package.targetFilename); return; } // Always override the passed-in target (which is a file) and figure it out again string targetDir = Path.Combine(_appPaths.PluginsPath, package.name); // CA5351: Do Not Use Broken Cryptographic Algorithms #pragma warning disable CA5351 using (var res = await _httpClient.SendAsync( new HttpRequestOptions { Url = package.sourceUrl, CancellationToken = cancellationToken, // We need it to be buffered for setting the position BufferContent = true }, HttpMethod.Get).ConfigureAwait(false)) using (var stream = res.Content) using (var md5 = MD5.Create()) { cancellationToken.ThrowIfCancellationRequested(); var hash = ToHexString(md5.ComputeHash(stream)); if (!string.Equals(package.checksum, hash, StringComparison.OrdinalIgnoreCase)) { _logger.LogError( "The checksums didn't match while installing {Package}, expected: {Expected}, got: {Received}", package.name, package.checksum, hash); throw new InvalidDataException("The checksum of the received data doesn't match."); } if (Directory.Exists(targetDir)) { Directory.Delete(targetDir, true); } stream.Position = 0; _zipClient.ExtractAllFromZip(stream, targetDir, true); } #pragma warning restore CA5351 } /// /// Uninstalls a plugin /// /// The plugin. public void UninstallPlugin(IPlugin plugin) { plugin.OnUninstalling(); // Remove it the quick way for now _applicationHost.RemovePlugin(plugin); var path = plugin.AssemblyFilePath; bool isDirectory = false; // Check if we have a plugin directory we should remove too if (Path.GetDirectoryName(plugin.AssemblyFilePath) != _appPaths.PluginsPath) { path = Path.GetDirectoryName(plugin.AssemblyFilePath); isDirectory = true; } // Make this case-insensitive to account for possible incorrect assembly naming var file = _fileSystem.GetFilePaths(Path.GetDirectoryName(path)) .FirstOrDefault(i => string.Equals(i, path, StringComparison.OrdinalIgnoreCase)); if (!string.IsNullOrWhiteSpace(file)) { path = file; } if (isDirectory) { _logger.LogInformation("Deleting plugin directory {0}", path); Directory.Delete(path, true); } else { _logger.LogInformation("Deleting plugin file {0}", path); _fileSystem.DeleteFile(path); } var list = _config.Configuration.UninstalledPlugins.ToList(); var filename = Path.GetFileName(path); if (!list.Contains(filename, StringComparer.OrdinalIgnoreCase)) { list.Add(filename); _config.Configuration.UninstalledPlugins = list.ToArray(); _config.SaveConfiguration(); } PluginUninstalled?.Invoke(this, new GenericEventArgs { Argument = plugin }); _applicationHost.NotifyPendingRestart(); } /// public bool CancelInstallation(Guid id) { lock (_currentInstallations) { var install = _currentInstallations.Find(x => x.Item1.Id == id); if (install == default((InstallationInfo, CancellationTokenSource))) { return false; } install.Item2.Cancel(); _currentInstallations.Remove(install); return true; } } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } /// /// Releases unmanaged and - optionally - managed resources. /// /// true to release both managed and unmanaged resources; false to release only unmanaged resources. protected virtual void Dispose(bool dispose) { if (dispose) { lock (_currentInstallations) { foreach (var tuple in _currentInstallations) { tuple.Item2.Dispose(); } _currentInstallations.Clear(); } } } } }