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.Cryptography; 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 { get; set; } public IEnumerable CompletedInstallations => CompletedInstallationsInternal; #region PluginUninstalled Event /// /// 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 }); } #endregion #region PluginUpdated Event /// /// 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(); } #endregion #region PluginInstalled Event /// /// 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(); } #endregion /// /// 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 ICryptoProvider _cryptographyProvider; // netframework or netcore private readonly string _packageRuntime; public InstallationManager( ILoggerFactory loggerFactory, IApplicationHost appHost, IApplicationPaths appPaths, IHttpClient httpClient, IJsonSerializer jsonSerializer, IServerConfigurationManager config, IFileSystem fileSystem, ICryptoProvider cryptographyProvider, string packageRuntime) { if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } CurrentInstallations = new List>(); CompletedInstallationsInternal = new ConcurrentBag(); _applicationHost = appHost; _appPaths = appPaths; _httpClient = httpClient; _jsonSerializer = jsonSerializer; _config = config; _fileSystem = fileSystem; _cryptographyProvider = cryptographyProvider; _packageRuntime = packageRuntime; _logger = loggerFactory.CreateLogger(nameof(InstallationManager)); } 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) { // TODO cvium: when plugins get back this would need to be fixed // var packages = await GetAvailablePackagesWithoutRegistrationInfo(cancellationToken).ConfigureAwait(false); return new List(); //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://www.mb3admin.local/admin/service/EmbyPackages.json", CancellationToken = cancellationToken, Progress = new SimpleProgress(), CacheLength = GetCacheLength(), CacheMode = CacheMode.Unconditional }, "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; } if (string.IsNullOrEmpty(version.runtimes) || version.runtimes.IndexOf(_packageRuntime, StringComparison.OrdinalIgnoreCase) == -1) { 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) { // Target based on if it is an archive or single assembly // zip archives are assumed to contain directory structures relative to our ProgramDataPath var extension = Path.GetExtension(package.targetFilename); var isArchive = string.Equals(extension, ".zip", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".rar", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".7z", StringComparison.OrdinalIgnoreCase); if (target == null) { target = Path.Combine(isArchive ? _appPaths.TempUpdatePath : _appPaths.PluginsPath, package.targetFilename); } // Download to temporary file so that, if interrupted, it won't destroy the existing installation var tempFile = await _httpClient.GetTempFile(new HttpRequestOptions { Url = package.sourceUrl, CancellationToken = cancellationToken, Progress = progress }).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); // Validate with a checksum var packageChecksum = string.IsNullOrWhiteSpace(package.checksum) ? Guid.Empty : new Guid(package.checksum); if (!packageChecksum.Equals(Guid.Empty)) // support for legacy uploads for now { using (var stream = File.OpenRead(tempFile)) { var check = Guid.Parse(BitConverter.ToString(_cryptographyProvider.ComputeMD5(stream)).Replace("-", string.Empty)); if (check != packageChecksum) { throw new Exception(string.Format("Download validation failed for {0}. Probably corrupted during transfer.", package.name)); } } } cancellationToken.ThrowIfCancellationRequested(); // Success - move it to the real target try { Directory.CreateDirectory(Path.GetDirectoryName(target)); File.Copy(tempFile, target, true); //If it is an archive - write out a version file so we know what it is if (isArchive) { File.WriteAllText(target + ".ver", package.versionStr); } } catch (IOException ex) { _logger.LogError(ex, "Error attempting to move file from {TempFile} to {TargetFile}", tempFile, target); throw; } try { _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; _logger.LogInformation("Deleting plugin file {0}", path); // 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; } _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); } } }