chylex/Minecraft-Phantom-Panel
1
0
Fork 0
mirror of https://github.com/chylex/Minecraft-Phantom-Panel.git synced 2026-04-07 12:46:53 +02:00
Code Activity

Compare commits

base: chylex:wip-backups
Branches Tags
chylex:main chylex:wip-backups chylex:wip-recipes chylex:wip-updates chylex:wip-forge chylex:experimental/agent-shutdown chylex:experimental/agent-name-generator
..
compare: chylex:wip-recipes
Branches Tags
chylex:wip-backups chylex:main chylex:wip-recipes chylex:wip-updates chylex:wip-forge chylex:experimental/agent-shutdown chylex:experimental/agent-name-generator

3 Commits
wip-backup ... wip-recipe

Author SHA1 Message Date
chylex
da206aacb2 wip status protocol 2026-02-23 04:05:44 +01:00
chylex
4ad9534d27 Merge Phantom.Agent.Minecraft project into Phantom.Agent.Services 2026-02-23 01:14:46 +01:00
chylex
2c63c1d7e0 Introduce instance launch recipes 2026-02-23 01:14:46 +01:00
64 changed files with 654 additions and 824 deletions
Expand all files Collapse all files

51
Agent/Phantom.Agent.Services/AgentDirectories.cs
View File

@@ -1,51 +0,0 @@
using Phantom.Utils.IO;
using Phantom.Utils.Logging;
using Serilog;
namespace Phantom.Agent.Services;
public sealed class AgentDirectories {
private static readonly ILogger Logger = PhantomLogger.Create<AgentDirectories>();
internal string DataDirectoryPath { get; }
internal string InstancesDirectoryPath { get; }
internal string BackupsDirectoryPath { get; }
internal string TemporaryDirectoryPath { get; }
internal string ServerExecutableDirectoryPath { get; }
public string JavaSearchDirectoryPath { get; }
public AgentDirectories(string dataDirectoryPath, string temporaryDirectoryPath, string javaSearchDirectoryPath) {
this.DataDirectoryPath = Path.GetFullPath(dataDirectoryPath);
this.InstancesDirectoryPath = Path.Combine(DataDirectoryPath, "instances");
this.BackupsDirectoryPath = Path.Combine(DataDirectoryPath, "backups");
this.TemporaryDirectoryPath = Path.GetFullPath(temporaryDirectoryPath);
this.ServerExecutableDirectoryPath = Path.Combine(TemporaryDirectoryPath, "servers");
this.JavaSearchDirectoryPath = javaSearchDirectoryPath;
}
public bool TryCreate() {
return TryCreateDirectory(DataDirectoryPath) &&
TryCreateDirectory(InstancesDirectoryPath) &&
TryCreateDirectory(BackupsDirectoryPath) &&
TryCreateDirectory(TemporaryDirectoryPath) &&
TryCreateDirectory(ServerExecutableDirectoryPath);
}
private static bool TryCreateDirectory(string directoryPath) {
if (Directory.Exists(directoryPath)) {
return true;
}
try {
Directories.Create(directoryPath, Chmod.URWX_GRX);
return true;
} catch (Exception e) {
Logger.Fatal(e, "Error creating directory: {DirectoryPath}", directoryPath);
return false;
}
}
}

51
Agent/Phantom.Agent.Services/AgentFolders.cs Normal file
View File

@@ -0,0 +1,51 @@
using Phantom.Utils.IO;
using Phantom.Utils.Logging;
using Serilog;
namespace Phantom.Agent.Services;
public sealed class AgentFolders {
private static readonly ILogger Logger = PhantomLogger.Create<AgentFolders>();
internal string DataFolderPath { get; }
internal string InstancesFolderPath { get; }
internal string BackupsFolderPath { get; }
internal string TemporaryFolderPath { get; }
internal string ServerExecutableFolderPath { get; }
public string JavaSearchFolderPath { get; }
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");
this.JavaSearchFolderPath = javaSearchFolderPath;
}
public bool TryCreate() {
return TryCreateFolder(DataFolderPath) &&
TryCreateFolder(InstancesFolderPath) &&
TryCreateFolder(BackupsFolderPath) &&
TryCreateFolder(TemporaryFolderPath) &&
TryCreateFolder(ServerExecutableFolderPath);
}
private static bool TryCreateFolder(string folderPath) {
if (Directory.Exists(folderPath)) {
return true;
}
try {
Directories.Create(folderPath, Chmod.URWX_GRX);
return true;
} catch (Exception e) {
Logger.Fatal(e, "Error creating folder: {FolderPath}", folderPath);
return false;
}
}
}

4
Agent/Phantom.Agent.Services/AgentRegistrationHandler.cs
View File

@@ -77,10 +77,8 @@ public sealed class AgentRegistrationHandler {
return new InstanceManagerActor.ConfigureInstanceCommand(
configureInstanceMessage.InstanceGuid,
configureInstanceMessage.Info,
configureInstanceMessage.LaunchRecipe.Value,
configureInstanceMessage.LaunchRecipe,
configureInstanceMessage.LaunchNow,
configureInstanceMessage.StopRecipe,
configureInstanceMessage.BackupConfiguration.Value,
AlwaysReportStatus: true
);
}

6
Agent/Phantom.Agent.Services/AgentServices.cs
View File

