Timerix/ParadoxSaveParser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactored responses

Browse Source
This commit is contained in:
Timerix 2025-04-06 15:37:32 +05:00
parent 3c1d195849
commit d70b605127
17 changed files with 415 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ParadoxSaveParser.CLI/ParadoxSaveParser.CLI.csproj
View File

@ -14,6 +14,6 @@
</ItemGroup>
<ItemGroup>
<PackageReference Include="DTLib" Version="1.7.0"/>
<PackageReference Include="DTLib" Version="1.7.1"/>
</ItemGroup>
</Project>

2
ParadoxSaveParser.Lib.Tests/ParadoxSaveParser.Lib.Tests.csproj
View File

@ -23,7 +23,7 @@
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="DTLib" Version="1.6.5"/>
<PackageReference Include="DTLib" Version="1.7.1"/>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
<PackageReference Include="NUnit" Version="4.3.2" />
<PackageReference Include="NUnit.Analyzers" Version="4.7.0">

22
ParadoxSaveParser.WebAPI/BackgroundTasks/BackgroundJobManager.cs Normal file
View File

@ -0,0 +1,22 @@
namespace ParadoxSaveParser.WebAPI.BackgroundTasks;
public class BackgroundJobManager
{
private readonly ILogger _parentLogger;
private long _lastJobId;
public BackgroundJobManager(ILogger logger)
{
_parentLogger = logger;
}
public SaveParsingOperation StartNewParsingOperation(
SaveFileMetadata meta, ISearchExpression searchQuery, CancellationToken ct)
{
long nextId = Interlocked.Increment(ref _lastJobId);
var contextLogger = new ContextLogger($"BackgroundJob-{nextId}", _parentLogger);
var op = new SaveParsingOperation(nextId, meta, searchQuery, contextLogger, ct);
op.StartAsync();
return op;
}
}

88
ParadoxSaveParser.WebAPI/BackgroundTasks/SaveParsingOperation.cs Normal file
View File

@ -0,0 +1,88 @@
using System.IO.Compression;
using System.Linq;
using System.Text.Encodings.Web;
namespace ParadoxSaveParser.WebAPI.BackgroundTasks;
public class SaveParsingOperation
{
public readonly long OperationId;
public readonly SaveFileMetadata Meta;
public readonly ISearchExpression SearchQuery;
private readonly ContextLogger _logger;
private readonly CancellationToken _cancelToken;
private static readonly JsonSerializerOptions _saveSerializerOptions = new()
{
WriteIndented = true,
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
MaxDepth = 1024
};
public SaveParsingOperation(long operationId, SaveFileMetadata meta, ISearchExpression searchQuery,
ContextLogger logger, CancellationToken cancelToken)
{
OperationId = operationId;
Meta = meta;
SearchQuery = searchQuery;
_logger = logger;
_cancelToken = cancelToken;
}
public async void StartAsync()
{
try
{
_logger.LogInfo($"Starting background parsing operation of {Meta.game} save {Meta.id}");
switch (Meta.game)
{
case Game.EU4:
await ParseSaveEU4();
break;
default:
throw new ArgumentOutOfRangeException(Meta.game.ToString());
}
_logger.LogInfo($"Finished parsing operation of {Meta.game} save {Meta.id}");
}
catch (Exception ex)
{
string errorMesage = ex.ToStringDemystified();
_logger.LogError(errorMesage);
Meta.errorMessage = errorMesage;
}
finally
{
GC.Collect(GC.MaxGeneration, GCCollectionMode.Aggressive, true, true);
}
}
private async Task ParseSaveEU4()
{
// wait for save file closing
await Task.Delay(200, _cancelToken);
string extractedGamestatePath = PathHelper.GetSaveFilePath(Meta.id) + ".gamestate";
using (var zipArchive = ZipFile.Open(PathHelper.GetSaveFilePath(Meta.id).Str, ZipArchiveMode.Read))
{
var zipEntry = zipArchive.Entries.FirstOrDefault(e => e.Name == "gamestate");
if (zipEntry is null)
throw new Exception("Invalid save format: no 'gamestate' file found");
zipEntry.ExtractToFile(extractedGamestatePath, true);
}
var gamestateStream = File.OpenRead(extractedGamestatePath);
Meta.status = SaveFileProcessingStatus.Parsing;
var parser = new SaveParserEU4(gamestateStream, SearchQuery);
var result = parser.Parse();
Meta.status = SaveFileProcessingStatus.SavingResults;
var resultFilePath = PathHelper.GetParsedSaveFilePath(Meta.id);
await using var resultFile = File.OpenWrite(resultFilePath);
await JsonSerializer.SerializeAsync(resultFile, result,
_saveSerializerOptions, _cancelToken);
Meta.status = SaveFileProcessingStatus.Done;
Meta.SaveToFile();
}
}

