195 lines
16 KiB
C#
195 lines
16 KiB
C#
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using Launcher.Next.Core;
|
|
|
|
namespace Launcher.Next.Infrastructure;
|
|
|
|
public sealed class PilotExecutionService(
|
|
IPackageManifestValidator validator,
|
|
IPilotRootPolicy rootPolicy,
|
|
INextPilotSafetyGate gate,
|
|
IFileHasher hasher,
|
|
IStartupScriptBuilder scriptBuilder,
|
|
IExecutionPermitService permits,
|
|
IAutoCadProcessProbe probe,
|
|
IOperatingSystemProcessInvoker invoker,
|
|
IPathResolver? pathResolver = null) : IPilotExecutionService
|
|
{
|
|
private sealed record Pointer(string Version);
|
|
private sealed record ActivationSnapshot(
|
|
string TransactionId, string PackageId, string PackageVersion,
|
|
string? CurrentContent, string? CurrentSha256,
|
|
string? PreviousContent, string? PreviousSha256,
|
|
string VersionDirectory, string StartupScriptPath, string StagingPath);
|
|
private sealed record PersistedSession(
|
|
int SchemaVersion, string SessionId, string TransactionId, string State,
|
|
string PackageId, string PackageVersion, string ManifestSha256,
|
|
string PilotRoot, string VersionDirectory, string StartupScriptPath,
|
|
string LaunchMode, IReadOnlyDictionary<string, string?> ResolvedPaths, IReadOnlyList<string> AcadArguments, string? ActualStartupScriptSha256,
|
|
string ActivationSnapshotPath, int? ProcessId, DateTimeOffset? ProcessStartUtc,
|
|
int? ProcessExitCode, DateTimeOffset CreatedAtUtc, DateTimeOffset UpdatedAtUtc,
|
|
string? LastErrorCode, string? LastErrorMessage);
|
|
|
|
public async Task<PilotPreparationResult> PrepareAsync(PilotPreparationRequest request, CancellationToken cancellationToken)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var resolver = pathResolver ?? new PathResolver();
|
|
var paths = resolver.Resolve(new LauncherPathVariables(request.Configuration.PathVariables), [LauncherPathVariableNames.LocalLauncherRoot, LauncherPathVariableNames.AcadExecutable]);
|
|
if (!string.Equals(Path.GetFullPath(request.PilotRoot), paths.LocalLauncherRoot, StringComparison.OrdinalIgnoreCase))
|
|
return new(null, new(false, ["PILOT_ROOT_PATH_VARIABLE_MISMATCH"]));
|
|
var root = rootPolicy.Validate(paths.LocalLauncherRoot);
|
|
var validation = validator.Validate(request.Manifest, 2026, "x64");
|
|
var hashes = await ValidateSource(request.Manifest, request.PackageSourceRoot, cancellationToken);
|
|
var product = request.Product with { ExecutablePath = paths.AcadExecutable };
|
|
var profile = new AutoCadProfileCandidate(string.Empty, false, true, ["Confirmed Plant 3D launch contract has no /p argument."]);
|
|
var safety = gate.Evaluate(new(request.Configuration, product, profile, root, validation, hashes, false, probe.IsAcadRunning()), false);
|
|
if (!safety.IsAllowed) return new(null, safety);
|
|
|
|
var automation = request.Configuration.LaunchMode is AcadLaunchMode.NextPilotPreview or AcadLaunchMode.NextPilotApply or AcadLaunchMode.LifecycleProbe;
|
|
var content = automation ? "AUTOMATION_SCRIPT_PENDING" : "PRODUCTION_NO_SCRIPT";
|
|
var scriptHash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(content)));
|
|
var plan = PilotPlanFactory.Create(product, profile, request.Manifest, request.ManifestHash, paths.LocalLauncherRoot, automation ? paths.Require(LauncherPathVariableNames.AutomationScriptPath) : string.Empty, scriptHash, safety, request.Configuration.LaunchMode);
|
|
var environment = new Dictionary<string, string> { ["P_REC_ANNOT_RUNTIME_MODE"] = request.Configuration.PluginExecutionMode.ToString() };
|
|
if (!string.IsNullOrWhiteSpace(request.Configuration.ApplyPermitPath))
|
|
environment["P_REC_ANNOT_APPLY_PERMIT_PATH"] = request.Configuration.ApplyPermitPath;
|
|
if (automation)
|
|
{
|
|
environment["P_REC_ANNOT_LAUNCHER_MODE"] = "NextPilot";
|
|
environment["P_REC_ANNOT_AUTOMATION"] = request.Configuration.AutomationMode!;
|
|
environment["P_REC_ANNOT_AUTOMATION_CONFIG"] = paths.Require(LauncherPathVariableNames.AutomationConfigPath);
|
|
}
|
|
return new(plan with { Process = plan.Process with { EnvironmentVariables = environment } }, safety);
|
|
}
|
|
|
|
public async Task<PilotExecutionResult> ExecuteAsync(PilotExecutionRequest request, CancellationToken cancellationToken)
|
|
{
|
|
var plan = request.Plan;
|
|
var resolver = pathResolver ?? new PathResolver();
|
|
var resolvedPaths = resolver.Resolve(new LauncherPathVariables(request.Preparation.Configuration.PathVariables));
|
|
var root = rootPolicy.Validate(request.Preparation.PilotRoot);
|
|
var validation = validator.Validate(request.Preparation.Manifest, 2026, "x64");
|
|
var hashes = await ValidateSource(request.Preparation.Manifest, request.Preparation.PackageSourceRoot, cancellationToken);
|
|
var context = new PilotSafetyContext(request.Preparation.Configuration, request.Preparation.Product,
|
|
new AutoCadProfileCandidate(string.Empty, false, true, ["No profile in confirmed contract."]), root, validation, hashes, false, probe.IsAcadRunning());
|
|
var decision = gate.Evaluate(context, true);
|
|
if (!decision.IsAllowed) return new(false, null, decision.Violations.First(), null, null);
|
|
if (!string.Equals(plan.PlanId, PilotPlanFactory.Create(plan.Product, context.Profile!, request.Preparation.Manifest, request.Preparation.ManifestHash, plan.PilotRoot, plan.StartupScriptPath, plan.StartupScriptSha256, plan.SafetyDecision, request.Preparation.Configuration.LaunchMode).PlanId, StringComparison.Ordinal))
|
|
return new(false, null, "PILOT_PLAN_CHANGED", null, null);
|
|
|
|
var sessionId = Guid.NewGuid().ToString("N");
|
|
var transactionId = Guid.NewGuid().ToString("N");
|
|
var packageRoot = Path.Combine(plan.PilotRoot, "packages", plan.PackageId);
|
|
var versionDirectory = plan.VersionDirectory;
|
|
var staging = Path.Combine(plan.PilotRoot, "staging", transactionId);
|
|
var scriptPath = plan.StartupScriptPath;
|
|
var snapshotPath = Path.Combine(plan.PilotRoot, "state", "transactions", transactionId + ".json");
|
|
Directory.CreateDirectory(Path.GetDirectoryName(snapshotPath)!);
|
|
var currentPath = Path.Combine(packageRoot, "current.json");
|
|
var previousPath = Path.Combine(packageRoot, "previous.json");
|
|
var current = await ReadTextOrNull(currentPath, cancellationToken);
|
|
var previous = await ReadTextOrNull(previousPath, cancellationToken);
|
|
var snapshot = new ActivationSnapshot(transactionId, plan.PackageId, plan.PackageVersion, current, Hash(current), previous, Hash(previous), versionDirectory, scriptPath, staging);
|
|
await WriteJsonAtomic(snapshotPath, snapshot, cancellationToken);
|
|
await WriteSession(plan.PilotRoot, new PersistedSession(2, sessionId, transactionId, "Activating", plan.PackageId, plan.PackageVersion, plan.ManifestSha256, plan.PilotRoot, versionDirectory, scriptPath, request.Preparation.Configuration.LaunchMode.ToString(), resolvedPaths.Values, plan.Process.Arguments, null, snapshotPath, null, null, null, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, null, null), cancellationToken);
|
|
try
|
|
{
|
|
Directory.CreateDirectory(staging);
|
|
foreach (var file in request.Preparation.Manifest.Files)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
var source = Path.Combine(request.Preparation.PackageSourceRoot, file.Path);
|
|
var target = Path.GetFullPath(Path.Combine(staging, file.Path));
|
|
if (!target.StartsWith(Path.GetFullPath(staging) + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase)) throw new InvalidOperationException("PACKAGE_ROOT_ESCAPE");
|
|
Directory.CreateDirectory(Path.GetDirectoryName(target)!);
|
|
File.Copy(source, target, true);
|
|
if (!string.Equals(await hasher.Sha256Async(target, cancellationToken), file.Sha256, StringComparison.OrdinalIgnoreCase)) throw new InvalidOperationException("HASH_VALIDATION_FAILED");
|
|
}
|
|
Directory.CreateDirectory(Path.GetDirectoryName(versionDirectory)!);
|
|
if (Directory.Exists(versionDirectory)) Directory.Delete(staging, true); else Directory.Move(staging, versionDirectory);
|
|
await WriteTextAtomic(previousPath, current ?? string.Empty, cancellationToken, current is not null);
|
|
await WriteTextAtomic(currentPath, JsonSerializer.Serialize(new Pointer(plan.PackageVersion)), cancellationToken, true);
|
|
var automation = request.Preparation.Configuration.LaunchMode is AcadLaunchMode.NextPilotPreview or AcadLaunchMode.NextPilotApply or AcadLaunchMode.LifecycleProbe;
|
|
if (automation)
|
|
{
|
|
var paths = resolver.Resolve(new LauncherPathVariables(request.Preparation.Configuration.PathVariables), [LauncherPathVariableNames.AutomationScriptPath, LauncherPathVariableNames.FixtureOrthoDwg, LauncherPathVariableNames.LocalSessionRoot]);
|
|
scriptPath = paths.Require(LauncherPathVariableNames.AutomationScriptPath);
|
|
if (!Path.GetFullPath(scriptPath).StartsWith(Path.GetFullPath(paths.Require(LauncherPathVariableNames.LocalSessionRoot)).TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase)) throw new InvalidOperationException("AUTOMATION_SCRIPT_OUTSIDE_SESSION_ROOT");
|
|
Directory.CreateDirectory(Path.GetDirectoryName(scriptPath)!);
|
|
var script = scriptBuilder.BuildAutomationScript(new(versionDirectory, request.Preparation.Manifest.EntryAssembly, paths.Require(LauncherPathVariableNames.FixtureOrthoDwg), scriptPath));
|
|
await File.WriteAllTextAsync(scriptPath, script, cancellationToken);
|
|
}
|
|
var arguments = new AcadArgumentBuilder().Build(request.Preparation.Configuration.LaunchMode, automation ? scriptPath : null);
|
|
var actualScriptHash = automation ? Convert.ToHexString(SHA256.HashData(await File.ReadAllBytesAsync(scriptPath, cancellationToken))) : null;
|
|
await WriteSession(plan.PilotRoot, (await ReadSession(plan.PilotRoot, cancellationToken))! with { State = "ProcessStarting", StartupScriptPath = automation ? scriptPath : string.Empty, AcadArguments = arguments, ActualStartupScriptSha256 = actualScriptHash, UpdatedAtUtc = DateTimeOffset.UtcNow }, cancellationToken);
|
|
var result = new GuardedAutodeskProcessLauncher(gate, probe, invoker).Start(context, plan with { StartupScriptPath = automation ? scriptPath : string.Empty, Process = plan.Process with { Arguments = arguments, WorkingDirectory = plan.PilotRoot } }, request.Permit, permits);
|
|
if (!result.Started)
|
|
{
|
|
await MarkFailed(plan.PilotRoot, result.BlockCode ?? "PROCESS_START_FAILED", cancellationToken);
|
|
return new(false, null, result.BlockCode, versionDirectory, scriptPath, sessionId, snapshotPath);
|
|
}
|
|
var session = (await ReadSession(plan.PilotRoot, cancellationToken))! with { State = "WaitingForRuntimeCheck", ProcessId = result.ProcessId, ProcessStartUtc = DateTimeOffset.UtcNow, UpdatedAtUtc = DateTimeOffset.UtcNow };
|
|
await WriteSession(plan.PilotRoot, session, cancellationToken);
|
|
return new(true, result.ProcessId, null, versionDirectory, scriptPath, sessionId, snapshotPath);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await MarkFailed(plan.PilotRoot, ex.Message, cancellationToken);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private static string ReadFixtureOrtho(string? automationConfigurationPath)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(automationConfigurationPath) || !File.Exists(automationConfigurationPath)) throw new InvalidOperationException("AUTOMATION_CONFIG_MISSING");
|
|
using var json = JsonDocument.Parse(File.ReadAllText(automationConfigurationPath));
|
|
if (!json.RootElement.TryGetProperty("orthoDrawingPath", out var value) || string.IsNullOrWhiteSpace(value.GetString())) throw new InvalidOperationException("AUTOMATION_ORTHO_PATH_REQUIRED");
|
|
return Path.GetFullPath(value.GetString()!);
|
|
}
|
|
|
|
public async Task<PilotRollbackResult> RollbackAsync(PilotRollbackRequest request, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
var session = await ReadSession(request.PilotRoot, cancellationToken);
|
|
var snapshotPath = request.ActivationSnapshotPath ?? session?.ActivationSnapshotPath;
|
|
if (string.IsNullOrWhiteSpace(snapshotPath) || !File.Exists(snapshotPath)) return new(false, "ACTIVATION_SNAPSHOT_MISSING");
|
|
var snapshot = await JsonSerializer.DeserializeAsync<ActivationSnapshot>(File.OpenRead(snapshotPath), cancellationToken: cancellationToken);
|
|
if (snapshot is null) return new(false, "ACTIVATION_SNAPSHOT_INVALID");
|
|
if (session?.ProcessId is int pid && probe.IsAcadRunning() && IsProcessRunning(pid)) return new(false, "PROCESS_STILL_RUNNING");
|
|
var packageRoot = Path.Combine(request.PilotRoot, "packages", snapshot.PackageId);
|
|
await Restore(Path.Combine(packageRoot, "current.json"), snapshot.CurrentContent, snapshot.CurrentSha256, cancellationToken);
|
|
await Restore(Path.Combine(packageRoot, "previous.json"), snapshot.PreviousContent, snapshot.PreviousSha256, cancellationToken);
|
|
if (File.Exists(snapshot.StartupScriptPath)) File.Delete(snapshot.StartupScriptPath);
|
|
if (Directory.Exists(snapshot.StagingPath)) Directory.Delete(snapshot.StagingPath, true);
|
|
if (Directory.Exists(snapshot.VersionDirectory)) Directory.Delete(snapshot.VersionDirectory, true);
|
|
if (session is not null) await WriteSession(request.PilotRoot, session with { State = "RolledBack", UpdatedAtUtc = DateTimeOffset.UtcNow, LastErrorCode = null, LastErrorMessage = null }, cancellationToken);
|
|
return new(true, null);
|
|
}
|
|
catch { return new(false, "ROLLBACK_FAILED"); }
|
|
}
|
|
|
|
private async Task<bool> ValidateSource(PackageManifest manifest, string root, CancellationToken ct)
|
|
{
|
|
foreach (var file in manifest.Files)
|
|
{
|
|
var path = Path.Combine(root, file.Path);
|
|
if (!File.Exists(path) || !string.Equals(await hasher.Sha256Async(path, ct), file.Sha256, StringComparison.OrdinalIgnoreCase)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
private static bool IsProcessRunning(int pid) { try { return !System.Diagnostics.Process.GetProcessById(pid).HasExited; } catch { return false; } }
|
|
private static string? Hash(string? text) => text is null ? null : Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(text)));
|
|
private static async Task<string?> ReadTextOrNull(string path, CancellationToken ct) => File.Exists(path) ? await File.ReadAllTextAsync(path, ct) : null;
|
|
private static async Task WriteTextAtomic(string path, string content, CancellationToken ct, bool exists)
|
|
{ if (!exists) { if (File.Exists(path)) File.Delete(path); return; } Directory.CreateDirectory(Path.GetDirectoryName(path)!); var temp = path + ".tmp"; await File.WriteAllTextAsync(temp, content, ct); File.Move(temp, path, true); }
|
|
private static async Task WriteJsonAtomic<T>(string path, T value, CancellationToken ct) => await WriteTextAtomic(path, JsonSerializer.Serialize(value), ct, true);
|
|
private static async Task<PersistedSession?> ReadSession(string root, CancellationToken ct)
|
|
{ var path = Path.Combine(root, "state", "pilot-session.json"); if (!File.Exists(path)) return null; await using var stream = File.OpenRead(path); return await JsonSerializer.DeserializeAsync<PersistedSession>(stream, cancellationToken: ct); }
|
|
private static Task WriteSession(string root, PersistedSession session, CancellationToken ct) => WriteJsonAtomic(Path.Combine(root, "state", "pilot-session.json"), session, ct);
|
|
private static async Task MarkFailed(string root, string code, CancellationToken ct)
|
|
{ var s = await ReadSession(root, ct); if (s is not null) await WriteSession(root, s with { State = "Failed", UpdatedAtUtc = DateTimeOffset.UtcNow, LastErrorCode = code, LastErrorMessage = code }, ct); }
|
|
private static async Task Restore(string path, string? content, string? sha, CancellationToken ct)
|
|
{ if (content is null) { if (File.Exists(path)) File.Delete(path); return; } if (!string.Equals(Hash(content), sha, StringComparison.OrdinalIgnoreCase)) throw new InvalidOperationException("SNAPSHOT_HASH_INVALID"); await WriteTextAtomic(path, content, ct, true); if (!string.Equals(Hash(await File.ReadAllTextAsync(path, ct)), sha, StringComparison.OrdinalIgnoreCase)) throw new InvalidOperationException("POINTER_RESTORE_FAILED"); }
|
|
}
|