| | | 1 | | using System; |
| | | 2 | | using System.Collections.Generic; |
| | | 3 | | using System.Globalization; |
| | | 4 | | using System.IO; |
| | | 5 | | using System.Linq; |
| | | 6 | | using System.Net.Http; |
| | | 7 | | using System.Reflection; |
| | | 8 | | using System.Runtime.Loader; |
| | | 9 | | using System.Text; |
| | | 10 | | using System.Text.Json; |
| | | 11 | | using System.Threading.Tasks; |
| | | 12 | | using Emby.Server.Implementations.Library; |
| | | 13 | | using Jellyfin.Extensions.Json; |
| | | 14 | | using Jellyfin.Extensions.Json.Converters; |
| | | 15 | | using MediaBrowser.Common.Extensions; |
| | | 16 | | using MediaBrowser.Common.Net; |
| | | 17 | | using MediaBrowser.Common.Plugins; |
| | | 18 | | using MediaBrowser.Controller; |
| | | 19 | | using MediaBrowser.Controller.Plugins; |
| | | 20 | | using MediaBrowser.Model.Configuration; |
| | | 21 | | using MediaBrowser.Model.IO; |
| | | 22 | | using MediaBrowser.Model.Plugins; |
| | | 23 | | using MediaBrowser.Model.Updates; |
| | | 24 | | using Microsoft.Extensions.DependencyInjection; |
| | | 25 | | using Microsoft.Extensions.Logging; |
| | | 26 | | |
| | | 27 | | namespace Emby.Server.Implementations.Plugins |
| | | 28 | | { |
| | | 29 | | /// <summary> |
| | | 30 | | /// Defines the <see cref="PluginManager" />. |
| | | 31 | | /// </summary> |
| | | 32 | | public sealed class PluginManager : IPluginManager, IDisposable |
| | | 33 | | { |
| | | 34 | | private const string MetafileName = "meta.json"; |
| | | 35 | | |
| | | 36 | | private readonly string _pluginsPath; |
| | | 37 | | private readonly Version _appVersion; |
| | | 38 | | private readonly List<AssemblyLoadContext> _assemblyLoadContexts; |
| | | 39 | | private readonly JsonSerializerOptions _jsonOptions; |
| | | 40 | | private readonly ILogger<PluginManager> _logger; |
| | | 41 | | private readonly IServerApplicationHost _appHost; |
| | | 42 | | private readonly ServerConfiguration _config; |
| | | 43 | | private readonly List<LocalPlugin> _plugins; |
| | | 44 | | private readonly Version _minimumVersion; |
| | | 45 | | |
| | | 46 | | private IHttpClientFactory? _httpClientFactory; |
| | | 47 | | |
| | | 48 | | /// <summary> |
| | | 49 | | /// Initializes a new instance of the <see cref="PluginManager"/> class. |
| | | 50 | | /// </summary> |
| | | 51 | | /// <param name="logger">The <see cref="ILogger{PluginManager}"/>.</param> |
| | | 52 | | /// <param name="appHost">The <see cref="IServerApplicationHost"/>.</param> |
| | | 53 | | /// <param name="config">The <see cref="ServerConfiguration"/>.</param> |
| | | 54 | | /// <param name="pluginsPath">The plugin path.</param> |
| | | 55 | | /// <param name="appVersion">The application version.</param> |
| | | 56 | | public PluginManager( |
| | | 57 | | ILogger<PluginManager> logger, |
| | | 58 | | IServerApplicationHost appHost, |
| | | 59 | | ServerConfiguration config, |
| | | 60 | | string pluginsPath, |
| | | 61 | | Version appVersion) |
| | | 62 | | { |
| | 38 | 63 | | _logger = logger ?? throw new ArgumentNullException(nameof(logger)); |
| | 38 | 64 | | _pluginsPath = pluginsPath; |
| | 38 | 65 | | _appVersion = appVersion ?? throw new ArgumentNullException(nameof(appVersion)); |
| | 38 | 66 | | _jsonOptions = new JsonSerializerOptions(JsonDefaults.Options) |
| | 38 | 67 | | { |
| | 38 | 68 | | WriteIndented = true |
| | 38 | 69 | | }; |
| | | 70 | | |
| | | 71 | | // We need to use the default GUID converter, so we need to remove any custom ones. |
| | 684 | 72 | | for (int a = _jsonOptions.Converters.Count - 1; a >= 0; a--) |
| | | 73 | | { |
| | 342 | 74 | | if (_jsonOptions.Converters[a] is JsonGuidConverter convertor) |
| | | 75 | | { |
| | 38 | 76 | | _jsonOptions.Converters.Remove(convertor); |
| | 38 | 77 | | break; |
| | | 78 | | } |
| | | 79 | | } |
| | | 80 | | |
| | 38 | 81 | | _config = config; |
| | 38 | 82 | | _appHost = appHost; |
| | 38 | 83 | | _minimumVersion = new Version(0, 0, 0, 1); |
| | 38 | 84 | | _plugins = Directory.Exists(_pluginsPath) ? DiscoverPlugins().ToList() : new List<LocalPlugin>(); |
| | | 85 | | |
| | 38 | 86 | | _assemblyLoadContexts = new List<AssemblyLoadContext>(); |
| | 38 | 87 | | } |
| | | 88 | | |
| | | 89 | | private IHttpClientFactory HttpClientFactory |
| | | 90 | | { |
| | | 91 | | get |
| | | 92 | | { |
| | 0 | 93 | | return _httpClientFactory ??= _appHost.Resolve<IHttpClientFactory>(); |
| | | 94 | | } |
| | | 95 | | } |
| | | 96 | | |
| | | 97 | | /// <summary> |
| | | 98 | | /// Gets the Plugins. |
| | | 99 | | /// </summary> |
| | 24 | 100 | | public IReadOnlyList<LocalPlugin> Plugins => _plugins; |
| | | 101 | | |
| | | 102 | | /// <summary> |
| | | 103 | | /// Returns all the assemblies. |
| | | 104 | | /// </summary> |
| | | 105 | | /// <returns>An IEnumerable{Assembly}.</returns> |
| | | 106 | | public IEnumerable<Assembly> LoadAssemblies() |
| | | 107 | | { |
| | | 108 | | // Attempt to remove any deleted plugins and change any successors to be active. |
| | 42 | 109 | | for (int i = _plugins.Count - 1; i >= 0; i--) |
| | | 110 | | { |
| | 0 | 111 | | var plugin = _plugins[i]; |
| | 0 | 112 | | if (plugin.Manifest.Status == PluginStatus.Deleted && DeletePlugin(plugin)) |
| | | 113 | | { |
| | | 114 | | // See if there is another version, and if so make that active. |
| | 0 | 115 | | ProcessAlternative(plugin); |
| | | 116 | | } |
| | | 117 | | } |
| | | 118 | | |
| | | 119 | | // Now load the assemblies.. |
| | 42 | 120 | | foreach (var plugin in _plugins) |
| | | 121 | | { |
| | 0 | 122 | | UpdatePluginSupersededStatus(plugin); |
| | | 123 | | |
| | 0 | 124 | | if (plugin.IsEnabledAndSupported == false) |
| | | 125 | | { |
| | 0 | 126 | | _logger.LogInformation("Skipping disabled plugin {Version} of {Name} ", plugin.Version, plugin.Name) |
| | 0 | 127 | | continue; |
| | | 128 | | } |
| | | 129 | | |
| | 0 | 130 | | var assemblyLoadContext = new PluginLoadContext(plugin.Path); |
| | 0 | 131 | | _assemblyLoadContexts.Add(assemblyLoadContext); |
| | | 132 | | |
| | 0 | 133 | | var assemblies = new List<Assembly>(plugin.DllFiles.Count); |
| | 0 | 134 | | var loadedAll = true; |
| | | 135 | | |
| | 0 | 136 | | foreach (var file in plugin.DllFiles) |
| | | 137 | | { |
| | | 138 | | try |
| | | 139 | | { |
| | 0 | 140 | | assemblies.Add(assemblyLoadContext.LoadFromAssemblyPath(file)); |
| | 0 | 141 | | } |
| | 0 | 142 | | catch (FileLoadException ex) |
| | | 143 | | { |
| | 0 | 144 | | _logger.LogError(ex, "Failed to load assembly {Path}. Disabling plugin", file); |
| | 0 | 145 | | ChangePluginState(plugin, PluginStatus.Malfunctioned); |
| | 0 | 146 | | loadedAll = false; |
| | 0 | 147 | | break; |
| | | 148 | | } |
| | | 149 | | #pragma warning disable CA1031 // Do not catch general exception types |
| | 0 | 150 | | catch (Exception ex) |
| | | 151 | | #pragma warning restore CA1031 // Do not catch general exception types |
| | | 152 | | { |
| | 0 | 153 | | _logger.LogError(ex, "Failed to load assembly {Path}. Unknown exception was thrown. Disabling pl |
| | 0 | 154 | | ChangePluginState(plugin, PluginStatus.Malfunctioned); |
| | 0 | 155 | | loadedAll = false; |
| | 0 | 156 | | break; |
| | | 157 | | } |
| | | 158 | | } |
| | | 159 | | |
| | 0 | 160 | | if (!loadedAll) |
| | | 161 | | { |
| | | 162 | | continue; |
| | | 163 | | } |
| | | 164 | | |
| | 0 | 165 | | foreach (var assembly in assemblies) |
| | | 166 | | { |
| | | 167 | | try |
| | | 168 | | { |
| | | 169 | | // Load all required types to verify that the plugin will load |
| | 0 | 170 | | assembly.GetTypes(); |
| | 0 | 171 | | } |
| | 0 | 172 | | catch (SystemException ex) when (ex is TypeLoadException or ReflectionTypeLoadException) // Undocume |
| | | 173 | | { |
| | 0 | 174 | | _logger.LogError(ex, "Failed to load assembly {Path}. This error occurs when a plugin references |
| | 0 | 175 | | ChangePluginState(plugin, PluginStatus.NotSupported); |
| | 0 | 176 | | break; |
| | | 177 | | } |
| | | 178 | | #pragma warning disable CA1031 // Do not catch general exception types |
| | 0 | 179 | | catch (Exception ex) |
| | | 180 | | #pragma warning restore CA1031 // Do not catch general exception types |
| | | 181 | | { |
| | 0 | 182 | | _logger.LogError(ex, "Failed to load assembly {Path}. Unknown exception was thrown. Disabling pl |
| | 0 | 183 | | ChangePluginState(plugin, PluginStatus.Malfunctioned); |
| | 0 | 184 | | break; |
| | | 185 | | } |
| | | 186 | | |
| | 0 | 187 | | _logger.LogInformation("Loaded assembly {Assembly} from {Path}", assembly.FullName, assembly.Locatio |
| | 0 | 188 | | yield return assembly; |
| | | 189 | | } |
| | 0 | 190 | | } |
| | 21 | 191 | | } |
| | | 192 | | |
| | | 193 | | /// <summary> |
| | | 194 | | /// Creates all the plugin instances. |
| | | 195 | | /// </summary> |
| | | 196 | | public void CreatePlugins() |
| | | 197 | | { |
| | 21 | 198 | | _ = _appHost.GetExports<IPlugin>(CreatePluginInstance); |
| | 21 | 199 | | } |
| | | 200 | | |
| | | 201 | | /// <summary> |
| | | 202 | | /// Registers the plugin's services with the DI. |
| | | 203 | | /// Note: DI is not yet instantiated yet. |
| | | 204 | | /// </summary> |
| | | 205 | | /// <param name="serviceCollection">A <see cref="ServiceCollection"/> instance.</param> |
| | | 206 | | public void RegisterServices(IServiceCollection serviceCollection) |
| | | 207 | | { |
| | 42 | 208 | | foreach (var pluginServiceRegistrator in _appHost.GetExportTypes<IPluginServiceRegistrator>()) |
| | | 209 | | { |
| | 0 | 210 | | var plugin = GetPluginByAssembly(pluginServiceRegistrator.Assembly); |
| | 0 | 211 | | if (plugin is null) |
| | | 212 | | { |
| | 0 | 213 | | _logger.LogError("Unable to find plugin in assembly {Assembly}", pluginServiceRegistrator.Assembly.F |
| | 0 | 214 | | continue; |
| | | 215 | | } |
| | | 216 | | |
| | 0 | 217 | | UpdatePluginSupersededStatus(plugin); |
| | 0 | 218 | | if (!plugin.IsEnabledAndSupported) |
| | | 219 | | { |
| | | 220 | | continue; |
| | | 221 | | } |
| | | 222 | | |
| | | 223 | | try |
| | | 224 | | { |
| | 0 | 225 | | var instance = (IPluginServiceRegistrator?)Activator.CreateInstance(pluginServiceRegistrator); |
| | 0 | 226 | | instance?.RegisterServices(serviceCollection, _appHost); |
| | 0 | 227 | | } |
| | | 228 | | #pragma warning disable CA1031 // Do not catch general exception types |
| | 0 | 229 | | catch (Exception ex) |
| | | 230 | | #pragma warning restore CA1031 // Do not catch general exception types |
| | | 231 | | { |
| | 0 | 232 | | _logger.LogError(ex, "Error registering plugin services from {Assembly}.", pluginServiceRegistrator. |
| | 0 | 233 | | if (ChangePluginState(plugin, PluginStatus.Malfunctioned)) |
| | | 234 | | { |
| | 0 | 235 | | _logger.LogInformation("Disabling plugin {Path}", plugin.Path); |
| | | 236 | | } |
| | 0 | 237 | | } |
| | | 238 | | } |
| | 21 | 239 | | } |
| | | 240 | | |
| | | 241 | | /// <summary> |
| | | 242 | | /// Imports a plugin manifest from <paramref name="folder"/>. |
| | | 243 | | /// </summary> |
| | | 244 | | /// <param name="folder">Folder of the plugin.</param> |
| | | 245 | | public void ImportPluginFrom(string folder) |
| | | 246 | | { |
| | 0 | 247 | | ArgumentException.ThrowIfNullOrEmpty(folder); |
| | | 248 | | |
| | | 249 | | // Load the plugin. |
| | 0 | 250 | | var plugin = LoadManifest(folder); |
| | | 251 | | // Make sure we haven't already loaded this. |
| | 0 | 252 | | if (_plugins.Any(p => p.Manifest.Equals(plugin.Manifest))) |
| | | 253 | | { |
| | 0 | 254 | | return; |
| | | 255 | | } |
| | | 256 | | |
| | 0 | 257 | | _plugins.Add(plugin); |
| | 0 | 258 | | EnablePlugin(plugin); |
| | 0 | 259 | | } |
| | | 260 | | |
| | | 261 | | /// <summary> |
| | | 262 | | /// Removes the plugin reference '<paramref name="plugin"/>. |
| | | 263 | | /// </summary> |
| | | 264 | | /// <param name="plugin">The plugin.</param> |
| | | 265 | | /// <returns>Outcome of the operation.</returns> |
| | | 266 | | public bool RemovePlugin(LocalPlugin plugin) |
| | | 267 | | { |
| | 0 | 268 | | ArgumentNullException.ThrowIfNull(plugin); |
| | | 269 | | |
| | 0 | 270 | | if (DeletePlugin(plugin)) |
| | | 271 | | { |
| | 0 | 272 | | ProcessAlternative(plugin); |
| | 0 | 273 | | return true; |
| | | 274 | | } |
| | | 275 | | |
| | 0 | 276 | | _logger.LogWarning("Unable to delete {Path}, so marking as deleteOnStartup.", plugin.Path); |
| | | 277 | | // Unable to delete, so disable. |
| | 0 | 278 | | if (ChangePluginState(plugin, PluginStatus.Deleted)) |
| | | 279 | | { |
| | 0 | 280 | | ProcessAlternative(plugin); |
| | 0 | 281 | | return true; |
| | | 282 | | } |
| | | 283 | | |
| | 0 | 284 | | return false; |
| | | 285 | | } |
| | | 286 | | |
| | | 287 | | /// <summary> |
| | | 288 | | /// Attempts to find the plugin with and id of <paramref name="id"/>. |
| | | 289 | | /// </summary> |
| | | 290 | | /// <param name="id">The <see cref="Guid"/> of plugin.</param> |
| | | 291 | | /// <param name="version">Optional <see cref="Version"/> of the plugin to locate.</param> |
| | | 292 | | /// <returns>A <see cref="LocalPlugin"/> if located, or null if not.</returns> |
| | | 293 | | public LocalPlugin? GetPlugin(Guid id, Version? version = null) |
| | | 294 | | { |
| | | 295 | | LocalPlugin? plugin; |
| | | 296 | | |
| | 831 | 297 | | if (version is null) |
| | | 298 | | { |
| | | 299 | | // If no version is given, return the current instance. |
| | 0 | 300 | | var plugins = _plugins.Where(p => p.Id.Equals(id)).ToList(); |
| | | 301 | | |
| | 0 | 302 | | plugin = plugins.FirstOrDefault(p => p.Instance is not null) ?? plugins.MaxBy(p => p.Version); |
| | | 303 | | } |
| | | 304 | | else |
| | | 305 | | { |
| | | 306 | | // Match id and version number. |
| | 831 | 307 | | plugin = _plugins.FirstOrDefault(p => p.Id.Equals(id) && p.Version.Equals(version)); |
| | | 308 | | } |
| | | 309 | | |
| | 831 | 310 | | return plugin; |
| | | 311 | | } |
| | | 312 | | |
| | | 313 | | /// <summary> |
| | | 314 | | /// Enables the plugin, disabling all other versions. |
| | | 315 | | /// </summary> |
| | | 316 | | /// <param name="plugin">The <see cref="LocalPlugin"/> of the plug to disable.</param> |
| | | 317 | | public void EnablePlugin(LocalPlugin plugin) |
| | | 318 | | { |
| | 0 | 319 | | ArgumentNullException.ThrowIfNull(plugin); |
| | | 320 | | |
| | 0 | 321 | | if (ChangePluginState(plugin, PluginStatus.Active)) |
| | | 322 | | { |
| | | 323 | | // See if there is another version, and if so, supercede it. |
| | 0 | 324 | | ProcessAlternative(plugin); |
| | | 325 | | } |
| | 0 | 326 | | } |
| | | 327 | | |
| | | 328 | | /// <summary> |
| | | 329 | | /// Disable the plugin. |
| | | 330 | | /// </summary> |
| | | 331 | | /// <param name="plugin">The <see cref="LocalPlugin"/> of the plug to disable.</param> |
| | | 332 | | public void DisablePlugin(LocalPlugin plugin) |
| | | 333 | | { |
| | 0 | 334 | | ArgumentNullException.ThrowIfNull(plugin); |
| | | 335 | | |
| | | 336 | | // Update the manifest on disk |
| | 0 | 337 | | if (ChangePluginState(plugin, PluginStatus.Disabled)) |
| | | 338 | | { |
| | | 339 | | // If there is another version, activate it. |
| | 0 | 340 | | ProcessAlternative(plugin); |
| | | 341 | | } |
| | 0 | 342 | | } |
| | | 343 | | |
| | | 344 | | /// <summary> |
| | | 345 | | /// Disable the plugin. |
| | | 346 | | /// </summary> |
| | | 347 | | /// <param name="assembly">The <see cref="Assembly"/> of the plug to disable.</param> |
| | | 348 | | public void FailPlugin(Assembly assembly) |
| | | 349 | | { |
| | | 350 | | // Only save if disabled. |
| | 0 | 351 | | ArgumentNullException.ThrowIfNull(assembly); |
| | | 352 | | |
| | 0 | 353 | | var plugin = _plugins.FirstOrDefault(p => p.DllFiles.Contains(assembly.Location)); |
| | 0 | 354 | | if (plugin is null) |
| | | 355 | | { |
| | | 356 | | // A plugin's assembly didn't cause this issue, so ignore it. |
| | 0 | 357 | | return; |
| | | 358 | | } |
| | | 359 | | |
| | 0 | 360 | | ChangePluginState(plugin, PluginStatus.Malfunctioned); |
| | 0 | 361 | | } |
| | | 362 | | |
| | | 363 | | /// <inheritdoc/> |
| | | 364 | | public bool SaveManifest(PluginManifest manifest, string path) |
| | | 365 | | { |
| | | 366 | | try |
| | | 367 | | { |
| | 14 | 368 | | var data = JsonSerializer.Serialize(manifest, _jsonOptions); |
| | 14 | 369 | | File.WriteAllText(Path.Combine(path, MetafileName), data); |
| | 14 | 370 | | return true; |
| | | 371 | | } |
| | 0 | 372 | | catch (ArgumentException e) |
| | | 373 | | { |
| | 0 | 374 | | _logger.LogWarning(e, "Unable to save plugin manifest due to invalid value. {Path}", path); |
| | 0 | 375 | | return false; |
| | | 376 | | } |
| | 14 | 377 | | } |
| | | 378 | | |
| | | 379 | | /// <inheritdoc/> |
| | | 380 | | public async Task<bool> PopulateManifest(PackageInfo packageInfo, Version version, string path, PluginStatus sta |
| | | 381 | | { |
| | 4 | 382 | | var versionInfo = packageInfo.Versions.First(v => v.Version == version.ToString()); |
| | 4 | 383 | | var imagePath = string.Empty; |
| | | 384 | | |
| | 4 | 385 | | if (!string.IsNullOrEmpty(packageInfo.ImageUrl)) |
| | | 386 | | { |
| | 0 | 387 | | var url = new Uri(packageInfo.ImageUrl); |
| | 0 | 388 | | imagePath = Path.Join(path, url.Segments[^1]); |
| | | 389 | | |
| | 0 | 390 | | var fileStream = AsyncFile.OpenWrite(imagePath); |
| | 0 | 391 | | Stream? downloadStream = null; |
| | | 392 | | try |
| | | 393 | | { |
| | 0 | 394 | | downloadStream = await HttpClientFactory |
| | 0 | 395 | | .CreateClient(NamedClient.Default) |
| | 0 | 396 | | .GetStreamAsync(url) |
| | 0 | 397 | | .ConfigureAwait(false); |
| | | 398 | | |
| | 0 | 399 | | await downloadStream.CopyToAsync(fileStream).ConfigureAwait(false); |
| | 0 | 400 | | } |
| | 0 | 401 | | catch (HttpRequestException ex) |
| | | 402 | | { |
| | 0 | 403 | | _logger.LogError(ex, "Failed to download image to path {Path} on disk.", imagePath); |
| | 0 | 404 | | imagePath = string.Empty; |
| | 0 | 405 | | } |
| | | 406 | | finally |
| | | 407 | | { |
| | 0 | 408 | | await fileStream.DisposeAsync().ConfigureAwait(false); |
| | 0 | 409 | | if (downloadStream is not null) |
| | | 410 | | { |
| | 0 | 411 | | await downloadStream.DisposeAsync().ConfigureAwait(false); |
| | | 412 | | } |
| | | 413 | | } |
| | 0 | 414 | | } |
| | | 415 | | |
| | 4 | 416 | | var manifest = new PluginManifest |
| | 4 | 417 | | { |
| | 4 | 418 | | Category = packageInfo.Category, |
| | 4 | 419 | | Changelog = versionInfo.Changelog ?? string.Empty, |
| | 4 | 420 | | Description = packageInfo.Description, |
| | 4 | 421 | | Id = packageInfo.Id, |
| | 4 | 422 | | Name = packageInfo.Name, |
| | 4 | 423 | | Overview = packageInfo.Overview, |
| | 4 | 424 | | Owner = packageInfo.Owner, |
| | 4 | 425 | | TargetAbi = versionInfo.TargetAbi ?? string.Empty, |
| | 4 | 426 | | Timestamp = string.IsNullOrEmpty(versionInfo.Timestamp) ? DateTime.MinValue : DateTime.Parse(versionInfo |
| | 4 | 427 | | Version = versionInfo.Version, |
| | 4 | 428 | | Status = status == PluginStatus.Disabled ? PluginStatus.Disabled : PluginStatus.Active, // Keep disabled |
| | 4 | 429 | | AutoUpdate = true, |
| | 4 | 430 | | ImagePath = imagePath |
| | 4 | 431 | | }; |
| | | 432 | | |
| | 4 | 433 | | if (!await ReconcileManifest(manifest, path).ConfigureAwait(false)) |
| | | 434 | | { |
| | | 435 | | // An error occurred during reconciliation and saving could be undesirable. |
| | 0 | 436 | | return false; |
| | | 437 | | } |
| | | 438 | | |
| | 4 | 439 | | return SaveManifest(manifest, path); |
| | 4 | 440 | | } |
| | | 441 | | |
| | | 442 | | /// <inheritdoc /> |
| | | 443 | | public void Dispose() |
| | | 444 | | { |
| | 42 | 445 | | foreach (var assemblyLoadContext in _assemblyLoadContexts) |
| | | 446 | | { |
| | 0 | 447 | | assemblyLoadContext.Unload(); |
| | | 448 | | } |
| | 21 | 449 | | } |
| | | 450 | | |
| | | 451 | | /// <summary> |
| | | 452 | | /// Reconciles the manifest against any properties that exist locally in a pre-packaged meta.json found at the p |
| | | 453 | | /// If no file is found, no reconciliation occurs. |
| | | 454 | | /// </summary> |
| | | 455 | | /// <param name="manifest">The <see cref="PluginManifest"/> to reconcile against.</param> |
| | | 456 | | /// <param name="path">The plugin path.</param> |
| | | 457 | | /// <returns>The reconciled <see cref="PluginManifest"/>.</returns> |
| | | 458 | | private async Task<bool> ReconcileManifest(PluginManifest manifest, string path) |
| | | 459 | | { |
| | | 460 | | try |
| | | 461 | | { |
| | 4 | 462 | | var metafile = Path.Combine(path, MetafileName); |
| | 4 | 463 | | if (!File.Exists(metafile)) |
| | | 464 | | { |
| | 1 | 465 | | _logger.LogInformation("No local manifest exists for plugin {Plugin}. Skipping manifest reconciliati |
| | 1 | 466 | | return true; |
| | | 467 | | } |
| | | 468 | | |
| | 3 | 469 | | using var metaStream = File.OpenRead(metafile); |
| | 3 | 470 | | var localManifest = await JsonSerializer.DeserializeAsync<PluginManifest>(metaStream, _jsonOptions).Conf |
| | 3 | 471 | | localManifest ??= new PluginManifest(); |
| | | 472 | | |
| | 3 | 473 | | if (!Equals(localManifest.Id, manifest.Id)) |
| | | 474 | | { |
| | 1 | 475 | | _logger.LogError("The manifest ID {LocalUUID} did not match the package info ID {PackageUUID}.", loc |
| | 1 | 476 | | manifest.Status = PluginStatus.Malfunctioned; |
| | | 477 | | } |
| | | 478 | | |
| | 3 | 479 | | if (localManifest.Version != manifest.Version) |
| | | 480 | | { |
| | | 481 | | // Package information provides the version and is the source of truth. Pre-packages meta.json is as |
| | 3 | 482 | | _logger.LogWarning("The version of the local manifest was {LocalVersion}, but {PackageVersion} was e |
| | | 483 | | } |
| | | 484 | | |
| | | 485 | | // Explicitly mapping properties instead of using reflection is preferred here. |
| | 3 | 486 | | manifest.Category = string.IsNullOrEmpty(localManifest.Category) ? manifest.Category : localManifest.Cat |
| | 3 | 487 | | manifest.AutoUpdate = localManifest.AutoUpdate; // Preserve whatever is local. Package info does not hav |
| | 3 | 488 | | manifest.Changelog = string.IsNullOrEmpty(localManifest.Changelog) ? manifest.Changelog : localManifest. |
| | 3 | 489 | | manifest.Description = string.IsNullOrEmpty(localManifest.Description) ? manifest.Description : localMan |
| | 3 | 490 | | manifest.Name = string.IsNullOrEmpty(localManifest.Name) ? manifest.Name : localManifest.Name; |
| | 3 | 491 | | manifest.Overview = string.IsNullOrEmpty(localManifest.Overview) ? manifest.Overview : localManifest.Ove |
| | 3 | 492 | | manifest.Owner = string.IsNullOrEmpty(localManifest.Owner) ? manifest.Owner : localManifest.Owner; |
| | 3 | 493 | | manifest.TargetAbi = string.IsNullOrEmpty(localManifest.TargetAbi) ? manifest.TargetAbi : localManifest. |
| | 3 | 494 | | manifest.Timestamp = localManifest.Timestamp.Equals(default) ? manifest.Timestamp : localManifest.Timest |
| | 3 | 495 | | manifest.ImagePath = string.IsNullOrEmpty(localManifest.ImagePath) ? manifest.ImagePath : localManifest. |
| | 3 | 496 | | manifest.Assemblies = localManifest.Assemblies; |
| | | 497 | | |
| | 3 | 498 | | return true; |
| | | 499 | | } |
| | 0 | 500 | | catch (Exception e) |
| | | 501 | | { |
| | 0 | 502 | | _logger.LogWarning(e, "Unable to reconcile plugin manifest due to an error. {Path}", path); |
| | 0 | 503 | | return false; |
| | | 504 | | } |
| | 4 | 505 | | } |
| | | 506 | | |
| | | 507 | | /// <summary> |
| | | 508 | | /// Changes a plugin's load status. |
| | | 509 | | /// </summary> |
| | | 510 | | /// <param name="plugin">The <see cref="LocalPlugin"/> instance.</param> |
| | | 511 | | /// <param name="state">The <see cref="PluginStatus"/> of the plugin.</param> |
| | | 512 | | /// <returns>Success of the task.</returns> |
| | | 513 | | private bool ChangePluginState(LocalPlugin plugin, PluginStatus state) |
| | | 514 | | { |
| | 9 | 515 | | if (plugin.Manifest.Status == state || string.IsNullOrEmpty(plugin.Path)) |
| | | 516 | | { |
| | | 517 | | // No need to save as the state hasn't changed. |
| | 0 | 518 | | return true; |
| | | 519 | | } |
| | | 520 | | |
| | 9 | 521 | | plugin.Manifest.Status = state; |
| | 9 | 522 | | return SaveManifest(plugin.Manifest, plugin.Path); |
| | | 523 | | } |
| | | 524 | | |
| | | 525 | | /// <summary> |
| | | 526 | | /// Finds the plugin record using the assembly. |
| | | 527 | | /// </summary> |
| | | 528 | | /// <param name="assembly">The <see cref="Assembly"/> being sought.</param> |
| | | 529 | | /// <returns>The matching record, or null if not found.</returns> |
| | | 530 | | private LocalPlugin? GetPluginByAssembly(Assembly assembly) |
| | | 531 | | { |
| | | 532 | | // Find which plugin it is by the path. |
| | 168 | 533 | | return _plugins.FirstOrDefault(p => p.DllFiles.Contains(assembly.Location, StringComparer.Ordinal)); |
| | | 534 | | } |
| | | 535 | | |
| | | 536 | | /// <summary> |
| | | 537 | | /// Creates the instance safe. |
| | | 538 | | /// </summary> |
| | | 539 | | /// <param name="type">The type.</param> |
| | | 540 | | /// <returns>System.Object.</returns> |
| | | 541 | | private IPlugin? CreatePluginInstance(Type type) |
| | | 542 | | { |
| | | 543 | | // Find the record for this plugin. |
| | 168 | 544 | | var plugin = GetPluginByAssembly(type.Assembly); |
| | 168 | 545 | | if (plugin?.Manifest.Status < PluginStatus.Active) |
| | | 546 | | { |
| | 0 | 547 | | return null; |
| | | 548 | | } |
| | | 549 | | |
| | | 550 | | try |
| | | 551 | | { |
| | 168 | 552 | | _logger.LogDebug("Creating instance of {Type}", type); |
| | | 553 | | // _appHost.ServiceProvider is already assigned when we create the plugins |
| | 168 | 554 | | var instance = (IPlugin)ActivatorUtilities.CreateInstance(_appHost.ServiceProvider!, type); |
| | 168 | 555 | | if (plugin is null) |
| | | 556 | | { |
| | | 557 | | // Create a dummy record for the providers. |
| | | 558 | | // TODO: remove this code once all provided have been released as separate plugins. |
| | 168 | 559 | | plugin = new LocalPlugin( |
| | 168 | 560 | | instance.AssemblyFilePath, |
| | 168 | 561 | | true, |
| | 168 | 562 | | new PluginManifest |
| | 168 | 563 | | { |
| | 168 | 564 | | Id = instance.Id, |
| | 168 | 565 | | Status = PluginStatus.Active, |
| | 168 | 566 | | Name = instance.Name, |
| | 168 | 567 | | Version = instance.Version.ToString(), |
| | 168 | 568 | | ImageResourceName = (instance as IHasEmbeddedImage)?.ImageResourceName |
| | 168 | 569 | | }) |
| | 168 | 570 | | { |
| | 168 | 571 | | Instance = instance |
| | 168 | 572 | | }; |
| | | 573 | | |
| | 168 | 574 | | _plugins.Add(plugin); |
| | | 575 | | |
| | 168 | 576 | | plugin.Manifest.Status = PluginStatus.Active; |
| | | 577 | | } |
| | | 578 | | else |
| | | 579 | | { |
| | 0 | 580 | | plugin.Instance = instance; |
| | 0 | 581 | | var manifest = plugin.Manifest; |
| | 0 | 582 | | var pluginStr = instance.Version.ToString(); |
| | 0 | 583 | | bool changed = false; |
| | 0 | 584 | | if (string.Equals(manifest.Version, pluginStr, StringComparison.Ordinal) |
| | 0 | 585 | | || !manifest.Id.Equals(instance.Id)) |
| | | 586 | | { |
| | | 587 | | // If a plugin without a manifest failed to load due to an external issue (eg config), |
| | | 588 | | // this updates the manifest to the actual plugin values. |
| | 0 | 589 | | manifest.Version = pluginStr; |
| | 0 | 590 | | manifest.Name = plugin.Instance.Name; |
| | 0 | 591 | | manifest.Description = plugin.Instance.Description; |
| | 0 | 592 | | manifest.Id = plugin.Instance.Id; |
| | 0 | 593 | | changed = true; |
| | | 594 | | } |
| | | 595 | | |
| | 0 | 596 | | changed = changed || manifest.Status != PluginStatus.Active; |
| | 0 | 597 | | manifest.Status = PluginStatus.Active; |
| | | 598 | | |
| | 0 | 599 | | if (changed) |
| | | 600 | | { |
| | 0 | 601 | | SaveManifest(manifest, plugin.Path); |
| | | 602 | | } |
| | | 603 | | } |
| | | 604 | | |
| | 168 | 605 | | _logger.LogInformation("Loaded plugin: {PluginName} {PluginVersion}", plugin.Name, plugin.Version); |
| | | 606 | | |
| | 168 | 607 | | return instance; |
| | | 608 | | } |
| | | 609 | | #pragma warning disable CA1031 // Do not catch general exception types |
| | 0 | 610 | | catch (Exception ex) |
| | | 611 | | #pragma warning restore CA1031 // Do not catch general exception types |
| | | 612 | | { |
| | 0 | 613 | | _logger.LogError(ex, "Error creating {Type}", type.FullName); |
| | 0 | 614 | | if (plugin is not null) |
| | | 615 | | { |
| | 0 | 616 | | if (ChangePluginState(plugin, PluginStatus.Malfunctioned)) |
| | | 617 | | { |
| | 0 | 618 | | _logger.LogInformation("Plugin {Path} has been disabled.", plugin.Path); |
| | 0 | 619 | | return null; |
| | | 620 | | } |
| | | 621 | | } |
| | | 622 | | |
| | 0 | 623 | | _logger.LogDebug("Unable to auto-disable."); |
| | 0 | 624 | | return null; |
| | | 625 | | } |
| | 168 | 626 | | } |
| | | 627 | | |
| | | 628 | | private void UpdatePluginSupersededStatus(LocalPlugin plugin) |
| | | 629 | | { |
| | 0 | 630 | | if (plugin.Manifest.Status != PluginStatus.Superseded) |
| | | 631 | | { |
| | 0 | 632 | | return; |
| | | 633 | | } |
| | | 634 | | |
| | 0 | 635 | | var predecessor = _plugins.OrderByDescending(p => p.Version) |
| | 0 | 636 | | .FirstOrDefault(p => p.Id.Equals(plugin.Id) && p.IsEnabledAndSupported && p.Version != plugin.Version); |
| | 0 | 637 | | if (predecessor is not null) |
| | | 638 | | { |
| | 0 | 639 | | return; |
| | | 640 | | } |
| | | 641 | | |
| | 0 | 642 | | plugin.Manifest.Status = PluginStatus.Active; |
| | 0 | 643 | | } |
| | | 644 | | |
| | | 645 | | /// <summary> |
| | | 646 | | /// Attempts to delete a plugin. |
| | | 647 | | /// </summary> |
| | | 648 | | /// <param name="plugin">A <see cref="LocalPlugin"/> instance to delete.</param> |
| | | 649 | | /// <returns>True if successful.</returns> |
| | | 650 | | private bool DeletePlugin(LocalPlugin plugin) |
| | | 651 | | { |
| | | 652 | | // Attempt a cleanup of old folders. |
| | | 653 | | try |
| | | 654 | | { |
| | 0 | 655 | | Directory.Delete(plugin.Path, true); |
| | 0 | 656 | | _logger.LogDebug("Deleted {Path}", plugin.Path); |
| | 0 | 657 | | } |
| | | 658 | | #pragma warning disable CA1031 // Do not catch general exception types |
| | 0 | 659 | | catch |
| | | 660 | | #pragma warning restore CA1031 // Do not catch general exception types |
| | | 661 | | { |
| | 0 | 662 | | return false; |
| | | 663 | | } |
| | | 664 | | |
| | 0 | 665 | | return _plugins.Remove(plugin); |
| | 0 | 666 | | } |
| | | 667 | | |
| | | 668 | | internal LocalPlugin LoadManifest(string dir) |
| | | 669 | | { |
| | | 670 | | Version? version; |
| | 16 | 671 | | PluginManifest? manifest = null; |
| | 16 | 672 | | var metafile = Path.Combine(dir, MetafileName); |
| | 16 | 673 | | if (File.Exists(metafile)) |
| | | 674 | | { |
| | | 675 | | // Only path where this stays null is when File.ReadAllBytes throws an IOException |
| | 16 | 676 | | byte[] data = null!; |
| | | 677 | | try |
| | | 678 | | { |
| | 16 | 679 | | data = File.ReadAllBytes(metafile); |
| | 16 | 680 | | manifest = JsonSerializer.Deserialize<PluginManifest>(data, _jsonOptions); |
| | 16 | 681 | | } |
| | 0 | 682 | | catch (IOException ex) |
| | | 683 | | { |
| | 0 | 684 | | _logger.LogError(ex, "Error reading file {Path}.", dir); |
| | 0 | 685 | | } |
| | 0 | 686 | | catch (JsonException ex) |
| | | 687 | | { |
| | 0 | 688 | | _logger.LogError(ex, "Error deserializing {Json}.", Encoding.UTF8.GetString(data)); |
| | 0 | 689 | | } |
| | | 690 | | |
| | 16 | 691 | | if (manifest is not null) |
| | | 692 | | { |
| | 16 | 693 | | if (!Version.TryParse(manifest.TargetAbi, out var targetAbi)) |
| | | 694 | | { |
| | 16 | 695 | | targetAbi = _minimumVersion; |
| | | 696 | | } |
| | | 697 | | |
| | 16 | 698 | | if (!Version.TryParse(manifest.Version, out version)) |
| | | 699 | | { |
| | 12 | 700 | | manifest.Version = _minimumVersion.ToString(); |
| | | 701 | | } |
| | | 702 | | |
| | 16 | 703 | | return new LocalPlugin(dir, _appVersion >= targetAbi, manifest); |
| | | 704 | | } |
| | | 705 | | } |
| | | 706 | | |
| | | 707 | | // No metafile, so lets see if the folder is versioned. |
| | | 708 | | // TODO: Phase this support out in future versions. |
| | 0 | 709 | | metafile = dir.Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries)[^1]; |
| | 0 | 710 | | int versionIndex = dir.LastIndexOf('_'); |
| | 0 | 711 | | if (versionIndex != -1) |
| | | 712 | | { |
| | | 713 | | // Get the version number from the filename if possible. |
| | 0 | 714 | | metafile = Path.GetFileName(dir[..versionIndex]); |
| | 0 | 715 | | version = Version.TryParse(dir.AsSpan()[(versionIndex + 1)..], out Version? parsedVersion) ? parsedVersi |
| | | 716 | | } |
| | | 717 | | else |
| | | 718 | | { |
| | | 719 | | // Un-versioned folder - Add it under the path name and version it suitable for this instance. |
| | 0 | 720 | | version = _appVersion; |
| | | 721 | | } |
| | | 722 | | |
| | | 723 | | // Auto-create a plugin manifest, so we can disable it, if it fails to load. |
| | 0 | 724 | | manifest = new PluginManifest |
| | 0 | 725 | | { |
| | 0 | 726 | | Status = PluginStatus.Active, |
| | 0 | 727 | | Name = metafile, |
| | 0 | 728 | | AutoUpdate = false, |
| | 0 | 729 | | Id = metafile.GetMD5(), |
| | 0 | 730 | | TargetAbi = _appVersion.ToString(), |
| | 0 | 731 | | Version = version.ToString() |
| | 0 | 732 | | }; |
| | | 733 | | |
| | 0 | 734 | | return new LocalPlugin(dir, true, manifest); |
| | | 735 | | } |
| | | 736 | | |
| | | 737 | | /// <summary> |
| | | 738 | | /// Gets the list of local plugins. |
| | | 739 | | /// </summary> |
| | | 740 | | /// <returns>Enumerable of local plugins.</returns> |
| | | 741 | | private IEnumerable<LocalPlugin> DiscoverPlugins() |
| | | 742 | | { |
| | 15 | 743 | | var versions = new List<LocalPlugin>(); |
| | | 744 | | |
| | 15 | 745 | | if (!Directory.Exists(_pluginsPath)) |
| | | 746 | | { |
| | | 747 | | // Plugin path doesn't exist, don't try to enumerate sub-folders. |
| | 0 | 748 | | return Enumerable.Empty<LocalPlugin>(); |
| | | 749 | | } |
| | | 750 | | |
| | 15 | 751 | | var directories = Directory.EnumerateDirectories(_pluginsPath, "*.*", SearchOption.TopDirectoryOnly); |
| | 60 | 752 | | foreach (var dir in directories) |
| | | 753 | | { |
| | 15 | 754 | | versions.Add(LoadManifest(dir)); |
| | | 755 | | } |
| | | 756 | | |
| | 15 | 757 | | string lastName = string.Empty; |
| | 15 | 758 | | versions.Sort(LocalPlugin.Compare); |
| | | 759 | | // Traverse backwards through the list. |
| | | 760 | | // The first item will be the latest version. |
| | 60 | 761 | | for (int x = versions.Count - 1; x >= 0; x--) |
| | | 762 | | { |
| | 15 | 763 | | var entry = versions[x]; |
| | 15 | 764 | | if (!string.Equals(lastName, entry.Name, StringComparison.OrdinalIgnoreCase)) |
| | | 765 | | { |
| | 12 | 766 | | if (!TryGetPluginDlls(entry, out var allowedDlls)) |
| | | 767 | | { |
| | 9 | 768 | | _logger.LogError("One or more assembly paths was invalid. Marking plugin {Plugin} as \"Malfuncti |
| | 9 | 769 | | ChangePluginState(entry, PluginStatus.Malfunctioned); |
| | 9 | 770 | | continue; |
| | | 771 | | } |
| | | 772 | | |
| | 3 | 773 | | entry.DllFiles = allowedDlls; |
| | | 774 | | |
| | 3 | 775 | | if (entry.IsEnabledAndSupported) |
| | | 776 | | { |
| | 3 | 777 | | lastName = entry.Name; |
| | 3 | 778 | | continue; |
| | | 779 | | } |
| | | 780 | | } |
| | | 781 | | |
| | 3 | 782 | | if (string.IsNullOrEmpty(lastName)) |
| | | 783 | | { |
| | | 784 | | continue; |
| | | 785 | | } |
| | | 786 | | |
| | 0 | 787 | | var cleaned = false; |
| | 0 | 788 | | var path = entry.Path; |
| | | 789 | | // Attempt a cleanup of old folders. |
| | | 790 | | try |
| | | 791 | | { |
| | 0 | 792 | | _logger.LogDebug("Deleting {Path}", path); |
| | 0 | 793 | | Directory.Delete(path, true); |
| | 0 | 794 | | cleaned = true; |
| | 0 | 795 | | } |
| | | 796 | | #pragma warning disable CA1031 // Do not catch general exception types |
| | 0 | 797 | | catch (Exception e) |
| | | 798 | | #pragma warning restore CA1031 // Do not catch general exception types |
| | | 799 | | { |
| | 0 | 800 | | _logger.LogWarning(e, "Unable to delete {Path}", path); |
| | 0 | 801 | | } |
| | | 802 | | |
| | 0 | 803 | | if (cleaned) |
| | | 804 | | { |
| | 0 | 805 | | versions.RemoveAt(x); |
| | | 806 | | } |
| | | 807 | | else |
| | | 808 | | { |
| | 0 | 809 | | ChangePluginState(entry, PluginStatus.Deleted); |
| | | 810 | | } |
| | | 811 | | } |
| | | 812 | | |
| | | 813 | | // Only want plugin folders which have files. |
| | 15 | 814 | | return versions.Where(p => p.DllFiles.Count != 0); |
| | | 815 | | } |
| | | 816 | | |
| | | 817 | | /// <summary> |
| | | 818 | | /// Attempts to retrieve valid DLLs from the plugin path. This method will consider the assembly whitelist |
| | | 819 | | /// from the manifest. |
| | | 820 | | /// </summary> |
| | | 821 | | /// <remarks> |
| | | 822 | | /// Loading DLLs from externally supplied paths introduces a path traversal risk. This method |
| | | 823 | | /// uses a safelisting tactic of considering DLLs from the plugin directory and only using |
| | | 824 | | /// the plugin's canonicalized assembly whitelist for comparison. See |
| | | 825 | | /// <see href="https://owasp.org/www-community/attacks/Path_Traversal"/> for more details. |
| | | 826 | | /// </remarks> |
| | | 827 | | /// <param name="plugin">The plugin.</param> |
| | | 828 | | /// <param name="whitelistedDlls">The whitelisted DLLs. If the method returns <see langword="false"/>, this will |
| | | 829 | | /// <returns> |
| | | 830 | | /// <see langword="true"/> if all assemblies listed in the manifest were available in the plugin directory. |
| | | 831 | | /// <see langword="false"/> if any assemblies were invalid or missing from the plugin directory. |
| | | 832 | | /// </returns> |
| | | 833 | | /// <exception cref="ArgumentNullException">If the <see cref="LocalPlugin"/> is null.</exception> |
| | | 834 | | private bool TryGetPluginDlls(LocalPlugin plugin, out IReadOnlyList<string> whitelistedDlls) |
| | | 835 | | { |
| | 12 | 836 | | ArgumentNullException.ThrowIfNull(plugin); |
| | | 837 | | |
| | 12 | 838 | | IReadOnlyList<string> pluginDlls = Directory.GetFiles(plugin.Path, "*.dll", SearchOption.AllDirectories); |
| | | 839 | | |
| | 12 | 840 | | whitelistedDlls = Array.Empty<string>(); |
| | 12 | 841 | | if (pluginDlls.Count > 0 && plugin.Manifest.Assemblies.Count > 0) |
| | | 842 | | { |
| | 12 | 843 | | _logger.LogInformation("Registering whitelisted assemblies for plugin \"{Plugin}\"...", plugin.Name); |
| | | 844 | | |
| | 12 | 845 | | var canonicalizedPaths = new List<string>(); |
| | 45 | 846 | | foreach (var path in plugin.Manifest.Assemblies) |
| | | 847 | | { |
| | 12 | 848 | | var canonicalized = Path.Combine(plugin.Path, path).Canonicalize(); |
| | | 849 | | |
| | | 850 | | // Ensure we stay in the plugin directory. |
| | 12 | 851 | | if (!canonicalized.StartsWith(plugin.Path.NormalizePath(), StringComparison.Ordinal)) |
| | | 852 | | { |
| | 3 | 853 | | _logger.LogError("Assembly path {Path} is not inside the plugin directory.", path); |
| | 3 | 854 | | return false; |
| | | 855 | | } |
| | | 856 | | |
| | 9 | 857 | | canonicalizedPaths.Add(canonicalized); |
| | | 858 | | } |
| | | 859 | | |
| | 9 | 860 | | var intersected = pluginDlls.Intersect(canonicalizedPaths).ToList(); |
| | | 861 | | |
| | 9 | 862 | | if (intersected.Count != canonicalizedPaths.Count) |
| | | 863 | | { |
| | 6 | 864 | | _logger.LogError("Plugin {Plugin} contained assembly paths that were not found in the directory.", p |
| | 6 | 865 | | return false; |
| | | 866 | | } |
| | | 867 | | |
| | 3 | 868 | | whitelistedDlls = intersected; |
| | | 869 | | } |
| | | 870 | | else |
| | | 871 | | { |
| | | 872 | | // No whitelist, default to loading all DLLs in plugin directory. |
| | 0 | 873 | | whitelistedDlls = pluginDlls; |
| | | 874 | | } |
| | | 875 | | |
| | 3 | 876 | | return true; |
| | 3 | 877 | | } |
| | | 878 | | |
| | | 879 | | /// <summary> |
| | | 880 | | /// Changes the status of the other versions of the plugin to "Superseded". |
| | | 881 | | /// </summary> |
| | | 882 | | /// <param name="plugin">The <see cref="LocalPlugin"/> that's master.</param> |
| | | 883 | | private void ProcessAlternative(LocalPlugin plugin) |
| | | 884 | | { |
| | | 885 | | // Detect whether there is another version of this plugin that needs disabling. |
| | 0 | 886 | | var previousVersion = _plugins.OrderByDescending(p => p.Version) |
| | 0 | 887 | | .FirstOrDefault( |
| | 0 | 888 | | p => p.Id.Equals(plugin.Id) |
| | 0 | 889 | | && p.IsEnabledAndSupported |
| | 0 | 890 | | && p.Version != plugin.Version); |
| | | 891 | | |
| | 0 | 892 | | if (previousVersion is null) |
| | | 893 | | { |
| | | 894 | | // This value is memory only - so that the web will show restart required. |
| | 0 | 895 | | plugin.Manifest.Status = PluginStatus.Restart; |
| | 0 | 896 | | plugin.Manifest.AutoUpdate = false; |
| | 0 | 897 | | return; |
| | | 898 | | } |
| | | 899 | | |
| | 0 | 900 | | if (plugin.Manifest.Status == PluginStatus.Active && !ChangePluginState(previousVersion, PluginStatus.Supers |
| | | 901 | | { |
| | 0 | 902 | | _logger.LogError("Unable to enable version {Version} of {Name}", previousVersion.Version, previousVersio |
| | | 903 | | } |
| | 0 | 904 | | else if (plugin.Manifest.Status == PluginStatus.Superseded && !ChangePluginState(previousVersion, PluginStat |
| | | 905 | | { |
| | 0 | 906 | | _logger.LogError("Unable to supercede version {Version} of {Name}", previousVersion.Version, previousVer |
| | | 907 | | } |
| | | 908 | | |
| | | 909 | | // This value is memory only - so that the web will show restart required. |
| | 0 | 910 | | plugin.Manifest.Status = PluginStatus.Restart; |
| | 0 | 911 | | plugin.Manifest.AutoUpdate = false; |
| | 0 | 912 | | } |
| | | 913 | | } |
| | | 914 | | } |