17
ParadoxSaveParser.WebAPI/HttpHelpers/ErrorMessage.cs Normal file
View File

@ -0,0 +1,17 @@
using System.Net;
using System.Text.Json.Serialization;
namespace ParadoxSaveParser.WebAPI.HttpHelpers;
public record ErrorMessage
{
public ErrorMessage(HttpStatusCode statusCode, string message)
{
StatusCode = statusCode;
Message = message;
}
[JsonIgnore] public HttpStatusCode StatusCode { get; }
[JsonPropertyName("errorMessage")] public string Message { get; }
}

17
ParadoxSaveParser.WebAPI/HttpHelpers/RequestHelper.cs Normal file
View File

@ -0,0 +1,17 @@
using System.Linq;
using System.Net;
namespace ParadoxSaveParser.WebAPI.HttpHelpers;
public class RequestHelper
{
internal static ValueOrError<string> GetQueryValue(HttpListenerContext ctx, string paramName)
{
string[]? values = ctx.Request.QueryString.GetValues(paramName);
string? value = values?.FirstOrDefault();
if (string.IsNullOrEmpty(value))
return new ErrorMessage(HttpStatusCode.BadRequest,
$"No request parameter '{paramName}' provided");
return value;
}
}

70
ParadoxSaveParser.WebAPI/HttpHelpers/ReturnHelper.cs Normal file
View File

@ -0,0 +1,70 @@
using System.Net;
using System.Text.Encodings.Web;
using DTLib.Extensions;
namespace ParadoxSaveParser.WebAPI.HttpHelpers;
public class ReturnHelper
{
private static readonly JsonSerializerOptions _responseJsonSerializerOptions = new()
{
WriteIndented = false,
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
MaxDepth = 1024
};
private static async Task ResponseShort(HttpListenerContext ctx,
ContextLogger logger,
CancellationToken ct,
byte[] value,
HttpStatusCode statusCode,
string contentType)
{
ctx.Response.StatusCode = (int)statusCode;
ctx.Response.ContentType = contentType;
logger.LogDebug($"response (length: {value.Length} type: {contentType})");
if (value.Length > 4000)
{
logger.LogWarn($"response (length: {value.Length} type: {contentType})\n"
+ $"Content is too big for {nameof(ResponseShort)}."
+ $"You should send stream instead of byte array.");
}
await ctx.Response.OutputStream.WriteAsync(value, ct);
}
public static async Task<HttpStatusCode> ResponseString(
HttpListenerContext ctx,
ContextLogger logger,
CancellationToken ct,
string value,
HttpStatusCode statusCode = HttpStatusCode.OK,
string contentType = "text/plain")
{
await ResponseShort(ctx, logger, ct, value.ToBytes(), statusCode, contentType);
logger.LogDebug(value);
return statusCode;
}
public static async Task<HttpStatusCode> ResponseJson(
HttpListenerContext ctx,
ContextLogger logger,
CancellationToken ct,
object value,
HttpStatusCode statusCode = HttpStatusCode.OK)
{
string json = JsonSerializer.Serialize(
value,
value.GetType(),
_responseJsonSerializerOptions);
return await ResponseString(ctx, logger, ct, json, statusCode, "application/json");
}
public static async Task<HttpStatusCode> ResponseError(
HttpListenerContext ctx,
ContextLogger logger,
CancellationToken ct,
ErrorMessage error)
{
return await ResponseJson(ctx, logger, ct, error, error.StatusCode);
}
}

19
ParadoxSaveParser.WebAPI/HttpHelpers/ValueOrError.cs Normal file
View File

@ -0,0 +1,19 @@
namespace ParadoxSaveParser.WebAPI.HttpHelpers;
public class ValueOrError<T>
{
public readonly ErrorMessage? Error;
public readonly T? Value;
private ValueOrError(T? value, ErrorMessage? error)
{
Value = value;
Error = error;
}
public bool HasError => Error is not null;
public static implicit operator ValueOrError<T>(T v) => new(v, null);
public static implicit operator ValueOrError<T>(ErrorMessage e) => new(default, e);
}

2
ParadoxSaveParser.WebAPI/ParadoxSaveParser.WebAPI.csproj
View File

@ -13,6 +13,6 @@
</ItemGroup>
<ItemGroup>
<PackageReference Include="DTLib.Web" Version="1.2.2"/>
<PackageReference Include="DTLib.Web" Version="1.3.0"/>
</ItemGroup>
</Project>

10
ParadoxSaveParser.WebAPI/PathHelper.cs
View File

@ -1,4 +1,6 @@
namespace ParadoxSaveParser.WebAPI;
using System.IO;
namespace ParadoxSaveParser.WebAPI;
public static class PathHelper
{
@ -10,4 +12,10 @@ public static class PathHelper
public static IOPath GetSaveFilePath(string save_id) => Path.Concat(SAVES_DIR, save_id + ".eu4");
public static IOPath GetParsedSaveFilePath(string save_id) => Path.Concat(SAVES_DIR, save_id + ".parsed.json");
public static void CreateProgramDirectories()
{
Directory.Create(DATA_DIR);
Directory.Create(SAVES_DIR);
}
}

97
ParadoxSaveParser.WebAPI/Program.HttpHelpers.cs
View File

@ -1,97 +0,0 @@
using System.Linq;
using System.Net;
using System.Text.Encodings.Web;
using System.Text.Json.Serialization;
using DTLib.Extensions;
namespace ParadoxSaveParser.WebAPI;
public partial class Program
{
private static readonly JsonSerializerOptions _responseJsonSerializerOptions = new()
{
WriteIndented = false,
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
MaxDepth = 1024
};
public static async Task<HttpStatusCode> ReturnResponseString(HttpListenerContext ctx,
string value, HttpStatusCode statusCode = HttpStatusCode.OK)
{
ctx.Response.StatusCode = (int)statusCode;
ctx.Response.ContentType = "text/plain";
await ctx.Response.OutputStream.WriteAsync(
value.ToBytes(),
_mainCancel.Token);
return statusCode;
}
public static async Task<HttpStatusCode> ReturnResponseJson(HttpListenerContext ctx,
object value, HttpStatusCode statusCode = HttpStatusCode.OK)
{
ctx.Response.StatusCode = (int)statusCode;
ctx.Response.ContentType = "application/json";
await JsonSerializer.SerializeAsync(
ctx.Response.OutputStream,
value,
value.GetType(),
_responseJsonSerializerOptions,
_mainCancel.Token);
return statusCode;
}
public static async Task<HttpStatusCode> ReturnResponseError(HttpListenerContext ctx, ErrorMessage error)
{
ctx.Response.StatusCode = (int)error.StatusCode;
ctx.Response.ContentType = "application/json";
await JsonSerializer.SerializeAsync(
ctx.Response.OutputStream,
error,
typeof(ErrorMessage),
_responseJsonSerializerOptions,
_mainCancel.Token);
return error.StatusCode;
}
internal static ValueOrError<string> GetRequestQueryValue(HttpListenerContext ctx, string paramName)
{
string[]? values = ctx.Request.QueryString.GetValues(paramName);
string? value = values?.FirstOrDefault();
if (string.IsNullOrEmpty(value))
return new ErrorMessage(HttpStatusCode.BadRequest,
$"No request parameter '{paramName}' provided");
return value;
}
public record ErrorMessage
{
public ErrorMessage(HttpStatusCode statusCode, string message)
{
StatusCode = statusCode;
Message = message;
}
[JsonIgnore] public HttpStatusCode StatusCode { get; }
[JsonPropertyName("errorMessage")] public string Message { get; }
}
public class ValueOrError<T>
{
public readonly ErrorMessage? Error;
public readonly T? Value;
private ValueOrError(T? value, ErrorMessage? error)
{
Value = value;
Error = error;
}
public bool HasError => Error is not null;
public static implicit operator ValueOrError<T>(T v) => new(v, null);
public static implicit operator ValueOrError<T>(ErrorMessage e) => new(default, e);
}
}

