added nlog custom targets assemblies loading

Dockerfile

@@ -1,17 +0,0 @@
-FROM mcr.microsoft.com/windows/servercore:ltsc2022
-
-USER ContainerAdministrator
-ADD https://aka.ms/highdpimfc2013x64enu vc_redist2013.exe
-ADD https://aka.ms/vs/16/release/vc_redist.x64.exe vc_redist.exe
-
-RUN vc_redist2013.exe /passive /norestart
-RUN vc_redist.exe /passive /norestart
-RUN del vc_redist2013.exe && del vc_redist.exe 
-
-USER ContainerUser
-COPY . .
-ENV TORCH_GAME_PATH="c:\dedi"
-ENV TORCH_INSTANCE="c:\instance"
-ENV TORCH_SERVICE="true"
-ENTRYPOINT ["Torch.Server.exe"]
-CMD ["-noupdate"]

Torch.Server/Patches/WorldLoadExceptionPatch.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
@@ -8,6 +9,7 @@ using NLog;
 using Sandbox;
 using Torch.Managers.PatchManager;
 using Torch.Managers.PatchManager.MSIL;
+using Torch.Utils;
 
 namespace Torch.Patches
 {
@@ -17,12 +19,14 @@ namespace Torch.Patches
     [PatchShim]
     public static class WorldLoadExceptionPatch
     {
-        private static readonly ILogger _log = LogManager.GetCurrentClassLogger();
+        private static readonly ILogger Log = LogManager.GetCurrentClassLogger();
+
+        [ReflectedMethodInfo(typeof(MySandboxGame), "InitQuickLaunch")]
+        private static MethodInfo _quickLaunchMethod = null!;
 
         public static void Patch(PatchContext ctx)
         {
-            ctx.GetPattern(typeof(MySandboxGame).GetMethod("InitQuickLaunch", BindingFlags.Instance | BindingFlags.NonPublic))
-               .Transpilers.Add(typeof(WorldLoadExceptionPatch).GetMethod(nameof(Transpile), BindingFlags.Static | BindingFlags.NonPublic));
+            ctx.GetPattern(_quickLaunchMethod).AddTranspiler(nameof(Transpile));
         }
 
         private static IEnumerable<MsilInstruction> Transpile(IEnumerable<MsilInstruction> method)
@@ -30,19 +34,19 @@ namespace Torch.Patches
             var msil = method.ToList();
             for (var i = 0; i < msil.Count; i++)
             {
-                if (msil[i].TryCatchOperations.All(x => x.Type != MsilTryCatchOperationType.BeginClauseBlock))
-                    continue;
-
-                for (; i < msil.Count; i++)
+                var instruction = msil[i];
+                if (instruction.IsLocalStore() && instruction.Operand is MsilOperandInline.MsilOperandLocal {Value.Index: 19} operand)
                 {
-                    if (msil[i].OpCode != OpCodes.Leave)
-                        continue;
-
-                    msil[i] = new MsilInstruction(OpCodes.Rethrow);
-                    break;
+                    msil.InsertRange(i + 1, new []
+                    {
+                        operand.Instruction.CopyWith(OpCodes.Ldloc_S),
+                        new MsilInstruction(OpCodes.Call).InlineValue(new Action<Exception>(LogFatal).Method)
+                    });
                 }
             }
             return msil;
         }
+
+        private static void LogFatal(Exception e) => Log.Fatal(e.ToStringDemystified());
     }
 }

Torch.Server/Program.cs

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using NLog;
+using NLog.Config;
 using NLog.Targets;
 using Torch.Utils;
 
@@ -7,11 +9,11 @@ namespace Torch.Server
 {
     internal static class Program
     {
+        [STAThread]
         public static void Main(string[] args)
         {
             var isService = Environment.GetEnvironmentVariable("TORCH_SERVICE")
                 ?.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase) ?? false;
-            Target.Register<LogViewerTarget>(nameof(LogViewerTarget));
             //Ensures that all the files are downloaded in the Torch directory.
             var workingDir = AppContext.BaseDirectory;
             var binDir = Path.Combine(Environment.GetEnvironmentVariable("TORCH_GAME_PATH") ?? workingDir, "DedicatedServer64");
@@ -23,8 +25,6 @@ namespace Torch.Server
                     File.Delete(file);
                 }
 
-            TorchLauncher.Launch(workingDir, binDir);
-            
             // Breaks on Windows Server 2019
 #if TORCH_SERVICE
             if (!new ComputerInfo().OSFullName.Contains("Server 2019") && !Environment.UserInteractive)
@@ -45,15 +45,26 @@ namespace Torch.Server
             }
             else
             {
-                instancePath = Path.GetFullPath(instanceName);
+                instancePath = Directory.CreateDirectory(instanceName).FullName;
             }
             
