check for mod transformer injection errors and treat as critical errors

Mumfrey
1 parent bd15e763
Showing 8 changed files with 217 additions and 24 deletions
java/client/com/mumfrey/liteloader/client/ClientEvents.java
java/client/com/mumfrey/liteloader/client/LiteLoaderPanelManager.java
java/client/com/mumfrey/liteloader/client/gui/GuiLiteLoaderPanel.java
java/common/com/mumfrey/liteloader/core/Events.java
java/common/com/mumfrey/liteloader/core/LiteLoaderMods.java
java/common/com/mumfrey/liteloader/interfaces/PanelManager.java
java/common/com/mumfrey/liteloader/launch/ClassTransformerManager.java
resources/assets/liteloader/lang/en_US.lang
@@ -481,7 +481,7 @@ public class ClientEvents extends Events&lt;Minecraft, IntegratedServer&gt;
 				catch (Throwable th)
 				{
 					this.mods.onLateInitFailed(initMod, th);
-					LiteLoaderLogger.warning(th, "Error initialising mod %s", initMod.getName());
+					LiteLoaderLogger.warning(th, "Error calling late init for mod %s", initMod.getName());
 				}
 			}
 		}
@@ -191,6 +191,12 @@ public class LiteLoaderPanelManager implements PanelManager&lt;GuiScreen&gt;
 	{
 		return this.mods.getStartupErrorCount();
 	}