117
ParadoxSaveParser.WebAPI/Program.RequestHandlers.cs
View File

@ -1,117 +0,0 @@
using System.IO.Compression;
using System.Linq;
using System.Net;
namespace ParadoxSaveParser.WebAPI;
public partial class Program
{
private static async Task<HttpStatusCode> UploadSaveHandler(HttpListenerContext ctx)
{
string? contentType = ctx.Request.Headers.GetValues("Content-Type")?.FirstOrDefault();
if (contentType != "application/octet-stream")
return await ReturnResponseError(ctx, new ErrorMessage(
HttpStatusCode.BadRequest,
$"Invalid request Content-Type: '{contentType}'"));
string saveId = Guid.NewGuid().ToString();
var metaFilePath = PathHelper.GetMetaFilePath(saveId);
if (File.Exists(metaFilePath))
return await ReturnResponseError(ctx, new ErrorMessage(
HttpStatusCode.InternalServerError,
$"Guid collision! file' {metaFilePath}' already exists."));
var meta = new SaveFileMetadata
{ id = saveId, game = Game.EU4, status = SaveFileProcessingStatus.Initialized };
if (!_saveMetadataStorage.TryAdd(saveId, meta))
return await ReturnResponseError(ctx, new ErrorMessage(
HttpStatusCode.InternalServerError,
$"Guid collision! Can't create metadata with id {saveId}"));
meta.status = SaveFileProcessingStatus.Uploading;
var saveFilePath = PathHelper.GetSaveFilePath(meta.id);
await using var saveFile = File.OpenWrite(saveFilePath);
await using var remoteStream = ctx.Request.InputStream;
await remoteStream.CopyToAsync(saveFile, _mainCancel.Token);
meta.status = SaveFileProcessingStatus.Uploaded;
return await ReturnResponseString(ctx, saveId);
}
private static ValueOrError<SaveFileMetadata> GetMetaFromRequestId(HttpListenerContext ctx,
string requestParamName)
{
var idOrError = GetRequestQueryValue(ctx, requestParamName);
if (idOrError.HasError)
return idOrError.Error!;
if (!_saveMetadataStorage.TryGetValue(idOrError.Value!, out var meta))
return new ErrorMessage(HttpStatusCode.InternalServerError,
$"Save with id {idOrError.Value} not found");
return meta;
}
private static async Task<HttpStatusCode> GetSaveStatusHandler(HttpListenerContext ctx)
{
var metaOrError = GetMetaFromRequestId(ctx, "id");
if (metaOrError.HasError)
return await ReturnResponseError(ctx, metaOrError.Error!);
return await ReturnResponseJson(ctx, metaOrError.Value!);
}
private static async Task<HttpStatusCode> ParseSaveEU4Handler(HttpListenerContext ctx)
{
var metaOrError = GetMetaFromRequestId(ctx, "id");
if (metaOrError.HasError)
return await ReturnResponseError(ctx, metaOrError.Error!);
var meta = metaOrError.Value!;
var searchQueryOrError = GetRequestQueryValue(ctx, "search");
if (searchQueryOrError.HasError)
return await ReturnResponseError(ctx, searchQueryOrError.Error!);
string searchQuery = searchQueryOrError.Value!;
try
{
string extractedGamestatePath = PathHelper.GetSaveFilePath(meta.id) + ".gamestate";
using (var zipArchive = ZipFile.Open(PathHelper.GetSaveFilePath(meta.id).Str, ZipArchiveMode.Read))
{
var zipEntry = zipArchive.Entries.FirstOrDefault(e => e.Name == "gamestate");
if (zipEntry is null)
return await ReturnResponseError(ctx, new ErrorMessage(
HttpStatusCode.BadRequest,
"Invalid save format: no 'gamestate' file found"));
zipEntry.ExtractToFile(extractedGamestatePath, true);
}
var gamestateStream = File.OpenRead(extractedGamestatePath);
meta.status = SaveFileProcessingStatus.Parsing;
var se = SearchExpressionCompiler.Compile(searchQuery);
var parser = new SaveParserEU4(gamestateStream, se);
var result = parser.Parse();
meta.status = SaveFileProcessingStatus.SavingResults;
var resultFilePath = PathHelper.GetParsedSaveFilePath(meta.id);
await using var resultFile = File.OpenWrite(resultFilePath);
await JsonSerializer.SerializeAsync(resultFile, result, _saveSerializerOptions, _mainCancel.Token);
meta.status = SaveFileProcessingStatus.Done;
meta.SaveToFile();
}
catch (Exception ex)
{
string errorMesage = ex.ToStringDemystified();
_loggerRoot.LogWarn(nameof(ParseSaveEU4Handler), errorMesage);
return await ReturnResponseError(ctx, new ErrorMessage(HttpStatusCode.BadRequest, errorMesage));
}
finally
{
GC.Collect(GC.MaxGeneration, GCCollectionMode.Aggressive, true, true);
}
return await ReturnResponseJson(ctx, meta);
}
}