+            var oldNlog = Path.Combine(workingDir, "NLog.config");
+            var newNlog = Path.Combine(instancePath, "NLog.config");
+            if (File.Exists(oldNlog))
+                File.Move(oldNlog, newNlog, true);
+            else if (!File.Exists(newNlog))
+                using (var f = File.Create(newNlog))
+                    typeof(Program).Assembly.GetManifestResourceStream("Torch.Server.NLog.config")!.CopyTo(f);
+
             var oldTorchCfg = Path.Combine(workingDir, "Torch.cfg");
             var torchCfg = Path.Combine(instancePath, "Torch.cfg");
             
             if (File.Exists(oldTorchCfg))
                 File.Move(oldTorchCfg, torchCfg, true);
             
+            Target.Register<LogViewerTarget>(nameof(LogViewerTarget));
+            TorchLogManager.SetConfiguration(new XmlLoggingConfiguration(newNlog));
+
             var config = Persistent<TorchConfig>.Load(torchCfg);
             config.Data.InstanceName = instanceName;
             config.Data.InstancePath = instancePath;
@@ -70,6 +81,11 @@ namespace Torch.Server
             if (!initializer.Initialize(args))
                 Environment.Exit(1);
 
+            TorchLauncher.Launch(workingDir, binDir);
+            TorchLogManager.SetConfiguration(TorchLogManager.Configuration,
+                Environment.GetEnvironmentVariable("TORCH_LOG_EXTENSIONS_PATH") ??
+                Path.Combine(instancePath, "LoggingExtensions"));
+            
             CopyNative(binDir);
             initializer.Run(isService, instanceName, instancePath);
         }

Torch.Server/Torch.Server.csproj

@@ -160,7 +160,6 @@
   </ItemGroup>
   <ItemGroup>
     <Page Remove="Views\WorldSelectControl.xaml" />
-    <None Include="..\NLog.config" Visible="false" CopyToOutputDirectory="PreserveNewest" CopyToPublishDirectory="Always" />
-    <None Include="..\Dockerfile" Visible="false" CopyToPublishDirectory="Always" />
+    <EmbeddedResource Include="..\NLog.config" Visible="false" />
   </ItemGroup>
 </Project>

Torch/Patches/GameAnalyticsPatch.cs

@@ -5,6 +5,7 @@ using System.Runtime.CompilerServices;
 using NLog;
 using NLog.Config;
 using Torch.Managers.PatchManager;
+using Torch.Utils;
 
 namespace Torch.Patches
 {
@@ -36,16 +37,13 @@ namespace Torch.Patches
                 _log.Warn("GALogger constructor is unknown.  Logging may not function.");
                 return;
             }
-            ctx.GetPattern(ctor).Prefixes.Add(typeof(GameAnalyticsPatch).GetMethod(nameof(PatchLogger),
-                BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public));
+            ctx.GetPattern(ctor).AddPrefix(nameof(PatchLogger));
         }
 
         private static void FixLogging()
         {
+            TorchLogManager.RestoreGlobalConfiguration();
             _setLogger(null, LogManager.GetLogger("GameAnalytics"));
-            if (!(LogManager.Configuration is XmlLoggingConfiguration))
-                LogManager.Configuration = new XmlLoggingConfiguration(Path.Combine(
-                    Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) ?? Environment.CurrentDirectory, "NLog.config"));
         }
 
         private static bool PatchLogger()

Torch/Patches/GcCollectPatch.cs

