Merge pull request #960 from aldelaro5/metaplugins

Implement patcher and plugin providers

Author: bbepis

BepInEx.Core/Bootstrap/BaseChainloader.cs

@@ -10,6 +10,41 @@
 
 namespace BepInEx.Bootstrap;
 
+internal class CachedPluginLoadContext : IPluginLoadContext, IDisposable
+{
+    public IPluginLoadContext PluginLoadContext { get; }
+    private byte[] assemblyData;
+    private byte[] assemblySymbolsData;
+
+    public CachedPluginLoadContext(IPluginLoadContext pluginLoadContext)
+    {
+        PluginLoadContext = pluginLoadContext;
+    }
+
+    public string AssemblyIdentifier => PluginLoadContext.AssemblyIdentifier;
+    public string AssemblyHash => PluginLoadContext.AssemblyHash;
+    public byte[] GetAssemblyData()
+    {
+        return assemblyData ??= PluginLoadContext.GetAssemblyData();
+    }
+
+    public byte[] GetAssemblySymbolsData()
+    {
+        return assemblySymbolsData ??= PluginLoadContext.GetAssemblySymbolsData();
+    }
+
+    public byte[] GetFile(string relativePath)
+    {
+        return PluginLoadContext.GetFile(relativePath);
+    }
+
+    public void Dispose()
+    {
+        assemblyData = null;
+        assemblySymbolsData = null;
+    }
+}
+
 /// <summary>
 ///     A cacheable metadata item. Can be used with <see cref="TypeLoader.LoadAssemblyCache{T}" /> and
 ///     <see cref="TypeLoader.SaveAssemblyCache{T}" /> to cache plugin metadata.