107
ParadoxSaveParser.WebAPI/Program.cs
View File

@ -13,42 +13,56 @@ global using File = DTLib.Filesystem.File;
global using Path = DTLib.Filesystem.Path;
using System.Collections.Concurrent;
using System.IO;
using System.Text.Encodings.Web;
using DTLib.Console;
using DTLib.Dtsod;
using DTLib.Web;
using DTLib.Web.Routes;
using ParadoxSaveParser.WebAPI.BackgroundTasks;
using ParadoxSaveParser.WebAPI.Routes;
namespace ParadoxSaveParser.WebAPI;
public static partial class Program
public static class Program
{
private static readonly IOPath _configPath = "./config.dtsod";
private static Config _config = new();
private static readonly ILogger _loggerRoot = new CompositeLogger(
new ConsoleLogger(),
new FileLogger("logs", "ParadoxSaveParser.WebAPI"));
private static bool IsDebug = true;
private static readonly CancellationTokenSource _mainCancel = new();
private static readonly ConcurrentDictionary<string, SaveFileMetadata> _saveMetadataStorage = new();
internal static readonly ConcurrentDictionary<string, SaveFileMetadata> _saveMetadataStorage = new();
private static readonly JsonSerializerOptions _saveSerializerOptions = new()
{
WriteIndented = true,
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
MaxDepth = 1024
};
public static void Main(string[] args)
{
Console.InputEncoding = Encoding.UTF8;
Console.OutputEncoding = Encoding.UTF8;
Console.CursorVisible = false;
var logger = new ContextLogger(nameof(Main), _loggerRoot);
#if DEBUG
IsDebug = true;
#endif
new LaunchArgumentParser(
new LaunchArgument(["-d", "--debug"],
"enables debug log output to console",
() => IsDebug = true)
).AllowNoArguments().ParseAndHandle(args);
var loggerRoot = new CompositeLogger(
new ConsoleLogger
{
DebugLogEnabled = IsDebug
},
new FileLogger("logs", "ParadoxSaveParser.WebAPI")
{
DebugLogEnabled = true
});
var loggerMain = new ContextLogger(nameof(Main), loggerRoot);
loggerMain.LogDebug("Debug log is enabled");
Console.CancelKeyPress += (_, e) =>
{
e.Cancel = true;
logger.LogInfo("Ctrl+C Pressed");
loggerMain.LogInfo("Ctrl+C Pressed");
_mainCancel.Cancel();
};
@ -57,54 +71,57 @@ public static partial class Program
// config
if (!File.Exists(_configPath))
{
logger.LogWarn("config file not found.");
loggerMain.LogWarn("config file not found.");
File.WriteAllText(_configPath, _config.ToString());
logger.LogWarn($"created default at {_configPath}.");
loggerMain.LogWarn($"created default at {_configPath}.");
}
else
{
_config = Config.FromDtsod(new DtsodV23(File.ReadAllText(_configPath)));
}
PrepareLocalFiles();
PathHelper.CreateProgramDirectories();
var metaFiles = System.IO.Directory.GetFiles(
PathHelper.SAVES_DIR.Str, "*.meta.json",
SearchOption.TopDirectoryOnly);
foreach (string metaFilePath in metaFiles)
{
using var metaFile = File.OpenRead(metaFilePath);
var meta = JsonSerializer.Deserialize<SaveFileMetadata>(metaFile) ??
throw new NullReferenceException(metaFilePath);
if (meta.status != SaveFileProcessingStatus.Done)
loggerMain.LogWarn(nameof(Main),
$"metadata file '{metaFilePath}' status has invalid status {meta.status}");
if (!_saveMetadataStorage.TryAdd(meta.id, meta))
throw new Exception("Guid collision!");
}
var bgJobManager = new BackgroundJobManager(loggerRoot);
var saveParsingSearchExpressions = new Dictionary<Game, ISearchExpression>
{
{ Game.EU4, SearchExpressionCompiler.Compile("*.~") },
};
// http server
var router = new SimpleRouter(_loggerRoot);
var router = new SimpleRouter(loggerRoot);
router.DefaultRoute = new ServeFilesRouteHandler("public");
router.MapRoute("/getSaveStatus", HttpMethod.GET, GetSaveStatusHandler);
router.MapRoute("/uploadSave/eu4", HttpMethod.POST, UploadSaveHandler);
router.MapRoute("/parseSave/eu4", HttpMethod.POST, ParseSaveEU4Handler);
router.MapRoute("/getSaveStatus", HttpMethod.GET, new GetSaveStatusHandler(_mainCancel.Token));
router.MapRoute("/uploadSave/eu4", HttpMethod.POST, new UploadSaveHandler(_mainCancel.Token, bgJobManager, saveParsingSearchExpressions));
var app = new WebApp(_config.BaseUrl, _loggerRoot, router, _mainCancel.Token);
var app = new WebApp(_config.BaseUrl, loggerRoot, router, _mainCancel.Token);
app.Run().GetAwaiter().GetResult();
}
catch (OperationCanceledException ex)
{
logger.LogWarn($"catched OperationCanceledException from {ex.Source}");
loggerMain.LogWarn($"catched OperationCanceledException from {ex.Source}");
}
catch (Exception ex)
{
logger.LogError(ex.ToStringDemystified());
loggerMain.LogError(ex.ToStringDemystified());
}
}
public static void PrepareLocalFiles()
{
Directory.Create(PathHelper.DATA_DIR);
Directory.Create(PathHelper.SAVES_DIR);
foreach (string metaFilePath in System.IO.Directory.GetFiles(
PathHelper.SAVES_DIR.Str, "*.meta.json",
SearchOption.TopDirectoryOnly))
{
using var metaFile = File.OpenRead(metaFilePath);
var meta = JsonSerializer.Deserialize<SaveFileMetadata>(metaFile) ??
throw new NullReferenceException(metaFilePath);
if (meta.status != SaveFileProcessingStatus.Done)
_loggerRoot.LogWarn(nameof(PrepareLocalFiles),
$"metadata file '{metaFilePath}' status has invalid status {meta.status}");
if (!_saveMetadataStorage.TryAdd(meta.id, meta))
throw new Exception("Guid collision!");
}
}
}