+	
+	@Override
+	public int getCriticalErrorCount()
+	{
+		return this.mods.getCriticalErrorCount();
+	}
 	private boolean isPanelSupportedOnScreen(GuiScreen guiScreen)
 	{
@@ -121,7 +121,7 @@ public class GuiLiteLoaderPanel extends GuiScreen
 	private boolean mouseOverLogo = false;
-	private int startupErrorCount = 0;
+	private int startupErrorCount = 0, criticalErrorCount = 0;
 	/**
 	 * @param minecraft
@@ -144,6 +144,7 @@ public class GuiLiteLoaderPanel extends GuiScreen
 		this.settingsPanel = new GuiPanelSettings(this, minecraft);
 		this.startupErrorCount = mods.getStartupErrorCount();
+		this.criticalErrorCount = mods.getCriticalErrorCount();
 	}
 	/**
@@ -465,7 +466,7 @@ public class GuiLiteLoaderPanel extends GuiScreen
 	private void drawErrorTooltip(int left, int top)
 	{
-		GuiLiteLoaderPanel.drawTooltip(this.fontRendererObj, I18n.format("gui.error.tooltip", this.startupErrorCount), left, top, this.width, this.height, 0xFF5555, 0xB0330000);
+		GuiLiteLoaderPanel.drawTooltip(this.fontRendererObj, I18n.format("gui.error.tooltip", this.startupErrorCount, this.criticalErrorCount), left, top, this.width, this.height, 0xFF5555, 0xB0330000);
 	}
 	/* (non-Javadoc)
@@ -99,6 +99,9 @@ public abstract class Events&lt;TClient, TServer extends MinecraftServer&gt; implement
 	 */
 	protected void onStartupComplete()
 	{
+		LoadingProgress.setMessage("Checking mods...");
+		this.mods.onStartupComplete();
+		
 		LoadingProgress.setMessage("Initialising CoreProviders...");
 		this.loader.onStartupComplete();
@@ -7,6 +7,7 @@ import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import javax.activity.InvalidActivityException;
@@ -18,6 +19,9 @@ import com.mumfrey.liteloader.common.LoadingProgress;
 import com.mumfrey.liteloader.interfaces.LoaderEnumerator;
 import com.mumfrey.liteloader.interfaces.Loadable;
 import com.mumfrey.liteloader.interfaces.LoadableMod;
+import com.mumfrey.liteloader.interfaces.TweakContainer;
+import com.mumfrey.liteloader.launch.ClassTransformerManager;
+import com.mumfrey.liteloader.launch.LiteLoaderTweaker;
 import com.mumfrey.liteloader.launch.LoaderEnvironment;
 import com.mumfrey.liteloader.launch.LoaderProperties;
 import com.mumfrey.liteloader.modconfig.ConfigManager;
@@ -88,7 +92,7 @@ public class LiteLoaderMods
 	 */
 	protected final LinkedList<NonMod> disabledMods = new LinkedList<NonMod>();
-	private int startupErrorCount;
+	private int startupErrorCount, criticalErrorCount;
 	LiteLoaderMods(LiteLoader loader, LoaderEnvironment environment, LoaderProperties properties, ConfigManager configManager)
 	{
@@ -162,6 +166,11 @@ public class LiteLoaderMods
 		return this.startupErrorCount;
 	}
+	public int getCriticalErrorCount()
+	{
+		return this.criticalErrorCount;
+	}
+	
 	public ModInfo<?> getModInfo(LiteMod instance)
 	{
 		for (Mod mod : this.allMods)
@@ -670,6 +679,47 @@ public class LiteLoaderMods
 		return String.format("version.%s", modName.toLowerCase().replaceAll("[^a-z0-9_\\-\\.]", ""));
 	}
+	void onStartupComplete()
+	{
+		this.validateModTransformers();
+	}
+
+	/**
+	 * Check that all specified mod transformers were injected successfully, tag mods with failed transformers
+	 * as critically errored
+	 */
+	private void validateModTransformers()
+	{
+		ClassTransformerManager transformerManager = LiteLoaderTweaker.getTransformerManager();
+		Set<String> injectedTransformers = transformerManager.getInjectedTransformers();
+		
+		for (Mod mod : this.loadedMods)
+		{
+			if (mod.hasClassTransformers())
+			{
+				List<String> modTransformers = ((TweakContainer<?>)mod.getContainer()).getClassTransformerClassNames();
+				for (String modTransformer : modTransformers)
+				{
+					if (!injectedTransformers.contains(modTransformer))
+					{
+						List<Throwable> throwables = transformerManager.getTransformerStartupErrors(modTransformer);
+						if (throwables != null)
+						{
+							for (Throwable th : throwables)
+							{
+								this.registerModStartupError(mod, th, true);
+							}
+						}
+						else
+						{
+							this.registerModStartupError(mod, new RuntimeException("Missing class transformer " + modTransformer), true);
+						}
+					}
+				}
+			}
+		}
+	}
+
 	/**
 	 * @param instance
 	 * @param th
@@ -685,7 +735,33 @@ public class LiteLoaderMods
 	private void registerModStartupError(ModInfo<?> mod, Throwable th)
 	{
+		// This is a critical error if a mod has already injected a transformer, since it may have injected
+		// callbacks which it is not in a position to handle!
+		boolean critical = this.hasModInjectedTransformers(mod);
+		
+		this.registerModStartupError(mod, th, critical);
+	}
+	
+	private boolean hasModInjectedTransformers(ModInfo<?> mod)
+	{
+		if (!mod.hasClassTransformers()) return false;
+		
+		Set<String> injectedTransformers = LiteLoaderTweaker.getTransformerManager().getInjectedTransformers();
+		List<String> modTransformers = ((TweakContainer<?>)mod.getContainer()).getClassTransformerClassNames();
+		
+		for (String modTransformer : modTransformers)
+		{
+			if (injectedTransformers.contains(modTransformer))
+				return true;
+		}
+
+		return false;
+	}
+
+	private void registerModStartupError(ModInfo<?> mod, Throwable th, boolean critical)
+	{
 		this.startupErrorCount++;
+		if (critical) this.criticalErrorCount++;
 		mod.registerStartupError(th);
 	}
@@ -54,4 +54,9 @@ public interface PanelManager&lt;TParentScreen&gt; extends TickObserver, PostRenderObs
 	 * @return
 	 */
 	public abstract int getStartupErrorCount();
+	
+	/**
+	 * @return
+	 */
+	public abstract int getCriticalErrorCount();
 }
 package com.mumfrey.liteloader.launch;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
+import java.lang.reflect.Field;
+import java.util.*;
 import java.util.Map.Entry;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+
 import net.minecraft.launchwrapper.IClassTransformer;
 import net.minecraft.launchwrapper.LaunchClassLoader;
+import net.minecraft.launchwrapper.LogWrapper;
 import com.mumfrey.liteloader.transformers.PacketTransformer;
 import com.mumfrey.liteloader.util.SortableValue;
@@ -33,7 +31,7 @@ public class ClassTransformerManager
 	/**
 	 * Transformers to inject
 	 */
-	private Set<String> injectedTransformers = new HashSet<String>();
+	private Set<String> pendingTransformers = new HashSet<String>();
 	/**
 	 * Transformers to inject after preInit but before the game starts, necessary for anything that needs to be downstream of forge
@@ -51,11 +49,60 @@ public class ClassTransformerManager
 	private final List<String> requiredTransformers;
 	/**
+	 * Transformers successfully injected by us
+	 */
+	private final Set<String> injectedTransformers = new HashSet<String>();
+	
+	/**
+	 * Catalogue of transformer startup failures
+	 */
+	private final Map<String, List<Throwable>> transformerStartupErrors = new HashMap<String, List<Throwable>>();
+	
+	private Logger attachedLog;
+	
+	private String pendingTransformer;
+	
+	class ThrowableObserver extends AbstractAppender
+	{
+		public ThrowableObserver()
+		{
+			super("Throwable Observer", null, null);
+			this.start();
+		}
+		
+		@Override
+		public void append(LogEvent event)
+		{
+			ClassTransformerManager.this.observeThrowable(event.getThrown());
+		}
+	}
+	
+	/**
 	 * @param requiredTransformers
 	 */
 	public ClassTransformerManager(List<String> requiredTransformers)
 	{
 		this.requiredTransformers = requiredTransformers;
+		
+		this.appendObserver();
+	}
+
+	private void appendObserver()
+	{
+		try
+		{
+			Field fLogger = LogWrapper.class.getDeclaredField("myLog");
+			fLogger.setAccessible(true);
+			this.attachedLog = (Logger)fLogger.get(LogWrapper.log);
+			if (this.attachedLog instanceof org.apache.logging.log4j.core.Logger)
+			{
+				((org.apache.logging.log4j.core.Logger)this.attachedLog).addAppender(new ThrowableObserver());
+			}
+		}
+		catch (Exception ex)
+		{
+			LiteLoaderLogger.warning("Failed to append ThrowableObserver to LogWrapper, transformer startup exceptions may not be logged");
+		}
 	}
 	/**
@@ -66,7 +113,7 @@ public class ClassTransformerManager
 	{
 		if (!this.gameStarted)
 		{
-			this.injectedTransformers.add(transformerClass);
+			this.pendingTransformers.add(transformerClass);
 			return true;
 		}
@@ -81,7 +128,7 @@ public class ClassTransformerManager
 	{
 		if (!this.gameStarted)
 		{
-			this.injectedTransformers.addAll(transformerClasses);
+			this.pendingTransformers.addAll(transformerClasses);
 			return true;
 		}
@@ -96,7 +143,7 @@ public class ClassTransformerManager
 	{
 		if (!this.gameStarted)
 		{
-			this.injectedTransformers.addAll(Arrays.asList(transformerClasses));
+			this.pendingTransformers.addAll(Arrays.asList(transformerClasses));
 			return true;
 		}
@@ -108,12 +155,12 @@ public class ClassTransformerManager
 	 */
 	void injectUpstreamTransformers(LaunchClassLoader classLoader)
 	{
-		this.sieveAndSortPacketTransformers(classLoader, this.injectedTransformers);
+		this.sieveAndSortPacketTransformers(classLoader, this.pendingTransformers);
 		for (String requiredTransformerClassName : this.requiredTransformers)
 		{
 			LiteLoaderLogger.info("Injecting required class transformer '%s'", requiredTransformerClassName);
-			classLoader.registerTransformer(requiredTransformerClassName);
+			this.injectTransformer(classLoader, requiredTransformerClassName);
 		}
 		for (Entry<String, TreeSet<SortableValue<String>>> packetClassTransformers : this.packetTransformers.entrySet())
@@ -121,14 +168,15 @@ public class ClassTransformerManager
 			for (SortableValue<String> transformerInfo : packetClassTransformers.getValue())
 			{
 				String packetClass = packetClassTransformers.getKey();
+				String transformerClassName = transformerInfo.getValue();
 				if (packetClass.lastIndexOf('.') != -1) packetClass = packetClass.substring(packetClass.lastIndexOf('.') + 1);
-				LiteLoaderLogger.info("Injecting packet class transformer '%s' for packet class '%s' with priority %d", transformerInfo.getValue(), packetClass, transformerInfo.getPriority());
-				classLoader.registerTransformer(transformerInfo.getValue());
+				LiteLoaderLogger.info("Injecting packet class transformer '%s' for packet class '%s' with priority %d", transformerClassName, packetClass, transformerInfo.getPriority());
+				this.injectTransformer(classLoader, transformerClassName);
 			}
 		}
 		// inject any transformers received after this point directly into the downstreamTransformers set
-		this.injectedTransformers = this.downstreamTransformers;
+		this.pendingTransformers = this.downstreamTransformers;
 	}
 	/**
@@ -142,7 +190,7 @@ public class ClassTransformerManager
 		for (String transformerClassName : this.downstreamTransformers)
 		{
 			LiteLoaderLogger.info("Injecting additional class transformer class '%s'", transformerClassName);
-			classLoader.registerTransformer(transformerClassName);
+			this.injectTransformer(classLoader, transformerClassName);
 		}
 		this.downstreamTransformers.clear();
@@ -211,4 +259,58 @@ public class ClassTransformerManager
 		LiteLoaderLogger.info("Added %d packet transformer classes to the transformer list", registeredTransformers);
 	}
+
+	private synchronized void injectTransformer(LaunchClassLoader classLoader, String transformerClassName)
+	{
+		// Assign pendingTransformer so that logged errors during transformer init can be put in the map
+		this.pendingTransformer = transformerClassName;
+		
+		// Register the transformer
+		classLoader.registerTransformer(transformerClassName);
+		
+		// Unassign pending transformer now init is completed
+		this.pendingTransformer = null;
+		
+		// Check whether the transformer was successfully injected, look for it in the transformer list
+		if (this.findTransformer(classLoader, transformerClassName) != null)
+		{
+			this.injectedTransformers.add(transformerClassName);
+		}
+	}
+
+	public void observeThrowable(Throwable th)
+	{
+		if (th != null && this.pendingTransformer != null)
+		{
+			List<Throwable> transformerErrors = this.transformerStartupErrors.get(this.pendingTransformer);
+			if (transformerErrors == null)
+			{
+				transformerErrors = new ArrayList<Throwable>();
+				this.transformerStartupErrors.put(this.pendingTransformer, transformerErrors);
+			}
+			transformerErrors.add(th);
+		}
+	}
+
+	private IClassTransformer findTransformer(LaunchClassLoader classLoader, String transformerClassName)
+	{
+		for (IClassTransformer transformer : classLoader.getTransformers())
+		{
+			if (transformer.getClass().getName().equals(transformerClassName))
+				return transformer;
+		}
+		
+		return null;
+	}
+	
+	public Set<String> getInjectedTransformers()
+	{
+		return Collections.unmodifiableSet(this.injectedTransformers);
+	}
+	
+	public List<Throwable> getTransformerStartupErrors(String transformerClassName)
+	{
+		List<Throwable> errorList = this.transformerStartupErrors.get(transformerClassName);
+		return errorList != null ? Collections.unmodifiableList(errorList) : null;
+	}
 }
@@ -70,4 +70,4 @@ gui.log.closedialog=Close
 gui.error.title=Startup errors for %s
-gui.error.tooltip=%d mod startup error(s) detected
 \ No newline at end of file
+gui.error.tooltip=%d mod startup error(s) detected (%d critical)
 \ No newline at end of file