@@ -17,6 +17,7 @@ internal static class GcCollectPatch
 {
     // FUCK YO KEEN
     // every call results in freeze for seconds
+    
     private static readonly MethodBase[] _targets =
     {
         Info.OfMethod<MyPlanetTextureMapProvider>(nameof(MyPlanetTextureMapProvider.GetHeightmap)),

Torch/Patches/ScriptCompilerPatch.cs

@@ -1,7 +1,9 @@
 using System;
+using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
@@ -43,11 +45,14 @@ namespace Torch.Patches
         private static void WhitelistCtorPrefix(MyScriptCompiler scriptCompiler)
         {
             scriptCompiler.AddReferencedAssemblies(
+                typeof(ValueType).Assembly.Location,
+                typeof(LinkedList<>).Assembly.Location,
                 typeof(Regex).Assembly.Location,
                 typeof(Enumerable).Assembly.Location,
                 typeof(ConcurrentBag<>).Assembly.Location,
                 typeof(ImmutableArray).Assembly.Location,
-                typeof(System.ComponentModel.TypeConverter).Assembly.Location,
+                typeof(PropertyChangedEventArgs).Assembly.Location,
+                typeof(TypeConverter).Assembly.Location,
                 typeof(System.Diagnostics.TraceSource).Assembly.Location,
                 typeof(ProtoBuf.Meta.RuntimeTypeModel).Assembly.Location,
                 Path.Combine(MyFileSystem.ExePath, "Sandbox.Game.dll"),

Torch/Utils/TorchLogManager.cs

@@ -0,0 +1,38 @@
+using System;
+using System.IO;
+using System.Runtime.Loader;
+using NLog;
+using NLog.Config;
+
+namespace Torch.Utils;
+
+public static class TorchLogManager
+{
+    private static readonly AssemblyLoadContext LoadContext = new("TorchLog");
+
+    public static LoggingConfiguration Configuration { get; private set; }
+
+    public static void SetConfiguration(LoggingConfiguration configuration, string extensionsDir = null)
+    {
+        Configuration = configuration;
+        LogManager.Setup()
+            .SetupExtensions(builder =>
+            {
+                if (extensionsDir is null || !Directory.Exists(extensionsDir))
+                    return;
+                foreach (var file in Directory.EnumerateFiles(extensionsDir, "*.dll", SearchOption.AllDirectories))
+                {
+                    builder.RegisterAssembly(LoadContext.LoadFromAssemblyPath(file));
+                }
+            })
+            .SetupLogFactory(builder => builder.SetThrowConfigExceptions(true))
+            .LoadConfiguration(configuration);
+        LogManager.ReconfigExistingLoggers();
+    }
+
+    public static void RestoreGlobalConfiguration()
+    {
+        LogManager.Configuration = Configuration;
+        LogManager.ReconfigExistingLoggers();
+    }
+}

appveyor.yml

@@ -11,7 +11,7 @@ platform: x64
 shallow_clone: true
 assembly_info:
   patch: true
-  file: '**\AssemblyInfo.*'
+  file: '**\AssemblyVersion.*'
   assembly_version: '{version}'
   assembly_file_version: '{version}'
   assembly_informational_version: v{version}
@@ -37,24 +37,21 @@ install:
 
     & "$steamCMDPath/steamcmd.exe" "+login anonymous" "+force_install_dir $steamData" "+app_update 298740" "+quit"
 
-    $dataPath = $steamData.Replace("/", "\")
-    
-    Remove-Item -LiteralPath $dataPath\Content -Force -Recurse
+    $dataPath = $steamData.Replace("/", "\");
+    $contentPath = "$dataPath\Content";
+    if (Test-Path $contentPath) {
+      Remove-Item -LiteralPath $contentPath -Force -Recurse
+    }
 
     cmd /S /C mklink /J .\GameBinaries $dataPath\DedicatedServer64
 cache:
 - c:\steam\dedi\
 - c:\steam\cmd\
-before_build:
-- pwsh: dotnet restore .\Torch.Server\Torch.Server.csproj
-build:
-  project: Torch.Server/Torch.Server.csproj
-  verbosity: minimal
-after_build:
+build_script:
 - pwsh: >-
-    dotnet publish .\Torch.Server\Torch.Server.csproj --self-contained -c Release -o .\publish\ --no-build
+    dotnet publish .\Torch.Server\Torch.Server.csproj --self-contained -f net6-windows -r win-x64 -c Release -o .\publish\
     
-    Compress-Archive -Path .\publish\ -DestinationPath torch-server.zip
+    Compress-Archive -Path .\publish\* -DestinationPath .\torch-server.zip
 artifacts:
 - path: torch-server.zip
 deploy: