importedItems = oft.importItems(importSettings);
diff --git a/src/main/java/org/itsallcode/openfasttrace/gradle/task/classloader/ChildFirstClassLoader.java b/src/main/java/org/itsallcode/openfasttrace/gradle/task/classloader/ChildFirstClassLoader.java
new file mode 100644
index 0000000..68b71e6
--- /dev/null
+++ b/src/main/java/org/itsallcode/openfasttrace/gradle/task/classloader/ChildFirstClassLoader.java
@@ -0,0 +1,81 @@
+package org.itsallcode.openfasttrace.gradle.task.classloader;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * This class loader will first try to load the class from the given URLs and
+ * then from the parent class loader, unlike {@link URLClassLoader} which does
+ * it the other way around.
+ *
+ * This allows us to prefer external plugins over plugins on the classpath
+ * included with OFT.
+ *
+ * This is based on
+ *
+ * "Java: A Child First Class Loader" by Isuru Weerarathna
+ *
+ *
+ */
+class ChildFirstClassLoader extends URLClassLoader
+{
+ private static final Logger LOGGER = Logger.getLogger(ChildFirstClassLoader.class.getName());
+
+ ChildFirstClassLoader(final String name, final URL[] urls, final ClassLoader parent)
+ {
+ super(name, urls, parent);
+ }
+
+ @Override
+ protected Class loadClass(final String name, final boolean resolve) throws ClassNotFoundException
+ {
+ if (isSharedOpenFastTraceClass(name))
+ {
+ return super.loadClass(name, resolve);
+ }
+ final Class loadedClass = findClass(name, resolve);
+ if (resolve)
+ {
+ resolveClass(loadedClass);
+ }
+ return loadedClass;
+ }
+
+ private static boolean isSharedOpenFastTraceClass(final String name)
+ {
+ return name.startsWith("org.itsallcode.openfasttrace.api.")
+ || name.startsWith("org.itsallcode.openfasttrace.core.");
+ }
+
+ private Class findClass(final String name, final boolean resolve) throws ClassNotFoundException
+ {
+ // Has the class loaded already?
+ final Class loadedClass = findLoadedClass(name);
+ if (loadedClass != null)
+ {
+ return loadedClass;
+ }
+ return loadClassInternally(name, resolve);
+ }
+
+ private Class loadClassInternally(final String name, final boolean resolve) throws ClassNotFoundException
+ {
+ try
+ {
+ // Find the class from given jar urls
+ return findClass(name);
+ }
+ catch (final ClassNotFoundException ignore)
+ {
+ LOGGER.log(Level.FINEST, () -> "Unable to find class " + name + " with child classloader '"
+ + this.getClass().getClassLoader().getName() + "'. "
+ + "Falling back to parent classloader '" + super.getClass().getClassLoader().getName() + "'.");
+ // Class does not exist in the given URLs.
+ // Let's try finding it in our parent class's classloader.
+ // This will throw ClassNotFoundException on failure.
+ return super.loadClass(name, resolve);
+ }
+ }
+}
diff --git a/src/main/java/org/itsallcode/openfasttrace/gradle/task/classloader/OftPluginClassLoader.java b/src/main/java/org/itsallcode/openfasttrace/gradle/task/classloader/OftPluginClassLoader.java
new file mode 100644
index 0000000..a941fca
--- /dev/null
+++ b/src/main/java/org/itsallcode/openfasttrace/gradle/task/classloader/OftPluginClassLoader.java
@@ -0,0 +1,108 @@
+package org.itsallcode.openfasttrace.gradle.task.classloader;
+
+import java.io.IOException;
+import java.net.*;
+import java.util.*;
+
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.Logging;
+import org.itsallcode.openfasttrace.core.OftRunner;
+
+/** Runs OpenFastTrace operations with additional plugin artifacts on the context classpath. */
+public final class OftPluginClassLoader
+{
+ private static final Logger LOG = Logging.getLogger(OftPluginClassLoader.class);
+
+ private OftPluginClassLoader()
+ {
+ }
+
+ /**
+ * Runs an operation with the given plugin files available to service loading.
+ *
+ * @param pluginFiles
+ * plugin artifacts to expose
+ * @param action
+ * operation to run
+ */
+ public static void runWithPlugins(final FileCollection pluginFiles, final Runnable action)
+ {
+ if (pluginFiles.isEmpty())
+ {
+ action.run();
+ return;
+ }
+
+ final Thread thread = Thread.currentThread();
+ final ClassLoader originalClassLoader = thread.getContextClassLoader();
+ final ClassLoader parent = new ParentClassLoader(OftRunner.class.getClassLoader(), originalClassLoader);
+ final URLClassLoader pluginClassLoader = createClassLoader(pluginFiles, parent);
+ thread.setContextClassLoader(pluginClassLoader);
+ try
+ {
+ action.run();
+ }
+ finally
+ {
+ thread.setContextClassLoader(originalClassLoader);
+ try
+ {
+ pluginClassLoader.close();
+ }
+ catch (final IOException e)
+ {
+ LOG.warn("Could not close OpenFastTrace plugin classloader", e);
+ }
+ }
+ }
+
+ private static URLClassLoader createClassLoader(final FileCollection pluginFiles, final ClassLoader parent)
+ {
+ final Set pluginUrls = new HashSet<>(pluginFiles.getFiles().stream()
+ .map(file -> file.toPath().toUri())
+ .toList());
+ // OFT only accepts service providers loaded by the classloader that discovered them.
+ // Add OFT's built-in provider JARs to this loader so they are not filtered out.
+ addServiceProviderJars(parent, pluginUrls,
+ "org.itsallcode.openfasttrace.api.exporter.ExporterFactory");
+ addServiceProviderJars(parent, pluginUrls,
+ "org.itsallcode.openfasttrace.api.importer.ImporterFactory");
+ final URL[] urls = pluginUrls.toArray(URL[]::new);
+ final String pluginUrlsString = Arrays.toString(urls);
+ return new ChildFirstClassLoader("ChildFirst ClassLoader for " + pluginUrlsString, urls, parent);
+ }
+
+ private static void addServiceProviderJars(final ClassLoader parent, final Set urls,
+ final String serviceName)
+ {
+ try
+ {
+ final String resourceName = "META-INF/services/" + serviceName;
+ for (final URL resource : java.util.Collections.list(parent.getResources(resourceName)))
+ {
+ final URLConnection connection = resource.openConnection();
+ if (connection instanceof final JarURLConnection jarConnection)
+ {
+ urls.add(toUri(jarConnection.getJarFileURL()));
+ }
+ }
+ }
+ catch (final IOException e)
+ {
+ throw new IllegalStateException("Could not locate service provider jars for " + serviceName, e);
+ }
+ }
+
+ private static URI toUri(final URL url)
+ {
+ try
+ {
+ return url.toURI();
+ }
+ catch (final URISyntaxException e)
+ {
+ throw new IllegalStateException("Invalid JAR file URL: " + url, e);
+ }
+ }
+}
diff --git a/src/main/java/org/itsallcode/openfasttrace/gradle/task/classloader/ParentClassLoader.java b/src/main/java/org/itsallcode/openfasttrace/gradle/task/classloader/ParentClassLoader.java
new file mode 100644
index 0000000..b7b50d4
--- /dev/null
+++ b/src/main/java/org/itsallcode/openfasttrace/gradle/task/classloader/ParentClassLoader.java
@@ -0,0 +1,73 @@
+package org.itsallcode.openfasttrace.gradle.task.classloader;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.*;
+
+final class ParentClassLoader extends ClassLoader
+{
+ private final ClassLoader[] parents;
+
+ ParentClassLoader(final ClassLoader... parents)
+ {
+ super(null);
+ this.parents = Arrays.stream(parents)
+ .filter(Objects::nonNull)
+ .distinct()
+ .toArray(ClassLoader[]::new);
+ }
+
+ @Override
+ @SuppressWarnings("java:S3032") // Explicit loading is required to delegate to multiple independent parents.
+ protected Class loadClass(final String name, final boolean resolve) throws ClassNotFoundException
+ {
+ for (final ClassLoader parent : parents)
+ {
+ try
+ {
+ return Class.forName(name, resolve, parent);
+ }
+ catch (final ClassNotFoundException e)
+ {
+ // Ignore and try the next parent class loader‚
+ }
+ }
+ throw new ClassNotFoundException(name);
+ }
+
+ @Override
+ public URL getResource(final String name)
+ {
+ for (final ClassLoader parent : parents)
+ {
+ final URL resource = parent.getResource(name);
+ if (resource != null)
+ {
+ return resource;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public Enumeration getResources(final String name) throws IOException
+ {
+ final List resources = Arrays.stream(parents)
+ .map(parent -> getResources(parent, name))
+ .flatMap(List::stream)
+ .toList();
+ return Collections.enumeration(resources);
+ }
+
+ private static List getResources(final ClassLoader parent, final String name)
+ {
+ try
+ {
+ return Collections.list(parent.getResources(name));
+ }
+ catch (final IOException e)
+ {
+ throw new IllegalStateException("Could not get resources for " + name, e);
+ }
+ }
+}
diff --git a/src/test/java/org/itsallcode/openfasttrace/gradle/OpenFastTracePluginTest.java b/src/test/java/org/itsallcode/openfasttrace/gradle/OpenFastTracePluginTest.java
index 27380c4..9482f0d 100644
--- a/src/test/java/org/itsallcode/openfasttrace/gradle/OpenFastTracePluginTest.java
+++ b/src/test/java/org/itsallcode/openfasttrace/gradle/OpenFastTracePluginTest.java
@@ -30,6 +30,7 @@ class OpenFastTracePluginTest
private static final Path DEPENDENCY_CONFIG_DIR = EXAMPLES_DIR.resolve("dependency-config");
private static final Path PUBLISH_CONFIG_DIR = EXAMPLES_DIR.resolve("publish-config");
private static final Path HTML_REPORT_CONFIG_DIR = EXAMPLES_DIR.resolve("html-report");
+ private static final Path PLUGIN_CONFIG_DIR = EXAMPLES_DIR.resolve("plugin-config");
@Parameter
private GradleTestConfig config;
@@ -318,6 +319,13 @@ void testTraceMultiProject()
.assertReportFileLines("ok - 6 total");
}
+ @Test
+ void testTraceExampleProjectWithPluginDependency()
+ {
+ testConfigurationCache(PLUGIN_CONFIG_DIR, Path.of("build/reports/tracing.txt"),
+ "ok - 6 total");
+ }
+
@Test
void traceDependencyProject()
{
diff --git a/src/test/java/org/itsallcode/openfasttrace/gradle/PluginTestFixture.java b/src/test/java/org/itsallcode/openfasttrace/gradle/PluginTestFixture.java
index 8951308..7ca8225 100644
--- a/src/test/java/org/itsallcode/openfasttrace/gradle/PluginTestFixture.java
+++ b/src/test/java/org/itsallcode/openfasttrace/gradle/PluginTestFixture.java
@@ -6,6 +6,7 @@
import java.nio.file.Path;
import java.util.*;
+import java.util.function.Function;
import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
@@ -53,15 +54,18 @@ public PluginTestFixture withReportFile(final Path relativeReportPath)
Result run()
{
- final GradleRunner runner = createGradleRunner();
- final BuildResult buildResult = runner.build();
- return new Result(buildResult);
+ return run(GradleRunner::build);
}
Result runExpectingFailure()
+ {
+ return run(GradleRunner::buildAndFail);
+ }
+
+ private Result run(final Function runnerFunction)
{
final GradleRunner runner = createGradleRunner();
- final BuildResult buildResult = runner.buildAndFail();
+ final BuildResult buildResult = runnerFunction.apply(runner);
return new Result(buildResult);
}