@@ -22,16 +22,16 @@ public sealed class AgentServices {
internal InstanceTicketManager InstanceTicketManager { get; }
internal ActorRef<InstanceManagerActor.ICommand> InstanceManager { get; }
public AgentServices(AgentInfo agentInfo, AgentDirectories agentDirectories, AgentServiceConfiguration serviceConfiguration, ControllerConnection controllerConnection, JavaRuntimeRepository javaRuntimeRepository) {
public AgentServices(AgentInfo agentInfo, AgentFolders agentFolders, AgentServiceConfiguration serviceConfiguration, ControllerConnection controllerConnection, JavaRuntimeRepository javaRuntimeRepository) {
this.ActorSystem = ActorSystemFactory.Create("Agent");
this.AgentState = new AgentState();
this.BackupManager = new BackupManager(agentDirectories, serviceConfiguration.MaxConcurrentCompressionTasks);
this.BackupManager = new BackupManager(agentFolders, serviceConfiguration.MaxConcurrentCompressionTasks);
this.JavaRuntimeRepository = javaRuntimeRepository;
this.InstanceTicketManager = new InstanceTicketManager(agentInfo, controllerConnection);
var instanceManagerInit = new InstanceManagerActor.Init(controllerConnection, agentDirectories, AgentState, JavaRuntimeRepository, InstanceTicketManager, BackupManager);
var instanceManagerInit = new InstanceManagerActor.Init(controllerConnection, agentFolders, AgentState, JavaRuntimeRepository, InstanceTicketManager, BackupManager);
this.InstanceManager = ActorSystem.ActorOf(InstanceManagerActor.Factory(instanceManagerInit), "InstanceManager");
}

305
Agent/Phantom.Agent.Services/Backups/BackupArchiver.cs
View File

@@ -1,7 +1,6 @@
using System.Collections.Immutable;
using System.Diagnostics.CodeAnalysis;
using System.Formats.Tar;
using System.Security.Cryptography;
using Phantom.Agent.Services.Instances;
using Phantom.Common.Data.Backups;
using Phantom.Utils.IO;
@@ -10,27 +9,30 @@ using Serilog;
namespace Phantom.Agent.Services.Backups;
static class BackupArchiver {
public static async Task<string?> Run(string loggerName, string destinationBasePath, string temporaryBasePath, InstanceProperties instanceProperties, BackupCreationResult.Builder resuiltBuilder, CancellationToken cancellationToken) {
string guid = instanceProperties.InstanceGuid.ToString();
string currentDateTime = DateTime.Now.ToString("yyyyMMdd-HHmmss");
string backupDirectoryPath = Path.Combine(destinationBasePath, guid);
string backupFilePath = Path.Combine(backupDirectoryPath, currentDateTime + ".tar");
string temporaryDirectoryPath = Path.Combine(temporaryBasePath, guid + "_" + currentDateTime);
return await new Runner(loggerName, backupDirectoryPath, backupFilePath, temporaryDirectoryPath, instanceProperties, resuiltBuilder, cancellationToken).Run();
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 static bool IsDirectorySkipped(RelativePath relativePath) {
return relativePath.Components is ["cache" or "crash-reports" or "debug" or "libraries" or "logs" or "mods" or "versions"];
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 static bool IsFileSkipped(RelativePath relativePath) {
var name = relativePath.Components[^1];
private bool IsFileSkipped(ImmutableList<string> relativePath) {
var name = relativePath[^1];
if (relativePath.Components.Count == 2 && name == "session.lock") {
if (relativePath.Count == 2 && name == "session.lock") {
return true;
}
@@ -42,184 +44,137 @@ static class BackupArchiver {
return false;
}
private sealed class Runner(
string loggerName,
string backupDirectoryPath,
string backupFilePath,
string temporaryDirectoryPath,
InstanceProperties instanceProperties,
BackupCreationResult.Builder resultBuilder,
CancellationToken cancellationToken
) {
private readonly ILogger logger = PhantomLogger.Create(nameof(BackupArchiver), loggerName);
private readonly FileHashComparer fileHashComparer = new (cancellationToken);
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");
public async Task<string?> Run() {
if (File.Exists(backupFilePath)) {
resultBuilder.Kind = BackupCreationResultKind.BackupFileAlreadyExists;
logger.Warning("Skipping backup, file already exists: {FilePath}", backupFilePath);
return null;
}
try {
Directories.Create(backupDirectoryPath, Chmod.URWX_GRX);
} catch (Exception e) {
resultBuilder.Kind = BackupCreationResultKind.CouldNotCreateBackupDirectory;
logger.Error(e, "Could not create backup directory: {DirectoryPath}", backupDirectoryPath);
return null;
}
try {
if (!await CopyInstanceDirectoryIntoTemporaryDirectory()) {
resultBuilder.Kind = BackupCreationResultKind.CouldNotCopyInstanceIntoTemporaryDirectory;
return null;
}
if (!await CreateBackupArchiveFromTemporaryDirectory()) {
resultBuilder.Kind = BackupCreationResultKind.CouldNotCreateBackupArchive;
return null;
}
logger.Information("Created backup: {FilePath}", backupFilePath);
return backupFilePath;
} finally {
try {
Directory.Delete(temporaryDirectoryPath, recursive: true);
} catch (Exception e1) {
resultBuilder.Warnings |= BackupCreationWarnings.CouldNotDeleteTemporaryDirectory;
logger.Error(e1, "Could not delete temporary directory: {DirectoryPath}", temporaryDirectoryPath);
}
}
if (File.Exists(backupFilePath)) {
resultBuilder.Kind = BackupCreationResultKind.BackupFileAlreadyExists;
logger.Warning("Skipping backup, file already exists: {File}", backupFilePath);
return null;
}
private async Task<bool> CopyInstanceDirectoryIntoTemporaryDirectory() {
try {
await CopyDirectory(new DirectoryInfo(instanceProperties.InstanceDirectoryPath), RelativePath.Empty, temporaryDirectoryPath);
return true;
} catch (Exception e) {
logger.Error(e, "Could not copy instance directory into temporary directory: {DirectoryPath}", temporaryDirectoryPath);
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;
}
}
private async Task CopyDirectory(DirectoryInfo sourceDirectory, RelativePath sourceDirectoryRelativePath, string destinationDirectoryPath) {
cancellationToken.ThrowIfCancellationRequested();
bool needsToCreateDirectory = true;
foreach (FileInfo file in sourceDirectory.EnumerateFiles()) {
var filePath = sourceDirectoryRelativePath.Child(file.Name);
if (IsFileSkipped(filePath)) {
logger.Verbose("Skipped file: {FilePath}", filePath);
continue;
}
if (needsToCreateDirectory) {
needsToCreateDirectory = false;
Directories.Create(destinationDirectoryPath, Chmod.URWX);
}
await CopyFileWithRetries(file, filePath, Path.Combine(destinationDirectoryPath, file.Name));
logger.Verbose("Copied file: {FilePath}", filePath);
}
foreach (DirectoryInfo directory in sourceDirectory.EnumerateDirectories()) {
var directoryPath = sourceDirectoryRelativePath.Child(directory.Name);
if (IsDirectorySkipped(directoryPath)) {
logger.Verbose("Skipped directory: {DirectoryPath}", directoryPath);
continue;
}
await CopyDirectory(directory, directoryPath, Path.Join(destinationDirectoryPath, directory.Name));
}
}
private async Task CopyFileWithRetries(FileInfo sourceFile, RelativePath sourceFileRelativePath, string destinationFilePath) {
const int TotalAttempts = 10;
for (int attempt = 1; attempt <= TotalAttempts; attempt++) {
try {
FileInfo destinationFile = sourceFile.CopyTo(destinationFilePath, overwrite: true);
if (await fileHashComparer.CheckHashEquals(sourceFile, destinationFile)) {
return;
}
if (attempt == TotalAttempts) {
logger.Warning("File {FilePath} changed while copying, using last attempt", sourceFileRelativePath);
resultBuilder.Warnings |= BackupCreationWarnings.SomeFilesChangedDuringBackup;
}
else {
logger.Warning("File {FilePath} changed while copying, retrying...", sourceFileRelativePath);
}
} catch (IOException) {
if (attempt == TotalAttempts) {
throw;
}
else {
logger.Warning("Failed copying file {FilePath}, retrying...", sourceFileRelativePath);
}
}
await Task.Delay(millisecondsDelay: 200, cancellationToken);
}
}
private async Task<bool> CreateBackupArchiveFromTemporaryDirectory() {
try {
await TarFile.CreateFromDirectoryAsync(temporaryDirectoryPath, backupFilePath, includeBaseDirectory: false, cancellationToken);
return true;
} catch (Exception e) {
logger.Error(e, "Could not create archive.");
DeleteBrokenArchiveFile(backupFilePath);
if (!await CreateTarArchive(temporaryFolderPath, backupFilePath)) {
resultBuilder.Kind = BackupCreationResultKind.CouldNotCreateWorldArchive;
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: {FilePath}", filePath);
}
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 readonly record struct RelativePath(ImmutableList<string> Components) {
public static RelativePath Empty => new (ImmutableList<string>.Empty);
public RelativePath Child(string component) {
return new RelativePath(Components.Add(component));
}
public override string ToString() {
return string.Join(separator: '/', Components);
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 sealed class FileHashComparer(CancellationToken cancellationToken) {
private static readonly FileStreamOptions FileStreamOptions = new () {
Mode = FileMode.Open,
Access = FileAccess.Read,
Share = FileShare.ReadWrite,
Options = FileOptions.Asynchronous | FileOptions.SequentialScan,
BufferSize = 65536,
};
private async Task<bool> CreateTarArchive(string sourceFolderPath, string backupFilePath) {
try {
await TarFile.CreateFromDirectoryAsync(sourceFolderPath, backupFilePath, includeBaseDirectory: 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();
private readonly Memory<byte> hash1 = new byte[SHA1.HashSizeInBytes];
private readonly Memory<byte> hash2 = new byte[SHA1.HashSizeInBytes];
bool needsToCreateFolder = true;
public async Task<bool> CheckHashEquals(FileInfo file1, FileInfo file2) {
await ComputeHash(file1, hash1);
await ComputeHash(file2, hash2);
return hash1.Span.SequenceEqual(hash2.Span);
foreach (FileInfo file in sourceFolder.EnumerateFiles()) {
var filePath = relativePath.Add(file.Name);
if (IsFileSkipped(filePath)) {
logger.Debug("Skipping file: {File}", string.Join(separator: '/', filePath));
continue;
}
if (needsToCreateFolder) {
needsToCreateFolder = false;
Directories.Create(destinationFolderPath, Chmod.URWX);
}
await CopyFileWithRetries(file, destinationFolderPath);
}
private async Task ComputeHash(FileInfo file, Memory<byte> destination) {
await using var fileStream = file.Open(FileStreamOptions);
await SHA1.HashDataAsync(fileStream, destination, cancellationToken);
foreach (DirectoryInfo directory in sourceFolder.EnumerateDirectories()) {
var folderPath = relativePath.Add(directory.Name);
if (IsFolderSkipped(folderPath)) {
logger.Debug("Skipping folder: {Folder}", string.Join(separator: '/', 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(millisecondsDelay: 200, cancellationToken);
}
}
}
}
}

80
Agent/Phantom.Agent.Services/Backups/BackupManager.cs
View File

@@ -5,10 +5,16 @@ using Serilog;
namespace Phantom.Agent.Services.Backups;
sealed class BackupManager(AgentDirectories agentDirectories, int maxConcurrentCompressionTasks) : IDisposable {
private readonly string destinationBasePath = agentDirectories.BackupsDirectoryPath;
private readonly string temporaryBasePath = Path.Combine(agentDirectories.TemporaryDirectoryPath, "backups");
private readonly SemaphoreSlim compressionSemaphore = new (maxConcurrentCompressionTasks, maxConcurrentCompressionTasks);
sealed class BackupManager : IDisposable {
private readonly string destinationBasePath;
private readonly string temporaryBasePath;
private readonly SemaphoreSlim compressionSemaphore;
public BackupManager(AgentFolders agentFolders, int maxConcurrentCompressionTasks) {
this.destinationBasePath = agentFolders.BackupsFolderPath;
this.temporaryBasePath = Path.Combine(agentFolders.TemporaryFolderPath, "backups");
this.compressionSemaphore = new SemaphoreSlim(maxConcurrentCompressionTasks, maxConcurrentCompressionTasks);
}
public Task<BackupCreationResult> CreateBackup(string loggerName, InstanceProcess process, CancellationToken cancellationToken) {
return new BackupCreator(this, loggerName, process, cancellationToken).CreateBackup();
@@ -18,17 +24,33 @@ sealed class BackupManager(AgentDirectories agentDirectories, int maxConcurrentC
compressionSemaphore.Dispose();
}
private sealed class BackupCreator(BackupManager manager, string loggerName, InstanceProcess process, CancellationToken cancellationToken) {
private readonly ILogger logger = PhantomLogger.Create<BackupManager>(loggerName);
private sealed class BackupCreator {
private readonly BackupManager manager;
private readonly string loggerName;
private readonly ILogger logger;
private readonly InstanceProcess process;
private readonly CancellationToken cancellationToken;
public BackupCreator(BackupManager manager, string loggerName, InstanceProcess process, CancellationToken cancellationToken) {
this.manager = manager;
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 = await CreateBackupArchive(resultBuilder);
string? backupFilePath;
using (var dispatcher = new BackupServerCommandDispatcher(logger, process, cancellationToken)) {
backupFilePath = await CreateWorldArchive(dispatcher, resultBuilder);
}
if (backupFilePath != null) {
await CompressBackupArchive(backupFilePath, resultBuilder);
await CompressWorldArchive(backupFilePath, resultBuilder);
}
var result = resultBuilder.Build();
@@ -36,9 +58,11 @@ sealed class BackupManager(AgentDirectories agentDirectories, int maxConcurrentC
return result;
}
private async Task<string?> CreateBackupArchive(BackupCreationResult.Builder resultBuilder) {
private async Task<string?> CreateWorldArchive(BackupServerCommandDispatcher dispatcher, BackupCreationResult.Builder resultBuilder) {
try {
return await BackupArchiver.Run(loggerName, manager.destinationBasePath, manager.temporaryBasePath, process.InstanceProperties, resultBuilder, cancellationToken);
await dispatcher.DisableAutomaticSaving();
await dispatcher.SaveAllChunks();
return await new BackupArchiver(manager.destinationBasePath, manager.temporaryBasePath, loggerName, process.InstanceProperties, cancellationToken).ArchiveWorld(resultBuilder);
} catch (OperationCanceledException) {
resultBuilder.Kind = BackupCreationResultKind.BackupCancelled;
logger.Warning("Backup creation was cancelled.");
@@ -51,10 +75,22 @@ sealed class BackupManager(AgentDirectories agentDirectories, int maxConcurrentC
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 (TimeoutException) {
resultBuilder.Warnings |= BackupCreationWarnings.CouldNotRestoreAutomaticSaving;
logger.Warning("Timed out waiting for automatic saving to be re-enabled.");
} catch (Exception e) {
resultBuilder.Warnings |= BackupCreationWarnings.CouldNotRestoreAutomaticSaving;
logger.Error(e, "Caught exception while enabling automatic saving after creating an instance backup.");
}
}
}
private async Task CompressBackupArchive(string filePath, BackupCreationResult.Builder resultBuilder) {
private async Task CompressWorldArchive(string filePath, BackupCreationResult.Builder resultBuilder) {
if (!await manager.compressionSemaphore.WaitAsync(TimeSpan.FromSeconds(1), cancellationToken)) {
logger.Information("Too many compression tasks running, waiting for one of them to complete...");
await manager.compressionSemaphore.WaitAsync(cancellationToken);
@@ -64,7 +100,7 @@ sealed class BackupManager(AgentDirectories agentDirectories, int maxConcurrentC
try {
var compressedFilePath = await BackupCompressor.Compress(filePath, cancellationToken);
if (compressedFilePath == null) {
resultBuilder.Warnings |= BackupCreationWarnings.CouldNotCompressBackupArchive;
resultBuilder.Warnings |= BackupCreationWarnings.CouldNotCompressWorldArchive;
}
} finally {
manager.compressionSemaphore.Release();
@@ -88,16 +124,16 @@ sealed class BackupManager(AgentDirectories agentDirectories, int maxConcurrentC
private static string DescribeResult(BackupCreationResultKind kind) {
return kind switch {
BackupCreationResultKind.Success => "Backup created successfully.",
BackupCreationResultKind.InstanceNotRunning => "Instance is not running.",
BackupCreationResultKind.BackupCancelled => "Backup cancelled.",
BackupCreationResultKind.BackupTimedOut => "Backup timed out.",
BackupCreationResultKind.BackupAlreadyRunning => "A backup is already being created.",
BackupCreationResultKind.BackupFileAlreadyExists => "Backup with the same name already exists.",
BackupCreationResultKind.CouldNotCreateBackupDirectory => "Could not create backup directory.",
BackupCreationResultKind.CouldNotCopyInstanceIntoTemporaryDirectory => "Could not copy instance into temporary directory.",
BackupCreationResultKind.CouldNotCreateBackupArchive => "Could not create backup archive.",
_ => "Unknown error.",
BackupCreationResultKind.Success => "Backup created successfully.",
BackupCreationResultKind.InstanceNotRunning => "Instance is not running.",
BackupCreationResultKind.BackupCancelled => "Backup cancelled.",
BackupCreationResultKind.BackupTimedOut => "Backup timed out.",
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.",
};
}
}

55
Agent/Phantom.Agent.Services/Backups/BackupScheduler.cs
View File

@@ -1,7 +1,5 @@
using System.Diagnostics.CodeAnalysis;
using Phantom.Agent.Services.Instances;
using Phantom.Agent.Services.Instances;
using Phantom.Agent.Services.Instances.State;
using Phantom.Common.Data.Agent.Instance.Backups;
using Phantom.Common.Data.Backups;
using Phantom.Utils.Logging;
using Phantom.Utils.Tasks;
@@ -9,39 +7,28 @@ using Phantom.Utils.Tasks;
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 BackupManager backupManager;
private readonly InstanceContext context;
private readonly SemaphoreSlim backupSemaphore = new (initialCount: 1, maxCount: 1);
private readonly TimeSpan initialDelay;
private readonly TimeSpan backupInterval;
private readonly TimeSpan failureRetryDelay;
private readonly ManualResetEventSlim serverOutputWhileWaitingForOnlinePlayers = new ();
private readonly InstancePlayerCountTracker? playerCountTracker;
private readonly InstancePlayerCountTracker playerCountTracker;
public event EventHandler<BackupCreationResult>? BackupCompleted;
[SuppressMessage("ReSharper", "ConvertIfStatementToConditionalTernaryExpression")]
public BackupScheduler(InstanceContext context, InstanceProcess process, InstanceBackupSchedule schedule) : base(PhantomLogger.Create<BackupScheduler>(context.ShortName)) {
public BackupScheduler(InstanceContext context, InstancePlayerCountTracker playerCountTracker) : base(PhantomLogger.Create<BackupScheduler>(context.ShortName)) {
this.backupManager = context.Services.BackupManager;
this.context = context;
this.initialDelay = schedule.InitialDelay;
this.backupInterval = schedule.BackupInterval;
this.failureRetryDelay = schedule.BackupFailureRetryDelay;
var playerCountDetectionStrategy = schedule.PlayerCountDetectionStrategy.Value;
if (playerCountDetectionStrategy == null) {
this.playerCountTracker = null;
}
else {
this.playerCountTracker = new InstancePlayerCountTracker(context, process, playerCountDetectionStrategy.CreateDetector(new InstancePlayerCountDetectorFactory(context)));
}
this.playerCountTracker = playerCountTracker;
Start();
}
protected override async Task RunTask() {
await Task.Delay(initialDelay, CancellationToken);
await Task.Delay(InitialDelay, CancellationToken);
Logger.Information("Starting a new backup after server launched.");
while (!CancellationToken.IsCancellationRequested) {
@@ -49,16 +36,13 @@ sealed class BackupScheduler : CancellableBackgroundTask {
BackupCompleted?.Invoke(this, result);
if (result.Kind.ShouldRetry()) {
Logger.Warning("Scheduled backup failed, retrying in {Minutes} minutes.", failureRetryDelay.TotalMinutes);
await Task.Delay(failureRetryDelay, CancellationToken);
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);
if (playerCountTracker != null) {
await WaitForOnlinePlayers(playerCountTracker);
}
Logger.Information("Scheduling next backup in {Minutes} minutes.", BackupInterval.TotalMinutes);
await Task.Delay(BackupInterval, CancellationToken);
await WaitForOnlinePlayers();
}
}
}
@@ -70,7 +54,7 @@ sealed class BackupScheduler : CancellableBackgroundTask {
try {
context.ActorCancellationToken.ThrowIfCancellationRequested();
return await context.Actor.Request(new InstanceActor.BackupInstanceCommand(context.Services.BackupManager), context.ActorCancellationToken);
return await context.Actor.Request(new InstanceActor.BackupInstanceCommand(backupManager), context.ActorCancellationToken);
} catch (OperationCanceledException) {
return new BackupCreationResult(BackupCreationResultKind.InstanceNotRunning);
} finally {
@@ -78,7 +62,7 @@ sealed class BackupScheduler : CancellableBackgroundTask {
}
}
private async Task WaitForOnlinePlayers(InstancePlayerCountTracker playerCountTracker) {
private async Task WaitForOnlinePlayers() {
var task = playerCountTracker.WaitForOnlinePlayers(CancellationToken);
if (!task.IsCompleted) {
Logger.Information("Waiting for someone to join before starting a new backup.");
@@ -95,7 +79,6 @@ sealed class BackupScheduler : CancellableBackgroundTask {
}
protected override void Dispose() {
playerCountTracker?.Stop();
backupSemaphore.Dispose();
serverOutputWhileWaitingForOnlinePlayers.Dispose();
}

98
Agent/Phantom.Agent.Services/Backups/BackupServerCommandDispatcher.cs Normal file
View File

@@ -0,0 +1,98 @@
using System.Collections.Immutable;
using System.Text.RegularExpressions;
using Phantom.Agent.Services.Games;
using Phantom.Agent.Services.Instances.State;
using Phantom.Utils.Tasks;
using Serilog;
namespace Phantom.Agent.Services.Backups;
sealed partial class BackupServerCommandDispatcher : IDisposable {
[GeneratedRegex(@"^(?:(?:\[.*?\] \[Server thread/INFO\].*?:)|(?:[\d-]+? [\d:]+? \[INFO\])) (.*?)$", RegexOptions.NonBacktracking)]
private static partial Regex ServerThreadInfoRegex();
private static readonly ImmutableHashSet<string> AutomaticSavingDisabledMessages = ImmutableHashSet.Create(
"Automatic saving is now disabled",
"Turned off world auto-saving",
"CONSOLE: Disabling level saving.."
);
private static readonly ImmutableHashSet<string> SavedTheGameMessages = ImmutableHashSet.Create(
"Saved the game",
"Saved the world",
"CONSOLE: Save complete."
);
private static readonly ImmutableHashSet<string> AutomaticSavingEnabledMessages = ImmutableHashSet.Create(
"Automatic saving is now enabled",
"Turned on world auto-saving",
"CONSOLE: Enabling level saving.."
);
private readonly ILogger logger;
private readonly InstanceProcess process;
private readonly CancellationToken cancellationToken;
private readonly TaskCompletionSource automaticSavingDisabled = AsyncTasks.CreateCompletionSource();
private readonly TaskCompletionSource savedTheGame = AsyncTasks.CreateCompletionSource();
private readonly TaskCompletionSource automaticSavingEnabled = AsyncTasks.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(TimeSpan.FromSeconds(30), cancellationToken);
}
public async Task SaveAllChunks() {
await process.SendCommand(MinecraftCommand.SaveAll(flush: true), cancellationToken);
await savedTheGame.Task.WaitAsync(TimeSpan.FromMinutes(1), cancellationToken);
}
public async Task EnableAutomaticSaving() {
await process.SendCommand(MinecraftCommand.SaveOn, cancellationToken);
await automaticSavingEnabled.Task.WaitAsync(TimeSpan.FromMinutes(1), 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 (AutomaticSavingDisabledMessages.Contains(info)) {
logger.Debug("Detected that automatic saving is disabled.");
automaticSavingDisabled.SetResult();
}
}
else if (!savedTheGame.Task.IsCompleted) {
if (SavedTheGameMessages.Contains(info)) {
logger.Debug("Detected that the game is saved.");
savedTheGame.SetResult();
}
}
else if (!automaticSavingEnabled.Task.IsCompleted) {
if (AutomaticSavingEnabledMessages.Contains(info)) {
logger.Debug("Detected that automatic saving is enabled.");
automaticSavingEnabled.SetResult();
}
}
}
}

2
Agent/Phantom.Agent.Services/Downloads/FileDownloadManager.cs
View File

@@ -22,7 +22,7 @@ sealed class FileDownloadManager {
try {
Directories.Create(parentPath.FullName, Chmod.URWX_GRX);
} catch (Exception e) {
Logger.Error(e, "Unable to create directory: {DirectoryName}", parentPath.FullName);
Logger.Error(e, "Unable to create folder: {FolderName}", parentPath.FullName);
return null;
}
}

3
Agent/Phantom.Agent.Services/Downloads/FileDownloader.cs
View File

@@ -3,6 +3,7 @@ using Phantom.Common.Data.Agent;
using Phantom.Utils.Cryptography;
using Phantom.Utils.IO;
using Phantom.Utils.Logging;
using Phantom.Utils.Net;
using Phantom.Utils.Runtime;
using Serilog;
@@ -110,7 +111,7 @@ sealed class FileDownloader {
var response = await httpClient.GetAsync(downloadUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
response.EnsureSuccessStatusCode();
FileSize? fileSize = response.Content.Headers.ContentLength is {} length and >= 0 ? new FileSize((ulong) length) : null;
FileSize? fileSize = response.Headers.ContentLength;
ulong? fileSizeBytes = fileSize?.Bytes;
Logger.Information("Downloading {Url} ({Size})...", downloadUrl, FormatFileSize(fileSize));

15
Agent/Phantom.Agent.Services/Games/MinecraftCommand.cs Normal file
View File

@@ -0,0 +1,15 @@
namespace Phantom.Agent.Services.Games;
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";
}
}

32
Agent/Phantom.Agent.Services/Games/MinecraftServerPlayerCountDetector.cs
View File

@@ -1,32 +0,0 @@
using System.Net.Sockets;
using Phantom.Agent.Services.Instances;
using Phantom.Common.Data.Agent.Instance.Backups;
using Phantom.Common.Data.Instance;
using Phantom.Utils.Logging;
using Serilog;
namespace Phantom.Agent.Services.Games;
sealed class MinecraftServerPlayerCountDetector(InstanceContext instanceContext, ushort serverPort) : IInstancePlayerCountDetector {
private readonly ILogger logger = PhantomLogger.Create<MinecraftServerPlayerCountDetector>(instanceContext.ShortName);
private bool waitingForFirstDetection = true;
public async Task<InstancePlayerCounts?> TryGetPlayerCounts(CancellationToken cancellationToken) {
try {
var playerCounts = await MinecraftServerStatusProtocol.GetPlayerCounts(serverPort, cancellationToken);
waitingForFirstDetection = false;
return playerCounts;
} catch (MinecraftServerStatusProtocol.ProtocolException e) {
logger.Error("{Message}", e.Message);
return null;
} catch (SocketException e) {
bool waitingForServerStart = e.SocketErrorCode == SocketError.ConnectionRefused && waitingForFirstDetection;
if (!waitingForServerStart) {
logger.Warning("Could not check online player count. Socket error {ErrorCode} ({ErrorCodeName}), reason: {ErrorMessage}", e.ErrorCode, e.SocketErrorCode, e.Message);
}
return null;
}
}
}

19
Agent/Phantom.Agent.Services/Instances/InstanceActor.cs
View File

@@ -3,10 +3,9 @@ using Phantom.Agent.Services.Instances.Launch;
using Phantom.Agent.Services.Instances.State;
using Phantom.Agent.Services.Rpc;
using Phantom.Common.Data.Agent.Instance;
using Phantom.Common.Data.Agent.Instance.Backups;
using Phantom.Common.Data.Agent.Instance.Stop;
using Phantom.Common.Data.Backups;
using Phantom.Common.Data.Instance;
using Phantom.Common.Data.Minecraft;
using Phantom.Common.Data.Replies;
using Phantom.Common.Messages.Agent.ToController;
using Phantom.Utils.Actor;
@@ -84,9 +83,9 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
public sealed record ReportInstanceStatusCommand : ICommand;
public sealed record LaunchInstanceCommand(InstanceInfo Info, InstanceLauncher Launcher, InstanceBackupConfiguration? BackupConfiguration, InstanceTicketManager.Ticket Ticket, bool IsRestarting) : ICommand;
public sealed record LaunchInstanceCommand(InstanceInfo Info, InstanceLauncher Launcher, InstanceTicketManager.Ticket Ticket, bool IsRestarting) : ICommand;
public sealed record StopInstanceCommand(InstanceStopRecipe StopRecipe) : ICommand;
public sealed record StopInstanceCommand(MinecraftStopStrategy StopStrategy) : ICommand;
public sealed record SendCommandToInstanceCommand(string Command) : ICommand, ICanReply<SendCommandToInstanceResult>;
@@ -94,7 +93,7 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
public sealed record HandleProcessEndedCommand(IInstanceStatus Status) : ICommand, IJumpAhead;
public sealed record ShutdownCommand(InstanceStopRecipe StopRecipe) : ICommand;
public sealed record ShutdownCommand : ICommand;
private void ReportInstanceStatus(ReportInstanceStatusCommand command) {
ReportCurrentStatus();
@@ -109,11 +108,7 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
SetAndReportStatus(newStatus ?? defaultLaunchStatus);
}
if (command.IsRestarting) {
await Task.Delay(TimeSpan.FromSeconds(1), shutdownCancellationToken);
}
var newState = await InstanceLaunchProcedure.Run(context, command.Info, command.Launcher, command.BackupConfiguration, instanceTicketManager, command.Ticket, UpdateStatus, shutdownCancellationToken);
var newState = await InstanceLaunchProcedure.Run(context, command.Info, command.Launcher, instanceTicketManager, command.Ticket, UpdateStatus, shutdownCancellationToken);
if (newState is null) {
instanceTicketManager.Release(command.Ticket);
}
@@ -130,7 +125,7 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
IInstanceStatus oldStatus = currentStatus;
SetAndReportStatus(InstanceStatus.Stopping);
if (await InstanceStopProcedure.Run(context, command.StopRecipe, runningState, SetAndReportStatus, shutdownCancellationToken)) {
if (await InstanceStopProcedure.Run(context, command.StopStrategy, runningState, SetAndReportStatus, shutdownCancellationToken)) {
instanceTicketManager.Release(runningState.Ticket);
TransitionState(null);
}
@@ -172,7 +167,7 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
}
private async Task Shutdown(ShutdownCommand command) {
await StopInstance(new StopInstanceCommand(command.StopRecipe));
await StopInstance(new StopInstanceCommand(MinecraftStopStrategy.Instant));
await actorCancellationTokenSource.CancelAsync();
await Task.WhenAll(

48
Agent/Phantom.Agent.Services/Instances/InstanceManagerActor.cs
View File

@@ -5,10 +5,9 @@ using Phantom.Agent.Services.Java;
using Phantom.Agent.Services.Rpc;
using Phantom.Common.Data;
using Phantom.Common.Data.Agent.Instance;
using Phantom.Common.Data.Agent.Instance.Backups;
using Phantom.Common.Data.Agent.Instance.Launch;
using Phantom.Common.Data.Agent.Instance.Stop;
using Phantom.Common.Data.Instance;
using Phantom.Common.Data.Minecraft;
using Phantom.Common.Data.Replies;
using Phantom.Utils.Actor;
using Phantom.Utils.IO;
@@ -20,14 +19,14 @@ namespace Phantom.Agent.Services.Instances;
sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand> {
private static readonly ILogger Logger = PhantomLogger.Create<InstanceManagerActor>();
public readonly record struct Init(ControllerConnection ControllerConnection, AgentDirectories AgentDirectories, AgentState AgentState, JavaRuntimeRepository JavaRuntimeRepository, InstanceTicketManager InstanceTicketManager, BackupManager BackupManager);
public readonly record struct Init(ControllerConnection ControllerConnection, AgentFolders AgentFolders, AgentState AgentState, JavaRuntimeRepository JavaRuntimeRepository, InstanceTicketManager InstanceTicketManager, BackupManager BackupManager);
public static Props<ICommand> Factory(Init init) {
return Props<ICommand>.Create(() => new InstanceManagerActor(init), new ActorConfiguration { SupervisorStrategy = SupervisorStrategies.Resume });
}
private readonly AgentState agentState;
private readonly AgentDirectories agentDirectories;
private readonly AgentFolders agentFolders;
private readonly InstanceServices instanceServices;
private readonly InstanceTicketManager instanceTicketManager;
@@ -40,7 +39,7 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
private InstanceManagerActor(Init init) {
this.agentState = init.AgentState;
this.agentDirectories = init.AgentDirectories;
this.agentFolders = init.AgentFolders;
this.instanceServices = new InstanceServices(init.ControllerConnection, init.BackupManager, new FileDownloadManager(), init.JavaRuntimeRepository);
this.instanceTicketManager = init.InstanceTicketManager;
@@ -53,22 +52,15 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
ReceiveAsync<ShutdownCommand>(Shutdown);
}
private sealed record Instance(
ActorRef<InstanceActor.ICommand> Actor,
InstanceInfo Info,
InstanceProperties Properties,
InstanceLaunchRecipe? LaunchRecipe,
InstanceStopRecipe StopRecipe,
InstanceBackupConfiguration? BackupConfiguration
);
private sealed record Instance(ActorRef<InstanceActor.ICommand> Actor, InstanceInfo Info, InstanceProperties Properties, InstanceLaunchRecipe? LaunchRecipe);
public interface ICommand;
public sealed record ConfigureInstanceCommand(Guid InstanceGuid, InstanceInfo InstanceInfo, InstanceLaunchRecipe? LaunchRecipe, bool LaunchNow, InstanceStopRecipe StopRecipe, InstanceBackupConfiguration? BackupConfiguration, bool AlwaysReportStatus) : ICommand, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;
public sealed record ConfigureInstanceCommand(Guid InstanceGuid, InstanceInfo InstanceInfo, InstanceLaunchRecipe? LaunchRecipe, bool LaunchNow, bool AlwaysReportStatus) : ICommand, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;
public sealed record LaunchInstanceCommand(Guid InstanceGuid) : ICommand, ICanReply<Result<LaunchInstanceResult, InstanceActionFailure>>;
public sealed record StopInstanceCommand(Guid InstanceGuid, InstanceStopRecipe StopRecipe) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
public sealed record StopInstanceCommand(Guid InstanceGuid, MinecraftStopStrategy StopStrategy) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
public sealed record SendCommandToInstanceCommand(Guid InstanceGuid, string Command) : ICommand, ICanReply<Result<SendCommandToInstanceResult, InstanceActionFailure>>;
@@ -78,15 +70,11 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
var instanceGuid = command.InstanceGuid;
var instanceInfo = command.InstanceInfo;
var launchRecipe = command.LaunchRecipe;
var stopRecipe = command.StopRecipe;
var backupConfiguration = command.BackupConfiguration;
if (instances.TryGetValue(instanceGuid, out var instance)) {
instances[instanceGuid] = instance with {
Info = instanceInfo,
LaunchRecipe = launchRecipe,
StopRecipe = stopRecipe,
BackupConfiguration = backupConfiguration,
};
Logger.Information("Reconfigured instance \"{Name}\" (GUID {Guid}).", instanceInfo.InstanceName, instanceGuid);
@@ -97,12 +85,10 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
}
else {
var instanceLoggerName = PhantomLogger.ShortenGuid(instanceGuid) + "/" + Interlocked.Increment(ref instanceLoggerSequenceId);
var instanceDirectoryPath = Path.Combine(agentDirectories.InstancesDirectoryPath, instanceGuid.ToString());
var instanceProperties = new InstanceProperties(instanceGuid, instanceDirectoryPath);
var instanceFolder = Path.Combine(agentFolders.InstancesFolderPath, instanceGuid.ToString());
var instanceProperties = new InstanceProperties(instanceGuid, instanceFolder);
var instanceInit = new InstanceActor.Init(agentState, instanceGuid, instanceLoggerName, instanceServices, instanceTicketManager, shutdownCancellationToken);
var instanceActor = Context.ActorOf(InstanceActor.Factory(instanceInit), "Instance-" + instanceGuid);
instances[instanceGuid] = instance = new Instance(instanceActor, instanceInfo, instanceProperties, launchRecipe, stopRecipe, backupConfiguration);
instances[instanceGuid] = instance = new Instance(Context.ActorOf(InstanceActor.Factory(instanceInit), "Instance-" + instanceGuid), instanceInfo, instanceProperties, launchRecipe);
Logger.Information("Created instance \"{Name}\" (GUID {Guid}).", instanceInfo.InstanceName, instanceGuid);
@@ -110,10 +96,10 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
}
try {
Directories.Create(instance.Properties.InstanceDirectoryPath, Chmod.URWX_GRX);
Directories.Create(instance.Properties.InstanceFolder, Chmod.URWX_GRX);
} catch (Exception e) {
Logger.Error(e, "Could not create instance directory: {Path}", instance.Properties.InstanceDirectoryPath);
return ConfigureInstanceResult.CouldNotCreateInstanceDirectory;
Logger.Error(e, "Could not create instance folder: {Path}", instance.Properties.InstanceFolder);
return ConfigureInstanceResult.CouldNotCreateInstanceFolder;
}
if (command.LaunchNow) {
@@ -148,11 +134,11 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
}
}
var pathResolver = new InstancePathResolver(agentDirectories, instanceServices.JavaRuntimeRepository, instance.Properties);
var pathResolver = new InstancePathResolver(agentFolders, instanceServices.JavaRuntimeRepository, instance.Properties);
var valueResolver = new InstanceValueResolver(pathResolver);
var launcher = new InstanceLauncher(instanceServices.DownloadManager, pathResolver, valueResolver, instance.Properties, launchRecipe);
instance.Actor.Tell(new InstanceActor.LaunchInstanceCommand(instance.Info, launcher, instance.BackupConfiguration, ticket.Value, IsRestarting: false));
instance.Actor.Tell(new InstanceActor.LaunchInstanceCommand(instance.Info, launcher, ticket.Value, IsRestarting: false));
return LaunchInstanceResult.LaunchInitiated;
}
@@ -173,7 +159,7 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
}
}
instanceInfo.Actor.Tell(new InstanceActor.StopInstanceCommand(command.StopRecipe));
instanceInfo.Actor.Tell(new InstanceActor.StopInstanceCommand(command.StopStrategy));
return StopInstanceResult.StopInitiated;
}
@@ -195,7 +181,7 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
await shutdownCancellationTokenSource.CancelAsync();
await Task.WhenAll(instances.Values.Select(static instance => instance.Actor.Stop(new InstanceActor.ShutdownCommand(instance.StopRecipe))));
await Task.WhenAll(instances.Values.Select(static instance => instance.Actor.Stop(new InstanceActor.ShutdownCommand())));
instances.Clear();
shutdownCancellationTokenSource.Dispose();

2
Agent/Phantom.Agent.Services/Instances/InstanceProperties.cs
View File

@@ -2,5 +2,5 @@
sealed record InstanceProperties(
Guid InstanceGuid,
string InstanceDirectoryPath
string InstanceFolder
);

14
Agent/Phantom.Agent.Services/Instances/Launch/InstanceLaunchProcedure.cs
View File

@@ -1,22 +1,12 @@
using Phantom.Agent.Services.Instances.State;
using Phantom.Common.Data;
using Phantom.Common.Data.Agent.Instance;
using Phantom.Common.Data.Agent.Instance.Backups;
using Phantom.Common.Data.Instance;
namespace Phantom.Agent.Services.Instances.Launch;
static class InstanceLaunchProcedure {
public static async Task<InstanceRunningState?> Run(
InstanceContext context,
InstanceInfo info,
InstanceLauncher launcher,
InstanceBackupConfiguration? backupConfiguration,
InstanceTicketManager ticketManager,
InstanceTicketManager.Ticket ticket,
Action<IInstanceStatus?> reportStatus,
CancellationToken cancellationToken
) {
public static async Task<InstanceRunningState?> Run(InstanceContext context, InstanceInfo info, InstanceLauncher launcher, InstanceTicketManager ticketManager, InstanceTicketManager.Ticket ticket, Action<IInstanceStatus?> reportStatus, CancellationToken cancellationToken) {
context.Logger.Information("Session starting...");
Result<InstanceProcess, InstanceLaunchFailReason> result;
@@ -40,7 +30,7 @@ static class InstanceLaunchProcedure {
if (result) {
reportStatus(InstanceStatus.Running);
context.ReportEvent(InstanceEvent.LaunchSucceeded);
return new InstanceRunningState(context, info, launcher, backupConfiguration, ticket, result.Value, cancellationToken);
return new InstanceRunningState(context, info, launcher, ticket, result.Value, cancellationToken);
}
else {
reportStatus(InstanceStatus.Failed(result.Error));

40
Agent/Phantom.Agent.Services/Instances/Launch/InstanceLauncher.cs
View File

@@ -18,8 +18,6 @@ sealed class InstanceLauncher(
InstanceProperties instanceProperties,
InstanceLaunchRecipe launchRecipe
) {
public IInstanceValueResolver ValueResolver => valueResolver;
public async Task<InstanceLaunchResult> Launch(ILogger logger, Action<IInstanceStatus?> reportStatus, CancellationToken cancellationToken) {
string? executablePath = launchRecipe.Executable.Resolve(pathResolver);
if (executablePath == null) {
@@ -28,13 +26,24 @@ sealed class InstanceLauncher(
}
var stepExecutor = new StepExecutor(logger, downloadManager, pathResolver, reportStatus, cancellationToken);
if (!await RunPreparationSteps(logger, stepExecutor)) {
var steps = launchRecipe.Preparation;
for (int stepIndex = 0; stepIndex < steps.Length; stepIndex++) {
var step = steps[stepIndex];
try {
if (await step.Run(stepExecutor)) {
continue;
}
} catch (Exception e) {
logger.Error(e, "Failed preparation step {StepIndex} out of {StepCount}: {StepName}", stepIndex, steps.Length, step.GetType().Name);
}
return new InstanceLaunchResult.CouldNotPrepareServerInstance();
}
var processConfigurator = new ProcessConfigurator {
FileName = executablePath,
WorkingDirectory = instanceProperties.InstanceDirectoryPath,
WorkingDirectory = instanceProperties.InstanceFolder,
RedirectInput = true,
UseShellExecute = false,
};
@@ -71,27 +80,6 @@ sealed class InstanceLauncher(
return new InstanceLaunchResult.Success(instanceProcess);
}
private async Task<bool> RunPreparationSteps(ILogger logger, StepExecutor stepExecutor) {
var steps = launchRecipe.Preparation;
for (int stepIndex = 0; stepIndex < steps.Length; stepIndex++) {
var step = steps[stepIndex];
try {
if (await step.Run(stepExecutor)) {
continue;
}
} catch (OperationCanceledException) {
throw;
} catch (Exception e) {
logger.Error(e, "Failed preparation step {StepIndex} out of {StepCount}: {StepName}", stepIndex, steps.Length, step.GetType().Name);
}
return false;
}
return true;
}
private sealed class StepExecutor(ILogger logger, FileDownloadManager downloadManager, IInstancePathResolver pathResolver, Action<IInstanceStatus?> reportStatus, CancellationToken cancellationToken) : IInstanceLaunchStepExecutor<bool> {
public async Task<bool> DownloadFile(FileDownloadInfo downloadInfo, IInstancePath path) {
string? filePath = path.Resolve(pathResolver);
@@ -111,8 +99,6 @@ sealed class InstanceLauncher(
}
}
reportStatus(InstanceStatus.Downloading(null));
if (await downloadManager.DownloadAndGetPath(downloadInfo, filePath, OnDownloadProgress, cancellationToken) == null) {
logger.Error("Could not download file: {Url}", downloadInfo.Url);
return false;

6
Agent/Phantom.Agent.Services/Instances/Launch/InstancePathResolver.cs
View File

@@ -5,13 +5,13 @@ using Phantom.Common.Data.Agent.Instance;
namespace Phantom.Agent.Services.Instances.Launch;
sealed class InstancePathResolver(AgentDirectories agentDirectories, JavaRuntimeRepository javaRuntimeRepository, InstanceProperties instanceProperties) : IInstancePathResolver {
sealed class InstancePathResolver(AgentFolders agentFolders, JavaRuntimeRepository javaRuntimeRepository, InstanceProperties instanceProperties) : IInstancePathResolver {
public string? Global(ImmutableArray<string> segments) {
return ValidateAndCombinePath(agentDirectories.ServerExecutableDirectoryPath, segments);
return ValidateAndCombinePath(agentFolders.ServerExecutableFolderPath, segments);
}
public string? Local(ImmutableArray<string> segments) {
return ValidateAndCombinePath(instanceProperties.InstanceDirectoryPath, segments);
return ValidateAndCombinePath(instanceProperties.InstanceFolder, segments);
}
public string? Runtime(Guid guid) {

10
Agent/Phantom.Agent.Services/Instances/State/InstancePlayerCountDetectorFactory.cs
View File

@@ -1,10 +0,0 @@
using Phantom.Agent.Services.Games;
using Phantom.Common.Data.Agent.Instance.Backups;
namespace Phantom.Agent.Services.Instances.State;
sealed class InstancePlayerCountDetectorFactory(InstanceContext instanceContext) : IInstancePlayerCountDetectorFactory {
public IInstancePlayerCountDetector MinecraftStatusProtocol(ushort port) {
return new MinecraftServerPlayerCountDetector(instanceContext, port);
}
}

27
Agent/Phantom.Agent.Services/Instances/State/InstancePlayerCountTracker.cs
View File

@@ -1,5 +1,6 @@
using Phantom.Agent.Services.Rpc;
using Phantom.Common.Data.Agent.Instance.Backups;
using System.Net.Sockets;
using Phantom.Agent.Services.Games;
using Phantom.Agent.Services.Rpc;
using Phantom.Common.Data.Instance;
using Phantom.Common.Messages.Agent.ToController;
using Phantom.Utils.Logging;
@@ -11,8 +12,8 @@ namespace Phantom.Agent.Services.Instances.State;
sealed class InstancePlayerCountTracker : CancellableBackgroundTask {
private readonly ControllerConnection controllerConnection;
private readonly Guid instanceGuid;
private readonly ushort serverPort;
private readonly InstanceProcess process;
private readonly IInstancePlayerCountDetector playerCountDetector;
private readonly TaskCompletionSource firstDetection = AsyncTasks.CreateCompletionSource();
private readonly ManualResetEventSlim serverOutputEvent = new ();
@@ -24,11 +25,11 @@ sealed class InstancePlayerCountTracker : CancellableBackgroundTask {
private bool isDisposed = false;
public InstancePlayerCountTracker(InstanceContext context, InstanceProcess process, IInstancePlayerCountDetector playerCountDetector) : base(PhantomLogger.Create<InstancePlayerCountTracker>(context.ShortName)) {
public InstancePlayerCountTracker(InstanceContext context, InstanceProcess process, ushort serverPort) : base(PhantomLogger.Create<InstancePlayerCountTracker>(context.ShortName)) {
this.controllerConnection = context.Services.ControllerConnection;
this.instanceGuid = context.InstanceGuid;
this.process = process;
this.playerCountDetector = playerCountDetector;
this.serverPort = serverPort;
Start();
}
@@ -58,7 +59,17 @@ sealed class InstancePlayerCountTracker : CancellableBackgroundTask {
private async Task<InstancePlayerCounts?> TryGetPlayerCounts() {
try {
return await playerCountDetector.TryGetPlayerCounts(CancellationToken);
return await MinecraftServerStatusProtocol.GetPlayerCounts(serverPort, CancellationToken);
} catch (MinecraftServerStatusProtocol.ProtocolException e) {
Logger.Error("Could not check online player count due to protocol error: {Message}", e.Message);
return null;
} catch (SocketException e) {
bool waitingForServerStart = e.SocketErrorCode == SocketError.ConnectionRefused && WaitingForFirstDetection;
if (!waitingForServerStart) {
Logger.Warning("Could not check online player count. Socket error {ErrorCode} ({ErrorCodeName}), reason: {ErrorMessage}", e.ErrorCode, e.SocketErrorCode, e.Message);
}
return null;
} catch (Exception e) {
Logger.Error(e, "Caught exception while checking online player count.");
return null;
@@ -66,8 +77,8 @@ sealed class InstancePlayerCountTracker : CancellableBackgroundTask {
}
private void UpdatePlayerCounts(InstancePlayerCounts? newPlayerCounts) {
if (newPlayerCounts != null) {
Logger.Debug("Detected {OnlinePlayerCount} / {MaximumPlayerCount} online player(s).", newPlayerCounts.Online, newPlayerCounts.Maximum);
if (newPlayerCounts is {} value) {
Logger.Debug("Detected {OnlinePlayerCount} / {MaximumPlayerCount} online player(s).", value.Online, value.Maximum);
firstDetection.TrySetResult();
}

9
Agent/Phantom.Agent.Services/Instances/State/InstanceProcess.cs
View File

@@ -27,15 +27,6 @@ sealed class InstanceProcess : IDisposable {
await process.StandardInput.WriteLineAsync(command.AsMemory(), cancellationToken);
}
public async Task<bool> TrySendCommand(string command, TimeSpan timeout, CancellationToken cancellationToken) {
try {
await SendCommand(command, cancellationToken).WaitAsync(timeout, cancellationToken);
return true;
} catch (TimeoutException) {
return false;
}
}
public void AddOutputListener(EventHandler<string> listener, uint maxLinesToReadFromHistory = uint.MaxValue) {
OutputEvent += listener;

24
Agent/Phantom.Agent.Services/Instances/State/InstanceRunningState.cs
View File

@@ -1,7 +1,6 @@
using Phantom.Agent.Services.Backups;
using Phantom.Agent.Services.Instances.Launch;
using Phantom.Common.Data.Agent.Instance;
using Phantom.Common.Data.Agent.Instance.Backups;
using Phantom.Common.Data.Backups;
using Phantom.Common.Data.Instance;
using Phantom.Common.Data.Replies;
@@ -12,38 +11,32 @@ sealed class InstanceRunningState : IDisposable {
public InstanceTicketManager.Ticket Ticket { get; }
public InstanceProcess Process { get; }
internal IInstanceValueResolver ValueResolver => launcher.ValueResolver;
internal bool IsStopping { get; set; }
private readonly InstanceContext context;
private readonly InstanceInfo info;
private readonly InstanceLauncher launcher;
private readonly InstanceBackupConfiguration? backupConfiguration;
private readonly CancellationToken cancellationToken;
private readonly InstanceLogSender logSender;
private readonly BackupScheduler? backupScheduler;
private readonly InstancePlayerCountTracker playerCountTracker;
private readonly BackupScheduler backupScheduler;
private bool isDisposed;
public InstanceRunningState(InstanceContext context, InstanceInfo info, InstanceLauncher launcher, InstanceBackupConfiguration? backupConfiguration, InstanceTicketManager.Ticket ticket, InstanceProcess process, CancellationToken cancellationToken) {
public InstanceRunningState(InstanceContext context, InstanceInfo info, InstanceLauncher launcher, InstanceTicketManager.Ticket ticket, InstanceProcess process, CancellationToken cancellationToken) {
this.context = context;
this.info = info;
this.launcher = launcher;
this.backupConfiguration = backupConfiguration;
this.Ticket = ticket;
this.Process = process;
this.cancellationToken = cancellationToken;
this.logSender = new InstanceLogSender(context.Services.ControllerConnection, context.InstanceGuid, context.ShortName);
this.playerCountTracker = new InstancePlayerCountTracker(context, process, info.ServerPort);
if (backupConfiguration == null) {
this.backupScheduler = null;
}
else {
this.backupScheduler = new BackupScheduler(context, process, backupConfiguration.Schedule);
this.backupScheduler.BackupCompleted += OnScheduledBackupCompleted;
}
this.backupScheduler = new BackupScheduler(context, playerCountTracker);
this.backupScheduler.BackupCompleted += OnScheduledBackupCompleted;
}
public void Initialize() {
@@ -81,7 +74,7 @@ sealed class InstanceRunningState : IDisposable {
else {
context.Logger.Information("Session ended unexpectedly, restarting...");
context.ReportEvent(InstanceEvent.Crashed);
context.Actor.Tell(new InstanceActor.LaunchInstanceCommand(info, launcher, backupConfiguration, Ticket, IsRestarting: true));
context.Actor.Tell(new InstanceActor.LaunchInstanceCommand(info, launcher, Ticket, IsRestarting: true));
}
}
@@ -103,7 +96,8 @@ sealed class InstanceRunningState : IDisposable {
}
public void OnStopInitiated() {
backupScheduler?.Stop();
backupScheduler.Stop();
playerCountTracker.Stop();
}
private bool TryDispose() {

105
Agent/Phantom.Agent.Services/Instances/State/InstanceStopProcedure.cs
View File

@@ -1,50 +1,37 @@
using System.Diagnostics;
using Phantom.Common.Data.Agent.Instance;
using Phantom.Common.Data.Agent.Instance.Stop;
using Phantom.Agent.Services.Games;
using Phantom.Common.Data.Instance;
using Serilog;
using Phantom.Common.Data.Minecraft;
namespace Phantom.Agent.Services.Instances.State;
static class InstanceStopProcedure {
public static async Task<bool> Run(InstanceContext context, InstanceStopRecipe stopRecipe, InstanceRunningState runningState, Action<IInstanceStatus> reportStatus, CancellationToken cancellationToken) {
var logger = context.Logger;
var stopCommand = stopRecipe.StopCommand.Resolve(runningState.ValueResolver);
if (stopCommand == null) {
logger.Error("Could not resolve stop command");
return false;
}
private static readonly ushort[] Stops = [60, 30, 10, 5, 4, 3, 2, 1, 0];
public static async Task<bool> Run(InstanceContext context, MinecraftStopStrategy stopStrategy, InstanceRunningState runningState, Action<IInstanceStatus> reportStatus, CancellationToken cancellationToken) {
var process = runningState.Process;
runningState.IsStopping = true;
bool continueStopping = false;
try {
var stepExecutor = new StepExecutor(logger, runningState.ValueResolver, runningState.Process, cancellationToken);
continueStopping = await RunPreparationSteps(context, stopRecipe, stepExecutor);
} finally {
if (!continueStopping) {
var seconds = stopStrategy.Seconds;
if (seconds > 0) {
try {
await CountDownWithAnnouncements(context, process, seconds, cancellationToken);
} catch (OperationCanceledException) {
runningState.IsStopping = false;
return false;
}
}
if (!continueStopping) {
return false;
}
try {
// Too late to cancel the stop procedure now.
runningState.OnStopInitiated();
if (!runningState.Process.HasEnded) {
logger.Information("Sending stop command...");
await TrySendStopCommand(context, runningState.Process, stopCommand);
logger.Information("Waiting for session to end...");
await WaitForSessionToEnd(context, runningState.Process);
if (!process.HasEnded) {
context.Logger.Information("Session stopping now.");
await DoStop(context, process);
}
} finally {
logger.Information("Session stopped.");
context.Logger.Information("Session stopped.");
reportStatus(InstanceStatus.NotRunning);
context.ReportEvent(InstanceEvent.Stopped);
}
@@ -52,51 +39,39 @@ static class InstanceStopProcedure {
return true;
}
private static async Task<bool> RunPreparationSteps(InstanceContext context, InstanceStopRecipe stopRecipe, StepExecutor executor) {
var steps = stopRecipe.Preparation;
private static async Task CountDownWithAnnouncements(InstanceContext context, InstanceProcess process, ushort seconds, CancellationToken cancellationToken) {
context.Logger.Information("Session stopping in {Seconds} seconds.", seconds);
for (int stepIndex = 0; stepIndex < steps.Length; stepIndex++) {
var step = steps[stepIndex];
try {
if (await step.Run(executor)) {
continue;
}
} catch (OperationCanceledException) {
throw;
} catch (Exception e) {
context.Logger.Error(e, "Failed preparation step {StepIndex} out of {StepCount}: {StepName}", stepIndex, steps.Length, step.GetType().Name);
foreach (var stop in Stops) {
// TODO change to event-based cancellation
if (process.HasEnded) {
return;
}
return false;
}
return true;
}
private sealed class StepExecutor(ILogger logger, IInstanceValueResolver valueResolver, InstanceProcess process, CancellationToken cancellationToken) : IInstanceStopStepExecutor<bool> {
public async Task<bool> Wait(TimeSpan duration) {
await Task.Delay(duration, cancellationToken);
return true;
}
public async Task<bool> SendToStandardInput(IInstanceValue line) {
string? command = line.Resolve(valueResolver);
if (command == null) {
logger.Error("Could not resolve standard input line: {Value}", line);
return false;
if (seconds > stop) {
await process.SendCommand(GetCountDownAnnouncementCommand(seconds), cancellationToken);
await Task.Delay(TimeSpan.FromSeconds(seconds - stop), cancellationToken);
seconds = stop;
}
// If the process can't process standard input, wait a bit but don't block or fail the whole stop procedure.
await process.TrySendCommand(command, TimeSpan.FromMilliseconds(500), cancellationToken);
return true;
}
}
private static async Task TrySendStopCommand(InstanceContext context, InstanceProcess process, string command) {
private static string GetCountDownAnnouncementCommand(ushort seconds) {
return MinecraftCommand.Say("Server shutting down in " + seconds + (seconds == 1 ? " second." : " seconds."));
}
private static async Task DoStop(InstanceContext context, InstanceProcess process) {
context.Logger.Information("Sending stop command...");
await TrySendStopCommand(context, process);
context.Logger.Information("Waiting for session to end...");
await WaitForSessionToEnd(context, process);
}
private static async Task TrySendStopCommand(InstanceContext context, InstanceProcess process) {
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
try {
await process.SendCommand(command, timeout.Token);
await process.SendCommand(MinecraftCommand.Stop, timeout.Token);
} catch (OperationCanceledException) {
// Ignore.
} catch (ObjectDisposedException e) when (e.ObjectName == typeof(Process).FullName && process.HasEnded) {

12
Agent/Phantom.Agent.Services/Java/JavaRuntimeDiscovery.cs
View File

@@ -21,19 +21,19 @@ public sealed class JavaRuntimeDiscovery {
return null;
}
public static async Task<JavaRuntimeRepository> Scan(string directoryPath, CancellationToken cancellationToken) {
var runtimes = await new JavaRuntimeDiscovery().ScanInternal(directoryPath, cancellationToken).ToImmutableArrayAsync(cancellationToken);
public static async Task<JavaRuntimeRepository> Scan(string folderPath, CancellationToken cancellationToken) {
var runtimes = await new JavaRuntimeDiscovery().ScanInternal(folderPath, cancellationToken).ToImmutableArrayAsync(cancellationToken);
return new JavaRuntimeRepository(runtimes);
}
private readonly Dictionary<string, int> duplicateDisplayNames = new ();
private async IAsyncEnumerable<JavaRuntimeExecutable> ScanInternal(string directoryPath, [EnumeratorCancellation] CancellationToken cancellationToken) {
Logger.Information("Starting Java runtime scan in: {DirectoryPath}", directoryPath);
private async IAsyncEnumerable<JavaRuntimeExecutable> ScanInternal(string folderPath, [EnumeratorCancellation] CancellationToken cancellationToken) {
Logger.Information("Starting Java runtime scan in: {FolderPath}", folderPath);
string javaExecutableName = OperatingSystem.IsWindows() ? "java.exe" : "java";
foreach (var binDirectoryPath in Directory.EnumerateDirectories(Paths.ExpandTilde(directoryPath), "bin", new EnumerationOptions {
foreach (var binFolderPath in Directory.EnumerateDirectories(Paths.ExpandTilde(folderPath), "bin", new EnumerationOptions {
MatchType = MatchType.Simple,
RecurseSubdirectories = true,
ReturnSpecialDirectories = false,
@@ -42,7 +42,7 @@ public sealed class JavaRuntimeDiscovery {
}).Order()) {
cancellationToken.ThrowIfCancellationRequested();
var javaExecutablePath = Paths.NormalizeSlashes(Path.Combine(binDirectoryPath, javaExecutableName));
var javaExecutablePath = Paths.NormalizeSlashes(Path.Combine(binFolderPath, javaExecutableName));
FileAttributes javaExecutableAttributes;
try {

4
Agent/Phantom.Agent.Services/Rpc/ControllerMessageHandlerActor.cs
View File

@@ -26,7 +26,7 @@ public sealed class ControllerMessageHandlerActor : ReceiveActor<IMessageToAgent
}
private async Task<Result<ConfigureInstanceResult, InstanceActionFailure>> HandleConfigureInstance(ConfigureInstanceMessage message) {
return await agent.InstanceManager.Request(new InstanceManagerActor.ConfigureInstanceCommand(message.InstanceGuid, message.Info, message.LaunchRecipe.Value, message.LaunchNow, message.StopRecipe, message.BackupConfiguration.Value, AlwaysReportStatus: false));
return await agent.InstanceManager.Request(new InstanceManagerActor.ConfigureInstanceCommand(message.InstanceGuid, message.Info, message.LaunchRecipe, message.LaunchNow, AlwaysReportStatus: false));
}
private async Task<Result<LaunchInstanceResult, InstanceActionFailure>> HandleLaunchInstance(LaunchInstanceMessage message) {
@@ -34,7 +34,7 @@ public sealed class ControllerMessageHandlerActor : ReceiveActor<IMessageToAgent
}
private async Task<Result<StopInstanceResult, InstanceActionFailure>> HandleStopInstance(StopInstanceMessage message) {
return await agent.InstanceManager.Request(new InstanceManagerActor.StopInstanceCommand(message.InstanceGuid, message.StopRecipe));
return await agent.InstanceManager.Request(new InstanceManagerActor.StopInstanceCommand(message.InstanceGuid, message.StopStrategy));
}
private async Task<Result<SendCommandToInstanceResult, InstanceActionFailure>> HandleSendCommandToInstance(SendCommandToInstanceMessage message) {

8
Agent/Phantom.Agent/Program.cs
View File

@@ -37,13 +37,13 @@ try {
return 1;
}
var agentDirectories = new AgentDirectories("./data", "./temp", javaSearchPath);
if (!agentDirectories.TryCreate()) {
var folders = new AgentFolders("./data", "./temp", javaSearchPath);
if (!folders.TryCreate()) {
return 1;
}
var agentInfo = new AgentInfo(ProtocolVersion, fullVersion, maxInstances, maxMemory, allowedServerPorts, allowedRconPorts);
var javaRuntimeRepository = await JavaRuntimeDiscovery.Scan(agentDirectories.JavaSearchDirectoryPath, shutdownCancellationToken);
var javaRuntimeRepository = await JavaRuntimeDiscovery.Scan(folders.JavaSearchFolderPath, shutdownCancellationToken);
var agentRegistrationHandler = new AgentRegistrationHandler();
var controllerHandshake = new ControllerHandshake(new AgentRegistration(agentInfo, javaRuntimeRepository.All), agentRegistrationHandler);
@@ -69,7 +69,7 @@ try {
try {
PhantomLogger.Root.InformationHeading("Launching Phantom Panel agent...");
var agentServices = new AgentServices(agentInfo, agentDirectories, new AgentServiceConfiguration(maxConcurrentBackupCompressionTasks), new ControllerConnection(rpcClient.MessageSender), javaRuntimeRepository);
var agentServices = new AgentServices(agentInfo, folders, new AgentServiceConfiguration(maxConcurrentBackupCompressionTasks), new ControllerConnection(rpcClient.MessageSender), javaRuntimeRepository);
var rpcMessageHandlerInit = new ControllerMessageHandlerActor.Init(agentServices);
var rpcMessageHandlerActor = agentServices.ActorSystem.ActorOf(ControllerMessageHandlerActor.Factory(rpcMessageHandlerInit), "ControllerMessageHandler");

2
Agent/Phantom.Agent/Variables.cs
View File

@@ -36,7 +36,7 @@ sealed record Variables(
}
private static string GetDefaultJavaSearchPath() {
return JavaRuntimeDiscovery.GetSystemSearchPath() ?? throw new Exception("Could not automatically determine the path to Java installations on this system. Please set the JAVA_SEARCH_PATH environment variable to the directory containing Java installations.");
return JavaRuntimeDiscovery.GetSystemSearchPath() ?? throw new Exception("Could not automatically determine the path to Java installations on this system. Please set the JAVA_SEARCH_PATH environment variable to the folder containing Java installations.");
}
public static Variables LoadOrStop() {

24
Common/Phantom.Common.Data.Agent/Instance/Backups/IInstanceBackupSchedule.cs
View File

@@ -1,24 +0,0 @@
using MemoryPack;
namespace Phantom.Common.Data.Agent.Instance.Backups;
[MemoryPackable(GenerateType.VersionTolerant)]
public sealed partial record InstanceBackupSchedule(
[property: MemoryPackOrder(0)] ushort InitialDelayInMinutes,
[property: MemoryPackOrder(1)] ushort BackupIntervalInMinutes,
[property: MemoryPackOrder(2)] ushort BackupFailureRetryDelayInMinutes,
[property: MemoryPackOrder(3)] Optional<IInstancePlayerCountDetectionStrategy> PlayerCountDetectionStrategy
) {
[MemoryPackIgnore]
public TimeSpan InitialDelay => TimeSpan.FromMinutes(InitialDelayInMinutes);
[MemoryPackIgnore]
public TimeSpan BackupInterval => TimeSpan.FromMinutes(AtLeastOne(BackupIntervalInMinutes));
[MemoryPackIgnore]
public TimeSpan BackupFailureRetryDelay => TimeSpan.FromMinutes(AtLeastOne(BackupFailureRetryDelayInMinutes));
private static ushort AtLeastOne(ushort value) {
return Math.Max(value, (ushort) 1);
}
}

20
Common/Phantom.Common.Data.Agent/Instance/Backups/IInstancePlayerCountDetectionStrategy.cs
View File

@@ -1,20 +0,0 @@
using MemoryPack;
namespace Phantom.Common.Data.Agent.Instance.Backups;
[MemoryPackable]
[MemoryPackUnion(tag: 0, type: typeof(InstancePlayerCountDetectionStrategy.MinecraftStatusProtocol))]
public partial interface IInstancePlayerCountDetectionStrategy {
IInstancePlayerCountDetector CreateDetector(IInstancePlayerCountDetectorFactory factory);
}
public static partial class InstancePlayerCountDetectionStrategy {
[MemoryPackable(GenerateType.VersionTolerant)]
public sealed partial record MinecraftStatusProtocol(
[property: MemoryPackOrder(0)] ushort Port
) : IInstancePlayerCountDetectionStrategy {
public IInstancePlayerCountDetector CreateDetector(IInstancePlayerCountDetectorFactory factory) {
return factory.MinecraftStatusProtocol(Port);
}
}
}

7
Common/Phantom.Common.Data.Agent/Instance/Backups/IInstancePlayerCountDetector.cs
View File

@@ -1,7 +0,0 @@
using Phantom.Common.Data.Instance;
namespace Phantom.Common.Data.Agent.Instance.Backups;
public interface IInstancePlayerCountDetector {
Task<InstancePlayerCounts?> TryGetPlayerCounts(CancellationToken cancellationToken);
}

5
Common/Phantom.Common.Data.Agent/Instance/Backups/IInstancePlayerCountDetectorFactory.cs
View File

@@ -1,5 +0,0 @@
namespace Phantom.Common.Data.Agent.Instance.Backups;
public interface IInstancePlayerCountDetectorFactory {
IInstancePlayerCountDetector MinecraftStatusProtocol(ushort port);
}

8
Common/Phantom.Common.Data.Agent/Instance/Backups/InstanceBackupConfiguration.cs
View File

@@ -1,8 +0,0 @@
using MemoryPack;
namespace Phantom.Common.Data.Agent.Instance.Backups;
[MemoryPackable(GenerateType.VersionTolerant)]
public sealed partial record InstanceBackupConfiguration(
[property: MemoryPackOrder(0)] InstanceBackupSchedule Schedule
);

30
Common/Phantom.Common.Data.Agent/Instance/Stop/IInstanceStopStep.cs
View File

@@ -1,30 +0,0 @@
using MemoryPack;
namespace Phantom.Common.Data.Agent.Instance.Stop;
[MemoryPackable]
[MemoryPackUnion(tag: 0, typeof(InstanceStopStep.Wait))]
[MemoryPackUnion(tag: 1, typeof(InstanceStopStep.SendToStandardInput))]
public partial interface IInstanceStopStep {
Task<TResult> Run<TResult>(IInstanceStopStepExecutor<TResult> executor);
}
public static partial class InstanceStopStep {
[MemoryPackable(GenerateType.VersionTolerant)]
public sealed partial record Wait(
[property: MemoryPackOrder(0)] TimeSpan Duration
) : IInstanceStopStep {
public Task<TResult> Run<TResult>(IInstanceStopStepExecutor<TResult> executor) {
return executor.Wait(Duration);
}
}
[MemoryPackable(GenerateType.VersionTolerant)]
public sealed partial record SendToStandardInput(
[property: MemoryPackOrder(0)] IInstanceValue Line
) : IInstanceStopStep {
public Task<TResult> Run<TResult>(IInstanceStopStepExecutor<TResult> executor) {
return executor.SendToStandardInput(Line);
}
}
}

6
Common/Phantom.Common.Data.Agent/Instance/Stop/IInstanceStopStepExecutor.cs
View File

@@ -1,6 +0,0 @@
namespace Phantom.Common.Data.Agent.Instance.Stop;
public interface IInstanceStopStepExecutor<TResult> {
Task<TResult> Wait(TimeSpan duration);
Task<TResult> SendToStandardInput(IInstanceValue line);
}

10
Common/Phantom.Common.Data.Agent/Instance/Stop/InstanceStopRecipe.cs
View File

@@ -1,10 +0,0 @@
using System.Collections.Immutable;
using MemoryPack;
namespace Phantom.Common.Data.Agent.Instance.Stop;
[MemoryPackable(GenerateType.VersionTolerant)]
public sealed partial record InstanceStopRecipe(
[property: MemoryPackOrder(0)] ImmutableArray<IInstanceStopStep> Preparation,
[property: MemoryPackOrder(1)] IInstanceValue StopCommand
);

2
Common/Phantom.Common.Data.Web/Java/JvmArgumentsHelper.cs → Common/Phantom.Common.Data.Web/Minecraft/JvmArgumentsHelper.cs
View File

@@ -1,6 +1,6 @@
using System.Collections.Immutable;
namespace Phantom.Common.Data.Web.Java;
namespace Phantom.Common.Data.Web.Minecraft;
public static class JvmArgumentsHelper {
public static ImmutableArray<string> Split(string arguments) {

6
Common/Phantom.Common.Data/Backups/BackupCreationResultKind.cs
View File

@@ -8,9 +8,9 @@ public enum BackupCreationResultKind : byte {
BackupCancelled = 4,
BackupAlreadyRunning = 5,
BackupFileAlreadyExists = 6,
CouldNotCreateBackupDirectory = 7,
CouldNotCopyInstanceIntoTemporaryDirectory = 8,
CouldNotCreateBackupArchive = 9,
CouldNotCreateBackupFolder = 7,
CouldNotCopyWorldToTemporaryFolder = 8,
CouldNotCreateWorldArchive = 9,
}
public static class BackupCreationResultSummaryExtensions {

22
Common/Phantom.Common.Data/Backups/BackupCreationWarnings.cs
View File

@@ -4,20 +4,18 @@ namespace Phantom.Common.Data.Backups;
[Flags]
public enum BackupCreationWarnings : byte {
None = 0,
CouldNotDeleteTemporaryDirectory = 1 << 0,
CouldNotCompressBackupArchive = 1 << 1,
SomeFilesChangedDuringBackup = 1 << 2,
None = 0,
CouldNotDeleteTemporaryFolder = 1 << 0,
CouldNotCompressWorldArchive = 1 << 1,
CouldNotRestoreAutomaticSaving = 1 << 2,
}
public static class BackupCreationWarningsExtensions {
extension(BackupCreationWarnings warnings) {
public int Count() {
return BitOperations.PopCount((byte) warnings);
}
public IEnumerable<BackupCreationWarnings> ListFlags() {
return Enum.GetValues<BackupCreationWarnings>().Where(warning => warning != BackupCreationWarnings.None && warnings.HasFlag(warning));
}
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));
}
}

10
Common/Phantom.Common.Data/Minecraft/MinecraftStopStrategy.cs Normal file
View File

@@ -0,0 +1,10 @@
using MemoryPack;
namespace Phantom.Common.Data.Minecraft;
[MemoryPackable(GenerateType.VersionTolerant)]
public sealed partial record MinecraftStopStrategy(
[property: MemoryPackOrder(0)] ushort Seconds
) {
public static MinecraftStopStrategy Instant => new (0);
}

13
Common/Phantom.Common.Data/Replies/ConfigureInstanceResult.cs
View File

@@ -1,19 +1,16 @@
namespace Phantom.Common.Data.Replies;
public enum ConfigureInstanceResult : byte {
Success = 0,
CouldNotCreateInstanceDirectory = 1,
MinecraftVersionNotFound = 2,
UnknownError = 255,
Success = 0,
CouldNotCreateInstanceFolder = 1,
}
public static class ConfigureInstanceResultExtensions {
public static string ToSentence(this ConfigureInstanceResult reason) {
return reason switch {
ConfigureInstanceResult.Success => "Success.",
ConfigureInstanceResult.CouldNotCreateInstanceDirectory => "Could not create instance directory.",
ConfigureInstanceResult.MinecraftVersionNotFound => "Minecraft version not found.",
_ => "Unknown error.",
ConfigureInstanceResult.Success => "Success.",
ConfigureInstanceResult.CouldNotCreateInstanceFolder => "Could not create instance folder.",
_ => "Unknown error.",
};
}
}

4
Common/Phantom.Common.Data/Result.cs
View File

@@ -43,10 +43,6 @@ public sealed partial class Result<TValue, TError> {
return hasValue ? valueConverter(value!) : errorConverter(error!);
}
public Result<TNewValue, TError> MapValue<TNewValue>(Func<TValue, TNewValue> valueConverter) {
return hasValue ? valueConverter(value!) : error!;
}
public Result<TValue, TNewError> MapError<TNewError>(Func<TError, TNewError> errorConverter) {
return hasValue ? value! : errorConverter(error!);
}

8
Common/Phantom.Common.Messages.Agent/ToAgent/ConfigureInstanceMessage.cs
View File

@@ -1,9 +1,7 @@
using MemoryPack;
using Phantom.Common.Data;
using Phantom.Common.Data.Agent.Instance;
using Phantom.Common.Data.Agent.Instance.Backups;
using Phantom.Common.Data.Agent.Instance.Launch;
using Phantom.Common.Data.Agent.Instance.Stop;
using Phantom.Common.Data.Replies;
using Phantom.Utils.Actor;
@@ -13,8 +11,6 @@ namespace Phantom.Common.Messages.Agent.ToAgent;
public sealed partial record ConfigureInstanceMessage(
[property: MemoryPackOrder(0)] Guid InstanceGuid,
[property: MemoryPackOrder(1)] InstanceInfo Info,
[property: MemoryPackOrder(2)] Optional<InstanceLaunchRecipe> LaunchRecipe,
[property: MemoryPackOrder(3)] bool LaunchNow,
[property: MemoryPackOrder(4)] InstanceStopRecipe StopRecipe,
[property: MemoryPackOrder(5)] Optional<InstanceBackupConfiguration> BackupConfiguration
[property: MemoryPackOrder(2)] InstanceLaunchRecipe? LaunchRecipe,
[property: MemoryPackOrder(3)] bool LaunchNow = false
) : IMessageToAgent, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;

4
Common/Phantom.Common.Messages.Agent/ToAgent/StopInstanceMessage.cs
View File

@@ -1,6 +1,6 @@
using MemoryPack;
using Phantom.Common.Data;
using Phantom.Common.Data.Agent.Instance.Stop;
using Phantom.Common.Data.Minecraft;
using Phantom.Common.Data.Replies;
using Phantom.Utils.Actor;
@@ -9,5 +9,5 @@ namespace Phantom.Common.Messages.Agent.ToAgent;
[MemoryPackable(GenerateType.VersionTolerant)]
public sealed partial record StopInstanceMessage(
[property: MemoryPackOrder(0)] Guid InstanceGuid,
[property: MemoryPackOrder(1)] InstanceStopRecipe StopRecipe
[property: MemoryPackOrder(1)] MinecraftStopStrategy StopStrategy
) : IMessageToAgent, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;

3
Common/Phantom.Common.Messages.Web/ToController/StopInstanceMessage.cs
View File

@@ -1,6 +1,7 @@
using System.Collections.Immutable;
using MemoryPack;
using Phantom.Common.Data;
using Phantom.Common.Data.Minecraft;
using Phantom.Common.Data.Replies;
using Phantom.Common.Data.Web.Users;
using Phantom.Utils.Actor;
@@ -12,5 +13,5 @@ public sealed partial record StopInstanceMessage(
[property: MemoryPackOrder(0)] ImmutableArray<byte> AuthToken,
[property: MemoryPackOrder(1)] Guid AgentGuid,
[property: MemoryPackOrder(2)] Guid InstanceGuid,
[property: MemoryPackOrder(3)] ushort AfterSeconds
[property: MemoryPackOrder(3)] MinecraftStopStrategy StopStrategy
) : IMessageToController, ICanReply<Result<StopInstanceResult, UserInstanceActionFailure>>;

6
Controller/Phantom.Controller.Database/Repositories/AuditLogRepository.Writer.cs
View File

@@ -87,8 +87,10 @@ sealed partial class AuditLogRepository {
});
}
public void InstanceStopped(Guid instanceGuid) {
AddItem(AuditLogEventType.InstanceStopped, instanceGuid.ToString());
public void InstanceStopped(Guid instanceGuid, int stopInSeconds) {
AddItem(AuditLogEventType.InstanceStopped, instanceGuid.ToString(), new Dictionary<string, object?> {
{ "stop_in_seconds", stopInSeconds.ToString() },
});
}
}
}

41
Controller/Phantom.Controller.Minecraft/MinecraftInstanceRecipes.Stop.cs
View File

@@ -1,41 +0,0 @@
using System.Collections.Immutable;
using Phantom.Common.Data.Agent.Instance;
using Phantom.Common.Data.Agent.Instance.Stop;
namespace Phantom.Controller.Minecraft;
public sealed partial class MinecraftInstanceRecipes {
private static readonly ushort[] Stops = [60, 30, 10, 5, 4, 3, 2, 1];
private static readonly IInstanceValue StopCommand = new InstanceValues.Text("stop");
private static InstanceValues.Text SayCommand(string message) {
return new InstanceValues.Text($"say {message}");
}
private static InstanceValues.Text SayCountDownAnnouncementCommand(ushort seconds) {
return SayCommand("Server shutting down in " + seconds + (seconds == 1 ? " second." : " seconds."));
}
public InstanceStopRecipe Stop(ushort afterSeconds) {
var steps = ImmutableArray.CreateBuilder<IInstanceStopStep>();
if (afterSeconds > 0) {
steps.Add(new InstanceStopStep.SendToStandardInput(SayCountDownAnnouncementCommand(afterSeconds)));
int remainingSeconds = afterSeconds;
for (int stopIndex = Array.FindIndex(Stops, stop => stop < afterSeconds); stopIndex != -1 && stopIndex < Stops.Length; stopIndex++) {
ushort currentStop = Stops[stopIndex];
steps.Add(new InstanceStopStep.Wait(TimeSpan.FromSeconds(remainingSeconds - currentStop)));
steps.Add(new InstanceStopStep.SendToStandardInput(SayCountDownAnnouncementCommand(currentStop)));
remainingSeconds = currentStop;
}
steps.Add(new InstanceStopStep.Wait(TimeSpan.FromSeconds(remainingSeconds)));
}
return new InstanceStopRecipe(steps.ToImmutable(), StopCommand);
}
}

14
Controller/Phantom.Controller.Minecraft/MinecraftInstanceRecipes.Launch.cs → Controller/Phantom.Controller.Minecraft/MinecraftLaunchRecipes.cs
View File

@@ -10,8 +10,12 @@ using Phantom.Utils.Collections;
namespace Phantom.Controller.Minecraft;
public sealed partial class MinecraftInstanceRecipes(MinecraftVersions minecraftVersions) {
public async Task<Result<InstanceLaunchRecipe, MinecraftLaunchRecipeCreationFailReason>> Launch(InstanceConfiguration configuration, CancellationToken cancellationToken) {
public sealed partial class MinecraftLaunchRecipes(MinecraftVersions minecraftVersions) {
private static readonly ImmutableDictionary<string, string> Eula = ImmutableDictionary.From([
("eula", "true"),
]);
public async Task<Result<InstanceLaunchRecipe, MinecraftLaunchRecipeCreationFailReason>> Create(InstanceConfiguration configuration, CancellationToken cancellationToken) {
string minecraftVersion = configuration.MinecraftVersion;
var serverExecutableInfo = await minecraftVersions.GetServerExecutableInfo(minecraftVersion, cancellationToken);
@@ -64,14 +68,12 @@ public sealed partial class MinecraftInstanceRecipes(MinecraftVersions minecraft
return SanitizePathRegex().IsMatch(path) ? SanitizePathRegex().Replace(path, "_") : path;
}
private static readonly ImmutableDictionary<string, string> Eula = ImmutableDictionary.From([
("eula", "true"),
]);
private static ImmutableDictionary<string, string> ServerProperties(InstanceConfiguration configuration) {
return ImmutableDictionary.From([
("server-port", configuration.ServerPort.ToString()),
("rcon.port", configuration.RconPort.ToString()),
("enable-rcon", "true"),
("sync-chunk-writes", "false"),
]);
}

69
Controller/Phantom.Controller.Services/Agents/AgentActor.cs
View File

@@ -2,12 +2,14 @@
using Akka.Actor;
using Microsoft.EntityFrameworkCore;
using Phantom.Common.Data;
using Phantom.Common.Data.Agent.Instance.Launch;
using Phantom.Common.Data.Instance;
using Phantom.Common.Data.Java;
using Phantom.Common.Data.Minecraft;
using Phantom.Common.Data.Replies;
using Phantom.Common.Data.Web.Agent;
using Phantom.Common.Data.Web.Instance;
using Phantom.Common.Data.Web.Java;
using Phantom.Common.Data.Web.Minecraft;
using Phantom.Common.Messages.Agent;
using Phantom.Common.Messages.Agent.ToAgent;
using Phantom.Controller.Database;
@@ -39,7 +41,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
AgentRuntimeInfo AgentRuntimeInfo,
AgentConnectionKeys AgentConnectionKeys,
ControllerState ControllerState,
MinecraftInstanceRecipes MinecraftInstanceRecipes,
MinecraftLaunchRecipes LaunchRecipes,
IDbContextProvider DbProvider,
CancellationToken CancellationToken
);
@@ -52,7 +54,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
private readonly AgentConnectionKeys agentConnectionKeys;
private readonly ControllerState controllerState;
private readonly MinecraftInstanceRecipes minecraftInstanceRecipes;
private readonly MinecraftLaunchRecipes launchRecipes;
private readonly IDbContextProvider dbProvider;
private readonly CancellationToken cancellationToken;
@@ -88,11 +90,12 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
private readonly ActorRef<AgentDatabaseStorageActor.ICommand> databaseStorageActor;
private readonly Dictionary<Guid, ActorRef<InstanceActor.ICommand>> instanceActorByGuid = new ();
private readonly Dictionary<Guid, Instance> instanceDataByGuid = new ();
private AgentActor(Init init) {
this.agentConnectionKeys = init.AgentConnectionKeys;
this.controllerState = init.ControllerState;
this.minecraftInstanceRecipes = init.MinecraftInstanceRecipes;
this.launchRecipes = init.LaunchRecipes;
this.dbProvider = init.DbProvider;
this.cancellationToken = init.CancellationToken;
@@ -140,15 +143,20 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
}
private ActorRef<InstanceActor.ICommand> CreateNewInstance(Instance instance) {
controllerState.UpdateInstance(instance);
UpdateInstanceData(instance);
var instanceActor = CreateInstanceActor(instance);
instanceActorByGuid.Add(instance.InstanceGuid, instanceActor);
return instanceActor;
}
private void UpdateInstanceData(Instance instance) {
instanceDataByGuid[instance.InstanceGuid] = instance;
controllerState.UpdateInstance(instance);
}
private ActorRef<InstanceActor.ICommand> CreateInstanceActor(Instance instance) {
var init = new InstanceActor.Init(instance, SelfTyped, connection, minecraftInstanceRecipes, dbProvider, cancellationToken);
var init = new InstanceActor.Init(instance, SelfTyped, connection, dbProvider, cancellationToken);
var name = "Instance:" + instance.InstanceGuid;
return Context.ActorOf(InstanceActor.Factory(init), name);
}
@@ -179,7 +187,15 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
}
private async Task<ImmutableArray<ConfigureInstanceMessage>> PrepareInitialConfigurationMessages() {
return [..await Task.WhenAll(instanceActorByGuid.Values.Select(async instance => await instance.Request(new InstanceActor.GetInitialInstanceConfigurationCommand(), cancellationToken)))];
var configurationMessages = ImmutableArray.CreateBuilder<ConfigureInstanceMessage>();
foreach (var (instanceGuid, instanceConfiguration, _, _, launchAutomatically) in instanceDataByGuid.Values.ToImmutableArray()) {
var launchRecipe = await launchRecipes.Create(instanceConfiguration, cancellationToken);
var configurationMessage = new ConfigureInstanceMessage(instanceGuid, instanceConfiguration.AsInfo, launchRecipe.OrElse(null), launchAutomatically);
configurationMessages.Add(configurationMessage);
}
return configurationMessages.ToImmutable();
}
public interface ICommand;
@@ -210,7 +226,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
public sealed record LaunchInstanceCommand(Guid LoggedInUserGuid, Guid InstanceGuid) : ICommand, ICanReply<Result<LaunchInstanceResult, InstanceActionFailure>>;
public sealed record StopInstanceCommand(Guid LoggedInUserGuid, Guid InstanceGuid, ushort AfterSeconds) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
public sealed record StopInstanceCommand(Guid LoggedInUserGuid, Guid InstanceGuid, MinecraftStopStrategy StopStrategy) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
public sealed record SendCommandToInstanceCommand(Guid LoggedInUserGuid, Guid InstanceGuid, string Command) : ICommand, ICanReply<Result<SendCommandToInstanceResult, InstanceActionFailure>>;
@@ -325,25 +341,38 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
return Task.FromResult<Result<CreateOrUpdateInstanceResult, InstanceActionFailure>>(CreateOrUpdateInstanceResult.InstanceMemoryMustNotBeZero);
}
return launchRecipes.Create(instanceConfiguration, cancellationToken)
.ContinueOnActor(CreateOrUpdateInstance1, command)
.Unwrap();
}
private Task<Result<CreateOrUpdateInstanceResult, InstanceActionFailure>> CreateOrUpdateInstance1(Result<InstanceLaunchRecipe, MinecraftLaunchRecipeCreationFailReason> launchRecipe, CreateOrUpdateInstanceCommand command) {
if (!launchRecipe) {
return Task.FromResult<Result<CreateOrUpdateInstanceResult, InstanceActionFailure>>(launchRecipe.Error switch {
MinecraftLaunchRecipeCreationFailReason.MinecraftVersionNotFound => CreateOrUpdateInstanceResult.MinecraftVersionNotFound,
_ => CreateOrUpdateInstanceResult.UnknownError,
});
}
var instanceGuid = command.InstanceGuid;
var instanceConfiguration = command.Configuration;
bool isCreatingInstance = !instanceActorByGuid.TryGetValue(instanceGuid, out var instanceActorRef);
if (isCreatingInstance) {
instanceActorRef = CreateNewInstance(Instance.Offline(instanceGuid, instanceConfiguration));
}
var configureInstanceCommand = new InstanceActor.ConfigureInstanceCommand(command.LoggedInUserGuid, instanceConfiguration, isCreatingInstance);
var configuredInstanceInfo = new ConfiguredInstanceInfo(instanceGuid, instanceConfiguration.InstanceName, isCreatingInstance);
var configureInstanceCommand = new InstanceActor.ConfigureInstanceCommand(command.LoggedInUserGuid, instanceGuid, instanceConfiguration, launchRecipe.Value, isCreatingInstance);
return instanceActorRef.Request(configureInstanceCommand, cancellationToken)
.ContinueOnActor(CreateOrUpdateInstance2, configuredInstanceInfo);
.ContinueOnActor(CreateOrUpdateInstance2, configureInstanceCommand);
}
private sealed record ConfiguredInstanceInfo(Guid InstanceGuid, string InstanceName, bool IsCreating);
#pragma warning disable CA2254
private Result<CreateOrUpdateInstanceResult, InstanceActionFailure> CreateOrUpdateInstance2(Result<ConfigureInstanceResult, InstanceActionFailure> result, ConfiguredInstanceInfo info) {
(Guid instanceGuid, string instanceName, bool isCreating) = info;
private Result<CreateOrUpdateInstanceResult, InstanceActionFailure> CreateOrUpdateInstance2(Result<ConfigureInstanceResult, InstanceActionFailure> result, InstanceActor.ConfigureInstanceCommand command) {
var instanceGuid = command.InstanceGuid;
var instanceName = command.Configuration.InstanceName;
var isCreating = command.IsCreatingInstance;
if (result.Is(ConfigureInstanceResult.Success)) {
string action = isCreating ? "Created" : "Edited";
@@ -356,10 +385,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
string reason = result.Into(ConfigureInstanceResultExtensions.ToSentence, InstanceActionFailureExtensions.ToSentence);
Logger.Information("Failed " + action + " instance \"{InstanceName}\" (GUID {InstanceGuid}) in agent \"{AgentName}\". {ErrorMessage}", instanceName, instanceGuid, AgentName, reason);
return result.MapValue(static value => value switch {
ConfigureInstanceResult.MinecraftVersionNotFound => CreateOrUpdateInstanceResult.MinecraftVersionNotFound,
_ => CreateOrUpdateInstanceResult.UnknownError,
});
return CreateOrUpdateInstanceResult.UnknownError;
}
}
#pragma warning restore CA2254
@@ -377,8 +403,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
}
private Task<Result<StopInstanceResult, InstanceActionFailure>> StopInstance(StopInstanceCommand command) {
var stopRecipe = minecraftInstanceRecipes.Stop(command.AfterSeconds);
return RequestInstance<InstanceActor.StopInstanceCommand, StopInstanceResult>(command.InstanceGuid, new InstanceActor.StopInstanceCommand(command.LoggedInUserGuid, stopRecipe));
return RequestInstance<InstanceActor.StopInstanceCommand, StopInstanceResult>(command.InstanceGuid, new InstanceActor.StopInstanceCommand(command.LoggedInUserGuid, command.StopStrategy));
}
private Task<Result<SendCommandToInstanceResult, InstanceActionFailure>> SendMinecraftCommand(SendCommandToInstanceCommand command) {
@@ -386,7 +411,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
}
private void ReceiveInstanceData(ReceiveInstanceDataCommand command) {
controllerState.UpdateInstance(command.Instance);
UpdateInstanceData(command.Instance);
}
private sealed class AuthInfo {

4
Controller/Phantom.Controller.Services/Agents/AgentManager.cs
View File

@@ -21,7 +21,7 @@ sealed class AgentManager(
IActorRefFactory actorSystem,
AgentConnectionKeys agentConnectionKeys,
ControllerState controllerState,
MinecraftInstanceRecipes minecraftInstanceRecipes,
MinecraftLaunchRecipes launchRecipes,
IDbContextProvider dbProvider,
CancellationToken cancellationToken
) {
@@ -42,7 +42,7 @@ sealed class AgentManager(
}
private bool AddAgent(Guid? loggedInUserGuid, Guid agentGuid, AgentConfiguration configuration, AuthSecret authSecret, AgentRuntimeInfo runtimeInfo) {
var init = new AgentActor.Init(loggedInUserGuid, agentGuid, configuration, authSecret, runtimeInfo, agentConnectionKeys, controllerState, minecraftInstanceRecipes, dbProvider, cancellationToken);
var init = new AgentActor.Init(loggedInUserGuid, agentGuid, configuration, authSecret, runtimeInfo, agentConnectionKeys, controllerState, launchRecipes, dbProvider, cancellationToken);
var name = "Agent:" + agentGuid;
return agentsByAgentGuid.TryAdd(agentGuid, actorSystem.ActorOf(AgentActor.Factory(init), name));
}

6
Controller/Phantom.Controller.Services/ControllerServices.cs
View File

@@ -20,7 +20,7 @@ public sealed class ControllerServices : IDisposable {
private ControllerState ControllerState { get; }
private MinecraftVersions MinecraftVersions { get; }
private MinecraftInstanceRecipes MinecraftInstanceRecipes { get; }
private MinecraftLaunchRecipes LaunchRecipes { get; }
private AuthenticatedUserCache AuthenticatedUserCache { get; }
private UserManager UserManager { get; }
@@ -51,7 +51,7 @@ public sealed class ControllerServices : IDisposable {
this.ControllerState = new ControllerState();
this.MinecraftVersions = new MinecraftVersions();
this.MinecraftInstanceRecipes = new MinecraftInstanceRecipes(MinecraftVersions);
this.LaunchRecipes = new MinecraftLaunchRecipes(MinecraftVersions);
this.AuthenticatedUserCache = new AuthenticatedUserCache();
this.UserManager = new UserManager(AuthenticatedUserCache, ControllerState, dbProvider);
@@ -60,7 +60,7 @@ public sealed class ControllerServices : IDisposable {
this.UserLoginManager = new UserLoginManager(AuthenticatedUserCache, dbProvider);
this.PermissionManager = new PermissionManager(dbProvider);
this.AgentManager = new AgentManager(ActorSystem, new AgentConnectionKeys(agentCertificateThumbprint), ControllerState, MinecraftInstanceRecipes, dbProvider, cancellationToken);
this.AgentManager = new AgentManager(ActorSystem, new AgentConnectionKeys(agentCertificateThumbprint), ControllerState, LaunchRecipes, dbProvider, cancellationToken);
this.InstanceLogManager = new InstanceLogManager();
this.AuditLogManager = new AuditLogManager(dbProvider);

55
Controller/Phantom.Controller.Services/Instances/InstanceActor.cs
View File

@@ -1,28 +1,19 @@
using Phantom.Common.Data;
using Phantom.Common.Data.Agent.Instance.Backups;
using Phantom.Common.Data.Agent.Instance.Launch;
using Phantom.Common.Data.Agent.Instance.Stop;
using Phantom.Common.Data.Instance;
using Phantom.Common.Data.Minecraft;
using Phantom.Common.Data.Replies;
using Phantom.Common.Data.Web.Instance;
using Phantom.Common.Messages.Agent;
using Phantom.Common.Messages.Agent.ToAgent;
using Phantom.Controller.Database;
using Phantom.Controller.Minecraft;
using Phantom.Controller.Services.Agents;
using Phantom.Utils.Actor;
namespace Phantom.Controller.Services.Instances;
sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
public readonly record struct Init(
Instance Instance,
ActorRef<AgentActor.ICommand> AgentActor,
AgentConnection AgentConnection,
MinecraftInstanceRecipes MinecraftInstanceRecipes,
IDbContextProvider DbProvider,
CancellationToken CancellationToken
);
public readonly record struct Init(Instance Instance, ActorRef<AgentActor.ICommand> AgentActor, AgentConnection AgentConnection, IDbContextProvider DbProvider, CancellationToken CancellationToken);
public static Props<ICommand> Factory(Init init) {
return Props<ICommand>.Create(() => new InstanceActor(init), new ActorConfiguration { SupervisorStrategy = SupervisorStrategies.Resume });
@@ -30,7 +21,6 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
private readonly ActorRef<AgentActor.ICommand> agentActor;
private readonly AgentConnection agentConnection;
private readonly MinecraftInstanceRecipes minecraftInstanceRecipes;
private readonly CancellationToken cancellationToken;
private readonly Guid instanceGuid;
@@ -45,7 +35,6 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
private InstanceActor(Init init) {
this.agentActor = init.AgentActor;
this.agentConnection = init.AgentConnection;
this.minecraftInstanceRecipes = init.MinecraftInstanceRecipes;
this.cancellationToken = init.CancellationToken;
(this.instanceGuid, this.configuration, this.status, this.playerCounts, this.launchAutomatically) = init.Instance;
@@ -54,7 +43,6 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
Receive<SetStatusCommand>(SetStatus);
Receive<SetPlayerCountsCommand>(SetPlayerCounts);
ReceiveAsyncAndReply<GetInitialInstanceConfigurationCommand, ConfigureInstanceMessage>(GetInitialInstanceConfiguration);
ReceiveAsyncAndReply<ConfigureInstanceCommand, Result<ConfigureInstanceResult, InstanceActionFailure>>(ConfigureInstance);
ReceiveAsyncAndReply<LaunchInstanceCommand, Result<LaunchInstanceResult, InstanceActionFailure>>(LaunchInstance);
ReceiveAsyncAndReply<StopInstanceCommand, Result<StopInstanceResult, InstanceActionFailure>>(StopInstance);
@@ -83,13 +71,11 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
public sealed record SetPlayerCountsCommand(InstancePlayerCounts? PlayerCounts) : ICommand;
public sealed record GetInitialInstanceConfigurationCommand : ICommand, ICanReply<ConfigureInstanceMessage>;
public sealed record ConfigureInstanceCommand(Guid AuditLogUserGuid, InstanceConfiguration Configuration, bool IsCreatingInstance) : ICommand, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;
public sealed record ConfigureInstanceCommand(Guid AuditLogUserGuid, Guid InstanceGuid, InstanceConfiguration Configuration, InstanceLaunchRecipe LaunchRecipe, bool IsCreatingInstance) : ICommand, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;
public sealed record LaunchInstanceCommand(Guid AuditLogUserGuid) : ICommand, ICanReply<Result<LaunchInstanceResult, InstanceActionFailure>>;
public sealed record StopInstanceCommand(Guid AuditLogUserGuid, InstanceStopRecipe StopRecipe) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
public sealed record StopInstanceCommand(Guid AuditLogUserGuid, MinecraftStopStrategy StopStrategy) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
public sealed record SendCommandToInstanceCommand(Guid AuditLogUserGuid, string Command) : ICommand, ICanReply<Result<SendCommandToInstanceResult, InstanceActionFailure>>;
@@ -108,21 +94,8 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
NotifyInstanceUpdated();
}
private async Task<ConfigureInstanceMessage> GetInitialInstanceConfiguration(GetInitialInstanceConfigurationCommand command) {
var launchRecipe = await minecraftInstanceRecipes.Launch(configuration, cancellationToken);
return CreateConfigureInstanceMessage(configuration, launchRecipe.OrElse(null), launchAutomatically);
}
private async Task<Result<ConfigureInstanceResult, InstanceActionFailure>> ConfigureInstance(ConfigureInstanceCommand command) {
var launchRecipe = await minecraftInstanceRecipes.Launch(command.Configuration, cancellationToken);
if (!launchRecipe) {
return launchRecipe.Error switch {
MinecraftLaunchRecipeCreationFailReason.MinecraftVersionNotFound => ConfigureInstanceResult.MinecraftVersionNotFound,
_ => ConfigureInstanceResult.UnknownError,
};
}
var message = CreateConfigureInstanceMessage(command.Configuration, launchRecipe.Value, launchNow: false);
var message = new ConfigureInstanceMessage(command.InstanceGuid, command.Configuration.AsInfo, command.LaunchRecipe);
var result = await SendInstanceActionMessage<ConfigureInstanceMessage, ConfigureInstanceResult>(message);
if (result.Is(ConfigureInstanceResult.Success)) {
@@ -141,20 +114,6 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
return result;
}
private ConfigureInstanceMessage CreateConfigureInstanceMessage(InstanceConfiguration configuration, InstanceLaunchRecipe? launchRecipe, bool launchNow) {
var stopRecipe = minecraftInstanceRecipes.Stop(afterSeconds: 0);
var backupSchedule = new InstanceBackupSchedule(
InitialDelayInMinutes: 2,
BackupIntervalInMinutes: 30,
BackupFailureRetryDelayInMinutes: 5,
PlayerCountDetectionStrategy: new InstancePlayerCountDetectionStrategy.MinecraftStatusProtocol(configuration.ServerPort)
);
var backupConfiguration = new InstanceBackupConfiguration(backupSchedule);
return new ConfigureInstanceMessage(instanceGuid, configuration.AsInfo, launchRecipe, launchNow, stopRecipe, backupConfiguration);
}
private async Task<Result<LaunchInstanceResult, InstanceActionFailure>> LaunchInstance(LaunchInstanceCommand command) {
var message = new LaunchInstanceMessage(instanceGuid);
var result = await SendInstanceActionMessage<LaunchInstanceMessage, LaunchInstanceResult>(message);
@@ -168,12 +127,12 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
}
private async Task<Result<StopInstanceResult, InstanceActionFailure>> StopInstance(StopInstanceCommand command) {
var message = new StopInstanceMessage(instanceGuid, command.StopRecipe);
var message = new StopInstanceMessage(instanceGuid, command.StopStrategy);
var result = await SendInstanceActionMessage<StopInstanceMessage, StopInstanceResult>(message);
if (result.Is(StopInstanceResult.StopInitiated)) {
SetLaunchAutomatically(false);
databaseStorageActor.Tell(new InstanceDatabaseStorageActor.StoreInstanceStoppedCommand(command.AuditLogUserGuid));
databaseStorageActor.Tell(new InstanceDatabaseStorageActor.StoreInstanceStoppedCommand(command.AuditLogUserGuid, command.StopStrategy));
}
return result;

9
Controller/Phantom.Controller.Services/Instances/InstanceDatabaseStorageActor.cs
View File

@@ -1,5 +1,6 @@
using Phantom.Common.Data.Web.Instance;
using Phantom.Common.Data.Web.Java;
using Phantom.Common.Data.Minecraft;
using Phantom.Common.Data.Web.Instance;
using Phantom.Common.Data.Web.Minecraft;
using Phantom.Controller.Database;
using Phantom.Controller.Database.Entities;
using Phantom.Controller.Database.Repositories;
@@ -43,7 +44,7 @@ sealed class InstanceDatabaseStorageActor : ReceiveActor<InstanceDatabaseStorage
public sealed record StoreInstanceLaunchedCommand(Guid AuditLogUserGuid) : ICommand;
public sealed record StoreInstanceStoppedCommand(Guid AuditLogUserGuid) : ICommand;
public sealed record StoreInstanceStoppedCommand(Guid AuditLogUserGuid, MinecraftStopStrategy StopStrategy) : ICommand;
public sealed record StoreInstanceCommandSentCommand(Guid AuditLogUserGuid, string Command) : ICommand;
@@ -99,7 +100,7 @@ sealed class InstanceDatabaseStorageActor : ReceiveActor<InstanceDatabaseStorage
}
var auditLogWriter = new AuditLogRepository(db).Writer(command.AuditLogUserGuid);
auditLogWriter.InstanceStopped(instanceGuid);
auditLogWriter.InstanceStopped(instanceGuid, command.StopStrategy.Seconds);
await db.Ctx.SaveChangesAsync(cancellationToken);
}

2
Controller/Phantom.Controller.Services/Rpc/WebMessageHandlerActor.cs
View File

@@ -156,7 +156,7 @@ sealed class WebMessageHandlerActor : ReceiveActor<IMessageToController> {
userLoginManager.GetLoggedInUser(message.AuthToken),
Permission.ControlInstances,
message.AgentGuid,
loggedInUserGuid => new AgentActor.StopInstanceCommand(loggedInUserGuid, message.InstanceGuid, message.AfterSeconds)
loggedInUserGuid => new AgentActor.StopInstanceCommand(loggedInUserGuid, message.InstanceGuid, message.StopStrategy)
);
}

4
Controller/Phantom.Controller/AuthTokenFile.cs
View File

@@ -19,8 +19,8 @@ abstract class AuthTokenFile {
this.certificate = certificate;
}
public async Task<ConnectionKey?> CreateOrLoad(string directoryPath) {
string filePath = Path.Combine(directoryPath, fileName);
public async Task<ConnectionKey?> CreateOrLoad(string folderPath) {
string filePath = Path.Combine(folderPath, fileName);
if (File.Exists(filePath)) {
try {

4
Controller/Phantom.Controller/CertificateFile.cs
View File

@@ -11,8 +11,8 @@ sealed class CertificateFile(string name) {
private readonly string fileName = name + ".pfx";
public async Task<RpcServerCertificate?> CreateOrLoad(string directoryPath) {
string filePath = Path.Combine(directoryPath, fileName);
public async Task<RpcServerCertificate?> CreateOrLoad(string folderPath) {
string filePath = Path.Combine(folderPath, fileName);
if (File.Exists(filePath)) {
try {

6
Controller/Phantom.Controller/Program.cs
View File

@@ -22,12 +22,12 @@ PosixSignals.RegisterCancellation(shutdownCancellationTokenSource, static () =>
PhantomLogger.Root.InformationHeading("Stopping Phantom Panel controller...");
});
static void CreateDirectoryOrStop(string path, UnixFileMode chmod) {
static void CreateFolderOrStop(string path, UnixFileMode chmod) {
if (!Directory.Exists(path)) {
try {
Directories.Create(path, chmod);
} catch (Exception e) {
PhantomLogger.Root.Fatal(e, "Error creating directory: {DirectoryName}", path);
PhantomLogger.Root.Fatal(e, "Error creating folder: {FolderName}", path);
throw StopProcedureException.Instance;
}
}
@@ -42,7 +42,7 @@ try {
var (agentRpcServerHost, webRpcServerHost, sqlConnectionString) = Variables.LoadOrStop();
string secretsPath = Path.GetFullPath("./secrets");
CreateDirectoryOrStop(secretsPath, Chmod.URWX_GRX);
CreateFolderOrStop(secretsPath, Chmod.URWX_GRX);
var agentCertificate = await new CertificateFile("agent").CreateOrLoad(secretsPath);
if (agentCertificate == null) {

2
Utils/Phantom.Utils/IO/StreamCopier.cs
View File

@@ -3,7 +3,7 @@
namespace Phantom.Utils.IO;
public sealed class StreamCopier(int bufferSize = StreamCopier.DefaultBufferSize) : IDisposable {
private const int DefaultBufferSize = 65536;
private const int DefaultBufferSize = 81920;
public event EventHandler<BufferEventArgs>? BufferReady;

21
Utils/Phantom.Utils/Net/HttpHeadersExtensions.cs Normal file
View File

@@ -0,0 +1,21 @@
using System.Net.Http.Headers;
using Phantom.Utils.IO;
namespace Phantom.Utils.Net;
public static class HttpHeadersExtensions {
private const string ContentLength = "Content-Length";
extension(HttpResponseHeaders headers) {
public FileSize? ContentLength {
get {
if (!headers.TryGetValues(ContentLength, out var values)) {
return null;
}
string? value = values.FirstOrDefault();
return value != null && ulong.TryParse(value, out ulong result) ? new FileSize(result) : null;
}
}
}
}

5
Web/Phantom.Web.Services/Instances/InstanceManager.cs
View File

@@ -1,5 +1,6 @@
using System.Collections.Immutable;
using Phantom.Common.Data;
using Phantom.Common.Data.Minecraft;
using Phantom.Common.Data.Replies;
using Phantom.Common.Data.Web.Instance;
using Phantom.Common.Data.Web.Users;
@@ -55,9 +56,9 @@ public sealed class InstanceManager(ControllerConnection controllerConnection) {
}
}
public async Task<Result<StopInstanceResult, UserInstanceActionFailure>> StopInstance(AuthenticatedUser? authenticatedUser, Guid agentGuid, Guid instanceGuid, ushort afterSeconds, CancellationToken cancellationToken) {
public async Task<Result<StopInstanceResult, UserInstanceActionFailure>> StopInstance(AuthenticatedUser? authenticatedUser, Guid agentGuid, Guid instanceGuid, MinecraftStopStrategy stopStrategy, CancellationToken cancellationToken) {
if (authenticatedUser != null && authenticatedUser.Info.CheckPermission(Permission.ControlInstances)) {
var message = new StopInstanceMessage(authenticatedUser.Token, agentGuid, instanceGuid, afterSeconds);
var message = new StopInstanceMessage(authenticatedUser.Token, agentGuid, instanceGuid, stopStrategy);
return await controllerConnection.Send<StopInstanceMessage, Result<StopInstanceResult, UserInstanceActionFailure>>(message, cancellationToken);
}
else {

6
Web/Phantom.Web/Program.cs
View File

@@ -21,12 +21,12 @@ PosixSignals.RegisterCancellation(shutdownCancellationTokenSource, static () =>
PhantomLogger.Root.InformationHeading("Stopping Phantom Panel web...");
});
static void CreateDirectoryOrStop(string path, UnixFileMode chmod) {
static void CreateFolderOrStop(string path, UnixFileMode chmod) {
if (!Directory.Exists(path)) {
try {
Directories.Create(path, chmod);
} catch (Exception e) {
PhantomLogger.Root.Fatal(e, "Error creating directory: {DirectoryName}", path);
PhantomLogger.Root.Fatal(e, "Error creating folder: {FolderName}", path);
throw StopProcedureException.Instance;
}
}
@@ -46,7 +46,7 @@ try {
}
string dataProtectionKeysPath = Path.GetFullPath("./keys");
CreateDirectoryOrStop(dataProtectionKeysPath, Chmod.URWX);
CreateFolderOrStop(dataProtectionKeysPath, Chmod.URWX);
var administratorToken = TokenGenerator.Create(60);
var applicationProperties = new ApplicationProperties(fullVersion, TokenGenerator.GetBytesOrThrow(administratorToken));

1
Web/Phantom.Web/Shared/InstanceAddOrEditForm.razor
View File

@@ -6,7 +6,6 @@
@using Phantom.Common.Data.Replies
@using Phantom.Common.Data.Web.Agent
@using Phantom.Common.Data.Web.Instance
@using Phantom.Common.Data.Web.Java
@using Phantom.Common.Data.Web.Minecraft
@using Phantom.Common.Data.Web.Users
@using Phantom.Common.Messages.Web.ToController

3
Web/Phantom.Web/Shared/InstanceStopDialog.razor
View File

@@ -1,4 +1,5 @@
@using System.ComponentModel.DataAnnotations
@using Phantom.Common.Data.Minecraft
@using Phantom.Common.Data.Replies
@using Phantom.Common.Data.Web.Users
@using Phantom.Utils.Result
@@ -53,7 +54,7 @@
private async Task StopInstance(EditContext context) {
await form.SubmitModel.StartSubmitting();
var result = await InstanceManager.StopInstance(await GetAuthenticatedUser(), AgentGuid, InstanceGuid, form.StopInSeconds, CancellationToken);
var result = await InstanceManager.StopInstance(await GetAuthenticatedUser(), AgentGuid, InstanceGuid, new MinecraftStopStrategy(form.StopInSeconds), CancellationToken);
switch (result.Variant()) {
case Ok<StopInstanceResult>(StopInstanceResult.StopInitiated):

2
Web/Phantom.Web/Utils/Messages.cs
View File

@@ -1,6 +1,6 @@
using Phantom.Common.Data.Instance;
using Phantom.Common.Data.Replies;
using Phantom.Common.Data.Web.Java;
using Phantom.Common.Data.Web.Minecraft;
using Phantom.Common.Data.Web.Users;
namespace Phantom.Web.Utils;

4
Web/Phantom.Web/WebLauncher.cs
View File

@@ -8,7 +8,7 @@ using ILogger = Serilog.ILogger;
namespace Phantom.Web;
static class WebLauncher {
internal sealed record Configuration(ILogger Logger, string Host, ushort Port, string BasePath, string DataProtectionKeyDirectoryPath, CancellationToken CancellationToken) {
internal sealed record Configuration(ILogger Logger, string Host, ushort Port, string BasePath, string DataProtectionKeyFolderPath, CancellationToken CancellationToken) {
public string HttpUrl => "http://" + Host + ":" + Port;
}
@@ -35,7 +35,7 @@ static class WebLauncher {
builder.Services.AddSingleton<IHostLifetime>(new NullLifetime());
builder.Services.AddScoped(Navigation.Create(config.BasePath));
builder.Services.AddDataProtection().PersistKeysToFileSystem(new DirectoryInfo(config.DataProtectionKeyDirectoryPath));
builder.Services.AddDataProtection().PersistKeysToFileSystem(new DirectoryInfo(config.DataProtectionKeyFolderPath));
builder.Services.AddRazorPages(static options => options.RootDirectory = "/Layout");
builder.Services.AddServerSideBlazor();