@@ -35,6 +70,11 @@ public interface ICacheable
 /// <typeparam name="T"></typeparam>
 public class CachedAssembly<T> where T : ICacheable
 {
+    /// <summary>
+    ///     The version of the cache which increments on each format changes
+    /// </summary>
+    public const int Version = 0;
+
     /// <summary>
     ///     List of cached items inside the assembly.
     /// </summary>
@@ -89,7 +129,9 @@ public static AssemblyDefinition CecilResolveOnFailure(object sender, AssemblyNa
         {
             Paths.BepInExAssemblyDirectory,
             Paths.PluginPath,
+            Paths.PluginProviderPath,
             Paths.PatcherPluginPath,
+            Paths.PatcherProviderPath,
             Paths.ManagedPath
         }.Concat(SearchDirectories);
 
@@ -126,9 +168,8 @@ public static AssemblyDefinition CecilResolveOnFailure(object sender, AssemblyNa
     ///     selector.
     /// </returns>
     public static Dictionary<string, List<T>> FindPluginTypes<T>(string directory,
-                                                                 Func<TypeDefinition, string, T> typeSelector,
-                                                                 Func<AssemblyDefinition, bool> assemblyFilter =
-                                                                     null,
+                                                                 Func<TypeDefinition, IPluginLoadContext, string, T> typeSelector,
+                                                                 Func<AssemblyDefinition, bool> assemblyFilter = null,
                                                                  string cacheName = null)
         where T : ICacheable, new()
     {
@@ -153,19 +194,7 @@ public static Dictionary<string, List<T>> FindPluginTypes<T>(string directory,
                         continue;
                     }
 
-                using var ass = AssemblyDefinition.ReadAssembly(dllMs, ReaderParameters);
-                Logger.Log(LogLevel.Debug, $"Examining '{dll}'");
-
-                if (!assemblyFilter?.Invoke(ass) ?? false)
-                {
-                    result[dll] = new List<T>();
-                    continue;
-                }
-
-                var matches = ass.MainModule.Types
-                                 .Select(t => typeSelector(t, dll))
-                                 .Where(t => t != null).ToList();
-                result[dll] = matches;
+                result[dll] = ExamineStream(typeSelector, assemblyFilter, dllMs, null, dll);
             }
             catch (BadImageFormatException e)
             {
@@ -183,6 +212,82 @@ public static Dictionary<string, List<T>> FindPluginTypes<T>(string directory,
         return result;
     }
 
+    /// <summary>
+    ///     Looks up assemblies using the given loaders and locates all types that can be loaded and collects their metadata.
+    /// </summary>
+    /// <typeparam name="T">The specific base type to search for.</typeparam>
+    /// <param name="loadContexts">The load contexts to obtain the assemblies from.</param>
+    /// <param name="typeSelector">A function to check if a type should be selected and to build the type metadata.</param>
+    /// <param name="assemblyFilter">A filter function to quickly determine if the assembly can be loaded.</param>
+    /// <param name="cacheName">The name of the cache to get cached types from.</param>
+    /// <returns>
+    ///     A dictionary of all assemblies in the directory and the list of type metadatas of types that match the
+    ///     selector.
+    /// </returns>
+    public static List<T> GetPluginsFromLoadContexts<T>(IEnumerable<IPluginLoadContext> loadContexts,
+                                                        Func<TypeDefinition, IPluginLoadContext, string, T> typeSelector,
+                                                        Func<AssemblyDefinition, bool> assemblyFilter = null,
+                                                        string cacheName = null)
+        where T : ICacheable, new()
+    {
+        var result = new Dictionary<string, List<T>>();
+        var hashes = new Dictionary<string, string>();
+        Dictionary<string, CachedAssembly<T>> cache = null;
+
+        if (cacheName != null)
+            cache = LoadAssemblyCache<T>(cacheName);
+
+        foreach (IPluginLoadContext loadContext in loadContexts)
+        {
+            IList<T> plugins;
+            if (cache != null && loadContext.AssemblyHash != null &&
+                cache.TryGetValue(loadContext.AssemblyIdentifier, out var cacheEntry) &&
+                loadContext.AssemblyHash == cacheEntry.Hash)
+            {
+                plugins = cacheEntry.CacheItems;
+            }
+            else
+            {
+                var assemblyData = loadContext.GetAssemblyData();
+                using var memory = new MemoryStream(assemblyData);
+                plugins = ExamineStream(typeSelector, assemblyFilter, memory, loadContext, null);
+            }
+                
+            foreach (T pluginInfo in plugins)
+            {
+                if (!result.ContainsKey(loadContext.AssemblyIdentifier))
+                    result[loadContext.AssemblyIdentifier] = new();
+                result[loadContext.AssemblyIdentifier].Add(pluginInfo);
+            }
+        }
+            
+        if (cache != null)
+            SaveAssemblyCache(cacheName, result, hashes);
+
+        return result.SelectMany(x => x.Value).ToList();
+    }
+
+    private static List<T> ExamineStream<T>(Func<TypeDefinition, IPluginLoadContext, string, T> typeSelector,
+                                           Func<AssemblyDefinition, bool> assemblyFilter,
+                                           MemoryStream dllMs,
+                                           IPluginLoadContext loadContext,
+                                           string location)
+        where T : ICacheable, new()
+    {
+        using var ass = AssemblyDefinition.ReadAssembly(dllMs, ReaderParameters);
+        Logger.Log(LogLevel.Debug, $"Examining '{ass.Name}'");
+
+        if (!assemblyFilter?.Invoke(ass) ?? false)
+        {
+            return new List<T>();
+        }
+
+        var matches = ass.MainModule.Types
+                         .Select(t => typeSelector(t, loadContext, location))
+                         .Where(t => t != null).ToList();
+        return matches;
+    }
+
     /// <summary>
     ///     Loads an index of type metadatas from a cache.
     /// </summary>
@@ -205,7 +310,9 @@ public static Dictionary<string, CachedAssembly<T>> LoadAssemblyCache<T>(string
             if (!File.Exists(path))
                 return null;
 
-            using (var br = new BinaryReader(File.OpenRead(path)))
+            using var br = new BinaryReader(File.OpenRead(path));
+            var version = br.ReadInt32();
+            if (version == CachedAssembly<T>.Version)
             {
                 var entriesCount = br.ReadInt32();
 
@@ -259,6 +366,7 @@ public static void SaveAssemblyCache<T>(string cacheName,
             var path = Path.Combine(Paths.CachePath, $"{cacheName}_typeloader.dat");
 
             using var bw = new BinaryWriter(File.OpenWrite(path));
+            bw.Write(CachedAssembly<T>.Version);
             bw.Write(entries.Count);
 
             foreach (var kv in entries)

BepInEx.Core/Bootstrap/TypeLoader.cs

@@ -76,6 +76,32 @@ internal static BepInPlugin FromCecilType(TypeDefinition td)
     }
 }
 
+/// <summary>
+///     This attribute denotes that a class is a plugin provider, and specifies the required metadata.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class)]
+public class BepInPluginProvider : BepInPlugin
+{
+    /// <param name="GUID">The unique identifier of the plugin. Should not change between plugin versions.</param>
+    /// <param name="Name">The user friendly name of the plugin. Is able to be changed between versions.</param>
+    /// <param name="Version">The specific version of the plugin.</param>
+    public BepInPluginProvider(string GUID, string Name, string Version) : base(GUID, Name, Version)
+    {
+    }
+
+    internal new static BepInPluginProvider FromCecilType(TypeDefinition td)
+    {
+        var attr = MetadataHelper.GetCustomAttributes<BepInPluginProvider>(td, false).FirstOrDefault();
+
+        if (attr == null)
+            return null;
+
+        return new BepInPluginProvider((string) attr.ConstructorArguments[0].Value,
+                                       (string) attr.ConstructorArguments[1].Value,
+                                       (string) attr.ConstructorArguments[2].Value);
+    }
+}
+
 /// <summary>
 ///     This attribute specifies any dependencies that this plugin has on other plugins.
 /// </summary>
@@ -281,6 +307,28 @@ public static BepInPlugin GetMetadata(Type pluginType)
     /// <returns>The BepInPlugin metadata of the plugin instance.</returns>
     public static BepInPlugin GetMetadata(object plugin) => GetMetadata(plugin.GetType());
 
+    /// <summary>
+    ///     Retrieves the BepInPluginProvider metadata from a plugin type.
+    /// </summary>
+    /// <param name="pluginType">The plugin type.</param>
+    /// <returns>The BepInPluginProvider metadata of the plugin type.</returns>
+    public static BepInPlugin GetPluginProviderMetadata(Type pluginType)
+    {
+        var attributes = pluginType.GetCustomAttributes(typeof(BepInPluginProvider), false);
+
+        if (attributes.Length == 0)
+            return null;
+
+        return (BepInPlugin) attributes[0];
+    }
+
+    /// <summary>
+    ///     Retrieves the BepInPluginProvider metadata from a plugin instance.
+    /// </summary>
+    /// <param name="plugin">The plugin instance.</param>
+    /// <returns>The BepInPluginProvider metadata of the plugin instance.</returns>
+    public static BepInPlugin GetPluginProviderMetadata(object plugin) => GetPluginProviderMetadata(plugin.GetType());
+
     /// <summary>
     ///     Gets the specified attributes of a type, if they exist.
     /// </summary>

BepInEx.Core/Contract/Attributes.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using BepInEx.Configuration;
+using BepInEx.Logging;
+
+namespace BepInEx;
+
+/// <summary>
+///     The base plugin provider type that is used by the BepInEx plugin loader.
+/// </summary>
+public abstract class BasePluginProvider
+{
+    /// <summary>
+    ///     Create a new instance of a plugin provider and all of its tied in objects.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">BepInPluginProvider attribute is missing.</exception>
+    protected BasePluginProvider()
+    {
+        var metadata = MetadataHelper.GetPluginProviderMetadata(this);
+        if (metadata == null)
+            throw new InvalidOperationException("Can't create an instance of " + GetType().FullName +
+                                                " because it inherits from BasePluginProvider and the BepInPluginProvider attribute is missing.");
+
+        Info = new PluginInfo
+        {
+            Metadata = metadata,
+            Instance = this,
+            Dependencies = MetadataHelper.GetDependencies(GetType()),
+            Processes = MetadataHelper.GetAttributes<BepInProcess>(GetType()),
+        };
+
+        Logger = BepInEx.Logging.Logger.CreateLogSource(metadata.Name);
+
+        Config = new ConfigFile(Utility.CombinePaths(Paths.ConfigPath, metadata.GUID + ".cfg"), false, metadata);
+    }
+
+    /// <summary>
+    ///     Information about this plugin provider as it was loaded.
+    /// </summary>
+    public PluginInfo Info { get; }
+
+    /// <summary>
+    ///     Logger instance tied to this plugin provider.
+    /// </summary>
+    protected ManualLogSource Logger { get; }
+
+    /// <summary>
+    ///     Default config file tied to this plugin provider. The config file will not be created until
+    ///     any settings are added and changed, or <see cref="ConfigFile.Save" /> is called.
+    /// </summary>
+    public ConfigFile Config { get; }
+
+    /// <summary>
+    ///     Obtains a list of assemblies containing plugins to load
+    /// </summary>
+    /// <returns>A list of load context, one per assembly</returns>
+    public abstract IList<IPluginLoadContext> GetPlugins();
+
+    /// <summary>
+    ///     A custom assembly resolver that can be used by this provider to resolve assemblies
+    ///     that have failed to resolve
+    /// </summary>
+    /// <param name="name">The assembly's name</param>
+    /// <returns>The resolved assembly or null if the assembly couldn't be resolved</returns>
+    public virtual Assembly ResolveAssembly(string name)
+    {
+        return null;
+    }
+}

BepInEx.Core/Contract/BasePluginProvider.cs

@@ -7,22 +7,22 @@
 
 namespace BepInEx.Contract
 {
-  public interface IPlugin
-  {
-	  /// <summary>
-	  /// Information about this plugin as it was loaded.
-	  /// </summary>
-	  PluginInfo Info { get; }
+    public interface IPlugin
+    {
+        /// <summary>
+        /// Information about this plugin as it was loaded.
+        /// </summary>
+        PluginInfo Info { get; }
 
-	  /// <summary>
-	  /// Logger instance tied to this plugin.
-	  /// </summary>
-	  ManualLogSource Logger { get; }
+        /// <summary>
+        /// Logger instance tied to this plugin.
+        /// </summary>
+        ManualLogSource Logger { get; }
 
-	  /// <summary>
-	  /// Default config file tied to this plugin. The config file will not be created until 
-	  /// any settings are added and changed, or <see cref="ConfigFile.Save"/> is called.
-	  /// </summary>
-	  ConfigFile Config { get; }
-  }
+        /// <summary>
+        /// Default config file tied to this plugin. The config file will not be created until 
+        /// any settings are added and changed, or <see cref="ConfigFile.Save"/> is called.
+        /// </summary>
+        ConfigFile Config { get; }
+    }
 }