Miscellany

I'm great at organizing my commits I know
- better logging
- fix def hashes not accounting for everything
- only extract natives if necessary

Author: TropheusJ

build.gradle.kts

@@ -22,7 +22,6 @@ val mc by minecraft.creating {
 }
 
 dependencies {
-    println("adding dependencies")
     implementation(mc.dependency)
 
 //    mc.transformer(fileTree("src/main/resources/transformers"))

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/mcmaven/JarProcessor.java

@@ -34,8 +34,8 @@ public static void run(Path inputJar, Path outputJar, CacheFunction function) th
 
 		try (FileSystem inputFs = FileSystems.newFileSystem(inputJar); FileSystem outputFs = FileSystems.newFileSystem(outputJar)) {
 			// jars should have 1 root
-			Path inputRoot = Utils.getOnly(inputFs.getRootDirectories());
-			Path outputRoot = Utils.getOnly(outputFs.getRootDirectories());
+			Path inputRoot = FileUtils.getSingleRoot(inputFs);
+			Path outputRoot = FileUtils.getSingleRoot(outputFs);
 
 			Input input = collectInput(inputRoot);
 			for (ClassGroup group : input.groups.values()) {

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/mcmaven/McMavenResourceAccessor.java

@@ -28,16 +28,12 @@ public McMavenResourceAccessor(MinecraftMaven mcMaven) {
 	public <T> T withContent(ExternalResourceName location, boolean revalidate,
 							 ExternalResource.ContentAndMetadataAction<T> action) throws ResourceException {
 		URI uri = location.getUri();
-		System.out.println("checking " + uri);
 
 		try {
 			InputStream stream = this.mcMaven.get(uri);
-			if (stream == null) {
-				System.out.println("nope :( " + uri);
+			if (stream == null)
 				return null;
-			}
 
-			System.out.println("yep :)");
 			return action.execute(stream, this.getMetaData(location, revalidate));
 		} catch (Exception e) {
 			logger.error("Error while getting URL from mcmaven: {}", uri, e);
@@ -49,7 +45,6 @@ public <T> T withContent(ExternalResourceName location, boolean revalidate,
 	@Override
 	public ExternalResourceMetaData getMetaData(ExternalResourceName location, boolean revalidate) throws ResourceException {
 		URI uri = location.getUri();
-		System.out.println("checking " + uri);
 
 		try {
 			return this.mcMaven.get(uri) == null ? null : new DefaultExternalResourceMetaData(uri, -1, -1);

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/mcmaven/MinecraftMaven.java

@@ -71,7 +71,7 @@ public InputStream get(URI uri) throws IOException {
 			throw new InvalidUserDataException("Minecraft definition '" + request.def + "' does not exist");
 		}
 
-		String version = def.getVersionOrThrow();
+		String version = def.version();
 
 		Iterable<File> transformerFiles = def.resolvableTransformers().getIncoming().getFiles();
 		Transformers transformers = new Transformers(transformerFiles, request.hash);
@@ -90,13 +90,17 @@ public InputStream get(URI uri) throws IOException {
 	private InputStream getArtifact(String versionId, Distribution dist, Transformers transformers, Request request) throws IOException {
 		// see if this version actually exists
 		Version version = ManifestCache.getVersion(versionId);
-		if (version == null)
+		if (version == null) {
+			logger.warn("Minecraft version does not exist: {}", versionId);
 			return null;
+		}
 
 		FullVersion fullVersion = ManifestCache.expand(version);
 		// and the dist. all versions have a client, check for server
-		if (dist != Distribution.CLIENT && fullVersion.downloads.server.isEmpty())
+		if (dist != Distribution.CLIENT && fullVersion.downloads.server.isEmpty()) {
+			logger.warn("Minecraft version doesn't have a server, but it was requested: {}", versionId);
 			return null;
+		}
 
 		if (fullVersion.downloads.clientMappings.isEmpty()) {
 			throw new InvalidUserDataException("Versions pre-mojmap are not currently supported!");
@@ -141,7 +145,9 @@ private InputStream getPom(FullVersion version, Distribution dist, Request reque
 
 		// file should now exist
 		String content = Files.readString(template);
-		String filled = content.replace(PomGenerator.VERSION_PLACEHOLDER, request.gradleRequestedVersion());
+		// of course & has special meaning in xml
+		String escaped = request.gradleRequestedVersion().replace("&", "&amp;");
+		String filled = content.replace(PomGenerator.VERSION_PLACEHOLDER, escaped);
 		return new ByteArrayInputStream(filled.getBytes(StandardCharsets.UTF_8));
 	}
 
@@ -195,7 +201,7 @@ private static Request extractRequest(URI uri) {
 			}
 		}
 
-		logger.quiet("Intercepted request for Minecraft definition {}, {}, {}", defName, artifact, hashAlgorithm);
+		logger.debug("Intercepted request for Minecraft definition {}, {}, {}", defName, artifact, hashAlgorithm);
 
 		return new Request(defName, hash, artifact, Optional.ofNullable(hashAlgorithm));
 	}

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/storage/VersionStorage.java

@@ -2,15 +2,14 @@
 
 import java.nio.file.Path;
 
-public class VersionStorage extends LockableStorage {
+public class VersionStorage {
 
 	public final MappingsStorage mappings;
 	public final JarsStorage jars;
 	public final Path natives;
 	public final RunTemplateStorage runs;
 
 	public VersionStorage(Path root) {
-		super(root);
 		this.mappings = new MappingsStorage(root.resolve("mappings"));
 		this.jars = new JarsStorage(root.resolve("jars"));
 		this.natives = root.resolve("natives");

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/task/CacheTask.java

@@ -1,41 +1,54 @@
 package fish.cichlidmc.cichlid_gradle.cache.task;
 
-import org.gradle.api.logging.Logger;
-import org.gradle.api.logging.Logging;
+import org.jetbrains.annotations.Nullable;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
+import java.util.function.Supplier;
 
-public abstract class CacheTask implements Runnable {
+public abstract class CacheTask {
 	public final String name;
 
 	protected final CacheTaskEnvironment env;
-	protected final Logger logger;
 
 	protected CacheTask(String name, CacheTaskEnvironment env) {
 		this.name = name;
 		this.env = env;
-		this.logger = Logging.getLogger(this.getClass());
 	}
 
-	protected abstract void doRun() throws IOException;
+	/**
+	 * @return a feedback message to be printed with the completion notice
+	 */
+	@Nullable
+	protected abstract String run() throws IOException;
 
+	/**
+	 * Perform any necessary cleanup, including in the case of an exception being thrown by {@link #run()}.
+	 */
 	protected void cleanup() throws IOException {
 	}
 
-	@Override
-	public final void run() {
-		try {
-			this.doRun();
-			this.cleanup();
-		} catch (IOException e) {
+	record Runner(CacheTask task, long startTime) implements Supplier<@Nullable String> {
+		Runner(CacheTask task) {
+			this(task, System.currentTimeMillis());
+		}
+
+		@Override
+		@Nullable
+		public String get() {
 			try {
-				this.cleanup();
-			} catch (IOException suppressed) {
-				e.addSuppressed(suppressed);
+				String message = this.task.run();
+				this.task.cleanup();
+				return message;
+			} catch (IOException e) {
+				try {
+					this.task.cleanup();
+				} catch (IOException suppressed) {
+					e.addSuppressed(suppressed);
+				}
+
+				throw new UncheckedIOException(e);
 			}
-
-			throw new UncheckedIOException(e);
 		}
 	}
 }

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/task/CacheTaskEnvironment.java

@@ -4,8 +4,10 @@
 import fish.cichlidmc.cichlid_gradle.cache.Transformers;
 import fish.cichlidmc.cichlid_gradle.util.Distribution;
 import fish.cichlidmc.pistonmetaparser.FullVersion;
+import fish.cichlidmc.tinycodecs.util.Either;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -24,9 +26,9 @@ public class CacheTaskEnvironment {
 	public final Distribution dist;
 	public final Transformers transformers;
 
-	private final Map<CacheTask, CompletableFuture<Void>> futures = Collections.synchronizedMap(new IdentityHashMap<>());
-	private final Set<CacheTask> incompleteTasks = Collections.synchronizedSet(new HashSet<>());
-	private final Map<CacheTask, Throwable> errors = Collections.synchronizedMap(new IdentityHashMap<>());
+	private final Map<CacheTask.Runner, CompletableFuture<Void>> futures = Collections.synchronizedMap(new IdentityHashMap<>());
+	private final Set<CacheTask.Runner> incompleteTasks = Collections.synchronizedSet(new HashSet<>());
+	private final Map<CacheTask.Runner, Throwable> errors = Collections.synchronizedMap(new IdentityHashMap<>());
 
 	public CacheTaskEnvironment(FullVersion version, CichlidCache cache, Distribution dist, Transformers transformers) {
 		this.version = version;
@@ -46,23 +48,25 @@ public CompletableFuture<Void> submit(TaskFactory factory) {
 	public CompletableFuture<Void> submit(CacheTask task) {
 		logger.quiet("Starting new task: {}", task.name);
 
-		CompletableFuture<Void> future = CompletableFuture.runAsync(task)
-				.thenRun(() -> this.finishTask(task))
+		CacheTask.Runner runner = new CacheTask.Runner(task);
+		this.incompleteTasks.add(runner);
+
+		CompletableFuture<Void> future = CompletableFuture.supplyAsync(runner)
+				.thenAccept(message -> this.finishTask(runner, Either.left(message)))
 				.exceptionally(error -> {
-					this.finishTask(task);
-					this.errors.put(task, error);
+					this.finishTask(runner, Either.right(error));
 					return null;
 				});
 
-		this.futures.put(task, future);
-		this.incompleteTasks.add(task);
+		this.futures.put(runner, future);
+
 		return future;
 	}
 
 	public void join() {
 		while (!this.incompleteTasks.isEmpty()) {
-			CacheTask task = this.incompleteTasks.iterator().next();
-			CompletableFuture<Void> future = this.futures.get(task);
+			CacheTask.Runner runner = this.incompleteTasks.iterator().next();
+			CompletableFuture<Void> future = this.futures.get(runner);
 			try {
 				future.join();
 			} catch (Throwable ignored) {}
@@ -77,16 +81,30 @@ public void report() {
 			return;
 		}
 
-		RuntimeException root = new RuntimeException("One or more CichlidGradle cache tasks failed!");
+		RuntimeException root = new RuntimeException(this.errors.size() + " CichlidGradle cache task(s) failed!");
 		this.errors.values().forEach(root::addSuppressed);
 
 		logger.error(root.getMessage(), root);
 		throw root;
 	}
 
-	private void finishTask(CacheTask task) {
-		this.incompleteTasks.remove(task);
-		logger.quiet("Task complete: {}", task.name);
+	private void finishTask(CacheTask.Runner runner, Either<@Nullable String, Throwable> result) {
+		this.incompleteTasks.remove(runner);
+
+		if (result.isRight()) {
+			this.errors.put(runner, result.right());
+		}
+
+		String name = runner.task().name;
+		String verb = result.isLeft() ? "finished" : "failed";
+		String seconds = String.format("%.2f", (System.currentTimeMillis() - runner.startTime()) / 1000f);
+		String message = result.isLeft() ? result.left() : result.right().getMessage();
+
+		if (message != null) {
+			logger.quiet("Task '{}' {} after {} seconds: {}", name, verb, seconds, message);
+		} else {
+			logger.quiet("Task '{}' {} after {} seconds", name, verb, seconds);
+		}
 	}
 
 	@FunctionalInterface

plugin/src/main/java/fish/cichlidmc/cichlid_gradle/cache/task/impl/AssetsTask.java

@@ -4,48 +4,48 @@
 import fish.cichlidmc.cichlid_gradle.cache.storage.LockableStorage;
 import fish.cichlidmc.cichlid_gradle.cache.task.CacheTask;
 import fish.cichlidmc.cichlid_gradle.cache.task.CacheTaskEnvironment;
+import fish.cichlidmc.cichlid_gradle.util.hash.Encoding;
+import fish.cichlidmc.cichlid_gradle.util.hash.HashAlgorithm;
 import fish.cichlidmc.cichlid_gradle.util.io.Download;
 import fish.cichlidmc.cichlid_gradle.util.io.DownloadBatch;
 import fish.cichlidmc.cichlid_gradle.util.io.FileUtils;
-import fish.cichlidmc.cichlid_gradle.util.hash.Encoding;
-import fish.cichlidmc.cichlid_gradle.util.hash.HashAlgorithm;
 import fish.cichlidmc.pistonmetaparser.version.assets.Asset;
 import fish.cichlidmc.pistonmetaparser.version.assets.AssetIndex;
 import fish.cichlidmc.pistonmetaparser.version.assets.FullAssetIndex;
 import fish.cichlidmc.tinyjson.TinyJson;
 import fish.cichlidmc.tinyjson.value.JsonValue;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.Logging;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Map;
 
 public class AssetsTask extends CacheTask {
+	private static final Logger logger = Logging.getLogger(AssetsTask.class);
+
 	private LockableStorage.Lock lock;
 
 	public AssetsTask(CacheTaskEnvironment env) {
 		super("Download asset index " + env.version.assets, env);
 	}
 
 	@Override
-	public void doRun() throws IOException {
+	public String run() throws IOException {
 		AssetStorage assets = this.env.cache.assets;
 		this.lock = assets.lockLoudly("Assets are currently locked by {}, awaiting release");
 		// see if it's done now
 		AssetIndex index = this.env.version.assetIndex;
 		if (assets.isComplete(index)) {
-			this.logger.quiet("Asset index {} is now cached.", index.id);
-			return;
+			return "Asset index " + index.id + " is now cached.";
 		}
 
-		this.logger.quiet("Asset index {} is not cached, downloading", index.id);
-
 		Path indexFile = assets.index(index);
 		new Download(index, indexFile).run();
 		// read downloaded file to avoid downloading again with expand()
 		JsonValue indexJson = TinyJson.parse(indexFile);
 		FullAssetIndex fullIndex = FullAssetIndex.parse(indexJson);
-		long startTime = System.currentTimeMillis();
 
 		DownloadBatch.Builder builder = new DownloadBatch.Builder();
 		for (Asset asset : fullIndex.objects.values()) {
@@ -55,24 +55,22 @@ public void doRun() throws IOException {
 			}
 		}
 
-		this.logger.quiet("Downloading {} asset objects...", builder.size());
+		logger.quiet("Downloading {} asset object(s)...", builder.size());
 
 		builder.build().execute();
 
-		long endTime = System.currentTimeMillis();
-		long seconds = (endTime - startTime) / 1000;
-		this.logger.quiet("Finished downloading assets in {} seconds.", seconds);
-
 		if (fullIndex.isVirtual()) {
-			this.logger.quiet("Extracting virtual assets");
+			logger.quiet("Extracting virtual assets...");
 			this.extractVirtualAssets(index, fullIndex);
 		}
 
 		assets.markComplete(index);
+		return "Index contained " + fullIndex.objects.size() + " object(s), " + builder.size() + " of which were missing.";
 	}
 
 	@Override
 	protected void cleanup() throws IOException {
+		// unlock here in case run throws
 		if (this.lock != null) {
 			this.lock.close();
 		}
@@ -96,13 +94,13 @@ private boolean shouldDownload(Asset asset, Path dest) throws IOException {
 
 		long existingSize = Files.size(dest);
 		if (asset.size != existingSize) {
-			this.logger.warn("Found an existing asset that has changed size: {}. Bad download? Overwriting.", asset.path);
+			logger.warn("Found an existing asset that has changed size: {}. Bad download? Overwriting.", asset.path);
 			return true;
 		}
 
 		String existingHash = Encoding.HEX.encode(HashAlgorithm.SHA1.hash(dest));
 		if (!asset.hash.equals(existingHash)) {
-			this.logger.warn("Found an existing asset that has changed hashes: {}. Bad download? Overwriting.", asset.path);
+			logger.warn("Found an existing asset that has changed hashes: {}. Bad download? Overwriting.", asset.path);
 			return true;
 		}