28
ParadoxSaveParser.WebAPI/Routes/GetSaveStatusHandler.cs Normal file
View File

@ -0,0 +1,28 @@
using System.Net;
using ParadoxSaveParser.WebAPI.HttpHelpers;
namespace ParadoxSaveParser.WebAPI.Routes;
internal class GetSaveStatusHandler : RouteHandlerBase
{
public GetSaveStatusHandler(CancellationToken cancelAllToken)
: base(cancelAllToken)
{
}
public override async Task<HttpStatusCode> HandleRequest(
HttpListenerContext ctx, ContextLogger requestLogger)
{
var idOrError = RequestHelper.GetQueryValue(ctx, "id");
if (idOrError.HasError)
return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, idOrError.Error!);
if (!Program._saveMetadataStorage.TryGetValue(idOrError.Value!, out var meta))
return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
new ErrorMessage(HttpStatusCode.InternalServerError,
$"Save with id {idOrError.Value} not found")
);
return await ReturnHelper.ResponseJson(ctx, requestLogger, _cancelAllToken, meta);
}
}

16
ParadoxSaveParser.WebAPI/Routes/RouteHandlerBase.cs Normal file
View File

@ -0,0 +1,16 @@
using System.Net;
using DTLib.Web.Routes;
namespace ParadoxSaveParser.WebAPI.Routes;
public abstract class RouteHandlerBase : IRouteHandler
{
protected readonly CancellationToken _cancelAllToken;
protected RouteHandlerBase(CancellationToken cancelAllToken)
{
_cancelAllToken = cancelAllToken;
}
public abstract Task<HttpStatusCode> HandleRequest(HttpListenerContext ctx, ContextLogger requestLogger);
}

