462 lines
19 KiB
C#
462 lines
19 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Aetheria.State.Documents;
|
|
using GameCult.Aetheria.State.Verse;
|
|
using GameCult.Caching;
|
|
using GameCult.Caching.MessagePack;
|
|
using GameCult.Mesh;
|
|
using GameCult.Networking;
|
|
using R3;
|
|
using EveSurfaceDocument = GameCult.Eve.Surface.EveSurfaceDocument;
|
|
using EveSurfaceCommandRequest = GameCult.Eve.Surface.EveSurfaceCommandRequest;
|
|
using EveCommandReceiptDocument = GameCult.Eve.Surface.EveCommandReceiptDocument;
|
|
|
|
namespace Aetheria.State;
|
|
|
|
public enum AetheriaStateHydrationProfile
|
|
{
|
|
All,
|
|
DaemonBoot
|
|
}
|
|
|
|
public sealed class AetheriaStateNode : IAsyncDisposable, IDisposable
|
|
{
|
|
private static readonly string[] DaemonNativeCatalogBootRecordKeys =
|
|
[
|
|
AetheriaCatalogKeys.ItemDefinitionFromLegacyId("82efc0a5-1ba5-4ff3-a281-b2e6e247521d").ToString(), // Zenith hull
|
|
AetheriaCatalogKeys.ItemDefinitionFromLegacyId("3e930a2c-ac72-4385-98aa-1c5b0b90db46").ToString(), // Medium docking bay
|
|
AetheriaCatalogKeys.ItemDefinitionFromLegacyId("ca098005-8cc8-47f4-be99-7bc842805359").ToString(), // Dockyard hull
|
|
AetheriaCatalogKeys.ItemDefinitionFromLegacyId("8ec30f8d-8536-48b4-bd64-65f29f229895").ToString() // Dockyard berth
|
|
];
|
|
private readonly CultMeshNode _node;
|
|
private CultMeshDocumentHandle<AetheriaRuntimeCatalogSnapshot>? _runtimeCatalog;
|
|
private CultMeshDocumentHandle<AetheriaRuntimeNameCorpusSnapshot>? _runtimeNameCorpus;
|
|
private CultMeshDocumentHandle<EveSurfaceDocument>? _catalogSurface;
|
|
|
|
private AetheriaStateNode(string statePath, string runtimeId, CultMeshNode node)
|
|
{
|
|
StatePath = statePath;
|
|
RuntimeId = string.IsNullOrWhiteSpace(runtimeId)
|
|
? "aetheria-local"
|
|
: runtimeId;
|
|
_node = node;
|
|
}
|
|
|
|
public string StatePath { get; }
|
|
|
|
public string RuntimeId { get; }
|
|
|
|
public CultMeshNode MeshNode => _node;
|
|
|
|
public CultCache Cache => _node.Cache;
|
|
|
|
public CultNetDatabase Database => _node.Database;
|
|
|
|
public static async Task<AetheriaStateNode> OpenAsync(
|
|
string statePath,
|
|
string runtimeId = "aetheria-local",
|
|
bool startServer = false,
|
|
bool enableDurableShardLogs = true,
|
|
bool useDirectoryStore = true,
|
|
AetheriaStateHydrationProfile hydrationProfile = AetheriaStateHydrationProfile.All)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(statePath))
|
|
{
|
|
throw new ArgumentException("State path must be non-empty.", nameof(statePath));
|
|
}
|
|
|
|
Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(statePath)) ?? ".");
|
|
|
|
var traceStartup = string.Equals(
|
|
Environment.GetEnvironmentVariable("AETHERIA_TRACE_STARTUP_PHASES"),
|
|
"1",
|
|
StringComparison.Ordinal);
|
|
var startupPhase = Stopwatch.StartNew();
|
|
void Trace(string phase)
|
|
{
|
|
if (traceStartup)
|
|
Console.WriteLine($"Aetheria state-node phase {phase} took {startupPhase.Elapsed.TotalMilliseconds:0.###}ms.");
|
|
startupPhase.Restart();
|
|
}
|
|
|
|
var cacheRegistry = AetheriaDocumentRegistry.CreateCultCacheRegistry();
|
|
Trace("cache-registry");
|
|
var hydrationFilter = CreateHydrationFilter(hydrationProfile, cacheRegistry);
|
|
Trace("hydration-filter");
|
|
var databaseRegistry = AetheriaDocumentRegistry.CreateCultNetRegistry(cacheRegistry);
|
|
Trace("database-registry");
|
|
var node = await CultMesh.CreateNodeAsync(
|
|
statePath,
|
|
new CultMeshNodeOptions
|
|
{
|
|
StartServer = startServer,
|
|
EnableDurableShardLogs = enableDurableShardLogs,
|
|
CacheOptions = new CultCacheOpenOptions
|
|
{
|
|
Registry = cacheRegistry,
|
|
PullOnOpen = true,
|
|
StoreFlushOnDispose = true,
|
|
UseDirectoryStore = useDirectoryStore,
|
|
DirectoryStoreHydrationFilter = hydrationFilter
|
|
},
|
|
DatabaseOptions = new CultNetDatabaseOptions
|
|
{
|
|
RuntimeId = runtimeId,
|
|
DocumentRegistry = databaseRegistry
|
|
}
|
|
}).ConfigureAwait(false);
|
|
Trace("cultmesh-node");
|
|
|
|
return new AetheriaStateNode(statePath, runtimeId, node);
|
|
}
|
|
|
|
private static Func<CultPersistedRecordMetadata, bool>? CreateHydrationFilter(
|
|
AetheriaStateHydrationProfile profile,
|
|
CultDocumentRegistry registry)
|
|
{
|
|
if (profile == AetheriaStateHydrationProfile.All)
|
|
return null;
|
|
if (profile != AetheriaStateHydrationProfile.DaemonBoot)
|
|
throw new ArgumentOutOfRangeException(nameof(profile), profile, "Unknown Aetheria state hydration profile.");
|
|
|
|
var schemaTypes = new[]
|
|
{
|
|
typeof(AetheriaLoadoutTemplate),
|
|
typeof(AetheriaRuntimeAuthorityLeaseDocument),
|
|
typeof(AetheriaRuntimeDaemonCommandDocument),
|
|
typeof(AetheriaRuntimeCommittedCommandFactDocument),
|
|
typeof(AetheriaRuntimeEveCommandDocument),
|
|
typeof(EveSurfaceCommandRequest),
|
|
typeof(EveCommandReceiptDocument)
|
|
};
|
|
var schemaIds = schemaTypes
|
|
.Select(registry.GetRequired)
|
|
.SelectMany(descriptor => descriptor.ToCatalogEntry().CompatibleSchemaIds.Append(descriptor.SchemaId))
|
|
.ToHashSet(StringComparer.Ordinal);
|
|
var recordKeys = new HashSet<string>(StringComparer.Ordinal)
|
|
{
|
|
WorldKey.ToString(),
|
|
RuntimeCatalogKey.ToString(),
|
|
TradeValuePolicyKey.ToString(),
|
|
PlayerSettingsKey.ToString(),
|
|
HangarKey.ToString(),
|
|
VerseHostSettingsKey.ToString(),
|
|
GameSessionStateKey.ToString(),
|
|
MainMenuStateKey.ToString(),
|
|
EveCommandAcceptanceStatusKey.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.DaemonFrameLatest.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.DaemonProviderAdvertisement.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.EveProviderAdvertisement.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.DaemonAssetManifest.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.EveAssetCatalog.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.PilotInputCapability.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.DaemonGameSurface.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.DaemonGameReactiveSurface.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.MapMenuSurface.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.VerseAuthorityPolicy.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.StarbridgeScenarioLatest.ToString(),
|
|
AetheriaRuntimeVerseRecordKeys.StarbridgeSessionLatest.ToString()
|
|
};
|
|
recordKeys.UnionWith(DaemonNativeCatalogBootRecordKeys);
|
|
return record => recordKeys.Contains(record.Key) || schemaIds.Contains(record.SchemaId);
|
|
}
|
|
|
|
public CultMeshDocumentHandle<TDocument> Document<TDocument>(CultRecordKey key)
|
|
where TDocument : class
|
|
{
|
|
return CultMesh.Document<TDocument>(
|
|
key.ToString(),
|
|
CultMesh.Verse("aetheria.local", RuntimeId),
|
|
async _ => (await Database.GetAsync<TDocument>(key).ConfigureAwait(false))!,
|
|
_ => Database.WatchRecord<TDocument>(key)
|
|
.Where(change => change.Document != null)
|
|
.Select(change => change.Document!),
|
|
sources: new[]
|
|
{
|
|
CultMesh.ProjectionSource(key.ToString())
|
|
},
|
|
routeHint: new CultMeshRouteHint(CultMeshLocalityKind.SharedMemory, "Aetheria typed state node document"));
|
|
}
|
|
|
|
public CultMeshMutableStatePointer<TDocument> MutableDocument<TDocument>(CultRecordKey key)
|
|
where TDocument : class
|
|
{
|
|
return MutableDocumentPointer<TDocument>(key);
|
|
}
|
|
|
|
public IReadOnlyList<TDocument> Documents<TDocument>()
|
|
where TDocument : class
|
|
{
|
|
return Cache.GetAll<TDocument>().ToArray();
|
|
}
|
|
|
|
public CultMeshDocumentHandle<AetheriaRuntimeCatalogSnapshot> RuntimeCatalog()
|
|
{
|
|
return _runtimeCatalog ??= CultMesh.Document(
|
|
"aetheria.catalog.runtime",
|
|
CultMesh.Verse("aetheria.local", RuntimeId),
|
|
async _ => await Database.GetAsync<AetheriaRuntimeCatalogSnapshot>(RuntimeCatalogKey)
|
|
.ConfigureAwait(false)
|
|
?? throw new InvalidDataException(
|
|
"The compiled Aetheria runtime catalog is missing. Refresh it after changing source catalog records."),
|
|
_ => Database.WatchRecord<AetheriaRuntimeCatalogSnapshot>(RuntimeCatalogKey)
|
|
.Where(change => change.Document != null)
|
|
.Select(change => change.Document!),
|
|
sources: new[]
|
|
{
|
|
CultMesh.ProjectionSource("catalog:aetheria.runtime"),
|
|
CultMesh.ProjectionSource(
|
|
"aetheria.catalog.runtime",
|
|
AetheriaRuntimeCatalogSnapshot.SchemaId,
|
|
"managed Aetheria runtime catalog document")
|
|
},
|
|
routeHint: new CultMeshRouteHint(CultMeshLocalityKind.SharedMemory, "Aetheria typed catalog state"));
|
|
}
|
|
|
|
public CultMeshDocumentHandle<AetheriaRuntimeNameCorpusSnapshot> RuntimeNameCorpus()
|
|
{
|
|
return _runtimeNameCorpus ??= CultMesh.Document(
|
|
"aetheria.catalog.runtime-names",
|
|
CultMesh.Verse("aetheria.local", RuntimeId),
|
|
async _ => await Database.GetAsync<AetheriaRuntimeNameCorpusSnapshot>(RuntimeNameCorpusKey)
|
|
.ConfigureAwait(false)
|
|
?? throw new InvalidDataException("The compiled Aetheria runtime name corpus is missing."),
|
|
_ => Database.WatchRecord<AetheriaRuntimeNameCorpusSnapshot>(RuntimeNameCorpusKey)
|
|
.Where(change => change.Document != null)
|
|
.Select(change => change.Document!),
|
|
sources: new[]
|
|
{
|
|
CultMesh.ProjectionSource(
|
|
RuntimeNameCorpusKey.ToString(),
|
|
AetheriaRuntimeNameCorpusSnapshot.SchemaId,
|
|
"managed Aetheria runtime name corpus")
|
|
},
|
|
routeHint: new CultMeshRouteHint(
|
|
CultMeshLocalityKind.SharedMemory,
|
|
"Aetheria typed name generation corpus"));
|
|
}
|
|
|
|
public async Task<AetheriaRuntimeCatalogSnapshot> RuntimeCatalogForGenerationAsync()
|
|
{
|
|
var catalog = RuntimeCatalog().Latest()
|
|
?? throw new InvalidDataException("The compiled Aetheria runtime catalog is missing.");
|
|
if (Cache.Get<AetheriaRuntimeNameCorpusSnapshot>(RuntimeNameCorpusKey) == null)
|
|
{
|
|
await Cache.PullBackingStoreRecordsAsync(metadata =>
|
|
string.Equals(metadata.Key, RuntimeNameCorpusKey.ToString(), StringComparison.Ordinal)).ConfigureAwait(false);
|
|
}
|
|
var corpus = await RuntimeNameCorpus().LatestAsync().ConfigureAwait(false);
|
|
return new AetheriaRuntimeCatalogSnapshot(
|
|
catalog.Items.ToArray(),
|
|
catalog.Corporations.ToArray(),
|
|
corpus.NameFiles.ToArray(),
|
|
catalog.TradeValueSettings)
|
|
{
|
|
CatalogId = catalog.CatalogId,
|
|
NameCorpusRecordKey = RuntimeNameCorpusKey.ToString()
|
|
};
|
|
}
|
|
|
|
public CultMeshDocumentHandle<EveSurfaceDocument> CatalogSurface()
|
|
{
|
|
var catalog = RuntimeCatalog();
|
|
return _catalogSurface ??= CultMesh.Document(
|
|
"aetheria.catalog.surface",
|
|
CultMesh.Verse("aetheria.local", RuntimeId),
|
|
_ => Task.FromResult(AetheriaEveSurfaceDocuments.BuildCatalogSurface(
|
|
catalog.Latest(),
|
|
DateTimeOffset.UtcNow.ToString("O"))),
|
|
_ => catalog.Watch()
|
|
.Select(snapshot => AetheriaEveSurfaceDocuments.BuildCatalogSurface(
|
|
snapshot,
|
|
DateTimeOffset.UtcNow.ToString("O"))),
|
|
sources: new[]
|
|
{
|
|
CultMesh.ProjectionSource(
|
|
"aetheria.catalog.runtime",
|
|
AetheriaRuntimeCatalogSnapshot.SchemaId,
|
|
"managed Aetheria runtime catalog document"),
|
|
CultMesh.ProjectionSource(
|
|
CatalogSurfaceKey.ToString(),
|
|
"gamecult.eve.surface.v1",
|
|
"managed Aetheria catalog Eve surface document")
|
|
},
|
|
routeHint: new CultMeshRouteHint(CultMeshLocalityKind.SharedMemory, "Aetheria typed catalog Eve surface"));
|
|
}
|
|
|
|
public async Task<AetheriaRuntimeCatalogSnapshot> RefreshRuntimeCatalogAsync()
|
|
{
|
|
var snapshot = AetheriaRuntimeCatalogStore.OpenReadOnly(StatePath);
|
|
await Database.PutAsync(
|
|
RuntimeNameCorpusKey,
|
|
new AetheriaRuntimeNameCorpusSnapshot
|
|
{
|
|
NameFiles = snapshot.NameFiles.ToArray()
|
|
}).ConfigureAwait(false);
|
|
snapshot.NameFiles = snapshot.NameFiles
|
|
.Select(nameFile => new AetheriaRuntimeNameFile(
|
|
nameFile.NameFileKey,
|
|
nameFile.Name,
|
|
nameFile.NameCount,
|
|
nameFile.SampleNames.ToArray(),
|
|
Array.Empty<string>()))
|
|
.ToArray();
|
|
snapshot.NameCorpusRecordKey = RuntimeNameCorpusKey.ToString();
|
|
await Database.PutAsync(RuntimeCatalogKey, snapshot).ConfigureAwait(false);
|
|
return snapshot;
|
|
}
|
|
|
|
public Task<CultRecordHandle<AetheriaRuntimeDaemonCommandDocument>> SubmitDaemonCommandAsync(
|
|
AetheriaRuntimeDaemonCommandDocument command)
|
|
{
|
|
if (command == null) throw new ArgumentNullException(nameof(command));
|
|
command.Schema = AetheriaRuntimeDaemonSchemas.Command;
|
|
if (string.IsNullOrWhiteSpace(command.CommandId))
|
|
command.CommandId = Guid.NewGuid().ToString("N");
|
|
if (string.IsNullOrWhiteSpace(command.IssuedAtUtc))
|
|
command.IssuedAtUtc = DateTime.UtcNow.ToString("O");
|
|
|
|
return Database.PutAsync(DaemonCommandKey(command.CommandId), command);
|
|
}
|
|
|
|
public Task<CultRecordHandle<AetheriaRuntimeCommittedCommandFactDocument>> PutCommittedCommandFactAsync(
|
|
AetheriaRuntimeCommittedCommandFactDocument fact)
|
|
{
|
|
if (fact == null) throw new ArgumentNullException(nameof(fact));
|
|
fact.Schema = AetheriaRuntimeDaemonSchemas.CommittedCommandFact;
|
|
if (string.IsNullOrWhiteSpace(fact.FactId))
|
|
fact.FactId = Guid.NewGuid().ToString("N");
|
|
if (string.IsNullOrWhiteSpace(fact.CommittedAtUtc))
|
|
fact.CommittedAtUtc = DateTime.UtcNow.ToString("O");
|
|
|
|
return Database.PutAsync(
|
|
new CultRecordKey(AetheriaRuntimeCommittedCommandFactDocument.CreateRecordKey(fact.FactId)),
|
|
fact);
|
|
}
|
|
|
|
private static CultRecordKey DaemonCommandKey(string commandId)
|
|
{
|
|
return new CultRecordKey($"daemon:commands:{StableToken(commandId)}:gamecult.aetheria.daemon_command.v1");
|
|
}
|
|
|
|
public Task<CultRecordHandle<AetheriaRuntimeEveCommandDocument>> SubmitEveCommandAsync(
|
|
AetheriaRuntimeEveCommandDocument command)
|
|
{
|
|
if (command == null) throw new ArgumentNullException(nameof(command));
|
|
AetheriaRuntimeEveCommandClient.NormalizeDocument(command);
|
|
command.Schema = AetheriaRuntimeEveCommandDocument.SchemaId;
|
|
if (string.IsNullOrWhiteSpace(command.CommandId))
|
|
command.CommandId = Guid.NewGuid().ToString("N");
|
|
if (string.IsNullOrWhiteSpace(command.IssuedAtUtc))
|
|
command.IssuedAtUtc = DateTime.UtcNow.ToString("O");
|
|
|
|
return Database.PutAsync(EveCommandKey(command.CommandId), command);
|
|
}
|
|
|
|
private static CultRecordKey EveCommandKey(string commandId)
|
|
{
|
|
return new CultRecordKey($"eve:commands:{StableToken(commandId)}:gamecult.eve.command.v1");
|
|
}
|
|
|
|
public Task FlushAsync(bool soft = false)
|
|
{
|
|
return _node.FlushAsync(soft);
|
|
}
|
|
|
|
private static string StableToken(string value)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(value))
|
|
return "empty";
|
|
|
|
var chars = value
|
|
.Select(character => char.IsLetterOrDigit(character) ? character : '-')
|
|
.ToArray();
|
|
var token = new string(chars).Trim('-').ToLowerInvariant();
|
|
while (token.Contains("--", StringComparison.Ordinal))
|
|
token = token.Replace("--", "-", StringComparison.Ordinal);
|
|
return string.IsNullOrWhiteSpace(token) ? "empty" : token;
|
|
}
|
|
|
|
public static CultRecordKey RuntimeSessionKey(string runtimeId)
|
|
{
|
|
return new CultRecordKey($"runtime:{runtimeId}:aetheria.runtime_session.v1");
|
|
}
|
|
|
|
public static CultRecordKey WorldKey { get; } =
|
|
new("global:aetheria.world_state.v1");
|
|
|
|
public static CultRecordKey MigrationLedgerKey { get; } =
|
|
new("global:aetheria.migration_ledger.v1");
|
|
|
|
public static CultRecordKey LegacyCatalogQuarantineKey { get; } =
|
|
new("global:aetheria.legacy_catalog_quarantine.v1");
|
|
|
|
public static CultRecordKey CatalogSurfaceKey { get; } =
|
|
new(AetheriaEveSurfaceDocuments.CatalogSurfaceKey);
|
|
|
|
public static CultRecordKey RuntimeCatalogKey { get; } =
|
|
new("global:aetheria.runtime_catalog.v1");
|
|
|
|
public static CultRecordKey RuntimeNameCorpusKey { get; } =
|
|
new("global:aetheria.runtime_name_corpus.v1");
|
|
|
|
public static CultRecordKey OperationsSurfaceKey { get; } =
|
|
new(AetheriaEveSurfaceDocuments.OperationsSurfaceKey);
|
|
|
|
public static CultRecordKey PlayerSettingsSurfaceKey { get; } =
|
|
new(AetheriaEveSurfaceDocuments.PlayerSettingsSurfaceKey);
|
|
|
|
public static CultRecordKey ProviderAdvertisementSurfaceKey { get; } =
|
|
new(AetheriaEveSurfaceDocuments.ProviderAdvertisementKey);
|
|
|
|
public static CultRecordKey PlayerSettingsKey { get; } =
|
|
new("global:aetheria.player_settings.v1");
|
|
|
|
public static CultRecordKey HangarKey { get; } =
|
|
new("global:gamecult.aetheria.hangar.v1");
|
|
|
|
public static CultRecordKey VerseHostSettingsKey { get; } =
|
|
new("global:aetheria.verse_host_settings.v1");
|
|
|
|
public static CultRecordKey EveCommandAcceptanceStatusKey { get; } =
|
|
new("global:aetheria.eve_command_acceptance_status.v1");
|
|
|
|
public static CultRecordKey MainMenuStateKey { get; } =
|
|
new("global:aetheria.main_menu_state.v1");
|
|
|
|
public static CultRecordKey GameSessionStateKey { get; } =
|
|
new("global:aetheria.game_session.v1");
|
|
|
|
public static CultRecordKey TradeValuePolicyKey { get; } =
|
|
new(AetheriaTradeValuePolicy.RecordKey);
|
|
|
|
private CultMeshMutableStatePointer<T> MutableDocumentPointer<T>(CultRecordKey key) where T : class
|
|
{
|
|
return CultMesh.MutableStatePointer(
|
|
key.ToString(),
|
|
_ => Database.GetAsync<T>(key),
|
|
_ => Database.WatchRecord<T>(key)
|
|
.Where(change => change.Document != null)
|
|
.Select(change => change.Document!),
|
|
async (_, value) => { await Database.PutAsync(key, value).ConfigureAwait(false); },
|
|
sources:
|
|
[
|
|
CultMesh.ProjectionSource(key.ToString())
|
|
]);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_node.Dispose();
|
|
}
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
await FlushAsync().ConfigureAwait(false);
|
|
Dispose();
|
|
}
|
|
}
|