return of the funny URL hack

Author: TropheusJ

build.gradle.kts

@@ -17,7 +17,10 @@ repositories {
 val mcVer = "1.21.5"
 
 dependencies {
-    implementation(minecraft.client(mcVer))
+    implementation(minecraft.of {
+        client()
+        version(mcVer)
+    })
 
     compileOnly(cichlid.api("0.3.2"))
     cichlidRuntime(cichlid.runtime("0.3.2"))
@@ -45,3 +48,25 @@ cichlid {
 //        }
     }
 }
+
+tasks.register("resolveCompileSources") {
+    val view = configurations.compileClasspath.get().incoming.artifactView {
+       componentFilter {
+           it.displayName.contains("minecraft")
+       }
+
+        withVariantReselection()
+
+        attributes {
+            attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
+            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.DOCUMENTATION))
+            attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType.SOURCES))
+        }
+    }.artifacts
+
+    doLast {
+        view.artifactFiles.forEach {
+            println(it)
+        }
+    }
+}

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/CichlidGradlePlugin.java

@@ -1,6 +1,7 @@
 package io.github.cichlidmc.cichlid_gradle;
 
 import io.github.cichlidmc.cichlid_gradle.cache.CichlidCache;
+import io.github.cichlidmc.cichlid_gradle.cache.mcmaven.McMavenConnectorFactory;
 import io.github.cichlidmc.cichlid_gradle.extension.CichlidExtension;
 import io.github.cichlidmc.cichlid_gradle.extension.dep.CichlidDepsExtension;
 import io.github.cichlidmc.cichlid_gradle.extension.dep.MinecraftDepsExtension;
@@ -11,17 +12,24 @@
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.ConfigurationContainer;
-import org.gradle.api.artifacts.Dependency;
 import org.gradle.api.artifacts.DependencyScopeConfiguration;
+import org.gradle.api.internal.artifacts.repositories.transport.RepositoryTransportFactory;
 
-import java.util.Objects;
+import javax.inject.Inject;
 
