WIP

Agent/Phantom.Agent.Minecraft/Command/MinecraftCommand.cs

@@ -1,9 +1,15 @@
 namespace Phantom.Agent.Minecraft.Command; 
 
 public static class MinecraftCommand {
+	public const string SaveOn = "save-on";
+	public const string SaveOff = "save-off";
 	public const string Stop = "stop";
 	
 	public static string Say(string message) {
 		return "say " + message;
 	}
+
+	public static string SaveAll(bool flush) {
+		return flush ? "save-all flush" : "save-all";
+	}
 }

Agent/Phantom.Agent.Minecraft/Instance/InstanceProcess.cs

@@ -1,23 +1,25 @@
-using System.Diagnostics;
+using Phantom.Utils.Collections;
-using Phantom.Utils.Collections;
+using Phantom.Utils.Runtime;
 
 namespace Phantom.Agent.Minecraft.Instance; 
 
-public sealed class InstanceSession : IDisposable {
+public sealed class InstanceProcess : IDisposable {
+	public InstanceProperties InstanceProperties { get; }
+	public CancellableSemaphore BackupSemaphore { get; } = new (1, 1);
+	
 	private readonly RingBuffer<string> outputBuffer = new (10000);
 	private event EventHandler<string>? OutputEvent;
 
-	public event EventHandler? SessionEnded;
+	public event EventHandler? Ended;
 	public bool HasEnded { get; private set; }
 
 	private readonly Process process;
 
-	internal InstanceSession(Process process) {
+	internal InstanceProcess(InstanceProperties instanceProperties, Process process) {
+		this.InstanceProperties = instanceProperties;
 		this.process = process;
-		this.process.EnableRaisingEvents = true;
 		this.process.Exited += ProcessOnExited;
-		this.process.OutputDataReceived += HandleOutputLine;
+		this.process.OutputReceived += ProcessOutputReceived;
-		this.process.ErrorDataReceived += HandleOutputLine;
 	}
 
 	public async Task SendCommand(string command, CancellationToken cancellationToken) {
@@ -36,17 +38,15 @@ public sealed class InstanceSession : IDisposable {
 		OutputEvent -= listener;
 	}
 
-	private void HandleOutputLine(object sender, DataReceivedEventArgs args) {
+	private void ProcessOutputReceived(object? sender, Process.Output output) {
-		if (args.Data is {} line) {
+		outputBuffer.Add(output.Line);
-			outputBuffer.Add(line);
+		OutputEvent?.Invoke(this, output.Line);
-			OutputEvent?.Invoke(this, line);
-		}
 	}
 
 	private void ProcessOnExited(object? sender, EventArgs e) {
 		OutputEvent = null;
 		HasEnded = true;
-		SessionEnded?.Invoke(this, EventArgs.Empty);
+		Ended?.Invoke(this, EventArgs.Empty);
 	}
 
 	public void Kill() {
@@ -61,7 +61,8 @@ public sealed class InstanceSession : IDisposable {
 
 	public void Dispose() {
 		process.Dispose();
+		BackupSemaphore.Dispose();
 		OutputEvent = null;
-		SessionEnded = null;
+		Ended = null;
 	}
 }

Agent/Phantom.Agent.Minecraft/Instance/InstanceProperties.cs

@@ -1,14 +1,17 @@
 using System.Collections.Immutable;
 using Phantom.Agent.Minecraft.Java;
 using Phantom.Agent.Minecraft.Properties;
+using Phantom.Common.Data.Instance;
 
 namespace Phantom.Agent.Minecraft.Instance;
 
 public sealed record InstanceProperties(
+	Guid InstanceGuid,
 	Guid JavaRuntimeGuid,
 	JvmProperties JvmProperties,
 	ImmutableArray<string> JvmArguments,
 	string InstanceFolder,
 	string ServerVersion,
-	ServerProperties ServerProperties
+	ServerProperties ServerProperties,
+	InstanceLaunchProperties LaunchProperties
 );

Agent/Phantom.Agent.Minecraft/Java/JavaRuntimeDiscovery.cs

@@ -7,7 +7,7 @@ using Serilog;
 namespace Phantom.Agent.Minecraft.Java;
 
 public sealed class JavaRuntimeDiscovery {
-	private static readonly ILogger Logger = PhantomLogger.Create(typeof(JavaRuntimeDiscovery));
+	private static readonly ILogger Logger = PhantomLogger.Create(nameof(JavaRuntimeDiscovery));
 
 	public static string? GetSystemSearchPath() {
 		const string LinuxJavaPath = "/usr/lib/jvm";

Agent/Phantom.Agent.Minecraft/Launcher/BaseLauncher.cs

@@ -1,17 +1,19 @@
-using System.Diagnostics;
+using System.Text;
-using System.Text;
 using Kajabity.Tools.Java;
 using Phantom.Agent.Minecraft.Instance;
 using Phantom.Agent.Minecraft.Java;
 using Phantom.Agent.Minecraft.Server;
 using Phantom.Common.Minecraft;
+using Phantom.Utils.Runtime;
 using Serilog;
 
 namespace Phantom.Agent.Minecraft.Launcher;
 
-public abstract class BaseLauncher {
+public abstract class BaseLauncher : IServerLauncher {
 	private readonly InstanceProperties instanceProperties;
 
+	protected string MinecraftVersion => instanceProperties.ServerVersion;
+
 	private protected BaseLauncher(InstanceProperties instanceProperties) {
 		this.instanceProperties = instanceProperties;
 	}
@@ -25,33 +27,25 @@ public abstract class BaseLauncher {
 			return new LaunchResult.InvalidJvmArguments();
 		}
 
-		var vanillaServerJarPath = await services.ServerExecutables.DownloadAndGetPath(instanceProperties.ServerVersion, downloadProgressEventHandler, cancellationToken);
+		var vanillaServerJarPath = await services.ServerExecutables.DownloadAndGetPath(instanceProperties.LaunchProperties.ServerDownloadInfo, MinecraftVersion, downloadProgressEventHandler, cancellationToken);
 		if (vanillaServerJarPath == null) {
 			return new LaunchResult.CouldNotDownloadMinecraftServer();
 		}
 
-		var startInfo = new ProcessStartInfo {
+		ServerJarInfo? serverJar;
-			FileName = javaRuntimeExecutable.ExecutablePath,
+		try {
-			WorkingDirectory = instanceProperties.InstanceFolder,
+			serverJar = await PrepareServerJar(logger, vanillaServerJarPath, cancellationToken);
-			RedirectStandardInput = true,
+		} catch (OperationCanceledException) {
-			RedirectStandardOutput = true,
+			throw;
-			RedirectStandardError = true,
+		} catch (Exception e) {
-			UseShellExecute = false,
+			logger.Error(e, "Caught exception while preparing the server jar.");
-			CreateNoWindow = false
+			return new LaunchResult.CouldNotPrepareMinecraftServerLauncher();
-		};
+		}
 
-		var jvmArguments = new JvmArgumentBuilder(instanceProperties.JvmProperties, instanceProperties.JvmArguments);
+		if (!File.Exists(serverJar.FilePath)) {
-		CustomizeJvmArguments(jvmArguments);
+			logger.Error("Missing prepared server or launcher jar: {FilePath}", serverJar.FilePath);
-
+			return new LaunchResult.CouldNotPrepareMinecraftServerLauncher();
-		var serverJarPath = await PrepareServerJar(vanillaServerJarPath, instanceProperties.InstanceFolder, cancellationToken);
+		}
-		var processArguments = startInfo.ArgumentList;
-		jvmArguments.Build(processArguments);
-		processArguments.Add("-jar");
-		processArguments.Add(serverJarPath);
-		processArguments.Add("nogui");
-
-		var process = new Process { StartInfo = startInfo };
-		var session = new InstanceSession(process);
 
 		try {
 			await AcceptEula(instanceProperties);
@@ -61,10 +55,32 @@ public abstract class BaseLauncher {
 			return new LaunchResult.CouldNotConfigureMinecraftServer();
 		}
 		
+		var processConfigurator = new ProcessConfigurator {
+			FileName = javaRuntimeExecutable.ExecutablePath,
+			WorkingDirectory = instanceProperties.InstanceFolder,
+			RedirectInput = true,
+			UseShellExecute = false
+		};
+		
+		var jvmArguments = new JvmArgumentBuilder(instanceProperties.JvmProperties, instanceProperties.JvmArguments);
+		CustomizeJvmArguments(jvmArguments);
+
+		var processArguments = processConfigurator.ArgumentList;
+		jvmArguments.Build(processArguments);
+		
+		foreach (var extraArgument in serverJar.ExtraArgs) {
+			processArguments.Add(extraArgument);
+		}
+		
+		processArguments.Add("-jar");
+		processArguments.Add(serverJar.FilePath);
+		processArguments.Add("nogui");
+
+		var process = processConfigurator.CreateProcess();
+		var instanceProcess = new InstanceProcess(instanceProperties, process);
+
 		try {
 			process.Start();
-			process.BeginOutputReadLine();
-			process.BeginErrorReadLine();
 		} catch (Exception launchException) {
 			logger.Error(launchException, "Caught exception launching the server process.");
 			
@@ -77,13 +93,13 @@ public abstract class BaseLauncher {
 			return new LaunchResult.CouldNotStartMinecraftServer();
 		}
 
-		return new LaunchResult.Success(session);
+		return new LaunchResult.Success(instanceProcess);
 	}
 
 	private protected virtual void CustomizeJvmArguments(JvmArgumentBuilder arguments) {}
 
-	private protected virtual Task<string> PrepareServerJar(string serverJarPath, string instanceFolderPath, CancellationToken cancellationToken) {
+	private protected virtual Task<ServerJarInfo> PrepareServerJar(ILogger logger, string serverJarPath, CancellationToken cancellationToken) {
-		return Task.FromResult(serverJarPath);
+		return Task.FromResult(new ServerJarInfo(serverJarPath));
 	}
 
 	private static async Task AcceptEula(InstanceProperties instanceProperties) {

Agent/Phantom.Agent.Minecraft/Launcher/IServerLauncher.cs

@@ -0,0 +1,8 @@
+using Phantom.Agent.Minecraft.Server;
+using Serilog;
+
+namespace Phantom.Agent.Minecraft.Launcher;
+
+public interface IServerLauncher {
+	Task<LaunchResult> Launch(ILogger logger, LaunchServices services, EventHandler<DownloadProgressEventArgs> downloadProgressEventHandler, CancellationToken cancellationToken);
+}

Agent/Phantom.Agent.Minecraft/Launcher/LaunchResult.cs

@@ -5,7 +5,7 @@ namespace Phantom.Agent.Minecraft.Launcher;
 public abstract record LaunchResult {
 	private LaunchResult() {}
 
-	public sealed record Success(InstanceSession Session) : LaunchResult;
+	public sealed record Success(InstanceProcess Process) : LaunchResult;
 
 	public sealed record InvalidJavaRuntime : LaunchResult;
 	
@@ -13,6 +13,8 @@ public abstract record LaunchResult {
 
 	public sealed record CouldNotDownloadMinecraftServer : LaunchResult;
 	
+	public sealed record CouldNotPrepareMinecraftServerLauncher : LaunchResult;
+	
 	public sealed record CouldNotConfigureMinecraftServer : LaunchResult;
 	
 	public sealed record CouldNotStartMinecraftServer : LaunchResult;

Agent/Phantom.Agent.Minecraft/Launcher/LaunchServices.cs

@@ -1,7 +1,6 @@
 using Phantom.Agent.Minecraft.Java;
 using Phantom.Agent.Minecraft.Server;
-using Phantom.Utils.Runtime;
 
 namespace Phantom.Agent.Minecraft.Launcher; 
 
-public sealed record LaunchServices(TaskManager TaskManager, MinecraftServerExecutables ServerExecutables, JavaRuntimeRepository JavaRuntimeRepository);
+public sealed record LaunchServices(MinecraftServerExecutables ServerExecutables, JavaRuntimeRepository JavaRuntimeRepository);

Agent/Phantom.Agent.Minecraft/Launcher/ServerJarInfo.cs

@@ -0,0 +1,7 @@
+using System.Collections.Immutable;
+
+namespace Phantom.Agent.Minecraft.Launcher;
+
+sealed record ServerJarInfo(string FilePath, ImmutableArray<string> ExtraArgs) {
+	public ServerJarInfo(string filePath) : this(filePath, ImmutableArray<string>.Empty) {}
+}

Agent/Phantom.Agent.Minecraft/Launcher/Types/FabricLauncher.cs

@@ -0,0 +1,55 @@
+using System.Collections.Immutable;
+using Phantom.Agent.Minecraft.Instance;
+using Phantom.Utils.IO;
+using Serilog;
+
+namespace Phantom.Agent.Minecraft.Launcher.Types; 
+
+public sealed class FabricLauncher : BaseLauncher {
+	public FabricLauncher(InstanceProperties instanceProperties) : base(instanceProperties) {}
+	
+	private protected override async Task<ServerJarInfo> PrepareServerJar(ILogger logger, string serverJarPath, CancellationToken cancellationToken) {
+		var serverJarParentFolderPath = Directory.GetParent(serverJarPath);
+		if (serverJarParentFolderPath == null) {
+			throw new ArgumentException("Could not get parent folder from: " + serverJarPath, nameof(serverJarPath));
+		}
+		
+		var launcherJarPath = Path.Combine(serverJarParentFolderPath.FullName, "fabric.jar");
+		
+		if (!File.Exists(launcherJarPath)) {
+			await DownloadLauncher(logger, launcherJarPath, cancellationToken);
+		}
+
+		return new ServerJarInfo(launcherJarPath, ImmutableArray.Create("-Dfabric.installer.server.gameJar=" + Paths.NormalizeSlashes(serverJarPath)));
+	}
+
+	private async Task DownloadLauncher(ILogger logger, string targetFilePath, CancellationToken cancellationToken) {
+		// TODO customizable loader version, probably with a dedicated temporary folder
+		string installerUrl = $"https://meta.fabricmc.net/v2/versions/loader/{MinecraftVersion}/stable/stable/server/jar";
+		logger.Information("Downloading Fabric launcher from: {Url}", installerUrl);
+		
+		using var http = new HttpClient();
+		
+		var response = await http.GetAsync(installerUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+		response.EnsureSuccessStatusCode();
+		
+		try {
+			await using var fileStream = new FileStream(targetFilePath, FileMode.CreateNew, FileAccess.Write, FileShare.Read);
+			await using var responseStream = await response.Content.ReadAsStreamAsync(cancellationToken);
+			await responseStream.CopyToAsync(fileStream, cancellationToken);
+		} catch (Exception) {
+			TryDeleteLauncherAfterFailure(logger, targetFilePath);
+			throw;
+		}
+	}
+
+	private static void TryDeleteLauncherAfterFailure(ILogger logger, string filePath) {
+		if (File.Exists(filePath)) {
+			try {
+				File.Delete(filePath);
+			} catch (Exception e) {
+				logger.Warning(e, "Could not clean up partially downloaded Fabric launcher: {FilePath}", filePath);
+			}
+		}
+	}
+}

Agent/Phantom.Agent.Minecraft/Launcher/Types/ForgeLauncher.cs

@@ -0,0 +1,12 @@
+using Phantom.Agent.Minecraft.Instance;
+using Phantom.Agent.Minecraft.Java;
+
+namespace Phantom.Agent.Minecraft.Launcher.Types; 
+
+public class ForgeLauncher : BaseLauncher {
+	public ForgeLauncher(InstanceProperties instanceProperties) : base(instanceProperties) {}
+	
+	private protected override void CustomizeJvmArguments(JvmArgumentBuilder arguments) {
+		arguments.AddProperty("terminal.ansi", "true"); // TODO
+	}
+}

Agent/Phantom.Agent.Minecraft/Launcher/Types/InvalidLauncher.cs

@@ -0,0 +1,14 @@
+using Phantom.Agent.Minecraft.Server;
+using Serilog;
+
+namespace Phantom.Agent.Minecraft.Launcher.Types; 
+
+public sealed class InvalidLauncher : IServerLauncher {
+	public static InvalidLauncher Instance { get; } = new ();
+	
+	private InvalidLauncher() {}
+	
+	public Task<LaunchResult> Launch(ILogger logger, LaunchServices services, EventHandler<DownloadProgressEventArgs> downloadProgressEventHandler, CancellationToken cancellationToken) {
+		return Task.FromResult<LaunchResult>(new LaunchResult.CouldNotPrepareMinecraftServerLauncher());
+	}
+}

Agent/Phantom.Agent.Minecraft/Server/MinecraftServerExecutableDownloader.cs

@@ -1,6 +1,6 @@
 using System.Security.Cryptography;
+using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Logging;
-using Phantom.Common.Minecraft;
 using Phantom.Utils.Cryptography;
 using Phantom.Utils.IO;
 using Phantom.Utils.Runtime;
@@ -11,8 +11,6 @@ namespace Phantom.Agent.Minecraft.Server;
 sealed class MinecraftServerExecutableDownloader {
 	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftServerExecutableDownloader>();
 
-	private readonly MinecraftVersions minecraftVersions;
-	
 	public Task<string?> Task { get; }
 	public event EventHandler<DownloadProgressEventArgs>? DownloadProgress;
 	public event EventHandler? Completed;
@@ -20,17 +18,15 @@ sealed class MinecraftServerExecutableDownloader {
 	private readonly CancellationTokenSource cancellationTokenSource = new ();
 	private int listeners = 0;
 
-	public MinecraftServerExecutableDownloader(MinecraftVersions minecraftVersions, string version, string filePath, MinecraftServerExecutableDownloadListener listener) {
+	public MinecraftServerExecutableDownloader(FileDownloadInfo fileDownloadInfo, string minecraftVersion, string filePath, MinecraftServerExecutableDownloadListener listener) {
-		this.minecraftVersions = minecraftVersions;
-		
 		Register(listener);
-		Task = DownloadAndGetPath(version, filePath);
+		Task = DownloadAndGetPath(fileDownloadInfo, minecraftVersion, filePath);
 		Task.ContinueWith(OnCompleted, TaskScheduler.Default);
 	}
 
 	public void Register(MinecraftServerExecutableDownloadListener listener) {
 		++listeners;
-		Logger.Verbose("Registered download listener, current listener count: {Listeners}", listeners);
+		Logger.Debug("Registered download listener, current listener count: {Listeners}", listeners);
 		
 		DownloadProgress += listener.DownloadProgressEventHandler;
 		listener.CancellationToken.Register(Unregister, listener);
@@ -41,11 +37,11 @@ sealed class MinecraftServerExecutableDownloader {
 		DownloadProgress -= listener.DownloadProgressEventHandler;
 
 		if (--listeners <= 0) {
-			Logger.Verbose("Unregistered last download listener, cancelling download.");
+			Logger.Debug("Unregistered last download listener, cancelling download.");
 			cancellationTokenSource.Cancel();
 		}
 		else {
-			Logger.Verbose("Unregistered download listener, current listener count: {Listeners}", listeners);
+			Logger.Debug("Unregistered download listener, current listener count: {Listeners}", listeners);
 		}
 	}
 
@@ -54,7 +50,7 @@ sealed class MinecraftServerExecutableDownloader {
 	}
 
 	private void OnCompleted(Task task) {
-		Logger.Verbose("Download task completed.");
+		Logger.Debug("Download task completed.");
 		Completed?.Invoke(this, EventArgs.Empty);
 		Completed = null;
 		DownloadProgress = null;
@@ -72,33 +68,26 @@ sealed class MinecraftServerExecutableDownloader {
 		}
 	}
 
-	private async Task<string?> DownloadAndGetPath(string version, string filePath) {
+	private async Task<string?> DownloadAndGetPath(FileDownloadInfo fileDownloadInfo, string minecraftVersion, string filePath) {
-		Logger.Information("Downloading server version {Version}...", version);
-
 		string tmpFilePath = filePath + ".tmp";
 
 		var cancellationToken = cancellationTokenSource.Token;
 		try {
-			var serverExecutableInfo = await minecraftVersions.GetServerExecutableInfo(version, cancellationToken);
+			Logger.Information("Downloading server version {Version} from: {Url} ({Size})", minecraftVersion, fileDownloadInfo.DownloadUrl, fileDownloadInfo.Size.ToHumanReadable(decimalPlaces: 1));
-			if (serverExecutableInfo == null) {
-				return null;
-			}
-
-			Logger.Information("Downloading server executable from: {Url} ({Size})", serverExecutableInfo.DownloadUrl, serverExecutableInfo.Size.ToHumanReadable(decimalPlaces: 1));
 			try {
 				using var http = new HttpClient();
-				await FetchServerExecutableFile(http, new DownloadProgressCallback(this), serverExecutableInfo, tmpFilePath, cancellationToken);
+				await FetchServerExecutableFile(http, new DownloadProgressCallback(this), fileDownloadInfo, tmpFilePath, cancellationToken);
 			} catch (Exception) {
 				TryDeleteExecutableAfterFailure(tmpFilePath);
 				throw;
 			}
 
 			File.Move(tmpFilePath, filePath, true);
-			Logger.Information("Server version {Version} downloaded.", version);
+			Logger.Information("Server version {Version} downloaded.", minecraftVersion);
 
 			return filePath;
 		} catch (OperationCanceledException) {
-			Logger.Information("Download for server version {Version} was cancelled.", version);
+			Logger.Information("Download for server version {Version} was cancelled.", minecraftVersion);
 			throw;
 		} catch (StopProcedureException) {
 			return null;
@@ -110,17 +99,17 @@ sealed class MinecraftServerExecutableDownloader {
 		}
 	}
 
-	private static async Task FetchServerExecutableFile(HttpClient http, DownloadProgressCallback progressCallback, MinecraftServerExecutableInfo info, string filePath, CancellationToken cancellationToken) {
+	private static async Task FetchServerExecutableFile(HttpClient http, DownloadProgressCallback progressCallback, FileDownloadInfo fileDownloadInfo, string filePath, CancellationToken cancellationToken) {
 		Sha1String downloadedFileHash;
 
 		try {
-			var response = await http.GetAsync(info.DownloadUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+			var response = await http.GetAsync(fileDownloadInfo.DownloadUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
 			response.EnsureSuccessStatusCode();
 
 			await using var fileStream = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.Read);
 			await using var responseStream = await response.Content.ReadAsStreamAsync(cancellationToken);
 
-			using var streamCopier = new MinecraftServerDownloadStreamCopier(progressCallback, info.Size.Bytes);
+			using var streamCopier = new MinecraftServerDownloadStreamCopier(progressCallback, fileDownloadInfo.Size.Bytes);
 			downloadedFileHash = await streamCopier.Copy(responseStream, fileStream, cancellationToken);
 		} catch (OperationCanceledException) {
 			throw;
@@ -129,8 +118,8 @@ sealed class MinecraftServerExecutableDownloader {
 			throw StopProcedureException.Instance;
 		}
 
-		if (!downloadedFileHash.Equals(info.Hash)) {
+		if (!downloadedFileHash.Equals(fileDownloadInfo.Hash)) {
-			Logger.Error("Downloaded server executable has mismatched SHA1 hash. Expected {Expected}, got {Actual}.", info.Hash, downloadedFileHash);
+			Logger.Error("Downloaded server executable has mismatched SHA1 hash. Expected {Expected}, got {Actual}.", fileDownloadInfo.Hash, downloadedFileHash);
 			throw StopProcedureException.Instance;
 		}
 	}

Agent/Phantom.Agent.Minecraft/Server/MinecraftServerExecutables.cs

@@ -1,32 +1,37 @@
 using System.Text.RegularExpressions;
+using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Logging;
-using Phantom.Common.Minecraft;
 using Phantom.Utils.IO;
 using Serilog;
 
 namespace Phantom.Agent.Minecraft.Server;
 
-public sealed class MinecraftServerExecutables : IDisposable {
+public sealed partial class MinecraftServerExecutables {
 	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftServerExecutables>();
 
-	private static readonly Regex VersionFolderSanitizeRegex = new (@"[^a-zA-Z0-9_\-\.]", RegexOptions.Compiled);
+	[GeneratedRegex(@"[^a-zA-Z0-9_\-\.]", RegexOptions.Compiled)]
+	private static partial Regex VersionFolderSanitizeRegex();
 
 	private readonly string basePath;
-	private readonly MinecraftVersions minecraftVersions = new ();
 	private readonly Dictionary<string, MinecraftServerExecutableDownloader> runningDownloadersByVersion = new ();
 
 	public MinecraftServerExecutables(string basePath) {
 		this.basePath = basePath;
 	}
 
-	internal async Task<string?> DownloadAndGetPath(string version, EventHandler<DownloadProgressEventArgs> progressEventHandler, CancellationToken cancellationToken) {
+	internal async Task<string?> DownloadAndGetPath(FileDownloadInfo? fileDownloadInfo, string minecraftVersion, EventHandler<DownloadProgressEventArgs> progressEventHandler, CancellationToken cancellationToken) {
-		string serverExecutableFolderPath = Path.Combine(basePath, VersionFolderSanitizeRegex.Replace(version, "_"));
+		string serverExecutableFolderPath = Path.Combine(basePath, VersionFolderSanitizeRegex().Replace(minecraftVersion, "_"));
 		string serverExecutableFilePath = Path.Combine(serverExecutableFolderPath, "server.jar");
 
 		if (File.Exists(serverExecutableFilePath)) {
 			return serverExecutableFilePath;
 		}
 
+		if (fileDownloadInfo == null) {
+			Logger.Error("Unable to download server executable for version {Version} because no download info was provided.", minecraftVersion);
+			return null;
+		}
+
 		try {
 			Directories.Create(serverExecutableFolderPath, Chmod.URWX_GRX);
 		} catch (Exception e) {
@@ -38,26 +43,22 @@ public sealed class MinecraftServerExecutables : IDisposable {
 		MinecraftServerExecutableDownloadListener listener = new (progressEventHandler, cancellationToken);
 
 		lock (this) {
-			if (runningDownloadersByVersion.TryGetValue(version, out downloader)) {
+			if (runningDownloadersByVersion.TryGetValue(minecraftVersion, out downloader)) {
-				Logger.Information("A download for server version {Version} is already running, waiting for it to finish...", version);
+				Logger.Information("A download for server version {Version} is already running, waiting for it to finish...", minecraftVersion);
 				downloader.Register(listener);
 			}
 			else {
-				downloader = new MinecraftServerExecutableDownloader(minecraftVersions, version, serverExecutableFilePath, listener);
+				downloader = new MinecraftServerExecutableDownloader(fileDownloadInfo, minecraftVersion, serverExecutableFilePath, listener);
 				downloader.Completed += (_, _) => {
 					lock (this) {
-						runningDownloadersByVersion.Remove(version);
+						runningDownloadersByVersion.Remove(minecraftVersion);
 					}
 				};
 
-				runningDownloadersByVersion[version] = downloader;
+				runningDownloadersByVersion[minecraftVersion] = downloader;
 			}
 		}
 
 		return await downloader.Task.WaitAsync(cancellationToken);
 	}
-
-	public void Dispose() {
-		minecraftVersions.Dispose();
-	}
 }

Agent/Phantom.Agent.Minecraft/Server/ServerStatusProtocol.cs

@@ -0,0 +1,93 @@
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using Phantom.Common.Logging;
+using Serilog;
+
+namespace Phantom.Agent.Minecraft.Server; 
+
+public sealed class ServerStatusProtocol {
+	private readonly ILogger logger;
+
+	public ServerStatusProtocol(string loggerName) {
+		this.logger = PhantomLogger.Create<ServerStatusProtocol>(loggerName);
+	}
+
+	public async Task<int?> GetOnlinePlayerCount(int serverPort, CancellationToken cancellationToken) {
+		try {
+			return await GetOnlinePlayerCountOrThrow(serverPort, cancellationToken);
+		} catch (Exception e) {
+			logger.Error(e, "Caught exception while checking if players are online.");
+			return null;
+		}
+	}
+
+	private async Task<int?> GetOnlinePlayerCountOrThrow(int serverPort, CancellationToken cancellationToken) {
+		using var tcpClient = new TcpClient();
+		await tcpClient.ConnectAsync(IPAddress.Loopback, serverPort, cancellationToken);
+		var tcpStream = tcpClient.GetStream();
+		
+		// https://wiki.vg/Server_List_Ping
+		tcpStream.WriteByte(0xFE);
+		await tcpStream.FlushAsync(cancellationToken);
+
+		short? messageLength = await ReadStreamHeader(tcpStream, cancellationToken);
+		return messageLength == null ? null : await ReadOnlinePlayerCount(tcpStream, messageLength.Value * 2, cancellationToken);
+	}
+
+	private async Task<short?> ReadStreamHeader(NetworkStream tcpStream, CancellationToken cancellationToken) {
+		var headerBuffer = ArrayPool<byte>.Shared.Rent(3);
+		try {
+			await tcpStream.ReadExactlyAsync(headerBuffer, 0, 3, cancellationToken);
+
+			if (headerBuffer[0] != 0xFF) {
+				logger.Error("Unexpected first byte in response from server: {FirstByte}.", headerBuffer[0]);
+				return null;
+			}
+
+			short messageLength = BinaryPrimitives.ReadInt16BigEndian(headerBuffer.AsSpan(1));
+			if (messageLength <= 0) {
+				logger.Error("Unexpected message length in response from server: {MessageLength}.", messageLength);
+				return null;
+			}
+			
+			return messageLength;
+		} finally {
+			ArrayPool<byte>.Shared.Return(headerBuffer);
+		}
+	}
+
+	private async Task<int?> ReadOnlinePlayerCount(NetworkStream tcpStream, int messageLength, CancellationToken cancellationToken) {
+		var messageBuffer = ArrayPool<byte>.Shared.Rent(messageLength);
+		try {
+			await tcpStream.ReadExactlyAsync(messageBuffer, 0, messageLength, cancellationToken);
+
+			// Valid response separator encoded in UTF-16BE is 0x00 0xA7 (§).
+			const byte SeparatorSecondByte = 0xA7;
+			
+			static bool IsValidSeparator(ReadOnlySpan<byte> buffer, int index) {
+				return index > 0 && buffer[index - 1] == 0x00;
+			}
+			
+			int separator2 = Array.LastIndexOf(messageBuffer, SeparatorSecondByte);
+			int separator1 = separator2 == -1 ? -1 : Array.LastIndexOf(messageBuffer, SeparatorSecondByte, separator2 - 1);
+			if (!IsValidSeparator(messageBuffer, separator1) || !IsValidSeparator(messageBuffer, separator2)) {
+				logger.Error("Could not find message separators in response from server.");
+				return null;
+			}
+
+			string onlinePlayerCountStr = Encoding.BigEndianUnicode.GetString(messageBuffer[(separator1 + 1)..(separator2 - 1)]);
+			if (!int.TryParse(onlinePlayerCountStr, out int onlinePlayerCount)) {
+				logger.Error("Could not parse online player count in response from server: {OnlinePlayerCount}.", onlinePlayerCountStr);
+				return null;
+			}
+			
+			logger.Debug("Detected {OnlinePlayerCount} online player(s).", onlinePlayerCount);
+			return onlinePlayerCount;
+		} finally {
+			ArrayPool<byte>.Shared.Return(messageBuffer);
+		}
+	}
+}

Agent/Phantom.Agent.Rpc/KeepAliveLoop.cs

@@ -1,6 +1,5 @@
 using Phantom.Common.Logging;
 using Phantom.Common.Messages.ToServer;
-using Phantom.Utils.Runtime;
 using Serilog;
 
 namespace Phantom.Agent.Rpc;
@@ -13,9 +12,9 @@ sealed class KeepAliveLoop {
 	private readonly RpcServerConnection connection;
 	private readonly CancellationTokenSource cancellationTokenSource = new ();
 
-	public KeepAliveLoop(RpcServerConnection connection, TaskManager taskManager) {
+	public KeepAliveLoop(RpcServerConnection connection) {
 		this.connection = connection;
-		taskManager.Run(Run);
+		Task.Run(Run);
 	}
 
 	private async Task Run() {

Agent/Phantom.Agent.Rpc/RpcLauncher.cs

@@ -2,6 +2,7 @@
 using NetMQ.Sockets;
 using Phantom.Common.Data.Agent;
 using Phantom.Common.Messages;
+using Phantom.Common.Messages.BiDirectional;
 using Phantom.Common.Messages.ToServer;
 using Phantom.Utils.Rpc;
 using Phantom.Utils.Rpc.Message;
@@ -30,7 +31,7 @@ public sealed class RpcLauncher : RpcRuntime<ClientSocket> {
 	private readonly SemaphoreSlim disconnectSemaphore;
 	private readonly CancellationToken receiveCancellationToken;
 
-	private RpcLauncher(RpcConfiguration config, ClientSocket socket, Guid agentGuid, Func<RpcServerConnection, IMessageToAgentListener> messageListenerFactory, SemaphoreSlim disconnectSemaphore, CancellationToken receiveCancellationToken) : base(socket, config.Logger) {
+	private RpcLauncher(RpcConfiguration config, ClientSocket socket, Guid agentGuid, Func<RpcServerConnection, IMessageToAgentListener> messageListenerFactory, SemaphoreSlim disconnectSemaphore, CancellationToken receiveCancellationToken) : base(config, socket) {
 		this.config = config;
 		this.agentGuid = agentGuid;
 		this.messageListenerFactory = messageListenerFactory;
@@ -39,7 +40,7 @@ public sealed class RpcLauncher : RpcRuntime<ClientSocket> {
 	}
 
 	protected override void Connect(ClientSocket socket) {
-		var logger = config.Logger;
+		var logger = config.RuntimeLogger;
 		var url = config.TcpUrl;
 
 		logger.Information("Starting ZeroMQ client and connecting to {Url}...", url);
@@ -51,9 +52,9 @@ public sealed class RpcLauncher : RpcRuntime<ClientSocket> {
 		var connection = new RpcServerConnection(socket, replyTracker);
 		ServerMessaging.SetCurrentConnection(connection);
 		
-		var logger = config.Logger;
+		var logger = config.RuntimeLogger;
 		var handler = new MessageToAgentHandler(messageListenerFactory(connection), logger, taskManager, receiveCancellationToken);
-		var keepAliveLoop = new KeepAliveLoop(connection, taskManager);
+		var keepAliveLoop = new KeepAliveLoop(connection);
 
 		try {
 			while (!receiveCancellationToken.IsCancellationRequested) {
@@ -68,7 +69,7 @@ public sealed class RpcLauncher : RpcRuntime<ClientSocket> {
 		} catch (OperationCanceledException) {
 			// Ignore.
 		} finally {
-			logger.Verbose("ZeroMQ client stopped receiving messages.");
+			logger.Debug("ZeroMQ client stopped receiving messages.");
 
 			disconnectSemaphore.Wait(CancellationToken.None);
 			keepAliveLoop.Cancel();
@@ -92,7 +93,7 @@ public sealed class RpcLauncher : RpcRuntime<ClientSocket> {
 		var unregisterTimeoutTask = Task.Delay(TimeSpan.FromSeconds(5), CancellationToken.None);
 		var finishedTask = await Task.WhenAny(ServerMessaging.Send(new UnregisterAgentMessage(agentGuid)), unregisterTimeoutTask);
 		if (finishedTask == unregisterTimeoutTask) {
-			config.Logger.Error("Timed out communicating agent shutdown with the server.");
+			config.RuntimeLogger.Error("Timed out communicating agent shutdown with the server.");
 		}
 	}
 

Agent/Phantom.Agent.Rpc/RpcServerConnection.cs

@@ -1,7 +1,7 @@
 using NetMQ;
 using NetMQ.Sockets;
 using Phantom.Common.Messages;
-using Phantom.Common.Messages.ToServer;
+using Phantom.Common.Messages.BiDirectional;
 using Phantom.Utils.Rpc.Message;
 
 namespace Phantom.Agent.Rpc; 
@@ -15,29 +15,24 @@ public sealed class RpcServerConnection {
 		this.replyTracker = replyTracker;
 	}
 
-	private byte[] WriteBytes<TMessage, TReply>(TMessage message) where TMessage : IMessageToServer<TReply> {
-		return MessageRegistries.ToServer.Write<TMessage, TReply>(message).ToArray();
-	}
-
 	internal async Task Send<TMessage>(TMessage message) where TMessage : IMessageToServer {
-		var bytes = WriteBytes<TMessage, NoReply>(message);
+		var bytes = MessageRegistries.ToServer.Write(message).ToArray();
 		if (bytes.Length > 0) {
 			await socket.SendAsync(bytes);
 		}
 	}
 
-	internal async Task<TReply?> Send<TMessage, TReply>(Func<uint, TMessage> messageFactory, TimeSpan waitForReplyTime, CancellationToken cancellationToken) where TMessage : IMessageToServer<TReply> where TReply : class {
+	internal async Task<TReply?> Send<TMessage, TReply>(TMessage message, TimeSpan waitForReplyTime, CancellationToken waitForReplyCancellationToken) where TMessage : IMessageToServer<TReply> where TReply : class {
 		var sequenceId = replyTracker.RegisterReply();
-		var message = messageFactory(sequenceId);
 		
-		var bytes = WriteBytes<TMessage, TReply>(message);
+		var bytes = MessageRegistries.ToServer.Write<TMessage, TReply>(sequenceId, message).ToArray();
 		if (bytes.Length == 0) {
 			replyTracker.ForgetReply(sequenceId);
 			return null;
 		}
 
 		await socket.SendAsync(bytes);
-		return await replyTracker.WaitForReply<TReply>(message.SequenceId, waitForReplyTime, cancellationToken);
+		return await replyTracker.WaitForReply<TReply>(sequenceId, waitForReplyTime, waitForReplyCancellationToken);
 	}
 
 	public void Receive(ReplyMessage message) {

Agent/Phantom.Agent.Rpc/ServerMessaging.cs

@@ -5,7 +5,7 @@ using Serilog;
 namespace Phantom.Agent.Rpc;
 
 public static class ServerMessaging {
-	private static readonly ILogger Logger = PhantomLogger.Create(typeof(ServerMessaging));
+	private static readonly ILogger Logger = PhantomLogger.Create(nameof(ServerMessaging));
 	
 	private static RpcServerConnection? CurrentConnection { get; set; }
 	private static RpcServerConnection CurrentConnectionOrThrow => CurrentConnection ?? throw new InvalidOperationException("Server connection not ready.");
@@ -28,7 +28,7 @@ public static class ServerMessaging {
 		return CurrentConnectionOrThrow.Send(message);
 	}
 
-	public static Task<TReply?> Send<TMessage, TReply>(Func<uint, TMessage> messageFactory, TimeSpan waitForReplyTime, CancellationToken cancellationToken) where TMessage : IMessageToServer<TReply> where TReply : class {
+	public static Task<TReply?> Send<TMessage, TReply>(TMessage message, TimeSpan waitForReplyTime, CancellationToken waitForReplyCancellationToken) where TMessage : IMessageToServer<TReply> where TReply : class {
-		return CurrentConnectionOrThrow.Send<TMessage, TReply>(messageFactory, waitForReplyTime, cancellationToken);
+		return CurrentConnectionOrThrow.Send<TMessage, TReply>(message, waitForReplyTime, waitForReplyCancellationToken);
 	}
 }

Agent/Phantom.Agent.Services/AgentFolders.cs

@@ -9,6 +9,7 @@ public sealed class AgentFolders {
 
 	public string DataFolderPath { get; }
 	public string InstancesFolderPath { get; }
+	public string BackupsFolderPath { get; }
 
 	public string TemporaryFolderPath { get; }
 	public string ServerExecutableFolderPath { get; }
@@ -18,6 +19,7 @@ public sealed class AgentFolders {
 	public AgentFolders(string dataFolderPath, string temporaryFolderPath, string javaSearchFolderPath) {
 		this.DataFolderPath = Path.GetFullPath(dataFolderPath);
 		this.InstancesFolderPath = Path.Combine(DataFolderPath, "instances");
+		this.BackupsFolderPath = Path.Combine(DataFolderPath, "backups");
 		
 		this.TemporaryFolderPath = Path.GetFullPath(temporaryFolderPath);
 		this.ServerExecutableFolderPath = Path.Combine(TemporaryFolderPath, "servers");
@@ -28,6 +30,7 @@ public sealed class AgentFolders {
 	public bool TryCreate() {
 		return TryCreateFolder(DataFolderPath) &&
 		       TryCreateFolder(InstancesFolderPath) &&
+		       TryCreateFolder(BackupsFolderPath) &&
 		       TryCreateFolder(TemporaryFolderPath) &&
 		       TryCreateFolder(ServerExecutableFolderPath);
 	}

Agent/Phantom.Agent.Services/AgentServices.cs

@@ -1,4 +1,5 @@
 using Phantom.Agent.Minecraft.Java;
+using Phantom.Agent.Services.Backups;
 using Phantom.Agent.Services.Instances;
 using Phantom.Common.Data.Agent;
 using Phantom.Common.Logging;
@@ -12,15 +13,17 @@ public sealed class AgentServices {
 	
 	private AgentFolders AgentFolders { get; }
 	private TaskManager TaskManager { get; }
+	private BackupManager BackupManager { get; }
 
 	internal JavaRuntimeRepository JavaRuntimeRepository { get; }
 	internal InstanceSessionManager InstanceSessionManager { get; }
 
 	public AgentServices(AgentInfo agentInfo, AgentFolders agentFolders) {
 		this.AgentFolders = agentFolders;
-		this.TaskManager = new TaskManager();
+		this.TaskManager = new TaskManager(PhantomLogger.Create<TaskManager, AgentServices>());
+		this.BackupManager = new BackupManager(agentFolders);
 		this.JavaRuntimeRepository = new JavaRuntimeRepository();
-		this.InstanceSessionManager = new InstanceSessionManager(agentInfo, agentFolders, JavaRuntimeRepository, TaskManager);
+		this.InstanceSessionManager = new InstanceSessionManager(agentInfo, agentFolders, JavaRuntimeRepository, TaskManager, BackupManager);
 	}
 
 	public async Task Initialize() {
@@ -30,10 +33,11 @@ public sealed class AgentServices {
 	}
 
 	public async Task Shutdown() {
-		Logger.Information("Stopping instances...");
+		Logger.Information("Stopping services...");
-		await InstanceSessionManager.StopAll();
+		
+		await InstanceSessionManager.StopAll();
+		InstanceSessionManager.Dispose();
 		
-		Logger.Information("Stopping task manager...");
 		await TaskManager.Stop();
 		
 		Logger.Information("Services stopped.");

Agent/Phantom.Agent.Services/Backups/BackupArchiver.cs

@@ -0,0 +1,180 @@
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Formats.Tar;
+using Phantom.Agent.Minecraft.Instance;
+using Phantom.Common.Data.Backups;
+using Phantom.Common.Logging;
+using Phantom.Utils.IO;
+using Serilog;
+
+namespace Phantom.Agent.Services.Backups; 
+
+sealed class BackupArchiver {
+	private readonly string destinationBasePath;
+	private readonly string temporaryBasePath;
+	private readonly ILogger logger;
+	private readonly InstanceProperties instanceProperties;
+	private readonly CancellationToken cancellationToken;
+	
+	public BackupArchiver(string destinationBasePath, string temporaryBasePath, string loggerName, InstanceProperties instanceProperties, CancellationToken cancellationToken) {
+		this.destinationBasePath = destinationBasePath;
+		this.temporaryBasePath = temporaryBasePath;
+		this.logger = PhantomLogger.Create<BackupArchiver>(loggerName);
+		this.instanceProperties = instanceProperties;
+		this.cancellationToken = cancellationToken;
+	}
+
+	private bool IsFolderSkipped(ImmutableList<string> relativePath) {
+		return relativePath is ["cache" or "crash-reports" or "debug" or "libraries" or "logs" or "mods" or "versions"];
+	}
+	
+	[SuppressMessage("ReSharper", "ConvertIfStatementToReturnStatement")]
+	private bool IsFileSkipped(ImmutableList<string> relativePath) {
+		var name = relativePath[^1];
+		
+		if (relativePath.Count == 2 && name == "session.lock") {
+			return true;
+		}
+
+		var extension = Path.GetExtension(name);
+		if (extension is ".jar" or ".zip") {
+			return true;
+		}
+		
+		return false;
+	}
+
+	public async Task<string?> ArchiveWorld(BackupCreationResult.Builder resultBuilder) {
+		string guid = instanceProperties.InstanceGuid.ToString();
+		string currentDateTime = DateTime.Now.ToString("yyyyMMdd-HHmmss");
+		string backupFolderPath = Path.Combine(destinationBasePath, guid);
+		string backupFilePath = Path.Combine(backupFolderPath, currentDateTime + ".tar");
+		
+		if (File.Exists(backupFilePath)) {
+			resultBuilder.Kind = BackupCreationResultKind.BackupFileAlreadyExists;
+			logger.Warning("Skipping backup, file already exists: {File}", backupFilePath);
+			return null;
+		}
+		
+		try {
+			Directories.Create(backupFolderPath, Chmod.URWX_GRX);
+		} catch (Exception e) {
+			resultBuilder.Kind = BackupCreationResultKind.CouldNotCreateBackupFolder;
+			logger.Error(e, "Could not create backup folder: {Folder}", backupFolderPath);
+			return null;
+		}
+
+		string temporaryFolderPath = Path.Combine(temporaryBasePath, guid + "_" + currentDateTime);
+		if (!await CopyWorldAndCreateTarArchive(temporaryFolderPath, backupFilePath, resultBuilder)) {
+			return null;
+		}
+		
+		logger.Debug("Created world backup: {FilePath}", backupFilePath);
+		return backupFilePath;
+	}
+
+	private async Task<bool> CopyWorldAndCreateTarArchive(string temporaryFolderPath, string backupFilePath, BackupCreationResult.Builder resultBuilder) {
+		try {
+			if (!await CopyWorldToTemporaryFolder(temporaryFolderPath)) {
+				resultBuilder.Kind = BackupCreationResultKind.CouldNotCopyWorldToTemporaryFolder;
+				return false;
+			}
+
+			if (!await CreateTarArchive(temporaryFolderPath, backupFilePath)) {
+				resultBuilder.Kind = BackupCreationResultKind.CouldNotCreateWorldArchive;
+				return false;
+			}
+
+			return true;
+		} finally {
+			try {
+				Directory.Delete(temporaryFolderPath, recursive: true);
+			} catch (Exception e) {
+				resultBuilder.Warnings |= BackupCreationWarnings.CouldNotDeleteTemporaryFolder;
+				logger.Error(e, "Could not delete temporary world folder: {Folder}", temporaryFolderPath);
+			}
+		}
+	}
+
+	private async Task<bool> CopyWorldToTemporaryFolder(string temporaryFolderPath) {
+		try {
+			await CopyDirectory(new DirectoryInfo(instanceProperties.InstanceFolder), temporaryFolderPath, ImmutableList<string>.Empty);
+			return true;
+		} catch (Exception e) {
+			logger.Error(e, "Could not copy world to temporary folder.");
+			return false;
+		}
+	}
+
+	private async Task<bool> CreateTarArchive(string sourceFolderPath, string backupFilePath) {
+		try {
+			await TarFile.CreateFromDirectoryAsync(sourceFolderPath, backupFilePath, false, cancellationToken);
+			return true;
+		} catch (Exception e) {
+			logger.Error(e, "Could not create archive.");
+			DeleteBrokenArchiveFile(backupFilePath);
+			return false;
+		}
+	}
+
+	private void DeleteBrokenArchiveFile(string filePath) {
+		if (File.Exists(filePath)) {
+			try {
+				File.Delete(filePath);
+			} catch (Exception e) {
+				logger.Error(e, "Could not delete broken archive: {File}", filePath);
+			}
+		}
+	}
+
+	private async Task CopyDirectory(DirectoryInfo sourceFolder, string destinationFolderPath, ImmutableList<string> relativePath) {
+		cancellationToken.ThrowIfCancellationRequested();
+
+		bool needsToCreateFolder = true;
+		
+		foreach (FileInfo file in sourceFolder.EnumerateFiles()) {
+			var filePath = relativePath.Add(file.Name);
+			if (IsFileSkipped(filePath)) {
+				logger.Debug("Skipping file: {File}", string.Join('/', filePath));
+				continue;
+			}
+
+			if (needsToCreateFolder) {
+				needsToCreateFolder = false;
+				Directories.Create(destinationFolderPath, Chmod.URWX);
+			}
+
+			await CopyFileWithRetries(file, destinationFolderPath);
+		}
+
+		foreach (DirectoryInfo directory in sourceFolder.EnumerateDirectories()) {
+			var folderPath = relativePath.Add(directory.Name);
+			if (IsFolderSkipped(folderPath)) {
+				logger.Debug("Skipping folder: {Folder}", string.Join('/', folderPath));
+				continue;
+			}
+			
+			await CopyDirectory(directory, Path.Join(destinationFolderPath, directory.Name), folderPath);
+		}
+	}
+
+	private async Task CopyFileWithRetries(FileInfo sourceFile, string destinationFolderPath) {
+		var destinationFilePath = Path.Combine(destinationFolderPath, sourceFile.Name);
+		
+		const int TotalAttempts = 10;
+		for (int attempt = 1; attempt <= TotalAttempts; attempt++) {
+			try {
+				sourceFile.CopyTo(destinationFilePath);
+				return;
+			} catch (IOException) {
+				if (attempt == TotalAttempts) {
+					throw;
+				}
+				else {
+					logger.Warning("Failed copying file {File}, retrying...", sourceFile.FullName);
+					await Task.Delay(200, cancellationToken);
+				}
+			}
+		}
+	}
+}

Agent/Phantom.Agent.Services/Backups/BackupCompressor.cs

@@ -0,0 +1,69 @@
+using Phantom.Common.Logging;
+using Phantom.Utils.Runtime;
+using Serilog;
+
+namespace Phantom.Agent.Services.Backups; 
+
+static class BackupCompressor {
+	private static ILogger Logger { get; } = PhantomLogger.Create(nameof(BackupCompressor));
+	private static ILogger ZstdLogger { get; } = PhantomLogger.Create(nameof(BackupCompressor), "Zstd");
+	
+	private const string Quality = "-10";
+	private const string Memory = "--long=26";
+	private const string Threads = "-T3";
+	
+	public static async Task<string?> Compress(string sourceFilePath, CancellationToken cancellationToken) {
+		if (sourceFilePath.Contains('"')) {
+			Logger.Error("Could not compress backup, archive path contains quotes: {Path}", sourceFilePath);
+			return null;
+		}
+		
+		var destinationFilePath = sourceFilePath + ".zst";
+
+		if (!await TryCompressFile(sourceFilePath, destinationFilePath, cancellationToken)) {
+			try {
+				File.Delete(destinationFilePath);
+			} catch (Exception e) {
+				Logger.Error(e, "Could not delete compresed archive after unsuccessful compression: {Path}", destinationFilePath);
+			}
+
+			return null;
+		}
+
+		return destinationFilePath;
+	}
+
+	private static async Task<bool> TryCompressFile(string sourceFilePath, string destinationFilePath, CancellationToken cancellationToken) {
+		var workingDirectory = Path.GetDirectoryName(sourceFilePath);
+		if (string.IsNullOrEmpty(workingDirectory)) {
+			Logger.Error("Invalid destination path: {Path}", destinationFilePath);
+			return false;
+		}
+
+		var launcher = new ProcessConfigurator {
+			FileName = "zstd",
+			WorkingDirectory = workingDirectory,
+			ArgumentList = {
+				Quality,
+				Memory,
+				Threads,
+				"-c",
+				"--rm",
+				"--no-progress",
+				"-c",
+				"-o", destinationFilePath,
+				"--", sourceFilePath
+			}
+		};
+
+		static void OnZstdOutput(object? sender, Process.Output output) {
+			if (!string.IsNullOrWhiteSpace(output.Line)) {
+				ZstdLogger.Debug("[Output] {Line}", output.Line);
+			}
+		}
+
+		var process = new OneShotProcess(ZstdLogger, launcher);
+		process.OutputReceived += OnZstdOutput;
+		return await process.Run(cancellationToken);
+	}
+}

Agent/Phantom.Agent.Services/Backups/BackupManager.cs

@@ -0,0 +1,118 @@
+using Phantom.Agent.Minecraft.Instance;
+using Phantom.Common.Data.Backups;
+using Phantom.Common.Logging;
+using Serilog;
+
+namespace Phantom.Agent.Services.Backups;
+
+sealed class BackupManager {
+	private readonly string destinationBasePath;
+	private readonly string temporaryBasePath;
+
+	public BackupManager(AgentFolders agentFolders) {
+		this.destinationBasePath = agentFolders.BackupsFolderPath;
+		this.temporaryBasePath = Path.Combine(agentFolders.TemporaryFolderPath, "backups");
+	}
+
+	public async Task<BackupCreationResult> CreateBackup(string loggerName, InstanceProcess process, CancellationToken cancellationToken) {
+		try {
+			if (!await process.BackupSemaphore.Wait(TimeSpan.FromSeconds(1), cancellationToken)) {
+				return new BackupCreationResult(BackupCreationResultKind.BackupAlreadyRunning);
+			}
+		} catch (ObjectDisposedException) {
+			return new BackupCreationResult(BackupCreationResultKind.InstanceNotRunning);
+		} catch (OperationCanceledException) {
+			return new BackupCreationResult(BackupCreationResultKind.InstanceNotRunning);
+		}
+
+		try {
+			return await new BackupCreator(destinationBasePath, temporaryBasePath, loggerName, process, cancellationToken).CreateBackup();
+		} finally {
+			process.BackupSemaphore.Release();
+		}
+	}
+
+	private sealed class BackupCreator {
+		private readonly string destinationBasePath;
+		private readonly string temporaryBasePath;
+		private readonly string loggerName;
+		private readonly ILogger logger;
+		private readonly InstanceProcess process;
+		private readonly CancellationToken cancellationToken;
+
+		public BackupCreator(string destinationBasePath, string temporaryBasePath, string loggerName, InstanceProcess process, CancellationToken cancellationToken) {
+			this.destinationBasePath = destinationBasePath;
+			this.temporaryBasePath = temporaryBasePath;
+			this.loggerName = loggerName;
+			this.logger = PhantomLogger.Create<BackupManager>(loggerName);
+			this.process = process;
+			this.cancellationToken = cancellationToken;
+		}
+
+		public async Task<BackupCreationResult> CreateBackup() {
+			logger.Information("Backup started.");
+			
+			var resultBuilder = new BackupCreationResult.Builder();
+			string? backupFilePath;
+			
+			using (var dispatcher = new BackupServerCommandDispatcher(logger, process, cancellationToken)) {
+				backupFilePath = await CreateWorldArchive(dispatcher, resultBuilder);
+			}
+			
+			if (backupFilePath != null) {
+				await CompressWorldArchive(backupFilePath, resultBuilder);
+			}
+			
+			var result = resultBuilder.Build();
+			LogBackupResult(result);
+			return result;
+		}
+
+		private async Task<string?> CreateWorldArchive(BackupServerCommandDispatcher dispatcher, BackupCreationResult.Builder resultBuilder) {
+			try {
+				await dispatcher.DisableAutomaticSaving();
+				await dispatcher.SaveAllChunks();
+				return await new BackupArchiver(destinationBasePath, temporaryBasePath, loggerName, process.InstanceProperties, cancellationToken).ArchiveWorld(resultBuilder);
+			} catch (OperationCanceledException) {
+				resultBuilder.Kind = BackupCreationResultKind.BackupCancelled;
+				logger.Warning("Backup creation was cancelled.");
+				return null;
+			} catch (Exception e) {
+				resultBuilder.Kind = BackupCreationResultKind.UnknownError;
+				logger.Error(e, "Caught exception while creating an instance backup.");
+				return null;
+			} finally {
+				try {
+					await dispatcher.EnableAutomaticSaving();
+				} catch (OperationCanceledException) {
+					// ignore
+				} catch (Exception e) {
+					resultBuilder.Warnings |= BackupCreationWarnings.CouldNotRestoreAutomaticSaving;
+					logger.Error(e, "Caught exception while enabling automatic saving after creating an instance backup.");
+				}
+			}
+		}
+
+		private async Task CompressWorldArchive(string filePath, BackupCreationResult.Builder resultBuilder) {
+			var compressedFilePath = await BackupCompressor.Compress(filePath, cancellationToken);
+			if (compressedFilePath == null) {
+				resultBuilder.Warnings |= BackupCreationWarnings.CouldNotCompressWorldArchive;
+			}
+		}
+
+		private void LogBackupResult(BackupCreationResult result) {
+			if (result.Kind != BackupCreationResultKind.Success) {
+				logger.Warning("Backup failed: {Reason}", result.Kind.ToSentence());
+				return;
+			}
+			
+			var warningCount = result.Warnings.Count();
+			if (warningCount > 0) {
+				logger.Warning("Backup finished with {Warnings} warning(s).", warningCount);
+			}
+			else {
+				logger.Information("Backup finished successfully.");
+			}
+		}
+	}
+}

Agent/Phantom.Agent.Services/Backups/BackupScheduler.cs

@@ -0,0 +1,96 @@
+using Phantom.Agent.Minecraft.Instance;
+using Phantom.Agent.Minecraft.Server;
+using Phantom.Common.Data.Backups;
+using Phantom.Common.Logging;
+using Phantom.Utils.Runtime;
+
+namespace Phantom.Agent.Services.Backups;
+
+sealed class BackupScheduler : CancellableBackgroundTask {
+	// TODO make configurable
+	private static readonly TimeSpan InitialDelay = TimeSpan.FromMinutes(2);
+	private static readonly TimeSpan BackupInterval = TimeSpan.FromMinutes(30);
+	private static readonly TimeSpan BackupFailureRetryDelay = TimeSpan.FromMinutes(5);
+
+	private readonly string loggerName;
+	private readonly BackupManager backupManager;
+	private readonly InstanceProcess process;
+	private readonly int serverPort;
+	private readonly ServerStatusProtocol serverStatusProtocol;
+	private readonly ManualResetEventSlim serverOutputWhileWaitingForOnlinePlayers = new ();
+	
+	public event EventHandler<BackupCreationResult>? BackupCompleted; 
+
+	public BackupScheduler(TaskManager taskManager, BackupManager backupManager, InstanceProcess process, int serverPort, string loggerName) : base(PhantomLogger.Create<BackupScheduler>(loggerName), taskManager, "Backup scheduler for " + loggerName) {
+		this.loggerName = loggerName;
+		this.backupManager = backupManager;
+		this.process = process;
+		this.serverPort = serverPort;
+		this.serverStatusProtocol = new ServerStatusProtocol(loggerName);
+	}
+
+	protected override async Task RunTask() {
+		await Task.Delay(InitialDelay, CancellationToken);
+		Logger.Information("Starting a new backup after server launched.");
+			
+		while (!CancellationToken.IsCancellationRequested) {
+			var result = await CreateBackup();
+			BackupCompleted?.Invoke(this, result);
+			
+			if (result.Kind.ShouldRetry()) {
+				Logger.Warning("Scheduled backup failed, retrying in {Minutes} minutes.", BackupFailureRetryDelay.TotalMinutes);
+				await Task.Delay(BackupFailureRetryDelay, CancellationToken);
+			}
+			else {
+				Logger.Information("Scheduling next backup in {Minutes} minutes.", BackupInterval.TotalMinutes);
+				await Task.Delay(BackupInterval, CancellationToken);
+				await WaitForOnlinePlayers();
+			}
+		}
+	}
+
+	private async Task<BackupCreationResult> CreateBackup() {
+		return await backupManager.CreateBackup(loggerName, process, CancellationToken.None);
+	}
+
+	private async Task WaitForOnlinePlayers() {
+		bool needsToLogOfflinePlayersMessage = true;
+		
+		process.AddOutputListener(ServerOutputListener, maxLinesToReadFromHistory: 0);
+		try {
+			while (!CancellationToken.IsCancellationRequested) {
+				serverOutputWhileWaitingForOnlinePlayers.Reset();
+				
+				var onlinePlayerCount = await serverStatusProtocol.GetOnlinePlayerCount(serverPort, CancellationToken);
+				if (onlinePlayerCount == null) {
+					Logger.Warning("Could not detect whether any players are online, starting a new backup.");
+					break;
+				}
+
+				if (onlinePlayerCount > 0) {
+					Logger.Information("Players are online, starting a new backup.");
+					break;
+				}
+
+				if (needsToLogOfflinePlayersMessage) {
+					needsToLogOfflinePlayersMessage = false;
+					Logger.Information("No players are online, waiting for someone to join before starting a new backup.");
+				}
+
+				await Task.Delay(TimeSpan.FromSeconds(10), CancellationToken);
+				
+				Logger.Debug("Waiting for server output before checking for online players again...");
+				await serverOutputWhileWaitingForOnlinePlayers.WaitHandle.WaitOneAsync(CancellationToken);
+			}
+		} finally {
+			process.RemoveOutputListener(ServerOutputListener);
+		}
+	}
+
+	private void ServerOutputListener(object? sender, string line) {
+		if (!serverOutputWhileWaitingForOnlinePlayers.IsSet) {
+			serverOutputWhileWaitingForOnlinePlayers.Set();
+			Logger.Debug("Detected server output, signalling to check for online players again.");
+		}
+	}
+}

Agent/Phantom.Agent.Services/Backups/BackupServerCommandDispatcher.cs

@@ -0,0 +1,80 @@
+using System.Text.RegularExpressions;
+using Phantom.Agent.Minecraft.Command;
+using Phantom.Agent.Minecraft.Instance;
+using Phantom.Utils.Runtime;
+using Serilog;
+
+namespace Phantom.Agent.Services.Backups;
+
+sealed partial class BackupServerCommandDispatcher : IDisposable {
+	[GeneratedRegex(@"^\[(?:.*?)\] \[Server thread/INFO\]: (.*?)$", RegexOptions.NonBacktracking)]
+	private static partial Regex ServerThreadInfoRegex();
+
+	private readonly ILogger logger;
+	private readonly InstanceProcess process;
+	private readonly CancellationToken cancellationToken;
+
+	private readonly TaskCompletionSource automaticSavingDisabled = Tasks.CreateCompletionSource();
+	private readonly TaskCompletionSource savedTheGame = Tasks.CreateCompletionSource();
+	private readonly TaskCompletionSource automaticSavingEnabled = Tasks.CreateCompletionSource();
+
+	public BackupServerCommandDispatcher(ILogger logger, InstanceProcess process, CancellationToken cancellationToken) {
+		this.logger = logger;
+		this.process = process;
+		this.cancellationToken = cancellationToken;
+
+		this.process.AddOutputListener(OnOutput, maxLinesToReadFromHistory: 0);
+	}
+
+	void IDisposable.Dispose() {
+		process.RemoveOutputListener(OnOutput);
+	}
+
+	public async Task DisableAutomaticSaving() {
+		await process.SendCommand(MinecraftCommand.SaveOff, cancellationToken);
+		await automaticSavingDisabled.Task.WaitAsync(cancellationToken);
+	}
+
+	public async Task SaveAllChunks() {
+		// TODO Try if not flushing and waiting a few seconds before flushing reduces lag.
+		await process.SendCommand(MinecraftCommand.SaveAll(flush: true), cancellationToken);
+		await savedTheGame.Task.WaitAsync(cancellationToken);
+	}
+
+	public async Task EnableAutomaticSaving() {
+		await process.SendCommand(MinecraftCommand.SaveOn, cancellationToken);
+		await automaticSavingEnabled.Task.WaitAsync(cancellationToken);
+	}
+
+	private void OnOutput(object? sender, string? line) {
+		if (line == null) {
+			return;
+		}
+
+		var match = ServerThreadInfoRegex().Match(line);
+		if (!match.Success) {
+			return;
+		}
+
+		string info = match.Groups[1].Value;
+
+		if (!automaticSavingDisabled.Task.IsCompleted) {
+			if (info == "Automatic saving is now disabled") {
+				logger.Debug("Detected that automatic saving is disabled.");
+				automaticSavingDisabled.SetResult();
+			}
+		}
+		else if (!savedTheGame.Task.IsCompleted) {
+			if (info == "Saved the game") {
+				logger.Debug("Detected that the game is saved.");
+				savedTheGame.SetResult();
+			}
+		}
+		else if (!automaticSavingEnabled.Task.IsCompleted) {
+			if (info == "Automatic saving is now enabled") {
+				logger.Debug("Detected that automatic saving is enabled.");
+				automaticSavingEnabled.SetResult();
+			}
+		}
+	}
+}

Agent/Phantom.Agent.Services/Instances/Instance.cs

@@ -18,40 +18,62 @@ sealed class Instance : IDisposable {
 		return prefix[..prefix.IndexOf('-')] + "/" + Interlocked.Increment(ref loggerSequenceId);
 	}
 
-	public static async Task<Instance> Create(InstanceConfiguration configuration, BaseLauncher launcher, LaunchServices launchServices, PortManager portManager) {
+	private InstanceServices Services { get; }
-		var instance = new Instance(configuration, launcher, launchServices, portManager);
-		await instance.ReportLastStatus();
-		return instance;
-	}
 	
 	public InstanceConfiguration Configuration { get; private set; }
-	private BaseLauncher Launcher { get; set; }
+	private IServerLauncher Launcher { get; set; }
 
 	private readonly string shortName;
 	private readonly ILogger logger;
 
-	private readonly LaunchServices launchServices;
-	private readonly PortManager portManager;
-
 	private IInstanceStatus currentStatus;
+	private int statusUpdateCounter;
+	
 	private IInstanceState currentState;
 	private readonly SemaphoreSlim stateTransitioningActionSemaphore = new (1, 1);
 
-	private Instance(InstanceConfiguration configuration, BaseLauncher launcher, LaunchServices launchServices, PortManager portManager) {
+	public bool IsRunning => currentState is not InstanceNotRunningState;
+	
+	public event EventHandler? IsRunningChanged; 
+
+	public Instance(InstanceServices services, InstanceConfiguration configuration, IServerLauncher launcher) {
 		this.shortName = GetLoggerName(configuration.InstanceGuid);
 		this.logger = PhantomLogger.Create<Instance>(shortName);
 
+		this.Services = services;
 		this.Configuration = configuration;
 		this.Launcher = launcher;
 		
-		this.launchServices = launchServices;
-		this.portManager = portManager;
 		this.currentState = new InstanceNotRunningState();
 		this.currentStatus = InstanceStatus.NotRunning;
 	}
 
-	private async Task ReportLastStatus() {
+	private void TryUpdateStatus(string taskName, Func<Task> getUpdateTask) {
-		await ServerMessaging.Send(new ReportInstanceStatusMessage(Configuration.InstanceGuid, currentStatus));
+		int myStatusUpdateCounter = Interlocked.Increment(ref statusUpdateCounter);
+		
+		Services.TaskManager.Run(taskName, async () => {
+			if (myStatusUpdateCounter == statusUpdateCounter) {
+				await getUpdateTask();
+			}
+		});
+	}
+
+	public void ReportLastStatus() {
+		TryUpdateStatus("Report last status of instance " + shortName, async () => {
+			await ServerMessaging.Send(new ReportInstanceStatusMessage(Configuration.InstanceGuid, currentStatus));
+		});
+	}
+
+	private void ReportAndSetStatus(IInstanceStatus status) {
+		TryUpdateStatus("Report status of instance " + shortName + " as " + status.GetType().Name, async () => {
+			currentStatus = status;
+			await ServerMessaging.Send(new ReportInstanceStatusMessage(Configuration.InstanceGuid, status));
+		});
+	}
+
+	private void ReportEvent(IInstanceEvent instanceEvent) {
+		var message = new ReportInstanceEventMessage(Guid.NewGuid(), DateTime.UtcNow, Configuration.InstanceGuid, instanceEvent);
+		Services.TaskManager.Run("Report event for instance " + shortName, async () => await ServerMessaging.Send(message));
 	}
 	
 	private void TransitionState(IInstanceState newState) {
@@ -63,10 +85,15 @@ sealed class Instance : IDisposable {
 			disposable.Dispose();
 		}
 
-		logger.Verbose("Transitioning instance state to: {NewState}", newState.GetType().Name);
+		logger.Debug("Transitioning instance state to: {NewState}", newState.GetType().Name);
 		
+		var wasRunning = IsRunning;
 		currentState = newState;
 		currentState.Initialize();
+
+		if (IsRunning != wasRunning) {
+			IsRunningChanged?.Invoke(this, EventArgs.Empty);
+		}
 	}
 
 	private T TransitionStateAndReturn<T>((IInstanceState State, T Result) newStateAndResult) {
@@ -74,21 +101,20 @@ sealed class Instance : IDisposable {
 		return newStateAndResult.Result;
 	}
 
-	public async Task Reconfigure(InstanceConfiguration configuration, BaseLauncher launcher, CancellationToken cancellationToken) {
+	public async Task Reconfigure(InstanceConfiguration configuration, IServerLauncher launcher, CancellationToken cancellationToken) {
 		await stateTransitioningActionSemaphore.WaitAsync(cancellationToken);
 		try {
 			Configuration = configuration;
 			Launcher = launcher;
-			await ReportLastStatus();
 		} finally {
 			stateTransitioningActionSemaphore.Release();
 		}
 	}
 
-	public async Task<LaunchInstanceResult> Launch(CancellationToken cancellationToken) {
+	public async Task<LaunchInstanceResult> Launch(CancellationToken shutdownCancellationToken) {
-		await stateTransitioningActionSemaphore.WaitAsync(cancellationToken);
+		await stateTransitioningActionSemaphore.WaitAsync(shutdownCancellationToken);
 		try {
-			return TransitionStateAndReturn(currentState.Launch(new InstanceContextImpl(this)));
+			return TransitionStateAndReturn(currentState.Launch(new InstanceContextImpl(this, shutdownCancellationToken)));
 		} catch (Exception e) {
 			logger.Error(e, "Caught exception while launching instance.");
 			return LaunchInstanceResult.UnknownError;
@@ -126,32 +152,45 @@ sealed class Instance : IDisposable {
 
 	private sealed class InstanceContextImpl : InstanceContext {
 		private readonly Instance instance;
-		private int statusUpdateCounter;
+		private readonly CancellationToken shutdownCancellationToken;
 		
-		public InstanceContextImpl(Instance instance) : base(instance.Configuration, instance.Launcher) {
+		public InstanceContextImpl(Instance instance, CancellationToken shutdownCancellationToken) : base(instance.Services, instance.Configuration, instance.Launcher) {
 			this.instance = instance;
+			this.shutdownCancellationToken = shutdownCancellationToken;
 		}
 
-		public override LaunchServices LaunchServices => instance.launchServices;
-		public override PortManager PortManager => instance.portManager;
 		public override ILogger Logger => instance.logger;
 		public override string ShortName => instance.shortName;
 
-		public override void ReportStatus(IInstanceStatus newStatus) {
+		public override void SetStatus(IInstanceStatus newStatus) {
-			int myStatusUpdateCounter = Interlocked.Increment(ref statusUpdateCounter);
+			instance.ReportAndSetStatus(newStatus);
-			
-			instance.launchServices.TaskManager.Run(async () => {
-				if (myStatusUpdateCounter == statusUpdateCounter) {
-					instance.currentStatus = newStatus;
-					await ServerMessaging.Send(new ReportInstanceStatusMessage(Configuration.InstanceGuid, newStatus));
-				}
-			});
 		}
 
-		public override void TransitionState(Func<IInstanceState> newState) {
+		public override void ReportEvent(IInstanceEvent instanceEvent) {
-			instance.stateTransitioningActionSemaphore.Wait();
+			instance.ReportEvent(instanceEvent);
+		}
+
+		public override void TransitionState(Func<(IInstanceState, IInstanceStatus?)> newStateAndStatus) {
+			instance.stateTransitioningActionSemaphore.Wait(CancellationToken.None);
 			try {
-				instance.TransitionState(newState());
+				var (state, status) = newStateAndStatus();
+				
+				if (!instance.IsRunning) {
+					// Only InstanceSessionManager is allowed to transition an instance out of a non-running state.
+					instance.logger.Debug("Cancelled state transition to {State} because instance is not running.", state.GetType().Name);
+					return;
+				}
+				
+				if (state is not InstanceNotRunningState && shutdownCancellationToken.IsCancellationRequested) {
+					instance.logger.Debug("Cancelled state transition to {State} due to Agent shutdown.", state.GetType().Name);
+					return;
+				}
+
+				if (status != null) {
+					SetStatus(status);
+				}
+
+				instance.TransitionState(state);
 			} catch (Exception e) {
 				instance.logger.Error(e, "Caught exception during state transition.");
 			} finally {
@@ -161,10 +200,10 @@ sealed class Instance : IDisposable {
 	}
 
 	public void Dispose() {
+		stateTransitioningActionSemaphore.Dispose();
+		
 		if (currentState is IDisposable disposable) {
 			disposable.Dispose();
 		}
-
-		stateTransitioningActionSemaphore.Dispose();
 	}
 }

Agent/Phantom.Agent.Services/Instances/InstanceContext.cs

@@ -6,23 +6,30 @@ using Serilog;
 namespace Phantom.Agent.Services.Instances;
 
 abstract class InstanceContext {
+	public InstanceServices Services { get; }
 	public InstanceConfiguration Configuration { get; }
-	public BaseLauncher Launcher { get; }
+	public IServerLauncher Launcher { get; }
 	
-	public abstract LaunchServices LaunchServices { get; }
-	public abstract PortManager PortManager { get; }
 	public abstract ILogger Logger { get; }
 	public abstract string ShortName { get; }
 
-	protected InstanceContext(InstanceConfiguration configuration, BaseLauncher launcher) {
+	protected InstanceContext(InstanceServices services, InstanceConfiguration configuration, IServerLauncher launcher) {
+		Services = services;
 		Configuration = configuration;
 		Launcher = launcher;
 	}
 
-	public abstract void ReportStatus(IInstanceStatus newStatus);
+	public abstract void SetStatus(IInstanceStatus newStatus);
-	public abstract void TransitionState(Func<IInstanceState> newState);
 
-	public void TransitionState(IInstanceState newState) {
+	public void SetLaunchFailedStatusAndReportEvent(InstanceLaunchFailReason reason) {
-		TransitionState(() => newState);
+		SetStatus(InstanceStatus.Failed(reason));
+		ReportEvent(new InstanceLaunchFailedEvent(reason));
+	}
+
+	public abstract void ReportEvent(IInstanceEvent instanceEvent);
+	public abstract void TransitionState(Func<(IInstanceState, IInstanceStatus?)> newStateAndStatus);
+
+	public void TransitionState(IInstanceState newState, IInstanceStatus? newStatus = null) {
+		TransitionState(() => (newState, newStatus));
 	}
 }

Agent/Phantom.Agent.Services/Instances/InstanceLogSender.cs

@@ -4,50 +4,33 @@ using Phantom.Common.Logging;
 using Phantom.Common.Messages.ToServer;
 using Phantom.Utils.Collections;
 using Phantom.Utils.Runtime;
-using Serilog;
 
 namespace Phantom.Agent.Services.Instances;
 
-sealed class InstanceLogSender {
+sealed class InstanceLogSender : CancellableBackgroundTask {
 	private static readonly TimeSpan SendDelay = TimeSpan.FromMilliseconds(200);
 
 	private readonly Guid instanceGuid;
-	private readonly ILogger logger;
-	private readonly CancellationTokenSource cancellationTokenSource;
-	private readonly CancellationToken cancellationToken;
 
 	private readonly SemaphoreSlim semaphore = new (1, 1);
 	private readonly RingBuffer<string> buffer = new (1000);
 
-	public InstanceLogSender(TaskManager taskManager, Guid instanceGuid, string name) {
+	public InstanceLogSender(TaskManager taskManager, Guid instanceGuid, string loggerName) : base(PhantomLogger.Create<InstanceLogSender>(loggerName), taskManager, "Instance log sender for " + loggerName) {
 		this.instanceGuid = instanceGuid;
-		this.logger = PhantomLogger.Create<InstanceLogSender>(name);
-		this.cancellationTokenSource = new CancellationTokenSource();
-		this.cancellationToken = cancellationTokenSource.Token;
-		taskManager.Run(Run);
 	}
 	
-	private async Task Run() {
+	protected override async Task RunTask() {
-		logger.Verbose("Task started.");
-
 		try {
-			try {
+			while (!CancellationToken.IsCancellationRequested) {
-				while (!cancellationToken.IsCancellationRequested) {
+				await SendOutputToServer(await DequeueOrThrow());
-					await SendOutputToServer(await DequeueOrThrow());
+				await Task.Delay(SendDelay, CancellationToken);
-					await Task.Delay(SendDelay, cancellationToken);
-				}
-			} catch (OperationCanceledException) {
-				// Ignore.
 			}
-
+		} catch (OperationCanceledException) {
-			// Flush remaining lines.
+			// Ignore.
-			await SendOutputToServer(DequeueWithoutSemaphore());
-		} catch (Exception e) {
-			logger.Error(e, "Caught exception in task.");
-		} finally {
-			cancellationTokenSource.Dispose();
-			logger.Verbose("Task stopped.");
 		}
+
+		// Flush remaining lines.
+		await SendOutputToServer(DequeueWithoutSemaphore());
 	}
 
 	private async Task SendOutputToServer(ImmutableArray<string> lines) {
@@ -63,7 +46,7 @@ sealed class InstanceLogSender {
 	}
 
 	private async Task<ImmutableArray<string>> DequeueOrThrow() {
-		await semaphore.WaitAsync(cancellationToken);
+		await semaphore.WaitAsync(CancellationToken);
 
 		try {
 			return DequeueWithoutSemaphore();
@@ -74,7 +57,7 @@ sealed class InstanceLogSender {
 
 	public void Enqueue(string line) {
 		try {
-			semaphore.Wait(cancellationToken);
+			semaphore.Wait(CancellationToken);
 		} catch (Exception) {
 			return;
 		}
@@ -85,12 +68,4 @@ sealed class InstanceLogSender {
 			semaphore.Release();
 		}
 	}
-
-	public void Cancel() {
-		try {
-			cancellationTokenSource.Cancel();
-		} catch (ObjectDisposedException) {
-			// Ignore.
-		}
-	}
 }

Agent/Phantom.Agent.Services/Instances/InstanceServices.cs

@@ -0,0 +1,7 @@
+using Phantom.Agent.Minecraft.Launcher;
+using Phantom.Agent.Services.Backups;
+using Phantom.Utils.Runtime;
+
+namespace Phantom.Agent.Services.Instances; 
+
+sealed record InstanceServices(TaskManager TaskManager, PortManager PortManager, BackupManager BackupManager, LaunchServices LaunchServices);

Agent/Phantom.Agent.Services/Instances/InstanceSessionManager.cs

@@ -1,16 +1,20 @@
-using System.Diagnostics.CodeAnalysis;
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using Phantom.Agent.Minecraft.Instance;
 using Phantom.Agent.Minecraft.Java;
 using Phantom.Agent.Minecraft.Launcher;
 using Phantom.Agent.Minecraft.Launcher.Types;
 using Phantom.Agent.Minecraft.Properties;
 using Phantom.Agent.Minecraft.Server;
+using Phantom.Agent.Rpc;
+using Phantom.Agent.Services.Backups;
 using Phantom.Common.Data;
 using Phantom.Common.Data.Agent;
 using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Logging;
+using Phantom.Common.Messages.ToServer;
 using Phantom.Utils.IO;
 using Phantom.Utils.Runtime;
 using Serilog;
@@ -23,63 +27,55 @@ sealed class InstanceSessionManager : IDisposable {
 	private readonly AgentInfo agentInfo;
 	private readonly string basePath;
 
-	private readonly MinecraftServerExecutables minecraftServerExecutables;
+	private readonly InstanceServices instanceServices;
-	private readonly LaunchServices launchServices;
-	private readonly PortManager portManager;
 	private readonly Dictionary<Guid, Instance> instances = new ();
 
 	private readonly CancellationTokenSource shutdownCancellationTokenSource = new ();
 	private readonly CancellationToken shutdownCancellationToken;
 	private readonly SemaphoreSlim semaphore = new (1, 1);
 
-	public InstanceSessionManager(AgentInfo agentInfo, AgentFolders agentFolders, JavaRuntimeRepository javaRuntimeRepository, TaskManager taskManager) {
+	public InstanceSessionManager(AgentInfo agentInfo, AgentFolders agentFolders, JavaRuntimeRepository javaRuntimeRepository, TaskManager taskManager, BackupManager backupManager) {
 		this.agentInfo = agentInfo;
 		this.basePath = agentFolders.InstancesFolderPath;
-		this.minecraftServerExecutables = new MinecraftServerExecutables(agentFolders.ServerExecutableFolderPath);
-		this.launchServices = new LaunchServices(taskManager, minecraftServerExecutables, javaRuntimeRepository);
-		this.portManager = new PortManager(agentInfo.AllowedServerPorts, agentInfo.AllowedRconPorts);
 		this.shutdownCancellationToken = shutdownCancellationTokenSource.Token;
+		
+		var minecraftServerExecutables = new MinecraftServerExecutables(agentFolders.ServerExecutableFolderPath);
+		var launchServices = new LaunchServices(minecraftServerExecutables, javaRuntimeRepository);
+		var portManager = new PortManager(agentInfo.AllowedServerPorts, agentInfo.AllowedRconPorts);
+		
+		this.instanceServices = new InstanceServices(taskManager, portManager, backupManager, launchServices);
 	}
 
-	[SuppressMessage("ReSharper", "ConvertIfStatementToReturnStatement")]
+	private async Task<InstanceActionResult<T>> AcquireSemaphoreAndRun<T>(Func<Task<InstanceActionResult<T>>> func) {
-	private async Task<InstanceActionResult<T>> AcquireSemaphoreAndRunWithInstance<T>(Guid instanceGuid, Func<Instance, Task<T>> func) {
 		try {
 			await semaphore.WaitAsync(shutdownCancellationToken);
+			try {
+				return await func();
+			} finally {
+				semaphore.Release();
+			}
 		} catch (OperationCanceledException) {
 			return InstanceActionResult.General<T>(InstanceActionGeneralResult.AgentShuttingDown);
 		}
-
-		try {
-			if (!instances.TryGetValue(instanceGuid, out var instance)) {
-				return InstanceActionResult.General<T>(InstanceActionGeneralResult.InstanceDoesNotExist);
-			}
-			else {
-				return InstanceActionResult.Concrete(await func(instance));
-			}
-		} finally {
-			semaphore.Release();
-		}
 	}
 
-	public async Task<InstanceActionResult<ConfigureInstanceResult>> Configure(InstanceConfiguration configuration) {
+	[SuppressMessage("ReSharper", "ConvertIfStatementToReturnStatement")]
-		try {
+	private Task<InstanceActionResult<T>> AcquireSemaphoreAndRunWithInstance<T>(Guid instanceGuid, Func<Instance, Task<T>> func) {
-			await semaphore.WaitAsync(shutdownCancellationToken);
+		return AcquireSemaphoreAndRun(async () => {
-		} catch (OperationCanceledException) {
+			if (instances.TryGetValue(instanceGuid, out var instance)) {
-			return InstanceActionResult.General<ConfigureInstanceResult>(InstanceActionGeneralResult.AgentShuttingDown);
+				return InstanceActionResult.Concrete(await func(instance));
-		}
-
-		var instanceGuid = configuration.InstanceGuid;
-
-		try {
-			var otherInstances = instances.Values.Where(inst => inst.Configuration.InstanceGuid != instanceGuid).ToArray();
-			if (otherInstances.Length + 1 > agentInfo.MaxInstances) {
-				return InstanceActionResult.Concrete(ConfigureInstanceResult.InstanceLimitExceeded);
 			}
-
+			else {
-			var availableMemory = agentInfo.MaxMemory - otherInstances.Aggregate(RamAllocationUnits.Zero, static (total, instance) => total + instance.Configuration.MemoryAllocation);
+				return InstanceActionResult.General<T>(InstanceActionGeneralResult.InstanceDoesNotExist);
-			if (availableMemory < configuration.MemoryAllocation) {
-				return InstanceActionResult.Concrete(ConfigureInstanceResult.MemoryLimitExceeded);
 			}
+		});
+	}
+
+	public async Task<InstanceActionResult<ConfigureInstanceResult>> Configure(InstanceConfiguration configuration, InstanceLaunchProperties launchProperties, bool launchNow, bool alwaysReportStatus) {
+		return await AcquireSemaphoreAndRun(async () => {
+			var instanceGuid = configuration.InstanceGuid;
+			var instanceFolder = Path.Combine(basePath, instanceGuid.ToString());
+			Directories.Create(instanceFolder, Chmod.URWX_GRX);
 			
 			var heapMegabytes = configuration.MemoryAllocation.InMegabytes;
 			var jvmProperties = new JvmProperties(
@@ -87,41 +83,87 @@ sealed class InstanceSessionManager : IDisposable {
 				MaximumHeapMegabytes: heapMegabytes
 			);
 
-			var instanceFolder = Path.Combine(basePath, instanceGuid.ToString());
-			Directories.Create(instanceFolder, Chmod.URWX_GRX);
-
 			var properties = new InstanceProperties(
+				instanceGuid,
 				configuration.JavaRuntimeGuid,
 				jvmProperties,
 				configuration.JvmArguments,
 				instanceFolder,
 				configuration.MinecraftVersion,
-				new ServerProperties(configuration.ServerPort, configuration.RconPort)
+				new ServerProperties(configuration.ServerPort, configuration.RconPort),
+				launchProperties
 			);
 
-			BaseLauncher launcher = new VanillaLauncher(properties);
+			IServerLauncher launcher = configuration.MinecraftServerKind switch {
+				MinecraftServerKind.Vanilla => new VanillaLauncher(properties),
+				MinecraftServerKind.Fabric  => new FabricLauncher(properties),
+				_                           => InvalidLauncher.Instance
+			};
 
 			if (instances.TryGetValue(instanceGuid, out var instance)) {
 				await instance.Reconfigure(configuration, launcher, shutdownCancellationToken);
 				Logger.Information("Reconfigured instance \"{Name}\" (GUID {Guid}).", configuration.InstanceName, configuration.InstanceGuid);
+				
+				if (alwaysReportStatus) {
+					instance.ReportLastStatus();
+				}
 			}
 			else {
-				instances[instanceGuid] = instance = await Instance.Create(configuration, launcher, launchServices, portManager);
+				instances[instanceGuid] = instance = new Instance(instanceServices, configuration, launcher);
 				Logger.Information("Created instance \"{Name}\" (GUID {Guid}).", configuration.InstanceName, configuration.InstanceGuid);
+				
+				instance.ReportLastStatus();
+				instance.IsRunningChanged += OnInstanceIsRunningChanged;
 			}
 
-			if (configuration.LaunchAutomatically) {
+			if (launchNow) {
-				await instance.Launch(shutdownCancellationToken);
+				await LaunchInternal(instance);
 			}
 
 			return InstanceActionResult.Concrete(ConfigureInstanceResult.Success);
-		} finally {
+		});
-			semaphore.Release();
+	}
+
+	private ImmutableArray<Instance> GetRunningInstancesInternal() {
+		return instances.Values.Where(static instance => instance.IsRunning).ToImmutableArray();
+	}
+
+	private void OnInstanceIsRunningChanged(object? sender, EventArgs e) {
+		instanceServices.TaskManager.Run("Handle instance running state changed event", RefreshAgentStatus);
+	}
+
+	public async Task RefreshAgentStatus() {
+		try {
+			await semaphore.WaitAsync(shutdownCancellationToken);
+			try {
+				var runningInstances = GetRunningInstancesInternal();
+				var runningInstanceCount = runningInstances.Length;
+				var runningInstanceMemory = runningInstances.Aggregate(RamAllocationUnits.Zero, static (total, instance) => total + instance.Configuration.MemoryAllocation);
+				await ServerMessaging.Send(new ReportAgentStatusMessage(runningInstanceCount, runningInstanceMemory));
+			} finally {
+				semaphore.Release();
+			}
+		} catch (OperationCanceledException) {
+			// ignore
 		}
 	}
 
 	public Task<InstanceActionResult<LaunchInstanceResult>> Launch(Guid instanceGuid) {
-		return AcquireSemaphoreAndRunWithInstance(instanceGuid, instance => instance.Launch(shutdownCancellationToken));
+		return AcquireSemaphoreAndRunWithInstance(instanceGuid, LaunchInternal);
+	}
+
+	private async Task<LaunchInstanceResult> LaunchInternal(Instance instance) {
+		var runningInstances = GetRunningInstancesInternal();
+		if (runningInstances.Length + 1 > agentInfo.MaxInstances) {
+			return LaunchInstanceResult.InstanceLimitExceeded;
+		}
+
+		var availableMemory = agentInfo.MaxMemory - runningInstances.Aggregate(RamAllocationUnits.Zero, static (total, instance) => total + instance.Configuration.MemoryAllocation);
+		if (availableMemory < instance.Configuration.MemoryAllocation) {
+			return LaunchInstanceResult.MemoryLimitExceeded;
+		}
+
+		return await instance.Launch(shutdownCancellationToken);
 	}
 
 	public Task<InstanceActionResult<StopInstanceResult>> Stop(Guid instanceGuid, MinecraftStopStrategy stopStrategy) {
@@ -135,18 +177,28 @@ sealed class InstanceSessionManager : IDisposable {
 	public async Task StopAll() {
 		shutdownCancellationTokenSource.Cancel();
 		
+		Logger.Information("Stopping all instances...");
+
 		await semaphore.WaitAsync(CancellationToken.None);
 		try {
 			await Task.WhenAll(instances.Values.Select(static instance => instance.StopAndWait(TimeSpan.FromSeconds(30))));
-			instances.Clear();
+			DisposeAllInstances();
 		} finally {
 			semaphore.Release();
 		}
 	}
 
 	public void Dispose() {
-		minecraftServerExecutables.Dispose();
+		DisposeAllInstances();
 		shutdownCancellationTokenSource.Dispose();
 		semaphore.Dispose();
 	}
+
+	private void DisposeAllInstances() {
+		foreach (var (_, instance) in instances) {
+			instance.Dispose();
+		}
+
+		instances.Clear();
+	}
 }

Agent/Phantom.Agent.Services/Instances/Sessions/InstanceSession.cs

@@ -0,0 +1,28 @@
+using Phantom.Agent.Minecraft.Instance;
+
+namespace Phantom.Agent.Services.Instances.Sessions; 
+
+sealed class InstanceSession : IDisposable {
+	private readonly InstanceProcess process;
+	private readonly InstanceContext context;
+	private readonly InstanceLogSender logSender;
+
+	public InstanceSession(InstanceProcess process, InstanceContext context) {
+		this.process = process;
+		this.context = context;
+		this.logSender = new InstanceLogSender(context.Services.TaskManager, context.Configuration.InstanceGuid, context.ShortName);
+		
+		this.process.AddOutputListener(SessionOutput);
+	}
+	
+	private void SessionOutput(object? sender, string line) {
+		context.Logger.Debug("[Server] {Line}", line);
+		logSender.Enqueue(line);
+	}
+	
+	public void Dispose() {
+		logSender.Stop();
+		process.Dispose();
+		context.Services.PortManager.Release(context.Configuration);
+	}
+}

Agent/Phantom.Agent.Services/Instances/States/InstanceLaunchingState.cs

@@ -1,6 +1,7 @@
 using Phantom.Agent.Minecraft.Instance;
 using Phantom.Agent.Minecraft.Launcher;
 using Phantom.Agent.Minecraft.Server;
+using Phantom.Agent.Services.Instances.Sessions;
 using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
@@ -19,12 +20,12 @@ sealed class InstanceLaunchingState : IInstanceState, IDisposable {
 	public void Initialize() {
 		context.Logger.Information("Session starting...");
 
-		var launchTask = context.LaunchServices.TaskManager.Run(DoLaunch);
+		var launchTask = context.Services.TaskManager.Run("Launch procedure for instance " + context.ShortName, DoLaunch);
 		launchTask.ContinueWith(OnLaunchSuccess, CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Default);
 		launchTask.ContinueWith(OnLaunchFailure, CancellationToken.None, TaskContinuationOptions.NotOnRanToCompletion, TaskScheduler.Default);
 	}
 
-	private async Task<InstanceSession> DoLaunch() {
+	private async Task<InstanceProcess> DoLaunch() {
 		var cancellationToken = cancellationTokenSource.Token;
 		cancellationToken.ThrowIfCancellationRequested();
 
@@ -33,11 +34,11 @@ sealed class InstanceLaunchingState : IInstanceState, IDisposable {
 
 			if (lastDownloadProgress != progress) {
 				lastDownloadProgress = progress;
-				context.ReportStatus(InstanceStatus.Downloading(progress));
+				context.SetStatus(InstanceStatus.Downloading(progress));
 			}
 		}
 
-		var launchResult = await context.Launcher.Launch(context.Logger, context.LaunchServices, OnDownloadProgress, cancellationToken);
+		var launchResult = await context.Launcher.Launch(context.Logger, context.Services.LaunchServices, OnDownloadProgress, cancellationToken);
 		if (launchResult is LaunchResult.InvalidJavaRuntime) {
 			throw new LaunchFailureException(InstanceLaunchFailReason.JavaRuntimeNotFound, "Session failed to launch, invalid Java runtime.");
 		}
@@ -47,6 +48,9 @@ sealed class InstanceLaunchingState : IInstanceState, IDisposable {
 		else if (launchResult is LaunchResult.CouldNotDownloadMinecraftServer) {
 			throw new LaunchFailureException(InstanceLaunchFailReason.CouldNotDownloadMinecraftServer, "Session failed to launch, could not download Minecraft server.");
 		}
+		else if (launchResult is LaunchResult.CouldNotPrepareMinecraftServerLauncher) {
+			throw new LaunchFailureException(InstanceLaunchFailReason.CouldNotPrepareMinecraftServerLauncher, "Session failed to launch, could not prepare Minecraft server launcher.");
+		}
 		else if (launchResult is LaunchResult.CouldNotConfigureMinecraftServer) {
 			throw new LaunchFailureException(InstanceLaunchFailReason.CouldNotConfigureMinecraftServer, "Session failed to launch, could not configure Minecraft server.");
 		}
@@ -58,33 +62,39 @@ sealed class InstanceLaunchingState : IInstanceState, IDisposable {
 			throw new LaunchFailureException(InstanceLaunchFailReason.UnknownError, "Session failed to launch.");
 		}
 
-		context.ReportStatus(InstanceStatus.Launching);
+		context.SetStatus(InstanceStatus.Launching);
-		return launchSuccess.Session;
+		return launchSuccess.Process;
 	}
 
-	private void OnLaunchSuccess(Task<InstanceSession> task) {
+	private void OnLaunchSuccess(Task<InstanceProcess> task) {
 		context.TransitionState(() => {
+			context.ReportEvent(InstanceEvent.LaunchSucceded);
+			
+			var process = task.Result;
+			var session = new InstanceSession(process, context);
+			
 			if (cancellationTokenSource.IsCancellationRequested) {
-				context.PortManager.Release(context.Configuration);
+				return (new InstanceStoppingState(context, process, session), InstanceStatus.Stopping);
-				context.ReportStatus(InstanceStatus.NotRunning);
-				return new InstanceNotRunningState();
 			}
 			else {
-				return new InstanceRunningState(context, task.Result);
+				return (new InstanceRunningState(context, process, session), null);
 			}
 		});
 	}
 
 	private void OnLaunchFailure(Task task) {
-		if (task.Exception is { InnerException: LaunchFailureException e }) {
+		if (task.IsFaulted) {
-			context.Logger.Error(e.LogMessage);
+			if (task.Exception is { InnerException: LaunchFailureException e }) {
-			context.ReportStatus(InstanceStatus.Failed(e.Reason));
+				context.Logger.Error(e.LogMessage);
-		}
+				context.SetLaunchFailedStatusAndReportEvent(e.Reason);
-		else {
+			}
-			context.ReportStatus(InstanceStatus.Failed(InstanceLaunchFailReason.UnknownError));
+			else {
+				context.Logger.Error(task.Exception, "Caught exception while launching instance.");
+				context.SetLaunchFailedStatusAndReportEvent(InstanceLaunchFailReason.UnknownError);
+			}
 		}
 
-		context.PortManager.Release(context.Configuration);
+		context.Services.PortManager.Release(context.Configuration);
 		context.TransitionState(new InstanceNotRunningState());
 	}
 

Agent/Phantom.Agent.Services/Instances/States/InstanceNotRunningState.cs

@@ -8,7 +8,7 @@ sealed class InstanceNotRunningState : IInstanceState {
 	public void Initialize() {}
 
 	public (IInstanceState, LaunchInstanceResult) Launch(InstanceContext context) {
-		InstanceLaunchFailReason? failReason = context.PortManager.Reserve(context.Configuration) switch {
+		InstanceLaunchFailReason? failReason = context.Services.PortManager.Reserve(context.Configuration) switch {
 			PortManager.Result.ServerPortNotAllowed   => InstanceLaunchFailReason.ServerPortNotAllowed,
 			PortManager.Result.ServerPortAlreadyInUse => InstanceLaunchFailReason.ServerPortAlreadyInUse,
 			PortManager.Result.RconPortNotAllowed     => InstanceLaunchFailReason.RconPortNotAllowed,
@@ -16,12 +16,12 @@ sealed class InstanceNotRunningState : IInstanceState {
 			_                                         => null
 		};
 
-		if (failReason != null) {
+		if (failReason is {} reason) {
-			context.ReportStatus(InstanceStatus.Failed(failReason.Value));
+			context.SetLaunchFailedStatusAndReportEvent(reason);
 			return (this, LaunchInstanceResult.LaunchInitiated);
 		}
 		
-		context.ReportStatus(InstanceStatus.Launching);
+		context.SetStatus(InstanceStatus.Launching);
 		return (new InstanceLaunchingState(context), LaunchInstanceResult.LaunchInitiated);
 	}
 

Agent/Phantom.Agent.Services/Instances/States/InstanceRunningState.cs

@@ -1,5 +1,8 @@
 using Phantom.Agent.Minecraft.Command;
 using Phantom.Agent.Minecraft.Instance;
+using Phantom.Agent.Services.Backups;
+using Phantom.Agent.Services.Instances.Sessions;
+using Phantom.Common.Data.Backups;
 using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
@@ -8,57 +11,52 @@ namespace Phantom.Agent.Services.Instances.States;
 
 sealed class InstanceRunningState : IInstanceState {
 	private readonly InstanceContext context;
-	private readonly InstanceSession session;
+	private readonly InstanceProcess process;
-	private readonly InstanceLogSender logSender;
+	private readonly BackupScheduler backupScheduler;
-	private readonly SessionObjects sessionObjects;
+	private readonly RunningSessionDisposer runningSessionDisposer;
 	
 	private readonly CancellationTokenSource delayedStopCancellationTokenSource = new ();
 	private bool stateOwnsDelayedStopCancellationTokenSource = true;
 	private bool isStopping;
 
-	public InstanceRunningState(InstanceContext context, InstanceSession session) {
+	public InstanceRunningState(InstanceContext context, InstanceProcess process, InstanceSession session) {
 		this.context = context;
-		this.session = session;
+		this.process = process;
-		this.logSender = new InstanceLogSender(context.LaunchServices.TaskManager, context.Configuration.InstanceGuid, context.ShortName);
+		this.backupScheduler = new BackupScheduler(context.Services.TaskManager, context.Services.BackupManager, process, context.Configuration.ServerPort, context.ShortName);
-		this.sessionObjects = new SessionObjects(this);
+		this.backupScheduler.BackupCompleted += OnScheduledBackupCompleted;
+		this.runningSessionDisposer = new RunningSessionDisposer(this, session);
 	}
 
 	public void Initialize() {
-		session.AddOutputListener(SessionOutput);
+		process.Ended += ProcessEnded;
-		session.SessionEnded += SessionEnded;
 		
-		if (session.HasEnded) {
+		if (process.HasEnded) {
-			if (sessionObjects.Dispose()) {
+			if (runningSessionDisposer.Dispose()) {
 				context.Logger.Warning("Session ended immediately after it was started.");
-				context.ReportStatus(InstanceStatus.Failed(InstanceLaunchFailReason.UnknownError));
+				context.ReportEvent(InstanceEvent.Stopped);
-				context.LaunchServices.TaskManager.Run(() => context.TransitionState(new InstanceNotRunningState()));
+				context.Services.TaskManager.Run("Transition state of instance " + context.ShortName + " to not running", () => context.TransitionState(new InstanceNotRunningState(), InstanceStatus.Failed(InstanceLaunchFailReason.UnknownError)));
 			}
 		}
 		else {
-			context.ReportStatus(InstanceStatus.Running);
+			context.SetStatus(InstanceStatus.Running);
 			context.Logger.Information("Session started.");
 		}
 	}
 
-	private void SessionOutput(object? sender, string e) {
+	private void ProcessEnded(object? sender, EventArgs e) {
-		context.Logger.Verbose("[Server] {Line}", e);
+		if (!runningSessionDisposer.Dispose()) {
-		logSender.Enqueue(e);
-	}
-
-	private void SessionEnded(object? sender, EventArgs e) {
-		if (!sessionObjects.Dispose()) {
 			return;
 		}
 
 		if (isStopping) {
 			context.Logger.Information("Session ended.");
-			context.ReportStatus(InstanceStatus.NotRunning);
+			context.ReportEvent(InstanceEvent.Stopped);
-			context.TransitionState(new InstanceNotRunningState());
+			context.TransitionState(new InstanceNotRunningState(), InstanceStatus.NotRunning);
 		}
 		else {
 			context.Logger.Information("Session ended unexpectedly, restarting...");
-			context.ReportStatus(InstanceStatus.Restarting);
+			context.ReportEvent(InstanceEvent.Crashed);
-			context.TransitionState(new InstanceLaunchingState(context));
+			context.TransitionState(new InstanceLaunchingState(context), InstanceStatus.Restarting);
 		}
 	}
 
@@ -78,13 +76,14 @@ sealed class InstanceRunningState : IInstanceState {
 		}
 		
 		isStopping = true;
-		context.LaunchServices.TaskManager.Run(() => StopLater(stopStrategy.Seconds));
+		context.Services.TaskManager.Run("Delayed stop timer for instance " + context.ShortName, () => StopLater(stopStrategy.Seconds));
 		return (this, StopInstanceResult.StopInitiated);
 	}
 
 	private IInstanceState PrepareStoppedState() {
-		session.SessionEnded -= SessionEnded;
+		process.Ended -= ProcessEnded;
-		return new InstanceStoppingState(context, session, sessionObjects);
+		backupScheduler.Stop();
+		return new InstanceStoppingState(context, process, runningSessionDisposer);
 	}
 
 	private void CancelDelayedStop() {
@@ -111,7 +110,7 @@ sealed class InstanceRunningState : IInstanceState {
 				}
 			}
 		} catch (OperationCanceledException) {
-			context.Logger.Verbose("Cancelled delayed stop.");
+			context.Logger.Debug("Cancelled delayed stop.");
 			return;
 		} catch (ObjectDisposedException) {
 			return;
@@ -128,7 +127,7 @@ sealed class InstanceRunningState : IInstanceState {
 	public async Task<bool> SendCommand(string command, CancellationToken cancellationToken) {
 		try {
 			context.Logger.Information("Sending command: {Command}", command);
-			await session.SendCommand(command, cancellationToken);
+			await process.SendCommand(command, cancellationToken);
 			return true;
 		} catch (OperationCanceledException) {
 			return false;
@@ -138,12 +137,18 @@ sealed class InstanceRunningState : IInstanceState {
 		}
 	}
 
-	public sealed class SessionObjects {
+	private void OnScheduledBackupCompleted(object? sender, BackupCreationResult e) {
+		context.ReportEvent(new InstanceBackupCompletedEvent(e.Kind, e.Warnings));
+	}
+
+	private sealed class RunningSessionDisposer : IDisposable {
 		private readonly InstanceRunningState state;
+		private readonly InstanceSession session;
 		private bool isDisposed;
 
-		public SessionObjects(InstanceRunningState state) {
+		public RunningSessionDisposer(InstanceRunningState state, InstanceSession session) {
 			this.state = state;
+			this.session = session;
 		}
 
 		public bool Dispose() {
@@ -162,10 +167,12 @@ sealed class InstanceRunningState : IInstanceState {
 				state.CancelDelayedStop();
 			}
 			
-			state.logSender.Cancel();
+			session.Dispose();
-			state.session.Dispose();
-			state.context.PortManager.Release(state.context.Configuration);
 			return true;
 		}
+
+		void IDisposable.Dispose() {
+			Dispose();
+		}
 	}
 }

Agent/Phantom.Agent.Services/Instances/States/InstanceStoppingState.cs

@@ -1,4 +1,5 @@
-using Phantom.Agent.Minecraft.Command;
+using System.Diagnostics;
+using Phantom.Agent.Minecraft.Command;
 using Phantom.Agent.Minecraft.Instance;
 using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Minecraft;
@@ -8,23 +9,29 @@ namespace Phantom.Agent.Services.Instances.States;
 
 sealed class InstanceStoppingState : IInstanceState, IDisposable {
 	private readonly InstanceContext context;
-	private readonly InstanceSession session;
+	private readonly InstanceProcess process;
-	private readonly InstanceRunningState.SessionObjects sessionObjects;
+	private readonly IDisposable sessionDisposer;
 
-	public InstanceStoppingState(InstanceContext context, InstanceSession session, InstanceRunningState.SessionObjects sessionObjects) {
+	public InstanceStoppingState(InstanceContext context, InstanceProcess process, IDisposable sessionDisposer) {
-		this.sessionObjects = sessionObjects;
-		this.session = session;
 		this.context = context;
+		this.process = process;
+		this.sessionDisposer = sessionDisposer;
 	}
 
 	public void Initialize() {
 		context.Logger.Information("Session stopping.");
-		context.ReportStatus(InstanceStatus.Stopping);
+		context.SetStatus(InstanceStatus.Stopping);
-		context.LaunchServices.TaskManager.Run(DoStop);
+		context.Services.TaskManager.Run("Stop procedure for instance " + context.ShortName, DoStop);
 	}
 
 	private async Task DoStop() {
 		try {
+			// Do not release the semaphore after this point.
+			if (!await process.BackupSemaphore.CancelAndWait(TimeSpan.FromSeconds(1))) {
+				context.Logger.Information("Waiting for backup to finish...");
+				await process.BackupSemaphore.CancelAndWait(Timeout.InfiniteTimeSpan);
+			}
+			
 			context.Logger.Information("Sending stop command...");
 			await DoSendStopCommand();
 
@@ -32,30 +39,32 @@ sealed class InstanceStoppingState : IInstanceState, IDisposable {
 			await DoWaitForSessionToEnd();
 		} finally {
 			context.Logger.Information("Session stopped.");
-			context.ReportStatus(InstanceStatus.NotRunning);
+			context.ReportEvent(InstanceEvent.Stopped);
-			context.TransitionState(new InstanceNotRunningState());
+			context.TransitionState(new InstanceNotRunningState(), InstanceStatus.NotRunning);
 		}
 	}
 
 	private async Task DoSendStopCommand() {
-		using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+		using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
 		try {
-			await session.SendCommand(MinecraftCommand.Stop, cts.Token);
+			await process.SendCommand(MinecraftCommand.Stop, timeout.Token);
 		} catch (OperationCanceledException) {
 			// ignore
+		} catch (ObjectDisposedException e) when (e.ObjectName == typeof(Process).FullName && process.HasEnded) {
+			// ignore
 		} catch (Exception e) {
 			context.Logger.Warning(e, "Caught exception while sending stop command.");
 		}
 	}
 
 	private async Task DoWaitForSessionToEnd() {
-		using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(55));
+		using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(55));
 		try {
-			await session.WaitForExit(cts.Token);
+			await process.WaitForExit(timeout.Token);
 		} catch (OperationCanceledException) {
 			try {
 				context.Logger.Warning("Waiting timed out, killing session...");
-				session.Kill();
+				process.Kill();
 			} catch (Exception e) {
 				context.Logger.Error(e, "Caught exception while killing session.");
 			}
@@ -75,6 +84,6 @@ sealed class InstanceStoppingState : IInstanceState, IDisposable {
 	}
 
 	public void Dispose() {
-		sessionObjects.Dispose();
+		sessionDisposer.Dispose();
 	}
 }

Agent/Phantom.Agent.Services/Rpc/MessageListener.cs

@@ -1,7 +1,9 @@
 using Phantom.Agent.Rpc;
+using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Logging;
 using Phantom.Common.Messages;
+using Phantom.Common.Messages.BiDirectional;
 using Phantom.Common.Messages.ToAgent;
 using Phantom.Common.Messages.ToServer;
 using Phantom.Utils.Rpc.Message;
@@ -25,17 +27,22 @@ public sealed class MessageListener : IMessageToAgentListener {
 	public async Task<NoReply> HandleRegisterAgentSuccess(RegisterAgentSuccessMessage message) {
 		Logger.Information("Agent authentication successful.");
 
-		foreach (var instanceInfo in message.InitialInstances) {
+		void ShutdownAfterConfigurationFailed(InstanceConfiguration configuration) {
-			var result = await agent.InstanceSessionManager.Configure(instanceInfo);
+			Logger.Fatal("Unable to configure instance \"{Name}\" (GUID {Guid}), shutting down.", configuration.InstanceName, configuration.InstanceGuid);
-			if (!result.Is(ConfigureInstanceResult.Success)) {
+			shutdownTokenSource.Cancel();
-				Logger.Fatal("Unable to configure instance \"{Name}\" (GUID {Guid}), shutting down.", instanceInfo.InstanceName, instanceInfo.InstanceGuid);
+		}
 		
-				shutdownTokenSource.Cancel();
+		foreach (var configureInstanceMessage in message.InitialInstanceConfigurations) {
+			var result = await HandleConfigureInstance(configureInstanceMessage, alwaysReportStatus: true);
+			if (!result.Is(ConfigureInstanceResult.Success)) {
+				ShutdownAfterConfigurationFailed(configureInstanceMessage.Configuration);
 				return NoReply.Instance;
 			}
 		}
 
 		await ServerMessaging.Send(new AdvertiseJavaRuntimesMessage(agent.JavaRuntimeRepository.All));
+		await agent.InstanceSessionManager.RefreshAgentStatus();
+		
 		return NoReply.Instance;
 	}
 
@@ -52,8 +59,12 @@ public sealed class MessageListener : IMessageToAgentListener {
 		return Task.FromResult(NoReply.Instance);
 	}
 	
+	private Task<InstanceActionResult<ConfigureInstanceResult>> HandleConfigureInstance(ConfigureInstanceMessage message, bool alwaysReportStatus) {
+		return agent.InstanceSessionManager.Configure(message.Configuration, message.LaunchProperties, message.LaunchNow, alwaysReportStatus);
+	}
+	
 	public async Task<InstanceActionResult<ConfigureInstanceResult>> HandleConfigureInstance(ConfigureInstanceMessage message) {
-		return await agent.InstanceSessionManager.Configure(message.Configuration);
+		return await HandleConfigureInstance(message, alwaysReportStatus: false);
 	}
 
 	public async Task<InstanceActionResult<LaunchInstanceResult>> HandleLaunchInstance(LaunchInstanceMessage message) {

Agent/Phantom.Agent/AgentKey.cs

@@ -8,7 +8,7 @@ using Serilog;
 namespace Phantom.Agent;
 
 static class AgentKey {
-	private static ILogger Logger { get; } = PhantomLogger.Create(typeof(AgentKey));
+	private static ILogger Logger { get; } = PhantomLogger.Create(nameof(AgentKey));
 
 	public static Task<(NetMQCertificate, AgentAuthToken)?> Load(string? agentKeyToken, string? agentKeyFilePath) {
 		if (agentKeyFilePath != null) {

Agent/Phantom.Agent/GuidFile.cs

@@ -6,7 +6,7 @@ using Serilog;
 namespace Phantom.Agent; 
 
 static class GuidFile {
-	private static ILogger Logger { get; } = PhantomLogger.Create(typeof(GuidFile));
+	private static ILogger Logger { get; } = PhantomLogger.Create(nameof(GuidFile));
 
 	private const string GuidFileName = "agent.guid";
 	

Agent/Phantom.Agent/Program.cs

@@ -53,7 +53,8 @@ try {
 	await agentServices.Initialize();
 
 	var rpcDisconnectSemaphore = new SemaphoreSlim(0, 1);
-	var rpcTask = RpcLauncher.Launch(new RpcConfiguration(PhantomLogger.Create("Rpc"), serverHost, serverPort, serverCertificate), agentToken, agentInfo, MessageListenerFactory, rpcDisconnectSemaphore, shutdownCancellationToken);
+	var rpcConfiguration = new RpcConfiguration(PhantomLogger.Create("Rpc"), PhantomLogger.Create<TaskManager>("Rpc"), serverHost, serverPort, serverCertificate);
+	var rpcTask = RpcLauncher.Launch(rpcConfiguration, agentToken, agentInfo, MessageListenerFactory, rpcDisconnectSemaphore, shutdownCancellationToken);
 	try {
 		await rpcTask.WaitAsync(shutdownCancellationToken);
 	} finally {

Common/Phantom.Common.Data/Agent/AgentAuthToken.cs

@@ -13,7 +13,7 @@ public sealed partial class AgentAuthToken {
 	[MemoryPackInclude]
 	private readonly byte[] bytes;
 
-	public AgentAuthToken(byte[]? bytes) {
+	internal AgentAuthToken(byte[]? bytes) {
 		if (bytes == null) {
 			throw new ArgumentNullException(nameof(bytes));
 		}

Common/Phantom.Common.Data/Backups/BackupCreationResult.cs

@@ -0,0 +1,18 @@
+using MemoryPack;
+
+namespace Phantom.Common.Data.Backups;
+
+[MemoryPackable]
+public sealed partial record BackupCreationResult(
+	[property: MemoryPackOrder(0)] BackupCreationResultKind Kind,
+	[property: MemoryPackOrder(1)] BackupCreationWarnings Warnings = BackupCreationWarnings.None
+) {
+	public sealed class Builder {
+		public BackupCreationResultKind Kind { get; set; } = BackupCreationResultKind.Success;
+		public BackupCreationWarnings Warnings { get; set; }
+		
+		public BackupCreationResult Build() {
+			return new BackupCreationResult(Kind, Warnings);
+		}
+	}
+}

Common/Phantom.Common.Data/Backups/BackupCreationResultKind.cs

@@ -0,0 +1,37 @@
+namespace Phantom.Common.Data.Backups;
+
+public enum BackupCreationResultKind : byte {
+	UnknownError,
+	Success,
+	InstanceNotRunning,
+	BackupCancelled,
+	BackupAlreadyRunning,
+	BackupFileAlreadyExists,
+	CouldNotCreateBackupFolder,
+	CouldNotCopyWorldToTemporaryFolder,
+	CouldNotCreateWorldArchive
+}
+
+public static class BackupCreationResultSummaryExtensions {
+	public static bool ShouldRetry(this BackupCreationResultKind kind) {
+		return kind != BackupCreationResultKind.Success &&
+		       kind != BackupCreationResultKind.InstanceNotRunning &&
+		       kind != BackupCreationResultKind.BackupCancelled &&
+		       kind != BackupCreationResultKind.BackupAlreadyRunning &&
+		       kind != BackupCreationResultKind.BackupFileAlreadyExists;
+	}
+
+	public static string ToSentence(this BackupCreationResultKind kind) {
+		return kind switch {
+			BackupCreationResultKind.Success                            => "Backup created successfully.",
+			BackupCreationResultKind.InstanceNotRunning                 => "Instance is not running.",
+			BackupCreationResultKind.BackupCancelled                    => "Backup cancelled.",
+			BackupCreationResultKind.BackupAlreadyRunning               => "A backup is already being created.",
+			BackupCreationResultKind.BackupFileAlreadyExists            => "Backup with the same name already exists.",
+			BackupCreationResultKind.CouldNotCreateBackupFolder         => "Could not create backup folder.",
+			BackupCreationResultKind.CouldNotCopyWorldToTemporaryFolder => "Could not copy world to temporary folder.",
+			BackupCreationResultKind.CouldNotCreateWorldArchive         => "Could not create world archive.",
+			_                                                           => "Unknown error."
+		};
+	}
+}

Common/Phantom.Common.Data/Backups/BackupCreationWarnings.cs

@@ -0,0 +1,21 @@
+using System.Numerics;
+
+namespace Phantom.Common.Data.Backups;
+
+[Flags]
+public enum BackupCreationWarnings : byte {
+	None = 0,
+	CouldNotDeleteTemporaryFolder = 1 << 0,
+	CouldNotCompressWorldArchive = 1 << 1,
+	CouldNotRestoreAutomaticSaving = 1 << 2
+}
+
+public static class BackupCreationWarningsExtensions {
+	public static int Count(this BackupCreationWarnings warnings) {
+		return BitOperations.PopCount((byte) warnings);
+	}
+
+	public static IEnumerable<BackupCreationWarnings> ListFlags(this BackupCreationWarnings warnings) {
+		return Enum.GetValues<BackupCreationWarnings>().Where(warning => warning != BackupCreationWarnings.None && warnings.HasFlag(warning));
+	}
+}

Common/Phantom.Common.Data/Instance/IInstanceEvent.cs

@@ -0,0 +1,55 @@
+using MemoryPack;
+using Phantom.Common.Data.Backups;
+
+namespace Phantom.Common.Data.Instance;
+
+[MemoryPackable]
+[MemoryPackUnion(0, typeof(InstanceLaunchSuccededEvent))]
+[MemoryPackUnion(1, typeof(InstanceLaunchFailedEvent))]
+[MemoryPackUnion(2, typeof(InstanceCrashedEvent))]
+[MemoryPackUnion(3, typeof(InstanceStoppedEvent))]
+[MemoryPackUnion(4, typeof(InstanceBackupCompletedEvent))]
+public partial interface IInstanceEvent {
+	void Accept(IInstanceEventVisitor visitor);
+}
+
+[MemoryPackable]
+public sealed partial record InstanceLaunchSuccededEvent : IInstanceEvent {
+	public void Accept(IInstanceEventVisitor visitor) {
+		visitor.OnLaunchSucceeded(this);
+	}
+}
+
+[MemoryPackable]
+public sealed partial record InstanceLaunchFailedEvent([property: MemoryPackOrder(0)] InstanceLaunchFailReason Reason) : IInstanceEvent {
+	public void Accept(IInstanceEventVisitor visitor) {
+		visitor.OnLaunchFailed(this);
+	}
+}
+
+[MemoryPackable]
+public sealed partial record InstanceCrashedEvent : IInstanceEvent {
+	public void Accept(IInstanceEventVisitor visitor) {
+		visitor.OnCrashed(this);
+	}
+}
+
+[MemoryPackable]
+public sealed partial record InstanceStoppedEvent : IInstanceEvent {
+	public void Accept(IInstanceEventVisitor visitor) {
+		visitor.OnStopped(this);
+	}
+}
+
+[MemoryPackable]
+public sealed partial record InstanceBackupCompletedEvent([property: MemoryPackOrder(0)] BackupCreationResultKind Kind, [property: MemoryPackOrder(1)] BackupCreationWarnings Warnings) : IInstanceEvent {
+	public void Accept(IInstanceEventVisitor visitor) {
+		visitor.OnBackupCompleted(this);
+	}
+}
+
+public static class InstanceEvent {
+	public static readonly IInstanceEvent LaunchSucceded = new InstanceLaunchSuccededEvent();
+	public static readonly IInstanceEvent Crashed = new InstanceCrashedEvent();
+	public static readonly IInstanceEvent Stopped = new InstanceStoppedEvent();
+}

Common/Phantom.Common.Data/Instance/IInstanceEventVisitor.cs

@@ -0,0 +1,9 @@
+namespace Phantom.Common.Data.Instance; 
+
+public interface IInstanceEventVisitor {
+	void OnLaunchSucceeded(InstanceLaunchSuccededEvent e);
+	void OnLaunchFailed(InstanceLaunchFailedEvent e);
+	void OnCrashed(InstanceCrashedEvent e);
+	void OnStopped(InstanceStoppedEvent e);
+	void OnBackupCompleted(InstanceBackupCompletedEvent e);
+}

Common/Phantom.Common.Data/Instance/InstanceConfiguration.cs

@@ -15,6 +15,5 @@ public sealed partial record InstanceConfiguration(
 	[property: MemoryPackOrder(6)] MinecraftServerKind MinecraftServerKind,
 	[property: MemoryPackOrder(7)] RamAllocationUnits MemoryAllocation,
 	[property: MemoryPackOrder(8)] Guid JavaRuntimeGuid,
-	[property: MemoryPackOrder(9)] ImmutableArray<string> JvmArguments,
+	[property: MemoryPackOrder(9)] ImmutableArray<string> JvmArguments
-	[property: MemoryPackOrder(10)] bool LaunchAutomatically
 );

Common/Phantom.Common.Data/Instance/InstanceLaunchFailReason.cs

@@ -1,6 +1,6 @@
 namespace Phantom.Common.Data.Instance;
 
-public enum InstanceLaunchFailReason {
+public enum InstanceLaunchFailReason : byte {
 	UnknownError,
 	ServerPortNotAllowed,
 	ServerPortAlreadyInUse,
@@ -10,22 +10,24 @@ public enum InstanceLaunchFailReason {
 	InvalidJvmArguments,
 	CouldNotDownloadMinecraftServer,
 	CouldNotConfigureMinecraftServer,
+	CouldNotPrepareMinecraftServerLauncher,
 	CouldNotStartMinecraftServer
 }
 
 public static class InstanceLaunchFailReasonExtensions {
 	public static string ToSentence(this InstanceLaunchFailReason reason) {
 		return reason switch {
-			InstanceLaunchFailReason.ServerPortNotAllowed             => "Server port not allowed.",
+			InstanceLaunchFailReason.ServerPortNotAllowed                   => "Server port not allowed.",
-			InstanceLaunchFailReason.ServerPortAlreadyInUse           => "Server port already in use.",
+			InstanceLaunchFailReason.ServerPortAlreadyInUse                 => "Server port already in use.",
-			InstanceLaunchFailReason.RconPortNotAllowed               => "Rcon port not allowed.",
+			InstanceLaunchFailReason.RconPortNotAllowed                     => "Rcon port not allowed.",
-			InstanceLaunchFailReason.RconPortAlreadyInUse             => "Rcon port already in use.",
+			InstanceLaunchFailReason.RconPortAlreadyInUse                   => "Rcon port already in use.",
-			InstanceLaunchFailReason.JavaRuntimeNotFound              => "Java runtime not found.",
+			InstanceLaunchFailReason.JavaRuntimeNotFound                    => "Java runtime not found.",
-			InstanceLaunchFailReason.InvalidJvmArguments              => "Invalid JVM arguments.",
+			InstanceLaunchFailReason.InvalidJvmArguments                    => "Invalid JVM arguments.",
-			InstanceLaunchFailReason.CouldNotDownloadMinecraftServer  => "Could not download Minecraft server.",
+			InstanceLaunchFailReason.CouldNotDownloadMinecraftServer        => "Could not download Minecraft server.",
-			InstanceLaunchFailReason.CouldNotConfigureMinecraftServer => "Could not configure Minecraft server.",
+			InstanceLaunchFailReason.CouldNotConfigureMinecraftServer       => "Could not configure Minecraft server.",
-			InstanceLaunchFailReason.CouldNotStartMinecraftServer     => "Could not start Minecraft server.",
+			InstanceLaunchFailReason.CouldNotPrepareMinecraftServerLauncher => "Could not prepare Minecraft server launcher.",
-			_                                                         => "Unknown error."
+			InstanceLaunchFailReason.CouldNotStartMinecraftServer           => "Could not start Minecraft server.",
+			_                                                               => "Unknown error."
 		};
 	}
 }

Common/Phantom.Common.Data/Instance/InstanceLaunchProperties.cs

@@ -0,0 +1,9 @@
+using MemoryPack;
+using Phantom.Common.Data.Minecraft;
+
+namespace Phantom.Common.Data.Instance; 
+
+[MemoryPackable]
+public sealed partial record InstanceLaunchProperties(
+	[property: MemoryPackOrder(0)] FileDownloadInfo? ServerDownloadInfo
+);

Common/Phantom.Common.Data/Minecraft/FileDownloadInfo.cs

@@ -0,0 +1,30 @@
+using MemoryPack;
+using Phantom.Utils.Cryptography;
+using Phantom.Utils.IO;
+
+namespace Phantom.Common.Data.Minecraft; 
+
+[MemoryPackable]
+public sealed partial class FileDownloadInfo {
+	[MemoryPackOrder(0)]
+	public string DownloadUrl { get; }
+	
+	[MemoryPackOrder(1)]
+	[MemoryPackInclude]
+	private readonly string hash;
+	
+	[MemoryPackIgnore]
+	public Sha1String Hash => Sha1String.FromString(hash);
+	
+	[MemoryPackOrder(2)]
+	public FileSize Size { get; }
+	
+	public FileDownloadInfo(string downloadUrl, Sha1String hash, FileSize size) : this(downloadUrl, hash.ToString(), size) {}
+
+	[MemoryPackConstructor]
+	private FileDownloadInfo(string downloadUrl, string hash, FileSize size) {
+		this.DownloadUrl = downloadUrl;
+		this.hash = hash;
+		this.Size = size;
+	}
+}

Common/Phantom.Common.Data/Minecraft/MinecraftServerKind.cs

@@ -1,5 +1,6 @@
 namespace Phantom.Common.Data.Minecraft; 
 
 public enum MinecraftServerKind : ushort {
-	Vanilla = 1
+	Vanilla = 1,
+	Fabric = 2
 }

Common/Phantom.Common.Data/PortRange.cs

@@ -4,7 +4,7 @@ using MemoryPack;
 namespace Phantom.Common.Data;
 
 [MemoryPackable]
-public readonly partial record struct PortRange(
+readonly partial record struct PortRange(
 	[property: MemoryPackOrder(0)] ushort FirstPort,
 	[property: MemoryPackOrder(1)] ushort LastPort
 ) {

Common/Phantom.Common.Data/Replies/ConfigureInstanceResult.cs

@@ -1,7 +1,5 @@
 namespace Phantom.Common.Data.Replies; 
 
-public enum ConfigureInstanceResult {
+public enum ConfigureInstanceResult : byte {
-	Success,
+	Success
-	InstanceLimitExceeded,
-	MemoryLimitExceeded
 }

Common/Phantom.Common.Data/Replies/LaunchInstanceResult.cs

@@ -1,11 +1,13 @@
 namespace Phantom.Common.Data.Replies;
 
-public enum LaunchInstanceResult {
+public enum LaunchInstanceResult : byte {
+	UnknownError,
 	LaunchInitiated,
 	InstanceAlreadyLaunching,
 	InstanceAlreadyRunning,
 	InstanceIsStopping,
-	UnknownError
+	InstanceLimitExceeded,
+	MemoryLimitExceeded
 }
 
 public static class LaunchInstanceResultExtensions {
@@ -15,6 +17,8 @@ public static class LaunchInstanceResultExtensions {
 			LaunchInstanceResult.InstanceAlreadyLaunching => "Instance is already launching.",
 			LaunchInstanceResult.InstanceAlreadyRunning   => "Instance is already running.",
 			LaunchInstanceResult.InstanceIsStopping       => "Instance is stopping.",
+			LaunchInstanceResult.InstanceLimitExceeded    => "Agent does not have any more available instances.",
+			LaunchInstanceResult.MemoryLimitExceeded      => "Agent does not have enough available memory.",
 			_                                             => "Unknown error."
 		};
 	}

Common/Phantom.Common.Data/Replies/SendCommandToInstanceResult.cs

@@ -1,8 +1,8 @@
 namespace Phantom.Common.Data.Replies;
 
-public enum SendCommandToInstanceResult {
+public enum SendCommandToInstanceResult : byte {
-	Success,
+	UnknownError,
-	UnknownError
+	Success
 }
 
 public static class SendCommandToInstanceResultExtensions {

Common/Phantom.Common.Data/Replies/StopInstanceResult.cs

@@ -1,10 +1,10 @@
 namespace Phantom.Common.Data.Replies;
 
-public enum StopInstanceResult {
+public enum StopInstanceResult : byte {
+	UnknownError,
 	StopInitiated,
 	InstanceAlreadyStopping,
-	InstanceAlreadyStopped,
+	InstanceAlreadyStopped
-	UnknownError
 }
 
 public static class StopInstanceResultExtensions {

Common/Phantom.Common.Logging/DefaultLogLevel.cs

@@ -0,0 +1,42 @@
+using System.Diagnostics.CodeAnalysis;
+using Serilog.Events;
+
+namespace Phantom.Common.Logging; 
+
+static class DefaultLogLevel {
+	private const string ENVIRONMENT_VARIABLE = "LOG_LEVEL";
+	
+	public static LogEventLevel Value { get; } = GetDefaultLevel();
+	
+	public static LogEventLevel Coerce(LogEventLevel level) {
+		return level < Value ? Value : level;
+	}
+	
+	private static LogEventLevel GetDefaultLevel() {
+		var level = Environment.GetEnvironmentVariable(ENVIRONMENT_VARIABLE);
+		return level switch {
+			"VERBOSE"     => LogEventLevel.Verbose,
+			"DEBUG"       => LogEventLevel.Debug,
+			"INFORMATION" => LogEventLevel.Information,
+			"WARNING"     => LogEventLevel.Warning,
+			"ERROR"       => LogEventLevel.Error,
+			null          => GetDefaultLevelFallback(),
+			_             => LogEnvironmentVariableErrorAndExit(level)
+		};
+	}
+
+	private static LogEventLevel GetDefaultLevelFallback() {
+		#if DEBUG
+		return LogEventLevel.Verbose;
+		#else
+		return LogEventLevel.Information;
+		#endif
+	}
+
+	[DoesNotReturn]
+	private static LogEventLevel LogEnvironmentVariableErrorAndExit(string logLevel) {
+		Console.Error.WriteLine("Invalid value of environment variable {0}: {1}", ENVIRONMENT_VARIABLE, logLevel);
+		Environment.Exit(1);
+		return LogEventLevel.Fatal;
+	}
+}

Common/Phantom.Common.Logging/Phantom.Common.Logging.csproj

@@ -8,6 +8,7 @@
   
   <ItemGroup>
     <PackageReference Include="Serilog" />
+    <PackageReference Include="Serilog.Sinks.Async" />
     <PackageReference Include="Serilog.Sinks.Console" />
   </ItemGroup>
 

Common/Phantom.Common.Logging/PhantomLogger.cs

@@ -7,34 +7,27 @@ using Serilog.Sinks.SystemConsole.Themes;
 namespace Phantom.Common.Logging;
 
 public static class PhantomLogger {
-	public static Logger Root { get; } = CreateBaseLogger("[{Timestamp:HH:mm:ss} {Level:u}] {Message:lj}{NewLine}{Exception}");
+	public static Logger Root { get; } = CreateLogger("[{Timestamp:HH:mm:ss} {Level:u}] {Message:lj}{NewLine}{Exception}");
-	private static Logger Base { get; } = CreateBaseLogger("[{Timestamp:HH:mm:ss} {Level:u}] [{Category}] {Message:lj}{NewLine}{Exception}");
+	private static Logger Base { get; } = CreateLogger("[{Timestamp:HH:mm:ss} {Level:u}] [{Category}] {Message:lj}{NewLine}{Exception}");
 	
-	private static LogEventLevel GetDefaultLevel() {
+	private static Logger CreateLogger(string template) {
-		#if DEBUG
+		return new LoggerConfiguration()
-		return LogEventLevel.Verbose;
+		       .MinimumLevel.Is(DefaultLogLevel.Value)
-		#else
+		       .MinimumLevel.Override("Microsoft", DefaultLogLevel.Coerce(LogEventLevel.Information))
-		return LogEventLevel.Information;
+		       .MinimumLevel.Override("Microsoft.AspNetCore", DefaultLogLevel.Coerce(LogEventLevel.Warning))
-		#endif
+		       .MinimumLevel.Override("Microsoft.EntityFrameworkCore.Database.Command", DefaultLogLevel.Coerce(LogEventLevel.Warning))
+		       .Filter.ByExcluding(static e => e.Exception is OperationCanceledException)
+		       .Enrich.FromLogContext()
+		       .WriteTo.Async(c => c.Console(outputTemplate: template, formatProvider: CultureInfo.InvariantCulture, theme: AnsiConsoleTheme.Literate))
+		       .CreateLogger();
 	}
 
-	private static Logger CreateBaseLogger(string template) =>
-		new LoggerConfiguration()
-			.MinimumLevel.Is(GetDefaultLevel())
-			.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
-			.MinimumLevel.Override("Microsoft.AspNetCore", LogEventLevel.Warning)
-			.MinimumLevel.Override("Microsoft.EntityFrameworkCore.Database.Command", LogEventLevel.Warning)
-			.Filter.ByExcluding(static e => e.Exception is OperationCanceledException)
-			.Enrich.FromLogContext()
-			.WriteTo.Console(outputTemplate: template, formatProvider: CultureInfo.InvariantCulture, theme: AnsiConsoleTheme.Literate)
-			.CreateLogger();
-
 	public static ILogger Create(string name) {
 		return Base.ForContext("Category", name);
 	}
 
-	public static ILogger Create(Type type) {
+	public static ILogger Create(string name1, string name2) {
-		return Create(type.Name);
+		return Create(name1 + ":" + name2);
 	}
 
 	public static ILogger Create<T>() {
@@ -42,11 +35,11 @@ public static class PhantomLogger {
 	}
 
 	public static ILogger Create<T>(string name) {
-		return Create(typeof(T).Name + ":" + name);
+		return Create(typeof(T).Name, name);
 	}
 
 	public static ILogger Create<T1, T2>() {
-		return Create(typeof(T1).Name + ":" + typeof(T2).Name);
+		return Create(typeof(T1).Name, typeof(T2).Name);
 	}
 
 	public static void Dispose() {

Common/Phantom.Common.Messages/BiDirectional/ReplyMessage.cs

@@ -1,7 +1,7 @@
 using MemoryPack;
 using Phantom.Utils.Rpc.Message;
 
-namespace Phantom.Common.Messages.ToServer;
+namespace Phantom.Common.Messages.BiDirectional;
 
 [MemoryPackable]
 public sealed partial record ReplyMessage(

Common/Phantom.Common.Messages/IMessageToAgent.cs

@@ -4,6 +4,4 @@ namespace Phantom.Common.Messages;
 
 public interface IMessageToAgent<TReply> : IMessage<IMessageToAgentListener, TReply> {}
 
-public interface IMessageToAgent : IMessageToAgent<NoReply> {
+public interface IMessageToAgent : IMessageToAgent<NoReply> {}
-	uint IMessage<IMessageToAgentListener, NoReply>.SequenceId => 0;
-}

Common/Phantom.Common.Messages/IMessageToAgentListener.cs

@@ -1,6 +1,6 @@
 using Phantom.Common.Data.Replies;
+using Phantom.Common.Messages.BiDirectional;
 using Phantom.Common.Messages.ToAgent;
-using Phantom.Common.Messages.ToServer;
 using Phantom.Utils.Rpc.Message;
 
 namespace Phantom.Common.Messages;

Common/Phantom.Common.Messages/IMessageToServer.cs

@@ -4,6 +4,4 @@ namespace Phantom.Common.Messages;
 
 public interface IMessageToServer<TReply> : IMessage<IMessageToServerListener, TReply> {}
 
-public interface IMessageToServer : IMessageToServer<NoReply> {
+public interface IMessageToServer : IMessageToServer<NoReply> {}
-	uint IMessage<IMessageToServerListener, NoReply>.SequenceId => 0;
-}

Common/Phantom.Common.Messages/IMessageToServerListener.cs

@@ -1,4 +1,5 @@
-using Phantom.Common.Messages.ToServer;
+using Phantom.Common.Messages.BiDirectional;
+using Phantom.Common.Messages.ToServer;
 using Phantom.Utils.Rpc.Message;
 
 namespace Phantom.Common.Messages; 
@@ -9,7 +10,9 @@ public interface IMessageToServerListener {
 	Task<NoReply> HandleUnregisterAgent(UnregisterAgentMessage message);
 	Task<NoReply> HandleAgentIsAlive(AgentIsAliveMessage message);
 	Task<NoReply> HandleAdvertiseJavaRuntimes(AdvertiseJavaRuntimesMessage message);
+	Task<NoReply> HandleReportAgentStatus(ReportAgentStatusMessage message);
 	Task<NoReply> HandleReportInstanceStatus(ReportInstanceStatusMessage message);
+	Task<NoReply> HandleReportInstanceEvent(ReportInstanceEventMessage message);
 	Task<NoReply> HandleInstanceOutput(InstanceOutputMessage message);
 	Task<NoReply> HandleReply(ReplyMessage message);
 }

Common/Phantom.Common.Messages/MessageRegistries.cs

@@ -1,5 +1,6 @@
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Logging;
+using Phantom.Common.Messages.BiDirectional;
 using Phantom.Common.Messages.ToAgent;
 using Phantom.Common.Messages.ToServer;
 using Phantom.Utils.Rpc.Message;
@@ -11,20 +12,22 @@ public static class MessageRegistries {
 	public static MessageRegistry<IMessageToServerListener> ToServer { get; } = new (PhantomLogger.Create("MessageRegistry:ToServer"));
 
 	static MessageRegistries() {
-		ToAgent.Add<RegisterAgentSuccessMessage, NoReply>(0);
+		ToAgent.Add<RegisterAgentSuccessMessage>(0);
-		ToAgent.Add<RegisterAgentFailureMessage, NoReply>(1);
+		ToAgent.Add<RegisterAgentFailureMessage>(1);
 		ToAgent.Add<ConfigureInstanceMessage, InstanceActionResult<ConfigureInstanceResult>>(2);
 		ToAgent.Add<LaunchInstanceMessage, InstanceActionResult<LaunchInstanceResult>>(3);
 		ToAgent.Add<StopInstanceMessage, InstanceActionResult<StopInstanceResult>>(4);
 		ToAgent.Add<SendCommandToInstanceMessage, InstanceActionResult<SendCommandToInstanceResult>>(5);
-		ToAgent.Add<ReplyMessage, NoReply>(127);
+		ToAgent.Add<ReplyMessage>(127);
 		
-		ToServer.Add<RegisterAgentMessage, NoReply>(0);
+		ToServer.Add<RegisterAgentMessage>(0);
-		ToServer.Add<UnregisterAgentMessage, NoReply>(1);
+		ToServer.Add<UnregisterAgentMessage>(1);
-		ToServer.Add<AgentIsAliveMessage, NoReply>(2);
+		ToServer.Add<AgentIsAliveMessage>(2);
-		ToServer.Add<AdvertiseJavaRuntimesMessage, NoReply>(3);
+		ToServer.Add<AdvertiseJavaRuntimesMessage>(3);
-		ToServer.Add<ReportInstanceStatusMessage, NoReply>(4);
+		ToServer.Add<ReportInstanceStatusMessage>(4);
-		ToServer.Add<InstanceOutputMessage, NoReply>(5);
+		ToServer.Add<InstanceOutputMessage>(5);
-		ToServer.Add<ReplyMessage, NoReply>(127);
+		ToServer.Add<ReportAgentStatusMessage>(6);
+		ToServer.Add<ReportInstanceEventMessage>(7);
+		ToServer.Add<ReplyMessage>(127);
 	}
 }

Common/Phantom.Common.Messages/ToAgent/ConfigureInstanceMessage.cs

@@ -6,8 +6,9 @@ namespace Phantom.Common.Messages.ToAgent;
 
 [MemoryPackable]
 public sealed partial record ConfigureInstanceMessage(
-	[property: MemoryPackOrder(0)] uint SequenceId,
+	[property: MemoryPackOrder(0)] InstanceConfiguration Configuration,
-	[property: MemoryPackOrder(1)] InstanceConfiguration Configuration
+	[property: MemoryPackOrder(1)] InstanceLaunchProperties LaunchProperties,
+	[property: MemoryPackOrder(2)] bool LaunchNow = false
 ) : IMessageToAgent<InstanceActionResult<ConfigureInstanceResult>> {
 	public Task<InstanceActionResult<ConfigureInstanceResult>> Accept(IMessageToAgentListener listener) {
 		return listener.HandleConfigureInstance(this);

Common/Phantom.Common.Messages/ToAgent/LaunchInstanceMessage.cs

@@ -5,8 +5,7 @@ namespace Phantom.Common.Messages.ToAgent;
 
 [MemoryPackable]
 public sealed partial record LaunchInstanceMessage(
-	[property: MemoryPackOrder(0)] uint SequenceId,
+	[property: MemoryPackOrder(0)] Guid InstanceGuid
-	[property: MemoryPackOrder(1)] Guid InstanceGuid
 ) : IMessageToAgent<InstanceActionResult<LaunchInstanceResult>> {
 	public Task<InstanceActionResult<LaunchInstanceResult>> Accept(IMessageToAgentListener listener) {
 		return listener.HandleLaunchInstance(this);

Common/Phantom.Common.Messages/ToAgent/RegisterAgentSuccessMessage.cs

@@ -1,13 +1,12 @@
 using System.Collections.Immutable;
 using MemoryPack;
-using Phantom.Common.Data.Instance;
 using Phantom.Utils.Rpc.Message;
 
 namespace Phantom.Common.Messages.ToAgent;
 
 [MemoryPackable]
 public sealed partial record RegisterAgentSuccessMessage(
-	[property: MemoryPackOrder(0)] ImmutableArray<InstanceConfiguration> InitialInstances
+	[property: MemoryPackOrder(0)] ImmutableArray<ConfigureInstanceMessage> InitialInstanceConfigurations
 ) : IMessageToAgent {
 	public Task<NoReply> Accept(IMessageToAgentListener listener) {
 		return listener.HandleRegisterAgentSuccess(this);

Common/Phantom.Common.Messages/ToAgent/SendCommandToInstanceMessage.cs

@@ -5,9 +5,8 @@ namespace Phantom.Common.Messages.ToAgent;
 
 [MemoryPackable]
 public sealed partial record SendCommandToInstanceMessage(
-	[property: MemoryPackOrder(0)] uint SequenceId,
+	[property: MemoryPackOrder(0)] Guid InstanceGuid,
-	[property: MemoryPackOrder(1)] Guid InstanceGuid,
+	[property: MemoryPackOrder(1)] string Command
-	[property: MemoryPackOrder(2)] string Command
 ) : IMessageToAgent<InstanceActionResult<SendCommandToInstanceResult>> {
 	public Task<InstanceActionResult<SendCommandToInstanceResult>> Accept(IMessageToAgentListener listener) {
 		return listener.HandleSendCommandToInstance(this);

Common/Phantom.Common.Messages/ToAgent/StopInstanceMessage.cs

@@ -6,9 +6,8 @@ namespace Phantom.Common.Messages.ToAgent;
 
 [MemoryPackable]
 public sealed partial record StopInstanceMessage(
-	[property: MemoryPackOrder(0)] uint SequenceId,
+	[property: MemoryPackOrder(0)] Guid InstanceGuid,
-	[property: MemoryPackOrder(1)] Guid InstanceGuid,
+	[property: MemoryPackOrder(1)] MinecraftStopStrategy StopStrategy
-	[property: MemoryPackOrder(2)] MinecraftStopStrategy StopStrategy
 ) : IMessageToAgent<InstanceActionResult<StopInstanceResult>> {
 	public Task<InstanceActionResult<StopInstanceResult>> Accept(IMessageToAgentListener listener) {
 		return listener.HandleStopInstance(this);

Common/Phantom.Common.Messages/ToServer/ReportAgentStatusMessage.cs

@@ -0,0 +1,15 @@
+using MemoryPack;
+using Phantom.Common.Data;
+using Phantom.Utils.Rpc.Message;
+
+namespace Phantom.Common.Messages.ToServer; 
+
+[MemoryPackable]
+public partial record ReportAgentStatusMessage(
+	[property: MemoryPackOrder(0)] int RunningInstanceCount,
+	[property: MemoryPackOrder(1)] RamAllocationUnits RunningInstanceMemory
+) : IMessageToServer {
+	public Task<NoReply> Accept(IMessageToServerListener listener) {
+		return listener.HandleReportAgentStatus(this);
+	}
+}

Common/Phantom.Common.Messages/ToServer/ReportInstanceEventMessage.cs

@@ -0,0 +1,17 @@
+using MemoryPack;
+using Phantom.Common.Data.Instance;
+using Phantom.Utils.Rpc.Message;
+
+namespace Phantom.Common.Messages.ToServer; 
+
+[MemoryPackable]
+public sealed partial record ReportInstanceEventMessage(
+	[property: MemoryPackOrder(0)] Guid EventGuid,
+	[property: MemoryPackOrder(1)] DateTime UtcTime,
+	[property: MemoryPackOrder(2)] Guid InstanceGuid,
+	[property: MemoryPackOrder(3)] IInstanceEvent Event
+) : IMessageToServer {
+	public Task<NoReply> Accept(IMessageToServerListener listener) {
+		return listener.HandleReportInstanceEvent(this);
+	}
+}

Common/Phantom.Common.Minecraft/MinecraftServerExecutableInfo.cs

@@ -1,10 +0,0 @@
-using Phantom.Utils.Cryptography;
-using Phantom.Utils.IO;
-
-namespace Phantom.Common.Minecraft; 
-
-public sealed record MinecraftServerExecutableInfo(
-	string DownloadUrl,
-	Sha1String Hash,
-	FileSize Size
-);

Common/Phantom.Common.Minecraft/Phantom.Common.Minecraft.csproj

@@ -6,11 +6,4 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
   
-  <ItemGroup>
-    <ProjectReference Include="..\..\Utils\Phantom.Utils.IO\Phantom.Utils.IO.csproj" />
-    <ProjectReference Include="..\..\Utils\Phantom.Utils.Runtime\Phantom.Utils.Runtime.csproj" />
-    <ProjectReference Include="..\Phantom.Common.Data\Phantom.Common.Data.csproj" />
-    <ProjectReference Include="..\Phantom.Common.Logging\Phantom.Common.Logging.csproj" />
-  </ItemGroup>
-  
 </Project>

Dockerfile

@@ -33,10 +33,13 @@ FROM ubuntu:focal AS java-legacy
 
 ARG DEBIAN_FRONTEND=noninteractive
 
-RUN apt-get update &&       \
+RUN --mount=target=/var/lib/apt/lists,type=cache,sharing=locked \
-    apt-get install -y      \
+    --mount=target=/var/cache/apt,type=cache,sharing=locked     \
-    openjdk-8-jre-headless  \
+    rm -f /etc/apt/apt.conf.d/docker-clean                   && \
-    openjdk-16-jre-headless \
+    apt-get update                                           && \
+    apt-get install -y                                          \
+    openjdk-8-jre-headless                                      \
+    openjdk-16-jre-headless                                     \
     openjdk-17-jre-headless
 
 
@@ -49,18 +52,21 @@ COPY --from=java-legacy /usr/lib/jvm/java-8-openjdk-amd64 /usr/lib/jvm/java-8-op
 COPY --from=java-legacy /usr/lib/jvm/java-16-openjdk-amd64 /usr/lib/jvm/java-16-openjdk-amd64
 COPY --from=java-legacy /usr/lib/jvm/java-17-openjdk-amd64 /usr/lib/jvm/java-17-openjdk-amd64
 
-COPY --from=phantom-agent-builder --chmod=755 /app/out /app
-
 ARG DEBIAN_FRONTEND=noninteractive
 
-RUN apt-get update &&  \
+RUN --mount=target=/var/lib/apt/lists,type=cache,sharing=locked \
-    apt-get install -y \
+    --mount=target=/var/cache/apt,type=cache,sharing=locked     \
-    openjdk-18-jre-headless
+    rm -f /etc/apt/apt.conf.d/docker-clean                   && \
+    apt-get update                                           && \
+    apt-get install -y                                          \
+    openjdk-18-jre-headless                                     \
+    zstd
 
-RUN mkdir /data
+RUN mkdir /data && chmod 777 /data
-RUN chmod 777 /data
 WORKDIR /data
 
+COPY --from=phantom-agent-builder --chmod=755 /app/out /app
+
 ENTRYPOINT ["dotnet", "/app/Phantom.Agent.dll"]
 
 
@@ -69,10 +75,9 @@ ENTRYPOINT ["dotnet", "/app/Phantom.Agent.dll"]
 # +-------------------------------+
 FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS phantom-server
 
-COPY --from=phantom-server-builder --chmod=755 /app/out /app
+RUN mkdir /data && chmod 777 /data
-
-RUN mkdir /data
-RUN chmod 777 /data
 WORKDIR /data
 
+COPY --from=phantom-server-builder --chmod=755 /app/out /app
+
 ENTRYPOINT ["dotnet", "/app/Phantom.Server.dll"]

Packages.props

@@ -20,6 +20,7 @@
   <ItemGroup>
     <PackageReference Update="Serilog"               Version="2.12.0" />
     <PackageReference Update="Serilog.AspNetCore"    Version="6.1.0" />
+    <PackageReference Update="Serilog.Sinks.Async"   Version="1.5.0" />
     <PackageReference Update="Serilog.Sinks.Console" Version="4.1.0" />
   </ItemGroup>
   

PhantomPanel.sln

@@ -36,6 +36,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Database", "
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Database.Postgres", "Server\Phantom.Server.Database.Postgres\Phantom.Server.Database.Postgres.csproj", "{81625B4A-3DB6-48BD-A739-D23DA02107D1}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Minecraft", "Server\Phantom.Server.Minecraft\Phantom.Server.Minecraft.csproj", "{4B3B73E6-48DD-4846-87FD-DFB86619B67C}"
+EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Rpc", "Server\Phantom.Server.Rpc\Phantom.Server.Rpc.csproj", "{79312D72-44E0-431D-96A4-4C0A066B9671}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Services", "Server\Phantom.Server.Services\Phantom.Server.Services.csproj", "{90F0F1B1-EB0A-49C9-8DF0-1153A87F77C9}"
@@ -118,6 +120,10 @@ Global
 		{81625B4A-3DB6-48BD-A739-D23DA02107D1}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{81625B4A-3DB6-48BD-A739-D23DA02107D1}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{81625B4A-3DB6-48BD-A739-D23DA02107D1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C}.Release|Any CPU.Build.0 = Release|Any CPU
 		{79312D72-44E0-431D-96A4-4C0A066B9671}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{79312D72-44E0-431D-96A4-4C0A066B9671}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{79312D72-44E0-431D-96A4-4C0A066B9671}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -184,6 +190,7 @@ Global
 		{A0F1C595-96B6-4DBF-8C16-6B99223F8F35} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{E3AD566F-384A-489A-A3BB-EA3BA400C18C} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{81625B4A-3DB6-48BD-A739-D23DA02107D1} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{79312D72-44E0-431D-96A4-4C0A066B9671} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{90F0F1B1-EB0A-49C9-8DF0-1153A87F77C9} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{7CA2E5FE-E507-4DC6-930C-E18711A9F856} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}

README.md

@@ -97,6 +97,18 @@ Use volumes to persist either the whole `/data` folder, or just `/data/data` if
   - `ALLOWED_SERVER_PORTS` is a comma-separated list of ports and port ranges that can be used as Minecraft Server ports. Example: `25565,25900,26000-27000`
   - `ALLOWED_RCON_PORTS` is a comma-separated list of ports and port ranges that can be used as Minecraft RCON ports. Example: `25575,25901,36000-37000`
 
+## Logging
+
+Both the Server and Agent support a `LOG_LEVEL` environment variable to set the minimum log level. Possible values:
+
+* `VERBOSE`
+* `DEBUG`
+* `INFORMATION`
+* `WARNING`
+* `ERROR`
+
+If the environment variable is omitted, the log level is set to `VERBOSE` for Debug builds and `INFORMATION` for Release builds.
+
 # Development
 
 The repository includes a [Rider](https://www.jetbrains.com/rider/) projects with several run configurations. The `.workdir` folder in the root of the repository is used for storage. Here's how to get started:

Server/Phantom.Server.Database.Postgres/Migrations/20230213040522_AuditLogRename.Designer.cs

@@ -0,0 +1,466 @@
+// <auto-generated />
+using System;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Phantom.Server.Database;
+
+#nullable disable
+
+namespace Phantom.Server.Database.Postgres.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20230213040522_AuditLogRename")]
+    partial class AuditLogRename
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "7.0.1")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("Roles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("RoleClaims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("Users", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserLogins", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("UserRoles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("UserTokens", "identity");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AgentEntity", b =>
+                {
+                    b.Property<Guid>("AgentGuid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BuildVersion")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("MaxInstances")
+                        .HasColumnType("integer");
+
+                    b.Property<ushort>("MaxMemory")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ProtocolVersion")
+                        .HasColumnType("integer");
+
+                    b.HasKey("AgentGuid");
+
+                    b.ToTable("Agents", "agents");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditEventEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<JsonDocument>("Data")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UtcTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AuditLog", "system");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.InstanceEntity", b =>
+                {
+                    b.Property<Guid>("InstanceGuid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AgentGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("InstanceName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("JavaRuntimeGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("JvmArguments")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("LaunchAutomatically")
+                        .HasColumnType("boolean");
+
+                    b.Property<ushort>("MemoryAllocation")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MinecraftServerKind")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MinecraftVersion")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("RconPort")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ServerPort")
+                        .HasColumnType("integer");
+
+                    b.HasKey("InstanceGuid");
+
+                    b.ToTable("Instances", "agents");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.PermissionEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Permissions", "identity");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.RolePermissionEntity", b =>
+                {
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PermissionId")
+                        .HasColumnType("text");
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("RolePermissions", "identity");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.UserPermissionEntity", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PermissionId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("UserPermissions", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditEventEntity", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.RolePermissionEntity", b =>
+                {
+                    b.HasOne("Phantom.Server.Database.Entities.PermissionEntity", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.UserPermissionEntity", b =>
+                {
+                    b.HasOne("Phantom.Server.Database.Entities.PermissionEntity", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Server/Phantom.Server.Database.Postgres/Migrations/20230213040522_AuditLogRename.cs

@@ -0,0 +1,92 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Phantom.Server.Database.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class AuditLogRename : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AuditEvents_Users_UserId",
+                schema: "system",
+                table: "AuditEvents");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AuditEvents",
+                schema: "system",
+                table: "AuditEvents");
+
+            migrationBuilder.RenameTable(
+                name: "AuditEvents",
+                schema: "system",
+                newName: "AuditLog",
+                newSchema: "system");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_AuditEvents_UserId",
+                schema: "system",
+                table: "AuditLog",
+                newName: "IX_AuditLog_UserId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AuditLog",
+                schema: "system",
+                table: "AuditLog",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AuditLog_Users_UserId",
+                schema: "system",
+                table: "AuditLog",
+                column: "UserId",
+                principalSchema: "identity",
+                principalTable: "Users",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AuditLog_Users_UserId",
+                schema: "system",
+                table: "AuditLog");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AuditLog",
+                schema: "system",
+                table: "AuditLog");
+
+            migrationBuilder.RenameTable(
+                name: "AuditLog",
+                schema: "system",
+                newName: "AuditEvents",
+                newSchema: "system");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_AuditLog_UserId",
+                schema: "system",
+                table: "AuditEvents",
+                newName: "IX_AuditEvents_UserId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AuditEvents",
+                schema: "system",
+                table: "AuditEvents",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AuditEvents_Users_UserId",
+                schema: "system",
+                table: "AuditEvents",
+                column: "UserId",
+                principalSchema: "identity",
+                principalTable: "Users",
+                principalColumn: "Id");
+        }
+    }
+}

Server/Phantom.Server.Database.Postgres/Migrations/20230215101444_EventLog.Designer.cs

@@ -0,0 +1,498 @@
+// <auto-generated />
+using System;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Phantom.Server.Database;
+
+#nullable disable
+
+namespace Phantom.Server.Database.Postgres.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20230215101444_EventLog")]
+    partial class EventLog
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "7.0.1")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("Roles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("RoleClaims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("Users", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserLogins", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("UserRoles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("UserTokens", "identity");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AgentEntity", b =>
+                {
+                    b.Property<Guid>("AgentGuid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BuildVersion")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("MaxInstances")
+                        .HasColumnType("integer");
+
+                    b.Property<ushort>("MaxMemory")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ProtocolVersion")
+                        .HasColumnType("integer");
+
+                    b.HasKey("AgentGuid");
+
+                    b.ToTable("Agents", "agents");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditLogEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<JsonDocument>("Data")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UtcTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AuditLog", "system");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.EventLogEntity", b =>
+                {
+                    b.Property<Guid>("EventGuid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AgentGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<JsonDocument>("Data")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UtcTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("EventGuid");
+
+                    b.ToTable("EventLog", "system");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.InstanceEntity", b =>
+                {
+                    b.Property<Guid>("InstanceGuid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AgentGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("InstanceName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("JavaRuntimeGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("JvmArguments")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("LaunchAutomatically")
+                        .HasColumnType("boolean");
+
+                    b.Property<ushort>("MemoryAllocation")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MinecraftServerKind")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MinecraftVersion")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("RconPort")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ServerPort")
+                        .HasColumnType("integer");
+
+                    b.HasKey("InstanceGuid");
+
+                    b.ToTable("Instances", "agents");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.PermissionEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Permissions", "identity");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.RolePermissionEntity", b =>
+                {
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PermissionId")
+                        .HasColumnType("text");
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("RolePermissions", "identity");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.UserPermissionEntity", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PermissionId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("UserPermissions", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditLogEntity", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.RolePermissionEntity", b =>
+                {
+                    b.HasOne("Phantom.Server.Database.Entities.PermissionEntity", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.UserPermissionEntity", b =>
+                {
+                    b.HasOne("Phantom.Server.Database.Entities.PermissionEntity", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Server/Phantom.Server.Database.Postgres/Migrations/20230215101444_EventLog.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Phantom.Server.Database.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class EventLog : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "EventLog",
+                schema: "system",
+                columns: table => new
+                {
+                    EventGuid = table.Column<Guid>(type: "uuid", nullable: false),
+                    UtcTime = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    AgentGuid = table.Column<Guid>(type: "uuid", nullable: true),
+                    EventType = table.Column<string>(type: "text", nullable: false),
+                    SubjectType = table.Column<string>(type: "text", nullable: false),
+                    SubjectId = table.Column<string>(type: "text", nullable: false),
+                    Data = table.Column<JsonDocument>(type: "jsonb", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_EventLog", x => x.EventGuid);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "EventLog",
+                schema: "system");
+        }
+    }
+}

Server/Phantom.Server.Database.Postgres/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -18,7 +18,7 @@ namespace Phantom.Server.Database.Postgres.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "7.0.0-rc.1.22426.7")
+                .HasAnnotation("ProductVersion", "7.0.1")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
@@ -247,7 +247,7 @@ namespace Phantom.Server.Database.Postgres.Migrations
                     b.ToTable("Agents", "agents");
                 });
 
-            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditEventEntity", b =>
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditLogEntity", b =>
                 {
                     b.Property<long>("Id")
                         .ValueGeneratedOnAdd()
@@ -280,7 +280,39 @@ namespace Phantom.Server.Database.Postgres.Migrations
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("AuditEvents", "system");
+                    b.ToTable("AuditLog", "system");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.EventLogEntity", b =>
+                {
+                    b.Property<Guid>("EventGuid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AgentGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<JsonDocument>("Data")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UtcTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("EventGuid");
+
+                    b.ToTable("EventLog", "system");
                 });
 
             modelBuilder.Entity("Phantom.Server.Database.Entities.InstanceEntity", b =>
@@ -419,7 +451,7 @@ namespace Phantom.Server.Database.Postgres.Migrations
                         .IsRequired();
                 });
 
-            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditEventEntity", b =>
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditLogEntity", b =>
                 {
                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", "User")
                         .WithMany()

Server/Phantom.Server.Database/ApplicationDbContext.cs

@@ -20,7 +20,8 @@ public class ApplicationDbContext : IdentityDbContext {
 	
 	public DbSet<AgentEntity> Agents { get; set; } = null!;
 	public DbSet<InstanceEntity> Instances { get; set; } = null!;
-	public DbSet<AuditEventEntity> AuditEvents { get; set; } = null!;
+	public DbSet<AuditLogEntity> AuditLog { get; set; } = null!;
+	public DbSet<EventLogEntity> EventLog { get; set; } = null!;
 
 	public AgentEntityUpsert AgentUpsert { get; }
 	public InstanceEntityUpsert InstanceUpsert { get; }
@@ -60,8 +61,10 @@ public class ApplicationDbContext : IdentityDbContext {
 	protected override void ConfigureConventions(ModelConfigurationBuilder builder) {
 		base.ConfigureConventions(builder);
 
-		builder.Properties<AuditEventType>().HaveConversion<EnumToStringConverter<AuditEventType>>();
+		builder.Properties<AuditLogEventType>().HaveConversion<EnumToStringConverter<AuditLogEventType>>();
-		builder.Properties<AuditSubjectType>().HaveConversion<EnumToStringConverter<AuditSubjectType>>();
+		builder.Properties<AuditLogSubjectType>().HaveConversion<EnumToStringConverter<AuditLogSubjectType>>();
+		builder.Properties<EventLogEventType>().HaveConversion<EnumToStringConverter<EventLogEventType>>();
+		builder.Properties<EventLogSubjectType>().HaveConversion<EnumToStringConverter<EventLogSubjectType>>();
 		builder.Properties<MinecraftServerKind>().HaveConversion<EnumToStringConverter<MinecraftServerKind>>();
 		builder.Properties<RamAllocationUnits>().HaveConversion<RamAllocationUnitsConverter>();
 	}

Server/Phantom.Server.Database/Entities/AuditLogEntity.cs

@@ -7,10 +7,10 @@ using Phantom.Server.Database.Enums;
 
 namespace Phantom.Server.Database.Entities; 
 
-[Table("AuditEvents", Schema = "system")]
+[Table("AuditLog", Schema = "system")]
 [SuppressMessage("ReSharper", "AutoPropertyCanBeMadeGetOnly.Global")]
 [SuppressMessage("ReSharper", "ClassWithVirtualMembersNeverInherited.Global")]
-public class AuditEventEntity : IDisposable {
+public class AuditLogEntity : IDisposable {
 	[Key]
 	[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
 	[SuppressMessage("ReSharper", "UnusedMember.Global")]
@@ -18,19 +18,19 @@ public class AuditEventEntity : IDisposable {
 
 	public string? UserId { get; set; }
 	public DateTime UtcTime { get; set; } // Note: Converting to UTC is not best practice, but for historical records it's good enough.
-	public AuditEventType EventType { get; set; }
+	public AuditLogEventType EventType { get; set; }
-	public AuditSubjectType SubjectType { get; set; }
+	public AuditLogSubjectType SubjectType { get; set; }
 	public string SubjectId { get; set; }
 	public JsonDocument? Data { get; set; }
 
 	public virtual IdentityUser? User { get; set; }
 	
 	[SuppressMessage("ReSharper", "UnusedMember.Global")]
-	internal AuditEventEntity() {
+	internal AuditLogEntity() {
 		SubjectId = string.Empty;
 	}
 
-	public AuditEventEntity(string? userId, AuditEventType eventType, string subjectId, Dictionary<string, object?>? data) {
+	public AuditLogEntity(string? userId, AuditLogEventType eventType, string subjectId, Dictionary<string, object?>? data) {
 		UserId = userId;
 		UtcTime = DateTime.UtcNow;
 		EventType = eventType;

Server/Phantom.Server.Database/Entities/EventLogEntity.cs

@@ -0,0 +1,41 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using Phantom.Server.Database.Enums;
+
+namespace Phantom.Server.Database.Entities; 
+
+[Table("EventLog", Schema = "system")]
+[SuppressMessage("ReSharper", "AutoPropertyCanBeMadeGetOnly.Global")]
+[SuppressMessage("ReSharper", "ClassWithVirtualMembersNeverInherited.Global")]
+public sealed class EventLogEntity : IDisposable {
+	[Key]
+	public Guid EventGuid { get; set; }
+
+	public DateTime UtcTime { get; set; } // Note: Converting to UTC is not best practice, but for historical records it's good enough.
+	public Guid? AgentGuid { get; set; }
+	public EventLogEventType EventType { get; set; }
+	public EventLogSubjectType SubjectType { get; set; }
+	public string SubjectId { get; set; }
+	public JsonDocument? Data { get; set; }
+	
+	[SuppressMessage("ReSharper", "UnusedMember.Global")]
+	internal EventLogEntity() {
+		SubjectId = string.Empty;
+	}
+
+	public EventLogEntity(Guid eventGuid, DateTime utcTime, Guid? agentGuid, EventLogEventType eventType, string subjectId, Dictionary<string, object?>? data) {
+		EventGuid = eventGuid;
+		UtcTime = utcTime;
+		AgentGuid = agentGuid;
+		EventType = eventType;
+		SubjectType = eventType.GetSubjectType();
+		SubjectId = subjectId;
+		Data = data == null ? null : JsonSerializer.SerializeToDocument(data);
+	}
+
+	public void Dispose() {
+		Data?.Dispose();
+	}
+}

Server/Phantom.Server.Database/Entities/PermissionEntity.cs

@@ -4,7 +4,7 @@ using System.ComponentModel.DataAnnotations.Schema;
 namespace Phantom.Server.Database.Entities; 
 
 [Table("Permissions", Schema = "identity")]
-public class PermissionEntity {
+public sealed class PermissionEntity {
 	[Key]
 	public string Id { get; set; }
 

Server/Phantom.Server.Database/Entities/RolePermissionEntity.cs

@@ -3,7 +3,7 @@
 namespace Phantom.Server.Database.Entities; 
 
 [Table("RolePermissions", Schema = "identity")]
-public class RolePermissionEntity {
+public sealed class RolePermissionEntity {
 	public string RoleId { get; set; }
 	public string PermissionId { get; set; }
 	

Server/Phantom.Server.Database/Entities/UserPermissionEntity.cs

@@ -3,7 +3,7 @@
 namespace Phantom.Server.Database.Entities;
 
 [Table("UserPermissions", Schema = "identity")]
-public class UserPermissionEntity {
+public sealed class UserPermissionEntity {
 	public string UserId { get; set; }
 	public string PermissionId { get; set; }
 

Server/Phantom.Server.Database/Enums/AuditEventType.cs

@@ -1,52 +0,0 @@
-using System.Text.RegularExpressions;
-
-namespace Phantom.Server.Database.Enums;
-
-public enum AuditEventType {
-	AdministratorUserCreated,
-	AdministratorUserModified,
-	UserLoggedIn,
-	UserLoggedOut,
-	UserCreated,
-	UserRolesChanged,
-	UserDeleted,
-	InstanceCreated,
-	InstanceLaunched,
-	InstanceStopped,
-	InstanceCommandExecuted
-}
-
-public static partial class AuditEventCategoryExtensions {
-	private static readonly Dictionary<AuditEventType, AuditSubjectType> SubjectTypes = new () {
-		{ AuditEventType.AdministratorUserCreated,  AuditSubjectType.User },
-		{ AuditEventType.AdministratorUserModified, AuditSubjectType.User },
-		{ AuditEventType.UserLoggedIn,              AuditSubjectType.User },
-		{ AuditEventType.UserLoggedOut,             AuditSubjectType.User },
-		{ AuditEventType.UserCreated,               AuditSubjectType.User },
-		{ AuditEventType.UserRolesChanged,          AuditSubjectType.User },
-		{ AuditEventType.UserDeleted,               AuditSubjectType.User },
-		{ AuditEventType.InstanceCreated,           AuditSubjectType.Instance },
-		{ AuditEventType.InstanceLaunched,          AuditSubjectType.Instance },
-		{ AuditEventType.InstanceStopped,           AuditSubjectType.Instance },
-		{ AuditEventType.InstanceCommandExecuted,   AuditSubjectType.Instance }
-	};
-
-	static AuditEventCategoryExtensions() {
-		foreach (var eventType in Enum.GetValues<AuditEventType>()) {
-			if (!SubjectTypes.ContainsKey(eventType)) {
-				throw new Exception("Missing mapping from " + eventType + " to a subject type.");
-			}
-		}
-	}
-
-	internal static AuditSubjectType GetSubjectType(this AuditEventType type) {
-		return SubjectTypes[type];
-	}
-	
-	[GeneratedRegex(@"\B([A-Z])", RegexOptions.NonBacktracking)]
-	private static partial Regex FindCapitalLettersRegex();
-
-	public static string ToNiceString(this AuditEventType type) {
-		return FindCapitalLettersRegex().Replace(type.ToString(), static match => " " + match.Groups[1].Value.ToLowerInvariant());
-	}
-}

Server/Phantom.Server.Database/Enums/AuditLogEventType.cs

@@ -0,0 +1,45 @@
+namespace Phantom.Server.Database.Enums;
+
+public enum AuditLogEventType {
+	AdministratorUserCreated,
+	AdministratorUserModified,
+	UserLoggedIn,
+	UserLoggedOut,
+	UserCreated,
+	UserRolesChanged,
+	UserDeleted,
+	InstanceCreated,
+	InstanceEdited,
+	InstanceLaunched,
+	InstanceStopped,
+	InstanceCommandExecuted
+}
+
+public static class AuditLogEventTypeExtensions {
+	private static readonly Dictionary<AuditLogEventType, AuditLogSubjectType> SubjectTypes = new () {
+		{ AuditLogEventType.AdministratorUserCreated,  AuditLogSubjectType.User },
+		{ AuditLogEventType.AdministratorUserModified, AuditLogSubjectType.User },
+		{ AuditLogEventType.UserLoggedIn,              AuditLogSubjectType.User },
+		{ AuditLogEventType.UserLoggedOut,             AuditLogSubjectType.User },
+		{ AuditLogEventType.UserCreated,               AuditLogSubjectType.User },
+		{ AuditLogEventType.UserRolesChanged,          AuditLogSubjectType.User },
+		{ AuditLogEventType.UserDeleted,               AuditLogSubjectType.User },
+		{ AuditLogEventType.InstanceCreated,           AuditLogSubjectType.Instance },
+		{ AuditLogEventType.InstanceEdited,            AuditLogSubjectType.Instance },
+		{ AuditLogEventType.InstanceLaunched,          AuditLogSubjectType.Instance },
+		{ AuditLogEventType.InstanceStopped,           AuditLogSubjectType.Instance },
+		{ AuditLogEventType.InstanceCommandExecuted,   AuditLogSubjectType.Instance }
+	};
+
+	static AuditLogEventTypeExtensions() {
+		foreach (var eventType in Enum.GetValues<AuditLogEventType>()) {
+			if (!SubjectTypes.ContainsKey(eventType)) {
+				throw new Exception("Missing mapping from " + eventType + " to a subject type.");
+			}
+		}
+	}
+
+	internal static AuditLogSubjectType GetSubjectType(this AuditLogEventType type) {
+		return SubjectTypes[type];
+	}
+}

Server/Phantom.Server.Database/Enums/AuditLogSubjectType.cs

@@ -1,6 +1,6 @@
 namespace Phantom.Server.Database.Enums; 
 
-public enum AuditSubjectType {
+public enum AuditLogSubjectType {
 	User,
 	Instance
 }

Server/Phantom.Server.Database/Enums/EventLogEventType.cs

@@ -0,0 +1,35 @@
+namespace Phantom.Server.Database.Enums;
+
+public enum EventLogEventType {
+	InstanceLaunchSucceded,
+	InstanceLaunchFailed,
+	InstanceCrashed,
+	InstanceStopped,
+	InstanceBackupSucceeded,
+	InstanceBackupSucceededWithWarnings,
+	InstanceBackupFailed,
+}
+
+internal static class EventLogEventTypeExtensions {
+	private static readonly Dictionary<EventLogEventType, EventLogSubjectType> SubjectTypes = new () {
+		{ EventLogEventType.InstanceLaunchSucceded, EventLogSubjectType.Instance },
+		{ EventLogEventType.InstanceLaunchFailed, EventLogSubjectType.Instance },
+		{ EventLogEventType.InstanceCrashed, EventLogSubjectType.Instance },
+		{ EventLogEventType.InstanceStopped, EventLogSubjectType.Instance },
+		{ EventLogEventType.InstanceBackupSucceeded, EventLogSubjectType.Instance },
+		{ EventLogEventType.InstanceBackupSucceededWithWarnings, EventLogSubjectType.Instance },
+		{ EventLogEventType.InstanceBackupFailed, EventLogSubjectType.Instance },
+	};
+
+	static EventLogEventTypeExtensions() {
+		foreach (var eventType in Enum.GetValues<EventLogEventType>()) {
+			if (!SubjectTypes.ContainsKey(eventType)) {
+				throw new Exception("Missing mapping from " + eventType + " to a subject type.");
+			}
+		}
+	}
+
+	public static EventLogSubjectType GetSubjectType(this EventLogEventType type) {
+		return SubjectTypes[type];
+	}
+}

Server/Phantom.Server.Database/Enums/EventLogSubjectType.cs

@@ -0,0 +1,5 @@
+namespace Phantom.Server.Database.Enums; 
+
+public enum EventLogSubjectType {
+	Instance
+}

Server/Phantom.Server.Minecraft/MinecraftVersionApi.cs

@@ -1,5 +1,4 @@
 using System.Collections.Immutable;
-using System.Diagnostics;
 using System.Net.Http.Json;
 using System.Text.Json;
 using Phantom.Common.Data.Minecraft;
@@ -9,71 +8,39 @@ using Phantom.Utils.IO;
 using Phantom.Utils.Runtime;
 using Serilog;
 
-namespace Phantom.Common.Minecraft;
+namespace Phantom.Server.Minecraft;
 
-public sealed class MinecraftVersions : IDisposable {
+sealed class MinecraftVersionApi : IDisposable {
-	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftVersions>();
+	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftVersionApi>();
-	private static readonly TimeSpan CacheRetentionTime = TimeSpan.FromMinutes(10);
 	
 	private const string VersionManifestUrl = "https://launchermeta.mojang.com/mc/game/version_manifest.json";
 	
 	private readonly HttpClient http = new ();
 
-	private readonly Stopwatch cacheTimer = new ();
-	private readonly SemaphoreSlim cachedVersionsSemaphore = new (1, 1);
-
-	private ImmutableArray<MinecraftVersion>? cachedVersions;
-	private ImmutableArray<MinecraftVersion>? CachedVersionsUnlessExpired => cacheTimer.IsRunning && cacheTimer.Elapsed < CacheRetentionTime ? cachedVersions : null;
-
 	public void Dispose() {
 		http.Dispose();
-		cachedVersionsSemaphore.Dispose();
 	}
 
 	public async Task<ImmutableArray<MinecraftVersion>> GetVersions(CancellationToken cancellationToken) {
-		if (CachedVersionsUnlessExpired is {} earlyResult) {
+		return await FetchVersions(cancellationToken) ?? ImmutableArray<MinecraftVersion>.Empty;
-			return earlyResult;
-		}
-
-		try {
-			await cachedVersionsSemaphore.WaitAsync(cancellationToken);
-		} catch (OperationCanceledException) {
-			return ImmutableArray<MinecraftVersion>.Empty;
-		}
-
-		try {
-			if (CachedVersionsUnlessExpired is {} racedResult) {
-				return racedResult;
-			}
-
-			ImmutableArray<MinecraftVersion> versions = await FetchVersions(cancellationToken) ?? ImmutableArray<MinecraftVersion>.Empty;
-			Logger.Information("Refreshed Minecraft version cache, {Versions} version(s) found.", versions.Length);
-			
-			cachedVersions = versions;
-			cacheTimer.Restart();
-			return versions;
-		} finally {
-			cachedVersionsSemaphore.Release();
-		}
 	}
 	
 	private async Task<ImmutableArray<MinecraftVersion>?> FetchVersions(CancellationToken cancellationToken) {
 		return await FetchOrFailSilently(async () => {
-			var versionManifest = await FetchJson(http, VersionManifestUrl, "version manifest", cancellationToken);
+			var versionManifest = await FetchJson(VersionManifestUrl, "version manifest", cancellationToken);
 			return GetVersionsFromManifest(versionManifest);
 		});
 	}
 	
-	public async Task<MinecraftServerExecutableInfo?> GetServerExecutableInfo(string version, CancellationToken cancellationToken) {
+	public async Task<FileDownloadInfo?> GetServerExecutableInfo(ImmutableArray<MinecraftVersion> versions, string version, CancellationToken cancellationToken) {
-		return await FetchOrFailSilently(async () => {
+		var versionObject = versions.FirstOrDefault(v => v.Id == version);
-			var versions = await GetVersions(cancellationToken);
+		if (versionObject == null) {
-			var versionObject = versions.FirstOrDefault(v => v.Id == version);
+			Logger.Error("Version {Version} was not found in version manifest.", version);
-			if (versionObject == null) {
+			return null;
-				Logger.Error("Version {Version} was not found in version manifest.", version);
+		}
-				return null;
-			}
 		
-			var versionMetadata = await FetchJson(http, versionObject.MetadataUrl, "version metadata", cancellationToken);
+		return await FetchOrFailSilently(async () => {
+			var versionMetadata = await FetchJson(versionObject.MetadataUrl, "version metadata", cancellationToken);
 			return GetServerExecutableInfoFromMetadata(versionMetadata);
 		});
 	}
@@ -81,8 +48,6 @@ public sealed class MinecraftVersions : IDisposable {
 	private static async Task<T?> FetchOrFailSilently<T>(Func<Task<T?>> task) {
 		try {
 			return await task();
-		} catch (OperationCanceledException) {
-			return default;
 		} catch (StopProcedureException) {
 			return default;
 		} catch (Exception e) {
@@ -91,14 +56,12 @@ public sealed class MinecraftVersions : IDisposable {
 		}
 	}
 
-	private static async Task<JsonElement> FetchJson(HttpClient http, string url, string description, CancellationToken cancellationToken) {
+	private async Task<JsonElement> FetchJson(string url, string description, CancellationToken cancellationToken) {
-		Logger.Information("Fetching {Description} JSON from: {Url}", description, url);
+		Logger.Debug("Fetching {Description} JSON from: {Url}", description, url);
 
 		try {
 			return await http.GetFromJsonAsync<JsonElement>(url, cancellationToken);
-		} catch (OperationCanceledException) {
+		} catch (HttpRequestException e) {
-			throw StopProcedureException.Instance;
-		}  catch (HttpRequestException e) {
 			Logger.Error(e, "Unable to download {Description}.", description);
 			throw StopProcedureException.Instance;
 		} catch (Exception e) {
@@ -117,7 +80,7 @@ public sealed class MinecraftVersions : IDisposable {
 			} catch (StopProcedureException) {}
 		}
 
-		return foundVersions.ToImmutable();
+		return foundVersions.MoveToImmutable();
 	}
 
 	private static MinecraftVersion GetVersionFromManifestEntry(JsonElement versionElement) {
@@ -129,7 +92,7 @@ public sealed class MinecraftVersions : IDisposable {
 
 		var type = MinecraftVersionTypes.FromString(typeString);
 		if (type == MinecraftVersionType.Other) {
-			Logger.Verbose("Unknown version type: {Type} ({Version})", typeString, id);
+			Logger.Warning("Unknown version type: {Type} ({Version})", typeString, id);
 		}
 
 		JsonElement urlElement = GetJsonPropertyOrThrow(versionElement, "url", JsonValueKind.String, "version entry in version manifest");
@@ -148,7 +111,7 @@ public sealed class MinecraftVersions : IDisposable {
 		return new MinecraftVersion(id, type, url);
 	}
 
-	private static MinecraftServerExecutableInfo GetServerExecutableInfoFromMetadata(JsonElement versionMetadata) {
+	private static FileDownloadInfo GetServerExecutableInfoFromMetadata(JsonElement versionMetadata) {
 		JsonElement downloadsElement = GetJsonPropertyOrThrow(versionMetadata, "downloads", JsonValueKind.Object, "version metadata");
 		JsonElement serverElement = GetJsonPropertyOrThrow(downloadsElement, "server", JsonValueKind.Object, "downloads object in version metadata");
 		JsonElement urlElement = GetJsonPropertyOrThrow(serverElement, "url", JsonValueKind.String, "downloads.server object in version metadata");
@@ -182,7 +145,7 @@ public sealed class MinecraftVersions : IDisposable {
 			throw StopProcedureException.Instance;
 		}
 
-		return new MinecraftServerExecutableInfo(url, hash, new FileSize(size));
+		return new FileDownloadInfo(url, hash, new FileSize(size));
 	}
 
 	private static JsonElement GetJsonPropertyOrThrow(JsonElement parentElement, string propertyKey, JsonValueKind expectedKind, string location) {

Server/Phantom.Server.Minecraft/MinecraftVersions.cs

@@ -0,0 +1,75 @@
+using System.Collections.Immutable;
+using System.Diagnostics;
+using Phantom.Common.Data.Minecraft;
+using Phantom.Common.Logging;
+using Serilog;
+
+namespace Phantom.Server.Minecraft;
+
+public sealed class MinecraftVersions : IDisposable {
+	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftVersions>();
+	private static readonly TimeSpan CacheRetentionTime = TimeSpan.FromMinutes(10);
+
+	private readonly MinecraftVersionApi api = new ();
+	private readonly Stopwatch cacheTimer = new ();
+	private readonly SemaphoreSlim cacheSemaphore = new (1, 1);
+
+	private bool IsCacheNotExpired => cacheTimer.IsRunning && cacheTimer.Elapsed < CacheRetentionTime;
+	
+	private ImmutableArray<MinecraftVersion>? cachedVersions;
+	private readonly Dictionary<string, FileDownloadInfo?> cachedServerExecutables = new ();
+
+	public void Dispose() {
+		api.Dispose();
+		cacheSemaphore.Dispose();
+	}
+
+	public async Task<ImmutableArray<MinecraftVersion>> GetVersions(CancellationToken cancellationToken) {
+		return await GetCachedObject(() => cachedVersions != null, () => cachedVersions.GetValueOrDefault(), v => cachedVersions = v, LoadVersions, cancellationToken);
+	}
+
+	private async Task<ImmutableArray<MinecraftVersion>> LoadVersions(CancellationToken cancellationToken) {
+		ImmutableArray<MinecraftVersion> versions = await api.GetVersions(cancellationToken);
+		Logger.Information("Refreshed Minecraft version cache, {Versions} version(s) found.", versions.Length);
+		return versions;
+	}
+
+	public async Task<FileDownloadInfo?> GetServerExecutableInfo(string version, CancellationToken cancellationToken) {
+		var versions = await GetVersions(cancellationToken);
+		return await GetCachedObject(() => cachedServerExecutables.ContainsKey(version), () => cachedServerExecutables[version], v => cachedServerExecutables[version] = v, ct => LoadServerExecutableInfo(versions, version, ct), cancellationToken);
+	}
+
+	private async Task<FileDownloadInfo?> LoadServerExecutableInfo(ImmutableArray<MinecraftVersion> versions, string version, CancellationToken cancellationToken) {
+		var info = await api.GetServerExecutableInfo(versions, version, cancellationToken);
+			
+		if (info == null) {
+			Logger.Information("Refreshed Minecraft {Version} server executable cache, no file found.", version);
+		}
+		else {
+			Logger.Information("Refreshed Minecraft {Version} server executable cache, found file: {Url}.", version, info.DownloadUrl);
+		}
+
+		return info;
+	}
+
+	private async Task<T> GetCachedObject<T>(Func<bool> isLoaded, Func<T> fieldGetter, Action<T> fieldSetter, Func<CancellationToken, Task<T>> fieldLoader, CancellationToken cancellationToken) {
+		if (IsCacheNotExpired && isLoaded()) {
+			return fieldGetter();
+		}
+
+		await cacheSemaphore.WaitAsync(cancellationToken);
+		try {
+			if (IsCacheNotExpired && isLoaded()) {
+				return fieldGetter();
+			}
+
+			T result = await fieldLoader(cancellationToken);
+			fieldSetter(result);
+			
+			cacheTimer.Restart();
+			return result;
+		} finally {
+			cacheSemaphore.Release();
+		}
+	}
+}

Server/Phantom.Server.Minecraft/Phantom.Server.Minecraft.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\Common\Phantom.Common.Data\Phantom.Common.Data.csproj" />
+    <ProjectReference Include="..\..\Common\Phantom.Common.Logging\Phantom.Common.Logging.csproj" />
+    <ProjectReference Include="..\..\Utils\Phantom.Utils.Runtime\Phantom.Utils.Runtime.csproj" />
+  </ItemGroup>
+
+</Project>

Server/Phantom.Server.Rpc/Phantom.Server.Rpc.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk">
   
   <PropertyGroup>
     <TargetFramework>net7.0</TargetFramework>
@@ -6,10 +6,6 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
   
-  <PropertyGroup>
-    <OutputType>Library</OutputType>
-  </PropertyGroup>
-  
   <ItemGroup>
     <ProjectReference Include="..\..\Common\Phantom.Common.Messages\Phantom.Common.Messages.csproj" />
   </ItemGroup>

Server/Phantom.Server.Rpc/RpcClientConnection.cs

@@ -1,7 +1,7 @@
 using NetMQ;
 using NetMQ.Sockets;
 using Phantom.Common.Messages;
-using Phantom.Common.Messages.ToServer;
+using Phantom.Common.Messages.BiDirectional;
 using Phantom.Utils.Rpc.Message;
 
 namespace Phantom.Server.Rpc;
@@ -34,29 +34,32 @@ public sealed class RpcClientConnection {
 		}
 	}
 
-	private byte[] WriteBytes<TMessage, TReply>(TMessage message) where TMessage : IMessageToAgent<TReply> {
-		return isClosed ? Array.Empty<byte>() : MessageRegistries.ToAgent.Write<TMessage, TReply>(message).ToArray();
-	}
-
 	public async Task Send<TMessage>(TMessage message) where TMessage : IMessageToAgent {
-		var bytes = WriteBytes<TMessage, NoReply>(message);
+		if (isClosed) {
+			return;
+		}
+		
+		var bytes = MessageRegistries.ToAgent.Write(message).ToArray();
 		if (bytes.Length > 0) {
 			await socket.SendAsync(routingId, bytes);
 		}
 	}
 
-	public async Task<TReply?> Send<TMessage, TReply>(Func<uint, TMessage> messageFactory, TimeSpan waitForReplyTime, CancellationToken cancellationToken) where TMessage : IMessageToAgent<TReply> where TReply : class {
+	public async Task<TReply?> Send<TMessage, TReply>(TMessage message, TimeSpan waitForReplyTime, CancellationToken waitForReplyCancellationToken) where TMessage : IMessageToAgent<TReply> where TReply : class {
-		var sequenceId = messageReplyTracker.RegisterReply();
+		if (isClosed) {
-		var message = messageFactory(sequenceId);
+			return null;
+		}
 		
-		var bytes = WriteBytes<TMessage, TReply>(message);
+		var sequenceId = messageReplyTracker.RegisterReply();
+		
+		var bytes = MessageRegistries.ToAgent.Write<TMessage, TReply>(sequenceId, message).ToArray();
 		if (bytes.Length == 0) {
 			messageReplyTracker.ForgetReply(sequenceId);
 			return null;
 		}
 
 		await socket.SendAsync(routingId, bytes);
-		return await messageReplyTracker.WaitForReply<TReply>(message.SequenceId, waitForReplyTime, cancellationToken);
+		return await messageReplyTracker.WaitForReply<TReply>(sequenceId, waitForReplyTime, waitForReplyCancellationToken);
 	}
 
 	public void Receive(ReplyMessage message) {

Server/Phantom.Server.Rpc/RpcLauncher.cs

@@ -1,11 +1,12 @@
 using NetMQ.Sockets;
 using Phantom.Common.Messages;
+using Phantom.Common.Messages.BiDirectional;
 using Phantom.Common.Messages.ToServer;
 using Phantom.Utils.Rpc;
 using Phantom.Utils.Rpc.Message;
 using Phantom.Utils.Runtime;
+using Serilog;
 using Serilog.Events;
-using ILogger = Serilog.ILogger;
 
 namespace Phantom.Server.Rpc;
 
@@ -24,14 +25,14 @@ public sealed class RpcLauncher : RpcRuntime<ServerSocket> {
 	private readonly Func<RpcClientConnection, IMessageToServerListener> listenerFactory;
 	private readonly CancellationToken cancellationToken;
 
-	private RpcLauncher(RpcConfiguration config, ServerSocket socket, Func<RpcClientConnection, IMessageToServerListener> listenerFactory, CancellationToken cancellationToken) : base(socket, config.Logger) {
+	private RpcLauncher(RpcConfiguration config, ServerSocket socket, Func<RpcClientConnection, IMessageToServerListener> listenerFactory, CancellationToken cancellationToken) : base(config, socket) {
 		this.config = config;
 		this.listenerFactory = listenerFactory;
 		this.cancellationToken = cancellationToken;
 	}
 
 	protected override void Connect(ServerSocket socket) {
-		var logger = config.Logger;
+		var logger = config.RuntimeLogger;
 		var url = config.TcpUrl;
 
 		logger.Information("Starting ZeroMQ server on {Url}...", url);
@@ -40,12 +41,12 @@ public sealed class RpcLauncher : RpcRuntime<ServerSocket> {
 	}
 
 	protected override void Run(ServerSocket socket, MessageReplyTracker replyTracker, TaskManager taskManager) {
-		var logger = config.Logger;
+		var logger = config.RuntimeLogger;
 		var clients = new Dictionary<ulong, Client>();
 
 		void OnConnectionClosed(object? sender, RpcClientConnectionClosedEventArgs e) {
 			clients.Remove(e.RoutingId);
-			logger.Verbose("Closed connection to {RoutingId}.", e.RoutingId);
+			logger.Debug("Closed connection to {RoutingId}.", e.RoutingId);
 		}
 
 		while (!cancellationToken.IsCancellationRequested) {