using System; using System.Collections.Concurrent; using System.Collections.Generic; using System.IO; using System.Linq; 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.Progress; 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; 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 /// public List> CurrentInstallations { get; set; } /// /// The completed installations /// private ConcurrentBag _completedInstallationsInternal; public IEnumerable CompletedInstallations => _completedInstallationsInternal; /// /// Occurs when [plugin uninstalled]. /// public event EventHandler> PluginUninstalled; /// /// Called when [plugin uninstalled]. /// /// The plugin. private void OnPluginUninstalled(IPlugin plugin) { PluginUninstalled?.Invoke(this, new GenericEventArgs { Argument = plugin }); } /// /// Occurs when [plugin updated]. /// public event EventHandler>> PluginUpdated; /// /// Called when [plugin updated]. /// /// The plugin. /// The new version. private void OnPluginUpdated(IPlugin plugin, PackageVersionInfo newVersion) { _logger.LogInformation("Plugin updated: {0} {1} {2}", newVersion.name, newVersion.versionStr ?? string.Empty, newVersion.classification); PluginUpdated?.Invoke(this, new GenericEventArgs> { Argument = new Tuple(plugin, newVersion) }); _applicationHost.NotifyPendingRestart(); } /// /// Occurs when [plugin updated]. /// public event EventHandler> PluginInstalled; /// /// Called when [plugin installed]. /// /// The package. private void OnPluginInstalled(PackageVersionInfo package) { _logger.LogInformation("New plugin installed: {0} {1} {2}", package.name, package.versionStr ?? string.Empty, package.classification); PluginInstalled?.Invoke(this, new GenericEventArgs { Argument = package }); _applicationHost.NotifyPendingRestart(); } /// /// 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( ILoggerFactory loggerFactory, IApplicationHost appHost, IApplicationPaths appPaths, IHttpClient httpClient, IJsonSerializer jsonSerializer, IServerConfigurationManager config, IFileSystem fileSystem, IZipClient zipClient) { if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } CurrentInstallations = new List>(); _completedInstallationsInternal = new ConcurrentBag(); _logger = loggerFactory.CreateLogger(nameof(InstallationManager)); _applicationHost = appHost; _appPaths = appPaths; _httpClient = httpClient; _jsonSerializer = jsonSerializer; _config = config; _fileSystem = fileSystem; _zipClient = zipClient; } private static Version GetPackageVersion(PackageVersionInfo version) { return new Version(ValueOrDefault(version.versionStr, "0.0.0.1")); } private static string ValueOrDefault(string str, string def) { return string.IsNullOrEmpty(str) ? def : str; } /// /// 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, Progress = new SimpleProgress(), CacheLength = GetCacheLength() }, "GET").ConfigureAwait(false)) { using (var stream = response.Content) { return FilterPackages(await _jsonSerializer.DeserializeFromStreamAsync(stream).ConfigureAwait(false)); } } } private PackageVersionClass GetSystemUpdateLevel() { return _applicationHost.SystemUpdateLevel; } 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(GetPackageVersion) .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 => GetPackageVersion(v).Equals(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)); if (package == null) { return null; } return package.versions .OrderByDescending(GetPackageVersion) .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 = GetSystemUpdateLevel(); // 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 && GetPackageVersion(latestPluginInfo) > 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))); } /// /// Installs the package. /// /// The package. /// if set to true [is plugin]. /// The progress. /// The cancellation token. /// Task. /// package public async Task InstallPackage(PackageVersionInfo package, bool isPlugin, IProgress progress, CancellationToken cancellationToken) { if (package == null) { throw new ArgumentNullException(nameof(package)); } if (progress == null) { throw new ArgumentNullException(nameof(progress)); } 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 = new Tuple(installationInfo, innerCancellationTokenSource); // Add it to the in-progress list lock (CurrentInstallations) { CurrentInstallations.Add(tuple); } var innerProgress = new ActionableProgress(); // Whenever the progress updates, update the outer progress object and InstallationInfo innerProgress.RegisterAction(percent => { progress.Report(percent); installationInfo.PercentComplete = percent; }); var linkedToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, innerCancellationTokenSource.Token).Token; var installationEventArgs = new InstallationEventArgs { InstallationInfo = installationInfo, PackageVersionInfo = package }; PackageInstalling?.Invoke(this, installationEventArgs); try { await InstallPackageInternal(package, isPlugin, innerProgress, 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. /// if set to true [is plugin]. /// The progress. /// The cancellation token. /// Task. private async Task InstallPackageInternal(PackageVersionInfo package, bool isPlugin, IProgress progress, CancellationToken cancellationToken) { IPlugin plugin = null; if (isPlugin) { // Set last update time if we were installed before 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)); } string targetPath = plugin == null ? null : plugin.AssemblyFilePath; // Do the install await PerformPackageInstallation(progress, targetPath, package, cancellationToken).ConfigureAwait(false); // Do plugin-specific processing if (isPlugin) { if (plugin == null) { OnPluginInstalled(package); } else { OnPluginUpdated(plugin, package); } } } private async Task PerformPackageInstallation(IProgress progress, string target, PackageVersionInfo package, CancellationToken cancellationToken) { // TODO: Remove the `string target` argument as it is not used any longer var extension = Path.GetExtension(package.targetFilename); var isArchive = string.Equals(extension, ".zip", StringComparison.OrdinalIgnoreCase); if (!isArchive) { _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 target = Path.Combine(_appPaths.PluginsPath, package.name); _logger.LogDebug("Installing plugin to {Filename}.", target); // Download to temporary file so that, if interrupted, it won't destroy the existing installation _logger.LogDebug("Downloading ZIP."); var tempFile = await _httpClient.GetTempFile(new HttpRequestOptions { Url = package.sourceUrl, CancellationToken = cancellationToken, Progress = progress }).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); // TODO: Validate with a checksum, *properly* // Check if the target directory already exists, and remove it if so if (Directory.Exists(target)) { _logger.LogDebug("Deleting existing plugin at {Filename}.", target); Directory.Delete(target, true); } // Success - move it to the real target try { _logger.LogDebug("Extracting ZIP {TempFile} to {Filename}.", tempFile, target); using (var stream = File.OpenRead(tempFile)) { _zipClient.ExtractAllFromZip(stream, target, true); } } catch (IOException ex) { _logger.LogError(ex, "Error attempting to extract {TempFile} to {TargetFile}", tempFile, target); throw; } try { _logger.LogDebug("Deleting temporary file {Filename}.", tempFile); _fileSystem.DeleteFile(tempFile); } catch (IOException ex) { // Don't fail because of this _logger.LogError(ex, "Error deleting temp file {TempFile}", tempFile); } } /// /// 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(); } OnPluginUninstalled(plugin); _applicationHost.NotifyPendingRestart(); } /// /// 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(); } } } public void Dispose() { Dispose(true); } } }