-public abstract class CichlidGradlePlugin implements Plugin<Project> {
+public class CichlidGradlePlugin implements Plugin<Project> {
 	public static final String NAME = "CichlidGradle";
 	public static final String VERSION = "1.0-SNAPSHOT";
 
 	public static final String CICHLID_CONFIGURATION = "cichlid";
 
+	private final RepositoryTransportFactory repositoryTransportFactory;
+
+	@Inject
+	public CichlidGradlePlugin(RepositoryTransportFactory repositoryTransportFactory) {
+		this.repositoryTransportFactory = repositoryTransportFactory;
+	}
+
 	@Override
 	public void apply(Project project) {
 		CichlidExtension.setup(project);
@@ -34,16 +42,7 @@ public void apply(Project project) {
 		ConfigurationContainer configurations = project.getConfigurations();
 		setupConfigurations(configurations);
 
-		// listen for all minecraft dependencies to ensure they're downloaded
-		configurations.configureEach(
-				configuration -> configuration.getDependencies().configureEach(dep -> {
-					if (isMinecraftDependency(dep)) {
-						String version = Objects.requireNonNull(dep.getVersion());
-						CichlidCache cache = CichlidCache.get(project);
-						cache.ensureVersionIsCached(version);
-					}
-				})
-		);
+		McMavenConnectorFactory.inject(this.repositoryTransportFactory, CichlidCache.get(project));
 	}
 
 	private static void setupConfigurations(ConfigurationContainer configurations) {
@@ -56,10 +55,4 @@ private static void setupConfigurations(ConfigurationContainer configurations) {
 		// add Cichlid and its dependencies to the runtime classpath
 		configurations.named("runtimeClasspath", runtime -> runtime.extendsFrom(cichlidRuntime.get()));
 	}
-
-	private static boolean isMinecraftDependency(Dependency dep) {
-		return "net.minecraft".equals(dep.getGroup())
-				&& CichlidCache.MINECRAFT_MODULES.contains(dep.getName())
-				&& dep.getVersion() != null;
-	}
 }

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/cache/CichlidCache.java

@@ -13,22 +13,31 @@
 
 /**
  * Interface for Cichlid's global Minecraft cache. Holds no state, just interfaces with the filesystem.
+ * Layout is versioned, and each one can be found at {@code "root/v" + FORMAT}.
+ * <p>
  * Layout:
- * - root
- *   - v1
- *     - assets
- *       - indices
- *       - objects
- *       - .lock
- *     - <version>
- *       - natives
- *       - mappings
- *       - jars
- *       - runs
+ * <ul>
+ *     <li>
+ *         assets
+ *         <ul>
+ *             <li>indices</li>
+ *             <li>objects</li>
+ *             <li>.lock</li>
+ *         </ul>
+ *     </li>
+ *     <li>
+ *         $version
+ *         <ul>
+ *             <li>natives</li>
+ *             <li>mappings</li>
+ *             <li>jars</li>
+ *             <li>runs</li>
+ *         </ul>
+ *     </li>
+ * </ul>
  */
-public class CichlidCache {
+public final class CichlidCache {
 	// pattern is relative to root
-	public static final String IVY_PATTERN = "[revision]/jars/[module]-[revision].[ext]";
 	public static final String MINECRAFT_GROUP = "net.minecraft";
 	public static final Set<String> MINECRAFT_MODULES = Set.of(
 			"minecraft-client", "minecraft-server", "minecraft-merged", "minecraft-bundler"

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/cache/mcmaven/McMavenConnectorFactory.java

@@ -0,0 +1,60 @@
+package io.github.cichlidmc.cichlid_gradle.cache.mcmaven;
+
+import io.github.cichlidmc.cichlid_gradle.cache.CichlidCache;
+import org.gradle.api.internal.artifacts.repositories.transport.RepositoryTransportFactory;
+import org.gradle.authentication.Authentication;
+import org.gradle.internal.resource.connector.ResourceConnectorFactory;
+import org.gradle.internal.resource.connector.ResourceConnectorSpecification;
+import org.gradle.internal.resource.transfer.DefaultExternalResourceConnector;
+import org.gradle.internal.resource.transfer.ExternalResourceConnector;
+
+import java.lang.reflect.Field;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+
+public final class McMavenConnectorFactory implements ResourceConnectorFactory {
+	public static final Set<String> PROTOCOLS = Set.of(MinecraftMaven.PROTOCOL);
+
+	private final CichlidCache cache;
+
+	public McMavenConnectorFactory(CichlidCache cache) {
+		this.cache = cache;
+	}
+
+	@Override
+	public Set<String> getSupportedProtocols() {
+		return PROTOCOLS;
+	}
+
+	@Override
+	public Set<Class<? extends Authentication>> getSupportedAuthentication() {
+		return Set.of();
+	}
+
+	@Override
+	public ExternalResourceConnector createResourceConnector(ResourceConnectorSpecification connectionDetails) {
+		return new DefaultExternalResourceConnector(
+				new McMavenResourceAccessor(this.cache),
+				NoOpResourceLister.INSTANCE,
+				NoOpUploader.INSTANCE
+		);
+	}
+
+	// built-in implementations use ServiceLoader, but that only works for Gradle modules.
+	public static void inject(RepositoryTransportFactory factory, CichlidCache cache) {
+		try {
+			Field registeredProtocols = RepositoryTransportFactory.class.getDeclaredField("registeredProtocols");
+			registeredProtocols.setAccessible(true);
+			@SuppressWarnings("unchecked")
+			List<ResourceConnectorFactory> list = (List<ResourceConnectorFactory>) registeredProtocols.get(factory);
+			// don't add if it already exists
+			if (list.stream().anyMatch(f -> f instanceof McMavenConnectorFactory))
+				return;
+
+			list.add(new McMavenConnectorFactory(cache));
+		} catch (ReflectiveOperationException e) {
+			throw new RuntimeException("Error accessing Gradle internals! You probably need to update Gradle, CichlidGradle, or both", e);
+		}
+	}
+}

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/cache/mcmaven/McMavenResourceAccessor.java

@@ -0,0 +1,70 @@
+package io.github.cichlidmc.cichlid_gradle.cache.mcmaven;
+
+import io.github.cichlidmc.cichlid_gradle.cache.CichlidCache;
+import io.github.cichlidmc.cichlid_gradle.util.FileUtils;
+import org.gradle.api.resources.ResourceException;
+import org.gradle.internal.hash.HashCode;
+import org.gradle.internal.resource.ExternalResource;
+import org.gradle.internal.resource.ExternalResourceName;
+import org.gradle.internal.resource.ResourceExceptions;
+import org.gradle.internal.resource.metadata.DefaultExternalResourceMetaData;
+import org.gradle.internal.resource.metadata.ExternalResourceMetaData;
+import org.gradle.internal.resource.transfer.ExternalResourceAccessor;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Date;
+
+public final class McMavenResourceAccessor implements ExternalResourceAccessor {
+	private final MinecraftMaven mcMaven;
+
+	public McMavenResourceAccessor(CichlidCache cache) {
+		this.mcMaven = new MinecraftMaven(cache);
+	}
+
+	@Nullable
+	@Override
+	public <T> T withContent(ExternalResourceName location, boolean revalidate,
+							 ExternalResource.ContentAndMetadataAction<T> action) throws ResourceException {
+		URI uri = location.getUri();
+		System.out.println("checking " + uri);
+		Path file = this.mcMaven.getFile(uri);
+		if (file == null)
+			return null;
+
+		try (InputStream stream = Files.newInputStream(file)) {
+			return action.execute(stream, this.getMetaData(location, revalidate));
+		} catch (IOException e) {
+			throw ResourceExceptions.getFailed(uri, e);
+		}
+	}
+
+	@Nullable
+	@Override
+	public ExternalResourceMetaData getMetaData(ExternalResourceName location, boolean revalidate) throws ResourceException {
+		URI uri = location.getUri();
+		System.out.println("checking " + uri);
+		Path file = this.mcMaven.getFile(uri);
+		if (file == null)
+			return null;
+
+		try {
+			return new DefaultExternalResourceMetaData(
+					uri,
+					new Date(Files.getLastModifiedTime(file).toMillis()),
+					Files.size(file),
+					null,
+					null,
+					HashCode.fromString(FileUtils.sha1(file)),
+					file.getFileName().toString(),
+					false
+			);
+		} catch (IOException e) {
+			throw ResourceExceptions.getFailed(uri, e);
+		}
+	}
+}

plugin/src/main/java/io/github/cichlidmc/cichlid_gradle/cache/mcmaven/MinecraftMaven.java

@@ -0,0 +1,104 @@
+package io.github.cichlidmc.cichlid_gradle.cache.mcmaven;
+
+import io.github.cichlidmc.cichlid_gradle.cache.CichlidCache;
+import io.github.cichlidmc.cichlid_gradle.cache.storage.JarsStorage;
+import io.github.cichlidmc.cichlid_gradle.util.Distribution;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.Logging;
+import org.jetbrains.annotations.Nullable;
+
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Intercepts requests for Minecraft files from a simulated maven repo.
+ * Provides Minecraft jars and pom files for each version.
+ */
+public final class MinecraftMaven {
+	public static final String PROTOCOL = "mcmaven";
+	public static final URI ROOT = URI.create(PROTOCOL + ":///");
+	/**
+	 * Regex for files that could possibly be provided.
+	 */
+	public static final Pattern VALID_FILE = Pattern.compile(
+			// groups:				  |-           1              -| |2 |           |-           3              -| |4 |   |-  5  -|
+			"/net/minecraft/minecraft-(client|server|merged|bundler)/(.+)/minecraft-(client|server|merged|bundler)-(.+)\\.(pom|jar)"
+	);
+
+	private static final Logger logger = Logging.getLogger(MinecraftMaven.class);
+
+	private final CichlidCache cache;
+
+	public MinecraftMaven(CichlidCache cache) {
+		this.cache = cache;
+	}
+
+	/**
+	 * Find a path corresponding to the file at the requested location.
+	 * Returns null if one does not exist.
+	 */
+	@Nullable
+	public Path getFile(URI uri) {
+		Request request = extractRequest(uri);
+		if (request == null)
+			return null;
+
+		this.cache.ensureVersionIsCached(request.version);
+		JarsStorage storage = this.cache.getVersion(request.version).jars;
+		Path path = switch (request.type) {
+			case JAR -> storage.path(request.dist);
+			case SOURCES -> storage.sources(request.dist);
+			case POM -> storage.metadata(request.dist);
+		};
+
+		return Files.exists(path) ? path : null;
+	}
+
+	@Nullable
+	private static Request extractRequest(URI uri) {
+		Matcher matcher = VALID_FILE.matcher(uri.getPath());
+		if (!matcher.matches())
+			return null;
+
+		// check that both distributions are the same
+		String dist1 = matcher.group(1);
+		String dist2 = matcher.group(3);
+		if (!dist1.equals(dist2))
+			return null;
+
+		Distribution dist = Distribution.ofName(dist1).orElseThrow();
+
+		// make sure the versions match too
+		String version1 = matcher.group(2);
+		String version2 = matcher.group(4);
+
+		// -sources will get caught in group 4 if present, check for it
+		boolean sources = false;
+		if (version2.endsWith("-sources")) {
+			sources = true;
+			version2 = version2.substring(0, version2.length() - "-sources".length());
+		}
+
+		if (!version1.equals(version2))
+			return null;
+
+		Request.Type type = switch (matcher.group(5)) {
+			case "jar" -> sources ? Request.Type.SOURCES : Request.Type.JAR;
+			case "pom" -> Request.Type.POM;
+			default -> throw new RuntimeException("Invalid Type");
+		};
+
+		logger.debug("Intercepted request for Minecraft {} {}, {}", dist, version1, type);
+
+		return new Request(dist, version1, type);
+	}
+
+	private record Request(Distribution dist, String version, Type type) {
+		private enum Type {
+			JAR, SOURCES, POM
+		}
+	}
+}