Upgrading Harmony to 2.x for the May 2024 update (#19)

Jexs · web-flow · commit 8853beb44f73 · 2024-05-02T12:38:30.000+08:00
* quick work around to get post-start patches working with harmony 2.x

* small message edit

* fix oxide spam if not running oxide
diff --git a/src/RustServerMetrics/HarmonyPatches/BasePlayer_OnDisconnected_Patch.cs b/src/RustServerMetrics/HarmonyPatches/BasePlayer_OnDisconnected_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
diff --git a/src/RustServerMetrics/HarmonyPatches/BasePlayer_PerformanceReport_Patch.cs b/src/RustServerMetrics/HarmonyPatches/BasePlayer_PerformanceReport_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
diff --git a/src/RustServerMetrics/HarmonyPatches/BasePlayer_PlayerInit_Patch.cs b/src/RustServerMetrics/HarmonyPatches/BasePlayer_PlayerInit_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using System;
 using System.Collections.Generic;
 using System.Reflection;
diff --git a/src/RustServerMetrics/HarmonyPatches/Bootstrap_StartServer_Patch.cs b/src/RustServerMetrics/HarmonyPatches/Bootstrap_StartServer_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
diff --git a/src/RustServerMetrics/HarmonyPatches/Delayed/ConsoleSystem_Internal_Patch.cs b/src/RustServerMetrics/HarmonyPatches/Delayed/ConsoleSystem_Internal_Patch.cs
@@ -1,16 +1,30 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using RustServerMetrics.HarmonyPatches.Utility;
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using UnityEngine;
 
 namespace RustServerMetrics.HarmonyPatches.Delayed
 {
     [DelayedHarmonyPatch]
+    [HarmonyPatch]
     internal class ConsoleSystem_Internal_Patch
     {
+        [HarmonyPrepare]
+        public static bool Prepare()
+        {
+            if (!RustServerMetricsLoader.__serverStarted)
+            {
+                Debug.Log("Note: Cannot patch ConsoleSystem_Internal_Patch yet. We will patch it upon server start.");
+                return false;
+            }
+
+            return true;
+        }
+        
         [HarmonyTargetMethods]
-        public static IEnumerable<MethodBase> TargetMethods(HarmonyInstance harmonyInstance)
+        public static IEnumerable<MethodBase> TargetMethods(Harmony harmonyInstance)
         {
             yield return AccessTools.DeclaredMethod(typeof(ConsoleSystem), nameof(ConsoleSystem.Internal));
         }
diff --git a/src/RustServerMetrics/HarmonyPatches/Delayed/InvokeHandlerBase_DoTick_Patch.cs b/src/RustServerMetrics/HarmonyPatches/Delayed/InvokeHandlerBase_DoTick_Patch.cs
@@ -1,14 +1,16 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using RustServerMetrics.HarmonyPatches.Utility;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
+using UnityEngine;
 
 namespace RustServerMetrics.HarmonyPatches.Delayed
 {
     [DelayedHarmonyPatch]
+    [HarmonyPatch]
     internal static class InvokeHandlerBase_DoTick_Patch
     {
         static System.Diagnostics.Stopwatch _stopwatch = new System.Diagnostics.Stopwatch();
@@ -21,8 +23,20 @@ internal static class InvokeHandlerBase_DoTick_Patch
             new CodeInstruction(OpCodes.Callvirt, AccessTools.Method(typeof(Action), nameof(Action.Invoke)))
         };
 
+        [HarmonyPrepare]
+        public static bool Prepare()
+        {
+            if (!RustServerMetricsLoader.__serverStarted)
+            {
+                Debug.Log("Note: Cannot patch InvokeHandlerBase_DoTick_Patch yet. We will patch it upon server start.");
+                return false;
+            }
+
+            return true;
+        }
+        
         [HarmonyTargetMethods]
-        public static IEnumerable<MethodBase> TargetMethods(HarmonyInstance harmonyInstance)
+        public static IEnumerable<MethodBase> TargetMethods(Harmony harmonyInstance)
         {
             yield return AccessTools.DeclaredMethod(typeof(InvokeHandlerBase<InvokeHandler>), nameof(InvokeHandlerBase<InvokeHandler>.DoTick));
         }
diff --git a/src/RustServerMetrics/HarmonyPatches/Delayed/ObjectWorkQueue_RunJob_Patch.cs b/src/RustServerMetrics/HarmonyPatches/Delayed/ObjectWorkQueue_RunJob_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using RustServerMetrics.HarmonyPatches.Utility;
 using System;
 using System.Collections.Generic;
@@ -10,10 +10,23 @@
 namespace RustServerMetrics.HarmonyPatches.Delayed
 {
     [DelayedHarmonyPatch]
+    [HarmonyPatch]
     internal static class ObjectWorkQueue_RunJob_Patch
     {
+        [HarmonyPrepare]
+        public static bool Prepare()
+        {
+            if (!RustServerMetricsLoader.__serverStarted)
+            {
+                Debug.Log("Note: Cannot patch ObjectWorkQueue_RunJob_Patch yet. We will patch it upon server start.");
+                return false;
+            }
+
+            return true;
+        }
+        
         [HarmonyTargetMethods]
-        public static IEnumerable<MethodBase> TargetMethods(HarmonyInstance harmonyInstance)
+        public static IEnumerable<MethodBase> TargetMethods(Harmony harmonyInstance)
         {
             var assemblyCSharp = typeof(BaseNetworkable).Assembly;
             Stack<Type> typesToScan = new Stack<Type>(assemblyCSharp.GetTypes());
diff --git a/src/RustServerMetrics/HarmonyPatches/Delayed/RPCServer_Attribute_Method_Patch.cs b/src/RustServerMetrics/HarmonyPatches/Delayed/RPCServer_Attribute_Method_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using RustServerMetrics.HarmonyPatches.Utility;
 using System;
 using System.Collections.Generic;
@@ -10,10 +10,23 @@
 namespace RustServerMetrics.HarmonyPatches.Delayed
 {
     [DelayedHarmonyPatch]
+    [HarmonyPatch]
     internal class RPCServer_Attribute_Method_Patch
     {
+        [HarmonyPrepare]
+        public static bool Prepare()
+        {
+            if (!RustServerMetricsLoader.__serverStarted)
+            {
+                Debug.Log("Note: Cannot patch RPCServer_Attribute_Method_Patch yet. We will patch it upon server start.");
+                return false;
+            }
+
+            return true;
+        }
+        
         [HarmonyTargetMethods]
-        public static IEnumerable<MethodBase> TargetMethods(HarmonyInstance harmonyInstance)
+        public static IEnumerable<MethodBase> TargetMethods(Harmony harmonyInstance)
         {
             var baseNetworkableType = typeof(BaseNetworkable);
             var baseNetworkableAssembly = baseNetworkableType.Assembly;
diff --git a/src/RustServerMetrics/HarmonyPatches/Delayed/ServerMgr_Metrics_Patches.cs b/src/RustServerMetrics/HarmonyPatches/Delayed/ServerMgr_Metrics_Patches.cs
@@ -3,17 +3,30 @@
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
-using Harmony;
+using HarmonyLib;
 using RustServerMetrics.HarmonyPatches.Utility;
 using UnityEngine;
 
 namespace RustServerMetrics.HarmonyPatches.Delayed;
 
 [DelayedHarmonyPatch]
+[HarmonyPatch]
 internal static class ServerMgr_Metrics_Patches
 {
+    [HarmonyPrepare]
+    public static bool Prepare()
+    {
+        if (!RustServerMetricsLoader.__serverStarted)
+        {
+            Debug.Log("Note: Cannot patch ServerMgr_Metrics_Patches yet. We will patch it upon server start.");
+            return false;
+        }
+
+        return true;
+    }
+    
     [HarmonyTargetMethods]
-    public static IEnumerable<MethodBase> TargetMethods(HarmonyInstance harmonyInstance)
+    public static IEnumerable<MethodBase> TargetMethods(Harmony harmonyInstance)
     {
         yield return AccessTools.Method(typeof(ServerMgr), nameof(ServerMgr.Update));
         yield return AccessTools.Method(typeof(ServerBuildingManager), nameof(ServerBuildingManager.Cycle));
diff --git a/src/RustServerMetrics/HarmonyPatches/NetWrite_PacketID_Patch.cs b/src/RustServerMetrics/HarmonyPatches/NetWrite_PacketID_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using Network;
 
 namespace RustServerMetrics.HarmonyPatches
diff --git a/src/RustServerMetrics/HarmonyPatches/NetWrite_Send_Patch.cs b/src/RustServerMetrics/HarmonyPatches/NetWrite_Send_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using Network;
 
 namespace RustServerMetrics.HarmonyPatches
diff --git a/src/RustServerMetrics/HarmonyPatches/OxideMod_OnFrame_Patch.cs b/src/RustServerMetrics/HarmonyPatches/OxideMod_OnFrame_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -20,8 +20,32 @@ public static class OxideMod_OnFrame_Patch
         static Assembly _oxideCoreAssembly = null;
         public static float nextTick = 0f;
 
+        [HarmonyPrepare]
+        public static bool Prepare()
+        {
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+            foreach (var assembly in assemblies)
+            {
+                if (!string.Equals(assembly.GetName().Name, OxideCore_AssemblyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+                
+                _oxideCoreAssembly = assembly;
+                
+                break;
+            }
+
+            if (_oxideCoreAssembly == null)
+            {
+                return false;
+            }
+
+            return true;
+        }
+        
         [HarmonyTargetMethods]
-        public static IEnumerable<MethodBase> TargetMethods(HarmonyInstance harmonyInstance)
+        public static IEnumerable<MethodBase> TargetMethods(Harmony harmonyInstance)
         {
             var assemblies = AppDomain.CurrentDomain.GetAssemblies();
             for (int i = 0; i < assemblies.Length; i++)
diff --git a/src/RustServerMetrics/HarmonyPatches/Performance_FPSTimer_Patch.cs b/src/RustServerMetrics/HarmonyPatches/Performance_FPSTimer_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 
 namespace RustServerMetrics.HarmonyPatches
 {
diff --git a/src/RustServerMetrics/HarmonyPatches/ServerMgr_OpenConnection_Patch.cs b/src/RustServerMetrics/HarmonyPatches/ServerMgr_OpenConnection_Patch.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 
 namespace RustServerMetrics.HarmonyPatches
 {
diff --git a/src/RustServerMetrics/HarmonyPatches/Utility/Helpers.cs b/src/RustServerMetrics/HarmonyPatches/Utility/Helpers.cs
@@ -4,7 +4,7 @@
 using System.Reflection;
 using System.Reflection.Emit;
 using System.Text;
-using Harmony;
+using HarmonyLib;
 using UnityEngine;
 
 namespace RustServerMetrics.HarmonyPatches.Utility;
diff --git a/src/RustServerMetrics/MetricsLogger.cs b/src/RustServerMetrics/MetricsLogger.cs
@@ -1,4 +1,4 @@
-﻿using Harmony;
+﻿using HarmonyLib;
 using Network;
 using Newtonsoft.Json;
 using RustServerMetrics.Config;
@@ -79,25 +79,25 @@ internal static void Initialize()
 
         internal void OnServerStarted()
         {
+            RustServerMetricsLoader.__serverStarted = true;
+            
             Debug.Log($"[ServerMetrics]: Applying Startup Patches");
             var assembly = GetType().Assembly;
 
-            var harmonyInstance = HarmonyLoader.loadedMods.FirstOrDefault(x => x.Assembly == assembly)?.Harmony;
+            var harmonyInstance = HarmonyLoader.loadedMods.FirstOrDefault(x => x.Assembly == assembly)?.Harmony.harmonyObject;
             if (harmonyInstance == null)
             {
-                RustServerMetricsLoader.__harmonyInstance ??= HarmonyInstance.Create("RustServerMetrics" + "PATCH");
+                RustServerMetricsLoader.__harmonyInstance ??= new Harmony("RustServerMetrics" + "PATCH");
                 harmonyInstance = RustServerMetricsLoader.__harmonyInstance;
             }
 
             var nestedTypes = assembly.GetTypes();
             foreach (var nestedType in nestedTypes)
             {
                 if (nestedType.GetCustomAttribute<DelayedHarmonyPatchAttribute>(false) == null) continue;
-                var attributes = HarmonyMethod.Merge(new List<HarmonyMethod> { new() });
-                var patchProcessor = new PatchProcessor(harmonyInstance, nestedType, attributes);
-                patchProcessor.Patch();
-
-                Debug.Log($"[ServerMetrics]: Applied Startup Patch: {nestedType.Name}");
+                
+                var patchProcessor = new PatchClassProcessor((Harmony)harmonyInstance, nestedType);
+                Debug.Log(patchProcessor.Patch() == null ? $"[ServerMetrics]: Failed to apply patch: {nestedType.Name}" : $"[ServerMetrics]: Applied Startup Patch: {nestedType.Name}");
             }
         }
 
diff --git a/src/RustServerMetrics/ModTimeWarnings.cs b/src/RustServerMetrics/ModTimeWarnings.cs
@@ -3,17 +3,31 @@
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
-using Harmony;
+using HarmonyLib;
 using RustServerMetrics.HarmonyPatches.Utility;
+using UnityEngine;
 
 namespace RustServerMetrics;
 
+[HarmonyPatch]
 public static class ModTimeWarnings
 {
     public static List<MethodInfo> Methods = new ();
 
+    [HarmonyPrepare]
+    public static bool Prepare()
+    {
+        if (!RustServerMetricsLoader.__serverStarted)
+        {
+            Debug.Log("Note: Cannot patch any time warnings yet. We will patch it upon server start.");
+            return false;
+        }
+
+        return true;
+    }
+    
     [HarmonyTargetMethods]
-    public static IEnumerable<MethodBase> TargetMethods(HarmonyInstance harmonyInstance) => Methods;
+    public static IEnumerable<MethodBase> TargetMethods(Harmony harmonyInstance) => Methods;
     
     [HarmonyTranspiler]
     public static IEnumerable<CodeInstruction> Transpile(IEnumerable<CodeInstruction> originalInstructions, MethodBase methodBase, ILGenerator ilGenerator)
diff --git a/src/RustServerMetrics/RustServerMetricsLoader.cs b/src/RustServerMetrics/RustServerMetricsLoader.cs
@@ -1,15 +1,16 @@
 ﻿using System.Collections.Generic;
 using System.Reflection;
-using Harmony;
-using RustServerMetrics.HarmonyPatches.Utility;
+using HarmonyLib;
 using UnityEngine;
 
 namespace RustServerMetrics;
 
 public class RustServerMetricsLoader : IHarmonyModHooks
 {
-    public static HarmonyInstance __harmonyInstance;
-    public static List<HarmonyInstance> __modTimeWarningsHarmonyInstances = new ();
+    public static bool __serverStarted = false;
+    
+    public static Harmony __harmonyInstance;
+    public static List<Harmony> __modTimeWarningsHarmonyInstances = new ();
     
     public void OnLoaded(OnHarmonyModLoadedArgs args)
     {
@@ -36,14 +37,13 @@ public void OnUnloaded(OnHarmonyModUnloadedArgs args)
 
     public void AddModTimeWarnings(List<MethodInfo> methods)
     { 
-        var instance = HarmonyInstance.Create($"RustServerMetrics.ModTimeWarnings.{__modTimeWarningsHarmonyInstances.Count}");
+        var instance = new Harmony($"RustServerMetrics.ModTimeWarnings.{__modTimeWarningsHarmonyInstances.Count}");
         __modTimeWarningsHarmonyInstances.Add(instance);
          
         ModTimeWarnings.Methods.Clear();
         ModTimeWarnings.Methods.AddRange(methods);
         
-        var attributes = HarmonyMethod.Merge(new List<HarmonyMethod> { new() });
-        var patchProcessor = new PatchProcessor(instance, typeof(ModTimeWarnings), attributes);
+        var patchProcessor = new PatchClassProcessor(instance, typeof(ModTimeWarnings));
         patchProcessor.Patch();
         
         foreach (var method in methods)

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using Harmony;`
	`1`	`+using HarmonyLib;`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Reflection;`
`4`	`4`	`using System.Reflection.Emit;`