60
ParadoxSaveParser.WebAPI/Routes/UploadSaveHandler.cs Normal file
View File

@ -0,0 +1,60 @@
using System.Linq;
using System.Net;
using ParadoxSaveParser.WebAPI.BackgroundTasks;
using ParadoxSaveParser.WebAPI.HttpHelpers;
namespace ParadoxSaveParser.WebAPI.Routes;
public class UploadSaveHandler : RouteHandlerBase
{
private readonly BackgroundJobManager _bgJobManager;
private readonly Dictionary<Game, ISearchExpression> _searchQueries;
public UploadSaveHandler(
CancellationToken cancelAllToken,
BackgroundJobManager bgJobManager,
Dictionary<Game, ISearchExpression> searchQueries)
: base(cancelAllToken)
{
_bgJobManager = bgJobManager;
_searchQueries = searchQueries;
}
public override async Task<HttpStatusCode> HandleRequest(
HttpListenerContext ctx, ContextLogger requestLogger)
{
string? contentType = ctx.Request.Headers.GetValues("Content-Type")?.FirstOrDefault();
if (contentType != "application/octet-stream")
return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
new ErrorMessage(HttpStatusCode.BadRequest,
$"Invalid request Content-Type: '{contentType}'")
);
string saveId = Guid.NewGuid().ToString();
var metaFilePath = PathHelper.GetMetaFilePath(saveId);
if (File.Exists(metaFilePath))
return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
new ErrorMessage(HttpStatusCode.InternalServerError,
$"Guid collision! file' {metaFilePath}' already exists.")
);
var meta = new SaveFileMetadata
{ id = saveId, game = Game.EU4, status = SaveFileProcessingStatus.Initialized };
if (!Program._saveMetadataStorage.TryAdd(saveId, meta))
return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
new ErrorMessage(HttpStatusCode.InternalServerError,
$"Guid collision! Can't create metadata with id {saveId}")
);
meta.status = SaveFileProcessingStatus.Uploading;
var saveFilePath = PathHelper.GetSaveFilePath(meta.id);
await using var saveFile = File.OpenWrite(saveFilePath);
await using var remoteStream = ctx.Request.InputStream;
await remoteStream.CopyToAsync(saveFile, _cancelAllToken);
meta.status = SaveFileProcessingStatus.Uploaded;
_bgJobManager.StartNewParsingOperation(meta, _searchQueries[meta.game], _cancelAllToken);
dynamic responseData = new { saveId };
return await ReturnHelper.ResponseJson(ctx, requestLogger, _cancelAllToken, responseData);
}
}

4
ParadoxSaveParser.WebAPI/SaveFileMetadata.cs
View File

@ -28,6 +28,10 @@ public class SaveFileMetadata
[JsonConverter(typeof(JsonStringEnumConverter))]
public required SaveFileProcessingStatus status { get; set; }
// if error occured during parsing, it's message is saved here
// status stays the same as when error occured
public string? errorMessage { get; set; }
public void SaveToFile()
{