From 5e3b6e07de773eac142d7524653d3164355e6c87 Mon Sep 17 00:00:00 2001 From: Gijs de Jong Date: Thu, 23 Nov 2023 00:12:34 +0100 Subject: [PATCH 1/5] Fix plugin bootstrap dependency tree population --- ...bootstrap-dependency-tree-population.patch | 482 ++++++++++++++++++ 1 file changed, 482 insertions(+) create mode 100644 patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch diff --git a/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch b/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch new file mode 100644 index 000000000000..57449fef732a --- /dev/null +++ b/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch @@ -0,0 +1,482 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Gijs de Jong +Date: Wed, 22 Nov 2023 23:58:55 +0100 +Subject: [PATCH] Fix plugin bootstrap dependency tree population + +This patch fixes a bug where the dependency tree used for classpath joining, +wasn't built using the bootstrap dependencies, for plugin bootstrappers. + +diff --git a/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java b/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java +index 8ade7eb97aa899ddd4bb8274b8f588a4d7265868..d4a092243e587e3a555fbc0f00c8f78c00b3d1c6 100644 +--- a/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java ++++ b/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java +@@ -16,7 +16,7 @@ import io.papermc.paper.plugin.entrypoint.classloader.group.SimpleListPluginClas + import io.papermc.paper.plugin.entrypoint.classloader.group.SpigotPluginClassLoaderGroup; + import io.papermc.paper.plugin.entrypoint.classloader.group.StaticPluginClassLoaderGroup; + import io.papermc.paper.plugin.entrypoint.dependency.GraphDependencyContext; +-import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; + import io.papermc.paper.plugin.provider.entrypoint.DependencyContext; + import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy; + import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration; +@@ -141,7 +141,7 @@ public final class DumpPluginsCommand implements PaperSubcommand { + return false; + } + }); +- modernPluginLoadingStrategy.loadProviders(pluginProviders, new MetaDependencyTree(GraphBuilder.directed().build())); ++ modernPluginLoadingStrategy.loadProviders(pluginProviders, new SimpleMetaDependencyTree(GraphBuilder.directed().build())); + + rootProviders.add(entry.getKey().getDebugName(), entrypoint); + } +diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java +new file mode 100644 +index 0000000000000000000000000000000000000000..b6273c99ae2d8a50cb91b3686b8b8b434a87fd7e +--- /dev/null ++++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java +@@ -0,0 +1,67 @@ ++package io.papermc.paper.plugin.entrypoint.dependency; ++ ++import com.google.common.graph.GraphBuilder; ++import com.google.common.graph.MutableGraph; ++import io.papermc.paper.plugin.configuration.PluginMeta; ++import io.papermc.paper.plugin.provider.configuration.PaperPluginMeta; ++ ++public class BootstrapMetaDependencyTree extends SimpleMetaDependencyTree { ++ public BootstrapMetaDependencyTree() { ++ this(GraphBuilder.directed().build()); ++ } ++ ++ public BootstrapMetaDependencyTree(MutableGraph graph) { ++ super(graph); ++ } ++ ++ @Override ++ public void add(PluginMeta configuration) { ++ if (!(configuration instanceof PaperPluginMeta paperPluginMeta)) { ++ throw new IllegalStateException("Only paper plugins can have a bootstrapper!"); ++ } ++ ++ String identifier = configuration.getName(); ++ ++ // Build a validated provider's dependencies into the graph ++ for (String dependency : paperPluginMeta.getBoostrapDependencies().keySet()) { ++ this.graph.putEdge(identifier, dependency); ++ } ++ ++ this.graph.addNode(identifier); // Make sure dependencies at least have a node ++ ++ // Add the provided plugins to the graph as well ++ for (String provides : configuration.getProvidedPlugins()) { ++ this.graph.putEdge(identifier, provides); ++ this.dependencies.add(provides); ++ } ++ this.dependencies.add(identifier); ++ } ++ ++ @Override ++ public void remove(PluginMeta configuration) { ++ String identifier = configuration.getName(); ++ // Remove a validated provider's dependencies into the graph ++ if (!(configuration instanceof PaperPluginMeta paperPluginMeta)) { ++ throw new IllegalStateException("PluginMeta must be a PaperPluginMeta"); ++ } ++ ++ // Build a validated provider's dependencies into the graph ++ for (String dependency : paperPluginMeta.getBoostrapDependencies().keySet()) { ++ this.graph.removeEdge(identifier, dependency); ++ } ++ ++ this.graph.removeNode(identifier); // Remove root node ++ ++ // Remove the provided plugins to the graph as well ++ for (String provides : configuration.getProvidedPlugins()) { ++ this.graph.removeEdge(identifier, provides); ++ this.dependencies.remove(provides); ++ } ++ this.dependencies.remove(identifier); ++ } ++ ++ @Override ++ public String toString() { ++ return "BootstrapDependencyTree{" + "graph=" + this.graph + '}'; ++ } ++} +diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java +index e72bec3b0cbc41580f1b4beecae316d1c083d3e3..62da59c30511065379658d1b34e780a33c15ce90 100644 +--- a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java ++++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java +@@ -1,117 +1,26 @@ + package io.papermc.paper.plugin.entrypoint.dependency; + +-import com.google.common.graph.GraphBuilder; +-import com.google.common.graph.Graphs; + import com.google.common.graph.MutableGraph; + import io.papermc.paper.plugin.configuration.PluginMeta; + import io.papermc.paper.plugin.provider.PluginProvider; + import io.papermc.paper.plugin.provider.entrypoint.DependencyContext; +-import org.jetbrains.annotations.NotNull; + +-import java.util.HashSet; +-import java.util.Set; ++public interface MetaDependencyTree extends DependencyContext { + +-public class MetaDependencyTree implements DependencyContext { ++ void add(PluginMeta configuration); + +- private final MutableGraph graph; +- +- // We need to upkeep a separate collection since when populating +- // a graph it adds nodes even if they are not present +- private final Set dependencies = new HashSet<>(); +- +- public MetaDependencyTree() { +- this(GraphBuilder.directed().build()); +- } +- +- public MetaDependencyTree(MutableGraph graph) { +- this.graph = graph; +- } +- +- public void add(PluginProvider provider) { ++ default void add(PluginProvider provider) { + add(provider.getMeta()); + } + +- public void remove(PluginProvider provider) { +- remove(provider.getMeta()); +- } +- +- public void add(PluginMeta configuration) { +- String identifier = configuration.getName(); +- // Build a validated provider's dependencies into the graph +- for (String dependency : configuration.getPluginDependencies()) { +- this.graph.putEdge(identifier, dependency); +- } +- for (String dependency : configuration.getPluginSoftDependencies()) { +- this.graph.putEdge(identifier, dependency); +- } +- +- this.graph.addNode(identifier); // Make sure dependencies at least have a node +- +- // Add the provided plugins to the graph as well +- for (String provides : configuration.getProvidedPlugins()) { +- this.graph.putEdge(identifier, provides); +- this.dependencies.add(provides); +- } +- this.dependencies.add(identifier); +- } +- +- public void remove(PluginMeta configuration) { +- String identifier = configuration.getName(); +- // Remove a validated provider's dependencies into the graph +- for (String dependency : configuration.getPluginDependencies()) { +- this.graph.removeEdge(identifier, dependency); +- } +- for (String dependency : configuration.getPluginSoftDependencies()) { +- this.graph.removeEdge(identifier, dependency); +- } +- +- this.graph.removeNode(identifier); // Remove root node +- +- // Remove the provided plugins to the graph as well +- for (String provides : configuration.getProvidedPlugins()) { +- this.graph.removeEdge(identifier, provides); +- this.dependencies.remove(provides); +- } +- this.dependencies.remove(identifier); +- } +- +- @Override +- public boolean isTransitiveDependency(@NotNull PluginMeta plugin, @NotNull PluginMeta depend) { +- String pluginIdentifier = plugin.getName(); +- +- if (this.graph.nodes().contains(pluginIdentifier)) { +- Set reachableNodes = Graphs.reachableNodes(this.graph, pluginIdentifier); +- if (reachableNodes.contains(depend.getName())) { +- return true; +- } +- for (String provided : depend.getProvidedPlugins()) { +- if (reachableNodes.contains(provided)) { +- return true; +- } +- } +- } +- +- return false; +- } +- +- @Override +- public boolean hasDependency(@NotNull String pluginIdentifier) { +- return this.dependencies.contains(pluginIdentifier); +- } +- + // Used by the legacy loader -- this isn't recommended +- public void addDirectDependency(String dependency) { +- this.dependencies.add(dependency); +- } ++ void addDirectDependency(String dependency); + +- @Override +- public String toString() { +- return "ProviderDependencyTree{" + +- "graph=" + this.graph + +- '}'; +- } ++ void remove(PluginMeta configuration); + +- public MutableGraph getGraph() { +- return graph; ++ default void remove(PluginProvider provider) { ++ remove(provider.getMeta()); + } ++ ++ MutableGraph getGraph(); + } +diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java +new file mode 100644 +index 0000000000000000000000000000000000000000..f02e4fd2d838470dbb0fb25359bdfea1e55552ba +--- /dev/null ++++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java +@@ -0,0 +1,107 @@ ++package io.papermc.paper.plugin.entrypoint.dependency; ++ ++import com.google.common.graph.GraphBuilder; ++import com.google.common.graph.Graphs; ++import com.google.common.graph.MutableGraph; ++import io.papermc.paper.plugin.configuration.PluginMeta; ++import org.jetbrains.annotations.NotNull; ++ ++import java.util.HashSet; ++import java.util.Set; ++ ++public class SimpleMetaDependencyTree implements MetaDependencyTree { ++ protected final MutableGraph graph; ++ ++ // We need to upkeep a separate collection since when populating ++ // a graph it adds nodes even if they are not present ++ protected final Set dependencies = new HashSet<>(); ++ ++ public SimpleMetaDependencyTree() { ++ this(GraphBuilder.directed().build()); ++ } ++ ++ public SimpleMetaDependencyTree(MutableGraph graph) { ++ this.graph = graph; ++ } ++ ++ public void add(PluginMeta configuration) { ++ String identifier = configuration.getName(); ++ // Build a validated provider's dependencies into the graph ++ for (String dependency : configuration.getPluginDependencies()) { ++ this.graph.putEdge(identifier, dependency); ++ } ++ for (String dependency : configuration.getPluginSoftDependencies()) { ++ this.graph.putEdge(identifier, dependency); ++ } ++ ++ this.graph.addNode(identifier); // Make sure dependencies at least have a node ++ ++ // Add the provided plugins to the graph as well ++ for (String provides : configuration.getProvidedPlugins()) { ++ this.graph.putEdge(identifier, provides); ++ this.dependencies.add(provides); ++ } ++ this.dependencies.add(identifier); ++ } ++ ++ public void remove(PluginMeta configuration) { ++ String identifier = configuration.getName(); ++ // Remove a validated provider's dependencies into the graph ++ for (String dependency : configuration.getPluginDependencies()) { ++ this.graph.removeEdge(identifier, dependency); ++ } ++ for (String dependency : configuration.getPluginSoftDependencies()) { ++ this.graph.removeEdge(identifier, dependency); ++ } ++ ++ this.graph.removeNode(identifier); // Remove root node ++ ++ // Remove the provided plugins to the graph as well ++ for (String provides : configuration.getProvidedPlugins()) { ++ this.graph.removeEdge(identifier, provides); ++ this.dependencies.remove(provides); ++ } ++ this.dependencies.remove(identifier); ++ } ++ ++ @Override ++ public boolean isTransitiveDependency(@NotNull PluginMeta plugin, @NotNull PluginMeta depend) { ++ String pluginIdentifier = plugin.getName(); ++ ++ if (this.graph.nodes().contains(pluginIdentifier)) { ++ Set reachableNodes = Graphs.reachableNodes(this.graph, depend.getName()); ++ if (reachableNodes.contains(depend.getName())) { ++ return true; ++ } ++ for (String provided : depend.getProvidedPlugins()) { ++ if (reachableNodes.contains(provided)) { ++ return true; ++ } ++ } ++ } ++ ++ return false; ++ } ++ ++ @Override ++ public boolean hasDependency(@NotNull String pluginIdentifier) { ++ return this.dependencies.contains(pluginIdentifier); ++ } ++ ++ @Override ++ public void addDirectDependency(String dependency) { ++ this.dependencies.add(dependency); ++ } ++ ++ @Override ++ public String toString() { ++ return "SimpleDependencyTree{" + ++ "graph=" + this.graph + ++ '}'; ++ } ++ ++ @Override ++ public MutableGraph getGraph() { ++ return graph; ++ } ++} +diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java b/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java +index 9c7552968b8c017c71a7a77557a66a03ed89f125..08b1aab5d37a56dc42542ce15ba1f7ccd1b08400 100644 +--- a/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java ++++ b/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java +@@ -6,6 +6,7 @@ import com.google.common.graph.MutableGraph; + import io.papermc.paper.plugin.configuration.PluginMeta; + import io.papermc.paper.plugin.entrypoint.Entrypoint; + import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; + import io.papermc.paper.plugin.entrypoint.strategy.PluginGraphCycleException; + import io.papermc.paper.plugin.provider.classloader.ConfiguredPluginClassLoader; + import io.papermc.paper.plugin.provider.classloader.PaperClassLoaderStorage; +@@ -55,7 +56,7 @@ class PaperPluginInstanceManager { + private final CommandMap commandMap; + private final Server server; + +- private final MetaDependencyTree dependencyTree = new MetaDependencyTree(GraphBuilder.directed().build()); ++ private final MetaDependencyTree dependencyTree = new SimpleMetaDependencyTree(GraphBuilder.directed().build()); + + public PaperPluginInstanceManager(PluginManager pluginManager, CommandMap commandMap, Server server) { + this.commandMap = commandMap; +diff --git a/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java +index 8ef13e4f00a61db0dab9ef63231d77adcfaba5ab..6db2bacd74a9eec9597bd8e62b1d5c7929655350 100644 +--- a/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java ++++ b/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java +@@ -5,7 +5,9 @@ import io.papermc.paper.plugin.PluginInitializerManager; + import io.papermc.paper.plugin.bootstrap.BootstrapContext; + import io.papermc.paper.plugin.bootstrap.PluginBootstrap; + import io.papermc.paper.plugin.bootstrap.PluginBootstrapContextImpl; ++import io.papermc.paper.plugin.entrypoint.dependency.BootstrapMetaDependencyTree; + import io.papermc.paper.plugin.entrypoint.dependency.DependencyContextHolder; ++import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; + import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration; + import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy; + import io.papermc.paper.plugin.provider.PluginProvider; +@@ -51,6 +53,11 @@ public class BootstrapProviderStorage extends SimpleProviderStorage { + + void register(PluginProvider provider); + ++ MetaDependencyTree getDependencyTree(); ++ + void enter(); + + Iterable> getRegisteredProviders(); +diff --git a/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java +index 861c245290696eef0fca846c3026b407593fdce1..e4296230c773e68c816d7210a70b42f4bb9a0011 100644 +--- a/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java ++++ b/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java +@@ -3,8 +3,8 @@ package io.papermc.paper.plugin.storage; + import com.google.common.graph.GraphBuilder; + import com.google.common.graph.MutableGraph; + import com.mojang.logging.LogUtils; +-import io.papermc.paper.plugin.entrypoint.dependency.GraphDependencyContext; + import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; + import io.papermc.paper.plugin.entrypoint.strategy.PluginGraphCycleException; + import io.papermc.paper.plugin.entrypoint.strategy.ProviderLoadingStrategy; + import io.papermc.paper.plugin.provider.PluginProvider; +@@ -44,8 +44,9 @@ public abstract class SimpleProviderStorage implements ProviderStorage { + } + } + ++ @Override + public MetaDependencyTree getDependencyTree() { +- return new MetaDependencyTree(GraphBuilder.directed().build()); ++ return new SimpleMetaDependencyTree(GraphBuilder.directed().build()); + } + + @Override +diff --git a/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java b/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java +index ad92ae93acd25af4d223a55a0bcbc2a5740390a9..83b1274ba56f03bec6cb69a35f33dc04f008cc1e 100644 +--- a/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java ++++ b/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java +@@ -1,6 +1,7 @@ + package io.papermc.paper.plugin; + + import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; + import org.junit.jupiter.api.Test; + + import java.util.List; +@@ -31,7 +32,7 @@ public class PluginDependencyValidationTest { + + @Test + public void testDependencyTree() { +- MetaDependencyTree tree = new MetaDependencyTree(); ++ MetaDependencyTree tree = new SimpleMetaDependencyTree(); + tree.add(MAIN); + tree.add(HARD_DEPENDENCY_1); + tree.add(SOFT_DEPENDENCY_1); +diff --git a/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java b/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java +index a66fd32cf8af310101161c1b820b3468657460f0..c2c3c2f24ea802628bc4a36ef180fc08f4e5d288 100644 +--- a/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java ++++ b/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java +@@ -1,7 +1,7 @@ + package io.papermc.paper.plugin; + + import com.google.common.graph.GraphBuilder; +-import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; + import io.papermc.paper.plugin.provider.entrypoint.DependencyContext; + import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy; + import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration; +@@ -105,7 +105,7 @@ public class PluginLoadOrderTest { + + }); + +- modernPluginLoadingStrategy.loadProviders(REGISTERED_PROVIDERS, new MetaDependencyTree(GraphBuilder.directed().build())); ++ modernPluginLoadingStrategy.loadProviders(REGISTERED_PROVIDERS, new SimpleMetaDependencyTree(GraphBuilder.directed().build())); + } + + @Test From 78ea24f1f3889effe47a1b7206a2985a1d8a470d Mon Sep 17 00:00:00 2001 From: Gijs de Jong Date: Thu, 23 Nov 2023 00:28:06 +0100 Subject: [PATCH 2/5] Remove unintended change --- ...1053-Fix-plugin-bootstrap-dependency-tree-population.patch | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch b/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch index 57449fef732a..bd4a496e1f5c 100644 --- a/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch +++ b/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch @@ -234,7 +234,7 @@ index e72bec3b0cbc41580f1b4beecae316d1c083d3e3..62da59c30511065379658d1b34e780a3 } diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java new file mode 100644 -index 0000000000000000000000000000000000000000..f02e4fd2d838470dbb0fb25359bdfea1e55552ba +index 0000000000000000000000000000000000000000..0676823ba232d1389378d3c1ce197079b754e3ec --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java @@ -0,0 +1,107 @@ @@ -309,7 +309,7 @@ index 0000000000000000000000000000000000000000..f02e4fd2d838470dbb0fb25359bdfea1 + String pluginIdentifier = plugin.getName(); + + if (this.graph.nodes().contains(pluginIdentifier)) { -+ Set reachableNodes = Graphs.reachableNodes(this.graph, depend.getName()); ++ Set reachableNodes = Graphs.reachableNodes(this.graph, pluginIdentifier); + if (reachableNodes.contains(depend.getName())) { + return true; + } From 50525f954dcacb2980cd89fab46c7b8b1f447e8e Mon Sep 17 00:00:00 2001 From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com> Date: Sat, 25 Nov 2023 17:43:31 -0500 Subject: [PATCH 3/5] rebase + update --- patches/server/0013-Paper-Plugins.patch | 232 +++++++-- ...bootstrap-dependency-tree-population.patch | 482 ------------------ 2 files changed, 184 insertions(+), 530 deletions(-) delete mode 100644 patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch diff --git a/patches/server/0013-Paper-Plugins.patch b/patches/server/0013-Paper-Plugins.patch index b1e4d7f317c1..369fb6cbabdf 100644 --- a/patches/server/0013-Paper-Plugins.patch +++ b/patches/server/0013-Paper-Plugins.patch @@ -250,7 +250,7 @@ index 0000000000000000000000000000000000000000..f0fce4113fb07c64adbec029d177c236 +} diff --git a/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java b/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java new file mode 100644 -index 0000000000000000000000000000000000000000..8ade7eb97aa899ddd4bb8274b8f588a4d7265868 +index 0000000000000000000000000000000000000000..d4a092243e587e3a555fbc0f00c8f78c00b3d1c6 --- /dev/null +++ b/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java @@ -0,0 +1,203 @@ @@ -272,7 +272,7 @@ index 0000000000000000000000000000000000000000..8ade7eb97aa899ddd4bb8274b8f588a4 +import io.papermc.paper.plugin.entrypoint.classloader.group.SpigotPluginClassLoaderGroup; +import io.papermc.paper.plugin.entrypoint.classloader.group.StaticPluginClassLoaderGroup; +import io.papermc.paper.plugin.entrypoint.dependency.GraphDependencyContext; -+import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; +import io.papermc.paper.plugin.provider.entrypoint.DependencyContext; +import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy; +import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration; @@ -397,7 +397,7 @@ index 0000000000000000000000000000000000000000..8ade7eb97aa899ddd4bb8274b8f588a4 + return false; + } + }); -+ modernPluginLoadingStrategy.loadProviders(pluginProviders, new MetaDependencyTree(GraphBuilder.directed().build())); ++ modernPluginLoadingStrategy.loadProviders(pluginProviders, new SimpleMetaDependencyTree(GraphBuilder.directed().build())); + + rootProviders.add(entry.getKey().getDebugName(), entrypoint); + } @@ -1714,6 +1714,90 @@ index 0000000000000000000000000000000000000000..2412155ddfd559023f42ff534b8f06a5 + '}'; + } +} +diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java +new file mode 100644 +index 0000000000000000000000000000000000000000..cc41e38b6303951ad98f5d49c613c26b9bd621e9 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java +@@ -0,0 +1,78 @@ ++package io.papermc.paper.plugin.entrypoint.dependency; ++ ++import com.google.common.graph.GraphBuilder; ++import com.google.common.graph.MutableGraph; ++import io.papermc.paper.plugin.configuration.PluginMeta; ++import io.papermc.paper.plugin.provider.configuration.PaperPluginMeta; ++ ++public class BootstrapMetaDependencyTree extends MetaDependencyTree { ++ public BootstrapMetaDependencyTree() { ++ this(GraphBuilder.directed().build()); ++ } ++ ++ public BootstrapMetaDependencyTree(MutableGraph graph) { ++ super(graph); ++ } ++ ++ @Override ++ public void add(PluginMeta configuration) { ++ ++ ++ String identifier = configuration.getName(); ++ ++ ++ this.graph.addNode(identifier); // Make sure dependencies at least have a node ++ ++ // Add the provided plugins to the graph as well ++ for (String provides : configuration.getProvidedPlugins()) { ++ this.graph.putEdge(identifier, provides); ++ this.dependencies.add(provides); ++ } ++ this.dependencies.add(identifier); ++ } ++ ++ @Override ++ protected void registerDependencies(final String identifier, final PluginMeta meta) { ++ if (!(meta instanceof PaperPluginMeta paperPluginMeta)) { ++ throw new IllegalStateException("Only paper plugins can have a bootstrapper!"); ++ } ++ // Build a validated provider's dependencies into the graph ++ for (String dependency : paperPluginMeta.getBoostrapDependencies().keySet()) { ++ this.graph.putEdge(identifier, dependency); ++ } ++ } ++ ++ @Override ++ public void remove(PluginMeta configuration) { ++ String identifier = configuration.getName(); ++ // Remove a validated provider's dependencies into the graph ++ ++ ++ ++ this.graph.removeNode(identifier); // Remove root node ++ ++ // Remove the provided plugins to the graph as well ++ for (String provides : configuration.getProvidedPlugins()) { ++ this.graph.removeEdge(identifier, provides); ++ this.dependencies.remove(provides); ++ } ++ this.dependencies.remove(identifier); ++ } ++ ++ @Override ++ protected void unregisterDependencies(final String identifier, final PluginMeta meta) { ++ if (!(meta instanceof PaperPluginMeta paperPluginMeta)) { ++ throw new IllegalStateException("PluginMeta must be a PaperPluginMeta"); ++ } ++ ++ // Build a validated provider's dependencies into the graph ++ for (String dependency : paperPluginMeta.getBoostrapDependencies().keySet()) { ++ this.graph.removeEdge(identifier, dependency); ++ } ++ } ++ ++ @Override ++ public String toString() { ++ return "BootstrapDependencyTree{" + "graph=" + this.graph + '}'; ++ } ++} diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/DependencyContextHolder.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/DependencyContextHolder.java new file mode 100644 index 0000000000000000000000000000000000000000..f43295fdeaa587cf30c35a1d545167071d58ce4b @@ -1791,10 +1875,10 @@ index 0000000000000000000000000000000000000000..a2fa8406bc3f0dcab6805633ae984d03 +} diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java new file mode 100644 -index 0000000000000000000000000000000000000000..e72bec3b0cbc41580f1b4beecae316d1c083d3e3 +index 0000000000000000000000000000000000000000..461ef285764aac88ced32be5e650b48e8fbc6bfd --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java -@@ -0,0 +1,117 @@ +@@ -0,0 +1,110 @@ +package io.papermc.paper.plugin.entrypoint.dependency; + +import com.google.common.graph.GraphBuilder; @@ -1804,17 +1888,16 @@ index 0000000000000000000000000000000000000000..e72bec3b0cbc41580f1b4beecae316d1 +import io.papermc.paper.plugin.provider.PluginProvider; +import io.papermc.paper.plugin.provider.entrypoint.DependencyContext; +import org.jetbrains.annotations.NotNull; -+ +import java.util.HashSet; +import java.util.Set; + -+public class MetaDependencyTree implements DependencyContext { ++public abstract class MetaDependencyTree implements DependencyContext { + -+ private final MutableGraph graph; ++ protected final MutableGraph graph; + + // We need to upkeep a separate collection since when populating + // a graph it adds nodes even if they are not present -+ private final Set dependencies = new HashSet<>(); ++ protected final Set dependencies = new HashSet<>(); + + public MetaDependencyTree() { + this(GraphBuilder.directed().build()); @@ -1824,23 +1907,10 @@ index 0000000000000000000000000000000000000000..e72bec3b0cbc41580f1b4beecae316d1 + this.graph = graph; + } + -+ public void add(PluginProvider provider) { -+ add(provider.getMeta()); -+ } -+ -+ public void remove(PluginProvider provider) { -+ remove(provider.getMeta()); -+ } -+ + public void add(PluginMeta configuration) { + String identifier = configuration.getName(); + // Build a validated provider's dependencies into the graph -+ for (String dependency : configuration.getPluginDependencies()) { -+ this.graph.putEdge(identifier, dependency); -+ } -+ for (String dependency : configuration.getPluginSoftDependencies()) { -+ this.graph.putEdge(identifier, dependency); -+ } ++ this.registerDependencies(identifier, configuration); + + this.graph.addNode(identifier); // Make sure dependencies at least have a node + @@ -1852,15 +1922,12 @@ index 0000000000000000000000000000000000000000..e72bec3b0cbc41580f1b4beecae316d1 + this.dependencies.add(identifier); + } + ++ protected abstract void registerDependencies(String identifier, PluginMeta meta); ++ + public void remove(PluginMeta configuration) { + String identifier = configuration.getName(); + // Remove a validated provider's dependencies into the graph -+ for (String dependency : configuration.getPluginDependencies()) { -+ this.graph.removeEdge(identifier, dependency); -+ } -+ for (String dependency : configuration.getPluginSoftDependencies()) { -+ this.graph.removeEdge(identifier, dependency); -+ } ++ this.unregisterDependencies(identifier, configuration); + + this.graph.removeNode(identifier); // Remove root node + @@ -1872,6 +1939,8 @@ index 0000000000000000000000000000000000000000..e72bec3b0cbc41580f1b4beecae316d1 + this.dependencies.remove(identifier); + } + ++ protected abstract void unregisterDependencies(String identifier, PluginMeta meta); ++ + @Override + public boolean isTransitiveDependency(@NotNull PluginMeta plugin, @NotNull PluginMeta depend) { + String pluginIdentifier = plugin.getName(); @@ -1896,14 +1965,13 @@ index 0000000000000000000000000000000000000000..e72bec3b0cbc41580f1b4beecae316d1 + return this.dependencies.contains(pluginIdentifier); + } + -+ // Used by the legacy loader -- this isn't recommended + public void addDirectDependency(String dependency) { + this.dependencies.add(dependency); + } + + @Override + public String toString() { -+ return "ProviderDependencyTree{" + ++ return "SimpleDependencyTree{" + + "graph=" + this.graph + + '}'; + } @@ -1911,6 +1979,61 @@ index 0000000000000000000000000000000000000000..e72bec3b0cbc41580f1b4beecae316d1 + public MutableGraph getGraph() { + return graph; + } ++ ++ public void add(PluginProvider provider) { ++ this.add(provider.getMeta()); ++ } ++ ++ public void remove(PluginProvider provider) { ++ this.remove(provider.getMeta()); ++ } ++ ++} +diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java +new file mode 100644 +index 0000000000000000000000000000000000000000..910caf78636769977dff55dd048c0150a36d218d +--- /dev/null ++++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java +@@ -0,0 +1,40 @@ ++package io.papermc.paper.plugin.entrypoint.dependency; ++ ++import com.google.common.graph.GraphBuilder; ++import com.google.common.graph.Graphs; ++import com.google.common.graph.MutableGraph; ++import io.papermc.paper.plugin.configuration.PluginMeta; ++import org.jetbrains.annotations.NotNull; ++ ++import java.util.HashSet; ++import java.util.Set; ++ ++public class SimpleMetaDependencyTree extends MetaDependencyTree { ++ ++ public SimpleMetaDependencyTree() { ++ } ++ ++ public SimpleMetaDependencyTree(final MutableGraph graph) { ++ super(graph); ++ } ++ ++ @Override ++ protected void registerDependencies(final String identifier, final PluginMeta meta) { ++ for (String dependency : meta.getPluginDependencies()) { ++ this.graph.putEdge(identifier, dependency); ++ } ++ for (String dependency : meta.getPluginSoftDependencies()) { ++ this.graph.putEdge(identifier, dependency); ++ } ++ } ++ ++ @Override ++ protected void unregisterDependencies(final String identifier, final PluginMeta meta) { ++ for (String dependency : meta.getPluginDependencies()) { ++ this.graph.removeEdge(identifier, dependency); ++ } ++ for (String dependency : meta.getPluginSoftDependencies()) { ++ this.graph.removeEdge(identifier, dependency); ++ } ++ } +} diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/strategy/JohnsonSimpleCycles.java b/src/main/java/io/papermc/paper/plugin/entrypoint/strategy/JohnsonSimpleCycles.java new file mode 100644 @@ -3678,10 +3801,10 @@ index 0000000000000000000000000000000000000000..92a69677f21b2c1c035119d8e5a6af63 +} diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java b/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java new file mode 100644 -index 0000000000000000000000000000000000000000..9c7552968b8c017c71a7a77557a66a03ed89f125 +index 0000000000000000000000000000000000000000..08b1aab5d37a56dc42542ce15ba1f7ccd1b08400 --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java -@@ -0,0 +1,301 @@ +@@ -0,0 +1,302 @@ +package io.papermc.paper.plugin.manager; + +import com.google.common.base.Preconditions; @@ -3690,6 +3813,7 @@ index 0000000000000000000000000000000000000000..9c7552968b8c017c71a7a77557a66a03 +import io.papermc.paper.plugin.configuration.PluginMeta; +import io.papermc.paper.plugin.entrypoint.Entrypoint; +import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; +import io.papermc.paper.plugin.entrypoint.strategy.PluginGraphCycleException; +import io.papermc.paper.plugin.provider.classloader.ConfiguredPluginClassLoader; +import io.papermc.paper.plugin.provider.classloader.PaperClassLoaderStorage; @@ -3739,7 +3863,7 @@ index 0000000000000000000000000000000000000000..9c7552968b8c017c71a7a77557a66a03 + private final CommandMap commandMap; + private final Server server; + -+ private final MetaDependencyTree dependencyTree = new MetaDependencyTree(GraphBuilder.directed().build()); ++ private final MetaDependencyTree dependencyTree = new SimpleMetaDependencyTree(GraphBuilder.directed().build()); + + public PaperPluginInstanceManager(PluginManager pluginManager, CommandMap commandMap, Server server) { + this.commandMap = commandMap; @@ -6545,10 +6669,10 @@ index 0000000000000000000000000000000000000000..14ed05945ba5bfeb2b539d4786278b0e + diff --git a/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java new file mode 100644 -index 0000000000000000000000000000000000000000..8ef13e4f00a61db0dab9ef63231d77adcfaba5ab +index 0000000000000000000000000000000000000000..6db2bacd74a9eec9597bd8e62b1d5c7929655350 --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java -@@ -0,0 +1,58 @@ +@@ -0,0 +1,65 @@ +package io.papermc.paper.plugin.storage; + +import com.mojang.logging.LogUtils; @@ -6556,7 +6680,9 @@ index 0000000000000000000000000000000000000000..8ef13e4f00a61db0dab9ef63231d77ad +import io.papermc.paper.plugin.bootstrap.BootstrapContext; +import io.papermc.paper.plugin.bootstrap.PluginBootstrap; +import io.papermc.paper.plugin.bootstrap.PluginBootstrapContextImpl; ++import io.papermc.paper.plugin.entrypoint.dependency.BootstrapMetaDependencyTree; +import io.papermc.paper.plugin.entrypoint.dependency.DependencyContextHolder; ++import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; +import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration; +import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy; +import io.papermc.paper.plugin.provider.PluginProvider; @@ -6603,6 +6729,11 @@ index 0000000000000000000000000000000000000000..8ef13e4f00a61db0dab9ef63231d77ad + } + + @Override ++ public MetaDependencyTree getDependencyTree() { ++ return new BootstrapMetaDependencyTree(); ++ } ++ ++ @Override + public String toString() { + return "BOOTSTRAP:" + super.toString(); + } @@ -6632,12 +6763,13 @@ index 0000000000000000000000000000000000000000..8ef4806cadabe56264dd861f1a1854b2 +} diff --git a/src/main/java/io/papermc/paper/plugin/storage/ProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/ProviderStorage.java new file mode 100644 -index 0000000000000000000000000000000000000000..374e7d3d69fc8603ecf54999f173123d3a9fbf6e +index 0000000000000000000000000000000000000000..23269665f5f13bc55a45c2384542f0194235f8b0 --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/storage/ProviderStorage.java -@@ -0,0 +1,18 @@ +@@ -0,0 +1,21 @@ +package io.papermc.paper.plugin.storage; + ++import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; +import io.papermc.paper.plugin.provider.PluginProvider; + +/** @@ -6649,6 +6781,8 @@ index 0000000000000000000000000000000000000000..374e7d3d69fc8603ecf54999f173123d + + void register(PluginProvider provider); + ++ MetaDependencyTree getDependencyTree(); ++ + void enter(); + + Iterable> getRegisteredProviders(); @@ -6732,17 +6866,17 @@ index 0000000000000000000000000000000000000000..cb9b13522a976b82bcb71cef486f11f4 +} diff --git a/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java new file mode 100644 -index 0000000000000000000000000000000000000000..861c245290696eef0fca846c3026b407593fdce1 +index 0000000000000000000000000000000000000000..e4296230c773e68c816d7210a70b42f4bb9a0011 --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java -@@ -0,0 +1,93 @@ +@@ -0,0 +1,94 @@ +package io.papermc.paper.plugin.storage; + +import com.google.common.graph.GraphBuilder; +import com.google.common.graph.MutableGraph; +import com.mojang.logging.LogUtils; -+import io.papermc.paper.plugin.entrypoint.dependency.GraphDependencyContext; +import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; +import io.papermc.paper.plugin.entrypoint.strategy.PluginGraphCycleException; +import io.papermc.paper.plugin.entrypoint.strategy.ProviderLoadingStrategy; +import io.papermc.paper.plugin.provider.PluginProvider; @@ -6782,8 +6916,9 @@ index 0000000000000000000000000000000000000000..861c245290696eef0fca846c3026b407 + } + } + ++ @Override + public MetaDependencyTree getDependencyTree() { -+ return new MetaDependencyTree(GraphBuilder.directed().build()); ++ return new SimpleMetaDependencyTree(GraphBuilder.directed().build()); + } + + @Override @@ -7274,13 +7409,14 @@ index 0000000000000000000000000000000000000000..1d14f530ef888102e47eeeaf0d1a6076 +} diff --git a/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java b/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java new file mode 100644 -index 0000000000000000000000000000000000000000..ad92ae93acd25af4d223a55a0bcbc2a5740390a9 +index 0000000000000000000000000000000000000000..83b1274ba56f03bec6cb69a35f33dc04f008cc1e --- /dev/null +++ b/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java -@@ -0,0 +1,59 @@ +@@ -0,0 +1,60 @@ +package io.papermc.paper.plugin; + +import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; +import org.junit.jupiter.api.Test; + +import java.util.List; @@ -7311,7 +7447,7 @@ index 0000000000000000000000000000000000000000..ad92ae93acd25af4d223a55a0bcbc2a5 + + @Test + public void testDependencyTree() { -+ MetaDependencyTree tree = new MetaDependencyTree(); ++ MetaDependencyTree tree = new SimpleMetaDependencyTree(); + tree.add(MAIN); + tree.add(HARD_DEPENDENCY_1); + tree.add(SOFT_DEPENDENCY_1); @@ -7339,14 +7475,14 @@ index 0000000000000000000000000000000000000000..ad92ae93acd25af4d223a55a0bcbc2a5 +} diff --git a/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java b/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java new file mode 100644 -index 0000000000000000000000000000000000000000..a66fd32cf8af310101161c1b820b3468657460f0 +index 0000000000000000000000000000000000000000..c2c3c2f24ea802628bc4a36ef180fc08f4e5d288 --- /dev/null +++ b/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java @@ -0,0 +1,148 @@ +package io.papermc.paper.plugin; + +import com.google.common.graph.GraphBuilder; -+import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; ++import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; +import io.papermc.paper.plugin.provider.entrypoint.DependencyContext; +import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy; +import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration; @@ -7450,7 +7586,7 @@ index 0000000000000000000000000000000000000000..a66fd32cf8af310101161c1b820b3468 + + }); + -+ modernPluginLoadingStrategy.loadProviders(REGISTERED_PROVIDERS, new MetaDependencyTree(GraphBuilder.directed().build())); ++ modernPluginLoadingStrategy.loadProviders(REGISTERED_PROVIDERS, new SimpleMetaDependencyTree(GraphBuilder.directed().build())); + } + + @Test diff --git a/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch b/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch deleted file mode 100644 index bd4a496e1f5c..000000000000 --- a/patches/server/1053-Fix-plugin-bootstrap-dependency-tree-population.patch +++ /dev/null @@ -1,482 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: Gijs de Jong -Date: Wed, 22 Nov 2023 23:58:55 +0100 -Subject: [PATCH] Fix plugin bootstrap dependency tree population - -This patch fixes a bug where the dependency tree used for classpath joining, -wasn't built using the bootstrap dependencies, for plugin bootstrappers. - -diff --git a/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java b/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java -index 8ade7eb97aa899ddd4bb8274b8f588a4d7265868..d4a092243e587e3a555fbc0f00c8f78c00b3d1c6 100644 ---- a/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java -+++ b/src/main/java/io/papermc/paper/command/subcommands/DumpPluginsCommand.java -@@ -16,7 +16,7 @@ import io.papermc.paper.plugin.entrypoint.classloader.group.SimpleListPluginClas - import io.papermc.paper.plugin.entrypoint.classloader.group.SpigotPluginClassLoaderGroup; - import io.papermc.paper.plugin.entrypoint.classloader.group.StaticPluginClassLoaderGroup; - import io.papermc.paper.plugin.entrypoint.dependency.GraphDependencyContext; --import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; -+import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; - import io.papermc.paper.plugin.provider.entrypoint.DependencyContext; - import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy; - import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration; -@@ -141,7 +141,7 @@ public final class DumpPluginsCommand implements PaperSubcommand { - return false; - } - }); -- modernPluginLoadingStrategy.loadProviders(pluginProviders, new MetaDependencyTree(GraphBuilder.directed().build())); -+ modernPluginLoadingStrategy.loadProviders(pluginProviders, new SimpleMetaDependencyTree(GraphBuilder.directed().build())); - - rootProviders.add(entry.getKey().getDebugName(), entrypoint); - } -diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java -new file mode 100644 -index 0000000000000000000000000000000000000000..b6273c99ae2d8a50cb91b3686b8b8b434a87fd7e ---- /dev/null -+++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java -@@ -0,0 +1,67 @@ -+package io.papermc.paper.plugin.entrypoint.dependency; -+ -+import com.google.common.graph.GraphBuilder; -+import com.google.common.graph.MutableGraph; -+import io.papermc.paper.plugin.configuration.PluginMeta; -+import io.papermc.paper.plugin.provider.configuration.PaperPluginMeta; -+ -+public class BootstrapMetaDependencyTree extends SimpleMetaDependencyTree { -+ public BootstrapMetaDependencyTree() { -+ this(GraphBuilder.directed().build()); -+ } -+ -+ public BootstrapMetaDependencyTree(MutableGraph graph) { -+ super(graph); -+ } -+ -+ @Override -+ public void add(PluginMeta configuration) { -+ if (!(configuration instanceof PaperPluginMeta paperPluginMeta)) { -+ throw new IllegalStateException("Only paper plugins can have a bootstrapper!"); -+ } -+ -+ String identifier = configuration.getName(); -+ -+ // Build a validated provider's dependencies into the graph -+ for (String dependency : paperPluginMeta.getBoostrapDependencies().keySet()) { -+ this.graph.putEdge(identifier, dependency); -+ } -+ -+ this.graph.addNode(identifier); // Make sure dependencies at least have a node -+ -+ // Add the provided plugins to the graph as well -+ for (String provides : configuration.getProvidedPlugins()) { -+ this.graph.putEdge(identifier, provides); -+ this.dependencies.add(provides); -+ } -+ this.dependencies.add(identifier); -+ } -+ -+ @Override -+ public void remove(PluginMeta configuration) { -+ String identifier = configuration.getName(); -+ // Remove a validated provider's dependencies into the graph -+ if (!(configuration instanceof PaperPluginMeta paperPluginMeta)) { -+ throw new IllegalStateException("PluginMeta must be a PaperPluginMeta"); -+ } -+ -+ // Build a validated provider's dependencies into the graph -+ for (String dependency : paperPluginMeta.getBoostrapDependencies().keySet()) { -+ this.graph.removeEdge(identifier, dependency); -+ } -+ -+ this.graph.removeNode(identifier); // Remove root node -+ -+ // Remove the provided plugins to the graph as well -+ for (String provides : configuration.getProvidedPlugins()) { -+ this.graph.removeEdge(identifier, provides); -+ this.dependencies.remove(provides); -+ } -+ this.dependencies.remove(identifier); -+ } -+ -+ @Override -+ public String toString() { -+ return "BootstrapDependencyTree{" + "graph=" + this.graph + '}'; -+ } -+} -diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java -index e72bec3b0cbc41580f1b4beecae316d1c083d3e3..62da59c30511065379658d1b34e780a33c15ce90 100644 ---- a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java -+++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/MetaDependencyTree.java -@@ -1,117 +1,26 @@ - package io.papermc.paper.plugin.entrypoint.dependency; - --import com.google.common.graph.GraphBuilder; --import com.google.common.graph.Graphs; - import com.google.common.graph.MutableGraph; - import io.papermc.paper.plugin.configuration.PluginMeta; - import io.papermc.paper.plugin.provider.PluginProvider; - import io.papermc.paper.plugin.provider.entrypoint.DependencyContext; --import org.jetbrains.annotations.NotNull; - --import java.util.HashSet; --import java.util.Set; -+public interface MetaDependencyTree extends DependencyContext { - --public class MetaDependencyTree implements DependencyContext { -+ void add(PluginMeta configuration); - -- private final MutableGraph graph; -- -- // We need to upkeep a separate collection since when populating -- // a graph it adds nodes even if they are not present -- private final Set dependencies = new HashSet<>(); -- -- public MetaDependencyTree() { -- this(GraphBuilder.directed().build()); -- } -- -- public MetaDependencyTree(MutableGraph graph) { -- this.graph = graph; -- } -- -- public void add(PluginProvider provider) { -+ default void add(PluginProvider provider) { - add(provider.getMeta()); - } - -- public void remove(PluginProvider provider) { -- remove(provider.getMeta()); -- } -- -- public void add(PluginMeta configuration) { -- String identifier = configuration.getName(); -- // Build a validated provider's dependencies into the graph -- for (String dependency : configuration.getPluginDependencies()) { -- this.graph.putEdge(identifier, dependency); -- } -- for (String dependency : configuration.getPluginSoftDependencies()) { -- this.graph.putEdge(identifier, dependency); -- } -- -- this.graph.addNode(identifier); // Make sure dependencies at least have a node -- -- // Add the provided plugins to the graph as well -- for (String provides : configuration.getProvidedPlugins()) { -- this.graph.putEdge(identifier, provides); -- this.dependencies.add(provides); -- } -- this.dependencies.add(identifier); -- } -- -- public void remove(PluginMeta configuration) { -- String identifier = configuration.getName(); -- // Remove a validated provider's dependencies into the graph -- for (String dependency : configuration.getPluginDependencies()) { -- this.graph.removeEdge(identifier, dependency); -- } -- for (String dependency : configuration.getPluginSoftDependencies()) { -- this.graph.removeEdge(identifier, dependency); -- } -- -- this.graph.removeNode(identifier); // Remove root node -- -- // Remove the provided plugins to the graph as well -- for (String provides : configuration.getProvidedPlugins()) { -- this.graph.removeEdge(identifier, provides); -- this.dependencies.remove(provides); -- } -- this.dependencies.remove(identifier); -- } -- -- @Override -- public boolean isTransitiveDependency(@NotNull PluginMeta plugin, @NotNull PluginMeta depend) { -- String pluginIdentifier = plugin.getName(); -- -- if (this.graph.nodes().contains(pluginIdentifier)) { -- Set reachableNodes = Graphs.reachableNodes(this.graph, pluginIdentifier); -- if (reachableNodes.contains(depend.getName())) { -- return true; -- } -- for (String provided : depend.getProvidedPlugins()) { -- if (reachableNodes.contains(provided)) { -- return true; -- } -- } -- } -- -- return false; -- } -- -- @Override -- public boolean hasDependency(@NotNull String pluginIdentifier) { -- return this.dependencies.contains(pluginIdentifier); -- } -- - // Used by the legacy loader -- this isn't recommended -- public void addDirectDependency(String dependency) { -- this.dependencies.add(dependency); -- } -+ void addDirectDependency(String dependency); - -- @Override -- public String toString() { -- return "ProviderDependencyTree{" + -- "graph=" + this.graph + -- '}'; -- } -+ void remove(PluginMeta configuration); - -- public MutableGraph getGraph() { -- return graph; -+ default void remove(PluginProvider provider) { -+ remove(provider.getMeta()); - } -+ -+ MutableGraph getGraph(); - } -diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java -new file mode 100644 -index 0000000000000000000000000000000000000000..0676823ba232d1389378d3c1ce197079b754e3ec ---- /dev/null -+++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/SimpleMetaDependencyTree.java -@@ -0,0 +1,107 @@ -+package io.papermc.paper.plugin.entrypoint.dependency; -+ -+import com.google.common.graph.GraphBuilder; -+import com.google.common.graph.Graphs; -+import com.google.common.graph.MutableGraph; -+import io.papermc.paper.plugin.configuration.PluginMeta; -+import org.jetbrains.annotations.NotNull; -+ -+import java.util.HashSet; -+import java.util.Set; -+ -+public class SimpleMetaDependencyTree implements MetaDependencyTree { -+ protected final MutableGraph graph; -+ -+ // We need to upkeep a separate collection since when populating -+ // a graph it adds nodes even if they are not present -+ protected final Set dependencies = new HashSet<>(); -+ -+ public SimpleMetaDependencyTree() { -+ this(GraphBuilder.directed().build()); -+ } -+ -+ public SimpleMetaDependencyTree(MutableGraph graph) { -+ this.graph = graph; -+ } -+ -+ public void add(PluginMeta configuration) { -+ String identifier = configuration.getName(); -+ // Build a validated provider's dependencies into the graph -+ for (String dependency : configuration.getPluginDependencies()) { -+ this.graph.putEdge(identifier, dependency); -+ } -+ for (String dependency : configuration.getPluginSoftDependencies()) { -+ this.graph.putEdge(identifier, dependency); -+ } -+ -+ this.graph.addNode(identifier); // Make sure dependencies at least have a node -+ -+ // Add the provided plugins to the graph as well -+ for (String provides : configuration.getProvidedPlugins()) { -+ this.graph.putEdge(identifier, provides); -+ this.dependencies.add(provides); -+ } -+ this.dependencies.add(identifier); -+ } -+ -+ public void remove(PluginMeta configuration) { -+ String identifier = configuration.getName(); -+ // Remove a validated provider's dependencies into the graph -+ for (String dependency : configuration.getPluginDependencies()) { -+ this.graph.removeEdge(identifier, dependency); -+ } -+ for (String dependency : configuration.getPluginSoftDependencies()) { -+ this.graph.removeEdge(identifier, dependency); -+ } -+ -+ this.graph.removeNode(identifier); // Remove root node -+ -+ // Remove the provided plugins to the graph as well -+ for (String provides : configuration.getProvidedPlugins()) { -+ this.graph.removeEdge(identifier, provides); -+ this.dependencies.remove(provides); -+ } -+ this.dependencies.remove(identifier); -+ } -+ -+ @Override -+ public boolean isTransitiveDependency(@NotNull PluginMeta plugin, @NotNull PluginMeta depend) { -+ String pluginIdentifier = plugin.getName(); -+ -+ if (this.graph.nodes().contains(pluginIdentifier)) { -+ Set reachableNodes = Graphs.reachableNodes(this.graph, pluginIdentifier); -+ if (reachableNodes.contains(depend.getName())) { -+ return true; -+ } -+ for (String provided : depend.getProvidedPlugins()) { -+ if (reachableNodes.contains(provided)) { -+ return true; -+ } -+ } -+ } -+ -+ return false; -+ } -+ -+ @Override -+ public boolean hasDependency(@NotNull String pluginIdentifier) { -+ return this.dependencies.contains(pluginIdentifier); -+ } -+ -+ @Override -+ public void addDirectDependency(String dependency) { -+ this.dependencies.add(dependency); -+ } -+ -+ @Override -+ public String toString() { -+ return "SimpleDependencyTree{" + -+ "graph=" + this.graph + -+ '}'; -+ } -+ -+ @Override -+ public MutableGraph getGraph() { -+ return graph; -+ } -+} -diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java b/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java -index 9c7552968b8c017c71a7a77557a66a03ed89f125..08b1aab5d37a56dc42542ce15ba1f7ccd1b08400 100644 ---- a/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java -+++ b/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java -@@ -6,6 +6,7 @@ import com.google.common.graph.MutableGraph; - import io.papermc.paper.plugin.configuration.PluginMeta; - import io.papermc.paper.plugin.entrypoint.Entrypoint; - import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; -+import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; - import io.papermc.paper.plugin.entrypoint.strategy.PluginGraphCycleException; - import io.papermc.paper.plugin.provider.classloader.ConfiguredPluginClassLoader; - import io.papermc.paper.plugin.provider.classloader.PaperClassLoaderStorage; -@@ -55,7 +56,7 @@ class PaperPluginInstanceManager { - private final CommandMap commandMap; - private final Server server; - -- private final MetaDependencyTree dependencyTree = new MetaDependencyTree(GraphBuilder.directed().build()); -+ private final MetaDependencyTree dependencyTree = new SimpleMetaDependencyTree(GraphBuilder.directed().build()); - - public PaperPluginInstanceManager(PluginManager pluginManager, CommandMap commandMap, Server server) { - this.commandMap = commandMap; -diff --git a/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java -index 8ef13e4f00a61db0dab9ef63231d77adcfaba5ab..6db2bacd74a9eec9597bd8e62b1d5c7929655350 100644 ---- a/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java -+++ b/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java -@@ -5,7 +5,9 @@ import io.papermc.paper.plugin.PluginInitializerManager; - import io.papermc.paper.plugin.bootstrap.BootstrapContext; - import io.papermc.paper.plugin.bootstrap.PluginBootstrap; - import io.papermc.paper.plugin.bootstrap.PluginBootstrapContextImpl; -+import io.papermc.paper.plugin.entrypoint.dependency.BootstrapMetaDependencyTree; - import io.papermc.paper.plugin.entrypoint.dependency.DependencyContextHolder; -+import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; - import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration; - import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy; - import io.papermc.paper.plugin.provider.PluginProvider; -@@ -51,6 +53,11 @@ public class BootstrapProviderStorage extends SimpleProviderStorage { - - void register(PluginProvider provider); - -+ MetaDependencyTree getDependencyTree(); -+ - void enter(); - - Iterable> getRegisteredProviders(); -diff --git a/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java -index 861c245290696eef0fca846c3026b407593fdce1..e4296230c773e68c816d7210a70b42f4bb9a0011 100644 ---- a/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java -+++ b/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java -@@ -3,8 +3,8 @@ package io.papermc.paper.plugin.storage; - import com.google.common.graph.GraphBuilder; - import com.google.common.graph.MutableGraph; - import com.mojang.logging.LogUtils; --import io.papermc.paper.plugin.entrypoint.dependency.GraphDependencyContext; - import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; -+import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; - import io.papermc.paper.plugin.entrypoint.strategy.PluginGraphCycleException; - import io.papermc.paper.plugin.entrypoint.strategy.ProviderLoadingStrategy; - import io.papermc.paper.plugin.provider.PluginProvider; -@@ -44,8 +44,9 @@ public abstract class SimpleProviderStorage implements ProviderStorage { - } - } - -+ @Override - public MetaDependencyTree getDependencyTree() { -- return new MetaDependencyTree(GraphBuilder.directed().build()); -+ return new SimpleMetaDependencyTree(GraphBuilder.directed().build()); - } - - @Override -diff --git a/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java b/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java -index ad92ae93acd25af4d223a55a0bcbc2a5740390a9..83b1274ba56f03bec6cb69a35f33dc04f008cc1e 100644 ---- a/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java -+++ b/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java -@@ -1,6 +1,7 @@ - package io.papermc.paper.plugin; - - import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; -+import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; - import org.junit.jupiter.api.Test; - - import java.util.List; -@@ -31,7 +32,7 @@ public class PluginDependencyValidationTest { - - @Test - public void testDependencyTree() { -- MetaDependencyTree tree = new MetaDependencyTree(); -+ MetaDependencyTree tree = new SimpleMetaDependencyTree(); - tree.add(MAIN); - tree.add(HARD_DEPENDENCY_1); - tree.add(SOFT_DEPENDENCY_1); -diff --git a/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java b/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java -index a66fd32cf8af310101161c1b820b3468657460f0..c2c3c2f24ea802628bc4a36ef180fc08f4e5d288 100644 ---- a/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java -+++ b/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java -@@ -1,7 +1,7 @@ - package io.papermc.paper.plugin; - - import com.google.common.graph.GraphBuilder; --import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; -+import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; - import io.papermc.paper.plugin.provider.entrypoint.DependencyContext; - import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy; - import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration; -@@ -105,7 +105,7 @@ public class PluginLoadOrderTest { - - }); - -- modernPluginLoadingStrategy.loadProviders(REGISTERED_PROVIDERS, new MetaDependencyTree(GraphBuilder.directed().build())); -+ modernPluginLoadingStrategy.loadProviders(REGISTERED_PROVIDERS, new SimpleMetaDependencyTree(GraphBuilder.directed().build())); - } - - @Test From 8d1639568635baa80f06e55e521a14f9edfaf5c5 Mon Sep 17 00:00:00 2001 From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com> Date: Sat, 25 Nov 2023 17:45:41 -0500 Subject: [PATCH 4/5] fix --- patches/server/0013-Paper-Plugins.patch | 38 ++----------------------- 1 file changed, 2 insertions(+), 36 deletions(-) diff --git a/patches/server/0013-Paper-Plugins.patch b/patches/server/0013-Paper-Plugins.patch index 369fb6cbabdf..e0fc9f3657ce 100644 --- a/patches/server/0013-Paper-Plugins.patch +++ b/patches/server/0013-Paper-Plugins.patch @@ -1716,10 +1716,10 @@ index 0000000000000000000000000000000000000000..2412155ddfd559023f42ff534b8f06a5 +} diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java new file mode 100644 -index 0000000000000000000000000000000000000000..cc41e38b6303951ad98f5d49c613c26b9bd621e9 +index 0000000000000000000000000000000000000000..74bf07be300d4893402614c9e9d9ac97dc574ac7 --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/entrypoint/dependency/BootstrapMetaDependencyTree.java -@@ -0,0 +1,78 @@ +@@ -0,0 +1,44 @@ +package io.papermc.paper.plugin.entrypoint.dependency; + +import com.google.common.graph.GraphBuilder; @@ -1737,23 +1737,6 @@ index 0000000000000000000000000000000000000000..cc41e38b6303951ad98f5d49c613c26b + } + + @Override -+ public void add(PluginMeta configuration) { -+ -+ -+ String identifier = configuration.getName(); -+ -+ -+ this.graph.addNode(identifier); // Make sure dependencies at least have a node -+ -+ // Add the provided plugins to the graph as well -+ for (String provides : configuration.getProvidedPlugins()) { -+ this.graph.putEdge(identifier, provides); -+ this.dependencies.add(provides); -+ } -+ this.dependencies.add(identifier); -+ } -+ -+ @Override + protected void registerDependencies(final String identifier, final PluginMeta meta) { + if (!(meta instanceof PaperPluginMeta paperPluginMeta)) { + throw new IllegalStateException("Only paper plugins can have a bootstrapper!"); @@ -1765,23 +1748,6 @@ index 0000000000000000000000000000000000000000..cc41e38b6303951ad98f5d49c613c26b + } + + @Override -+ public void remove(PluginMeta configuration) { -+ String identifier = configuration.getName(); -+ // Remove a validated provider's dependencies into the graph -+ -+ -+ -+ this.graph.removeNode(identifier); // Remove root node -+ -+ // Remove the provided plugins to the graph as well -+ for (String provides : configuration.getProvidedPlugins()) { -+ this.graph.removeEdge(identifier, provides); -+ this.dependencies.remove(provides); -+ } -+ this.dependencies.remove(identifier); -+ } -+ -+ @Override + protected void unregisterDependencies(final String identifier, final PluginMeta meta) { + if (!(meta instanceof PaperPluginMeta paperPluginMeta)) { + throw new IllegalStateException("PluginMeta must be a PaperPluginMeta"); From 4e555c6b67f135a1b54abea06e18704e439f8641 Mon Sep 17 00:00:00 2001 From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com> Date: Sat, 25 Nov 2023 17:50:26 -0500 Subject: [PATCH 5/5] Rename --- patches/server/0013-Paper-Plugins.patch | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/patches/server/0013-Paper-Plugins.patch b/patches/server/0013-Paper-Plugins.patch index e0fc9f3657ce..7b6ce3a60574 100644 --- a/patches/server/0013-Paper-Plugins.patch +++ b/patches/server/0013-Paper-Plugins.patch @@ -3244,7 +3244,7 @@ index 0000000000000000000000000000000000000000..aef19b44075a3b2e8696315baa89117d +} diff --git a/src/main/java/io/papermc/paper/plugin/manager/MultiRuntimePluginProviderStorage.java b/src/main/java/io/papermc/paper/plugin/manager/MultiRuntimePluginProviderStorage.java new file mode 100644 -index 0000000000000000000000000000000000000000..49bcce79139797649c775af65c7310c149611a56 +index 0000000000000000000000000000000000000000..d681222f355af5c4c26f35aaba484a393aee41c6 --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/manager/MultiRuntimePluginProviderStorage.java @@ -0,0 +1,61 @@ @@ -3305,7 +3305,7 @@ index 0000000000000000000000000000000000000000..49bcce79139797649c775af65c7310c1 + } + + @Override -+ public MetaDependencyTree getDependencyTree() { ++ public MetaDependencyTree createDependencyTree() { + return this.dependencyTree; + } +} @@ -4375,7 +4375,7 @@ index 0000000000000000000000000000000000000000..5d50d1d312388e979c0e1cd53a6bf597 +} diff --git a/src/main/java/io/papermc/paper/plugin/manager/SingularRuntimePluginProviderStorage.java b/src/main/java/io/papermc/paper/plugin/manager/SingularRuntimePluginProviderStorage.java new file mode 100644 -index 0000000000000000000000000000000000000000..3872f5a9287fc348d57812847ab18eb2d3e4b362 +index 0000000000000000000000000000000000000000..b0e723bcda9b1fc01e6aa5e53e57c09ea4f1a1c8 --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/manager/SingularRuntimePluginProviderStorage.java @@ -0,0 +1,79 @@ @@ -4454,7 +4454,7 @@ index 0000000000000000000000000000000000000000..3872f5a9287fc348d57812847ab18eb2 + } + + @Override -+ public MetaDependencyTree getDependencyTree() { ++ public MetaDependencyTree createDependencyTree() { + return this.dependencyTree; + } +} @@ -6635,7 +6635,7 @@ index 0000000000000000000000000000000000000000..14ed05945ba5bfeb2b539d4786278b0e + diff --git a/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java new file mode 100644 -index 0000000000000000000000000000000000000000..6db2bacd74a9eec9597bd8e62b1d5c7929655350 +index 0000000000000000000000000000000000000000..2e96308696e131f3f013469a395e5ddda2c5d529 --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/storage/BootstrapProviderStorage.java @@ -0,0 +1,65 @@ @@ -6695,7 +6695,7 @@ index 0000000000000000000000000000000000000000..6db2bacd74a9eec9597bd8e62b1d5c79 + } + + @Override -+ public MetaDependencyTree getDependencyTree() { ++ public MetaDependencyTree createDependencyTree() { + return new BootstrapMetaDependencyTree(); + } + @@ -6729,7 +6729,7 @@ index 0000000000000000000000000000000000000000..8ef4806cadabe56264dd861f1a1854b2 +} diff --git a/src/main/java/io/papermc/paper/plugin/storage/ProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/ProviderStorage.java new file mode 100644 -index 0000000000000000000000000000000000000000..23269665f5f13bc55a45c2384542f0194235f8b0 +index 0000000000000000000000000000000000000000..39cd3acd3f76b3b0d065e0efb04a3eacea1c2e6b --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/storage/ProviderStorage.java @@ -0,0 +1,21 @@ @@ -6747,7 +6747,7 @@ index 0000000000000000000000000000000000000000..23269665f5f13bc55a45c2384542f019 + + void register(PluginProvider provider); + -+ MetaDependencyTree getDependencyTree(); ++ MetaDependencyTree createDependencyTree(); + + void enter(); + @@ -6832,14 +6832,13 @@ index 0000000000000000000000000000000000000000..cb9b13522a976b82bcb71cef486f11f4 +} diff --git a/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java b/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java new file mode 100644 -index 0000000000000000000000000000000000000000..e4296230c773e68c816d7210a70b42f4bb9a0011 +index 0000000000000000000000000000000000000000..26422904751647a061397ce978bba752149003cd --- /dev/null +++ b/src/main/java/io/papermc/paper/plugin/storage/SimpleProviderStorage.java -@@ -0,0 +1,94 @@ +@@ -0,0 +1,93 @@ +package io.papermc.paper.plugin.storage; + +import com.google.common.graph.GraphBuilder; -+import com.google.common.graph.MutableGraph; +import com.mojang.logging.LogUtils; +import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree; +import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree; @@ -6874,7 +6873,7 @@ index 0000000000000000000000000000000000000000..e4296230c773e68c816d7210a70b42f4 + this.filterLoadingProviders(providerList); + + try { -+ for (ProviderLoadingStrategy.ProviderPair providerPair : this.strategy.loadProviders(providerList, this.getDependencyTree())) { ++ for (ProviderLoadingStrategy.ProviderPair providerPair : this.strategy.loadProviders(providerList, this.createDependencyTree())) { + this.processProvided(providerPair.provider(), providerPair.provided()); + } + } catch (PluginGraphCycleException exception) { @@ -6883,7 +6882,7 @@ index 0000000000000000000000000000000000000000..e4296230c773e68c816d7210a70b42f4 + } + + @Override -+ public MetaDependencyTree getDependencyTree() { ++ public MetaDependencyTree createDependencyTree() { + return new SimpleMetaDependencyTree(GraphBuilder.directed().build()); + } +