273 lines
21 KiB
C#
273 lines
21 KiB
C#
using System.Text.Json;
|
|
using System.Reflection;
|
|
using System.Security.Cryptography;
|
|
using Autodesk.AutoCAD.ApplicationServices;
|
|
using Autodesk.AutoCAD.DatabaseServices;
|
|
using Autodesk.AutoCAD.Runtime;
|
|
using Autodesk.ProcessPower.PlantInstance;
|
|
using Autodesk.ProcessPower.ProjectManager;
|
|
using PRecAnnot.Abstractions;
|
|
using AcadApplication = Autodesk.AutoCAD.ApplicationServices.Application;
|
|
|
|
namespace PRecAnnot.Plant3D2026;
|
|
|
|
// Test-only observer. The AutoCAD /b processor, never this type, drives PXP-OA.
|
|
internal static class ScriptDrivenFirstApplyAutomation
|
|
{
|
|
private sealed record Config(string Phase, string OrthoDrawingPath, string EvidencePath, string FixtureMarkerPath, string ExpectedEntryAssemblySha256, bool Diagnostic);
|
|
private sealed record Run(int Sequence, string? PlanId, IReadOnlyList<string> Candidates, string? View, int Create, int Skip, bool? PermitAccepted, string? ApplyOutcome, int? DbmodBefore, int? DbmodAfter, AutomationEntityCounts? Before, AutomationEntityCounts? After, bool WillStart, bool Ended, bool Failed, bool Cancelled, int? SourceRows, int? MembershipResolved);
|
|
private static Config? config;
|
|
private static Document? fixture;
|
|
private static Database? database;
|
|
private static AutomationEntityCounts? baseline;
|
|
private static int? dbmodBaseline;
|
|
private static readonly List<Run> runs = [];
|
|
private static readonly List<string> transitions = [];
|
|
private static readonly List<string> commandEvents = [];
|
|
private static readonly List<AutomationSentinelEvidence> sentinels = [];
|
|
private static readonly List<AutomationCommandCorrelationEvidence> correlations = [];
|
|
private static PxpOaDiscoveryEvidence? discovery;
|
|
// Plant's implicit current-document lookup can lag between script commands.
|
|
// PREPARE has already proved this immutable context belongs to the live fixture;
|
|
// retain it for the two immediately following public PXP-OA commands only.
|
|
private static PlantRuntimeContext? preparedContext;
|
|
private static string? selectedTargetSnapshotId;
|
|
private static bool prepared;
|
|
private static bool terminal;
|
|
private static string? applyExceptionText;
|
|
|
|
internal static void Prepare()
|
|
{
|
|
try
|
|
{
|
|
if (terminal) return;
|
|
config = ReadConfig();
|
|
RequireGate(config);
|
|
discovery = DiscoverPxpOa(config);
|
|
RequireDiscovery(discovery);
|
|
var active = AcadApplication.DocumentManager.MdiActiveDocument ?? throw new InvalidOperationException("AUTOMATION_ACTIVE_DOCUMENT_MISSING");
|
|
if (!SamePath(active.Name, config.OrthoDrawingPath)) throw new InvalidOperationException("AUTOMATION_UNEXPECTED_ACTIVE_FIXTURE");
|
|
fixture = active;
|
|
database = active.Database ?? throw new InvalidOperationException("AUTOMATION_FIXTURE_DATABASE_MISSING");
|
|
fixture.CommandWillStart += OnWillStart;
|
|
fixture.CommandEnded += OnEnded;
|
|
fixture.CommandFailed += OnFailed;
|
|
fixture.CommandCancelled += OnCancelled;
|
|
var projectXml = Path.Combine(Path.GetDirectoryName(config.FixtureMarkerPath)!, "Project.xml");
|
|
if (!File.Exists(projectXml)) throw new InvalidOperationException("AUTOMATION_PROJECT_XML_MISSING");
|
|
var project = PlantProject.LoadProject(projectXml, false, string.Empty, string.Empty);
|
|
PlantApplication.SetCurrentProject(project, true);
|
|
var context = new PlantRuntimeContextReader().ReadCurrentContext(fixture);
|
|
if (!context.HasPlantProject || !context.IsOrthoDrawing || context.Viewports.Count != 1)
|
|
throw new InvalidOperationException("AUTOMATION_ORTHO_CONTEXT_INVALID");
|
|
var candidates = new PlantObjectReader().ReadObjects(context.Viewports.Single(), CancellationToken.None)
|
|
.Where(x => string.Equals(x.ObjectClass, "Pipe", StringComparison.OrdinalIgnoreCase) && x.MembershipStatus == ViewMembershipStatus.Resolved && x.Geometry.PaperPosition is not null)
|
|
.Select(x => x.SnapshotId).OrderBy(x => x, StringComparer.Ordinal).ToArray();
|
|
if (candidates.Length == 0) throw new InvalidOperationException("AUTOMATION_NO_ELIGIBLE_CANDIDATE");
|
|
preparedContext = context;
|
|
selectedTargetSnapshotId = candidates[0];
|
|
dbmodBaseline = Dbmod();
|
|
baseline = Counts(database);
|
|
prepared = true;
|
|
transitions.Add("Prepared");
|
|
Write(false, null);
|
|
}
|
|
catch (System.Exception exception) { Fail("AUTOMATION_PREPARE_FAILED", exception); }
|
|
}
|
|
|
|
internal static void RecordSentinel(string stage)
|
|
{
|
|
Guard(() =>
|
|
{
|
|
if (!prepared || terminal || fixture is null || database is null) return;
|
|
sentinels.Add(new(stage, fixture.Name, database.Filename, DateTimeOffset.UtcNow));
|
|
transitions.Add("Sentinel:" + stage);
|
|
Write(false, null);
|
|
});
|
|
}
|
|
|
|
internal static void RecordPxpOa(string? planId, IReadOnlyList<string> candidates, string? view, int create, int skip, bool? permitAccepted, int sourceRows, int membershipResolved)
|
|
{
|
|
if (!prepared || terminal || runs.Count == 0) return;
|
|
var last = runs[^1];
|
|
if (!last.WillStart || last.PlanId is not null) return;
|
|
runs[^1] = last with { PlanId = planId, Candidates = candidates, View = view, Create = create, Skip = skip, PermitAccepted = permitAccepted, SourceRows = sourceRows, MembershipResolved = membershipResolved };
|
|
}
|
|
|
|
internal static void RecordApplyOutcome(PipeAnnotationWriteOutcome outcome)
|
|
{
|
|
if (!prepared || terminal || runs.Count == 0) return;
|
|
var last = runs[^1];
|
|
runs[^1] = outcome == PipeAnnotationWriteOutcome.AlreadyExists
|
|
? last with { ApplyOutcome = outcome.ToString(), Create = 0, Skip = 1 }
|
|
: last with { ApplyOutcome = outcome.ToString() };
|
|
}
|
|
internal static void RecordApplyFailure(System.Exception exception)
|
|
{
|
|
if (!prepared || terminal) return;
|
|
applyExceptionText = exception.ToString();
|
|
Write(false, "AUTOMATION_APPLY_COMMAND_FAILED");
|
|
}
|
|
|
|
internal static bool TryGetPreparedContext(Document? commandDocument, out PlantRuntimeContext context)
|
|
{
|
|
context = null!;
|
|
if (!prepared || terminal || fixture is null || preparedContext is null || commandDocument is null || config is null) return false;
|
|
if (!SamePath(commandDocument.Name, config.OrthoDrawingPath) || !SamePath(fixture.Name, config.OrthoDrawingPath)) return false;
|
|
if (commandDocument.Database is null || database is null || !SamePath(commandDocument.Database.Filename, database.Filename)) return false;
|
|
context = preparedContext;
|
|
return true;
|
|
}
|
|
|
|
internal static string? SelectedTargetSnapshotId => prepared && !terminal ? selectedTargetSnapshotId : null;
|
|
|
|
internal static void FinalizeAutomation()
|
|
{
|
|
try
|
|
{
|
|
if (!prepared) throw new InvalidOperationException("AUTOMATION_NOT_PREPARED");
|
|
if (runs.Count != 2) throw new InvalidOperationException("AUTOMATION_EXPECTS_EXACTLY_TWO_PXP_OA");
|
|
if (runs.Any(x => !x.WillStart || !x.Ended || x.Failed || x.Cancelled)) throw new InvalidOperationException("AUTOMATION_PXP_OA_NOT_ENDED");
|
|
if (runs.Any(x => string.IsNullOrWhiteSpace(x.PlanId))) throw new InvalidOperationException("PXP_OA_PLAN_RESULT_NOT_CAPTURED");
|
|
if (!string.Equals(runs[0].PlanId, runs[1].PlanId, StringComparison.Ordinal)) throw new InvalidOperationException("AUTOMATION_PLAN_IDS_DIFFER");
|
|
var apply = string.Equals(config!.Phase, "Apply", StringComparison.OrdinalIgnoreCase);
|
|
if ((!apply && runs.Any(x => x.Create != 1)) || (apply && (runs[0].Create != 1 || runs[1].Create != 0))) throw new InvalidOperationException("AUTOMATION_CREATE_COUNTS_INVALID");
|
|
if (runs[0].Candidates.Count == 0) throw new InvalidOperationException("AUTOMATION_NO_ELIGIBLE_CANDIDATE");
|
|
if (apply)
|
|
{
|
|
if (runs[0].PermitAccepted != true) throw new InvalidOperationException("AUTOMATION_APPLY_PERMIT_NOT_ACCEPTED");
|
|
if (!string.Equals(runs[0].ApplyOutcome, PipeAnnotationWriteOutcome.Created.ToString(), StringComparison.Ordinal)) throw new InvalidOperationException("AUTOMATION_APPLY_CREATE_NOT_CONFIRMED");
|
|
if (!string.Equals(runs[1].ApplyOutcome, PipeAnnotationWriteOutcome.AlreadyExists.ToString(), StringComparison.Ordinal)) throw new InvalidOperationException("AUTOMATION_APPLY_DUPLICATE_NOT_CONFIRMED");
|
|
var undoCounts = Counts(database!);
|
|
if (!Equals(undoCounts, baseline)) throw new InvalidOperationException("AUTOMATION_UNDO_DID_NOT_RESTORE_BASELINE");
|
|
}
|
|
else if (Dbmod() != dbmodBaseline || !Equals(Counts(database!), baseline)) throw new InvalidOperationException("AUTOMATION_INSPECTOR_INVARIANCE_FAILED");
|
|
terminal = true;
|
|
transitions.Add(apply ? "ApplyCompleted" : "PreviewCompleted");
|
|
Write(true, null);
|
|
Unsubscribe();
|
|
}
|
|
catch (System.Exception exception) { Fail("PREVIEW_ACCEPTANCE_FAILED", exception); }
|
|
}
|
|
|
|
private static void OnWillStart(object sender, CommandEventArgs args)
|
|
{
|
|
Guard(() =>
|
|
{
|
|
commandEvents.Add("WillStart:" + args.GlobalCommandName);
|
|
var correlation = Correlate("WillStart", sender, args.GlobalCommandName, runs.Count < 2);
|
|
correlations.Add(correlation);
|
|
if (correlation.RejectionReason is not null) return;
|
|
runs.Add(new Run(runs.Count + 1, null, [], null, 0, 0, null, null, Dbmod(), null, Counts(database!), null, true, false, false, false, null, null));
|
|
transitions.Add("PxpOaWillStart:" + runs.Count);
|
|
});
|
|
}
|
|
private static void OnEnded(object sender, CommandEventArgs args) => Finish(sender, args, false, false);
|
|
private static void OnFailed(object sender, CommandEventArgs args) => Finish(sender, args, true, false);
|
|
private static void OnCancelled(object sender, CommandEventArgs args) => Finish(sender, args, false, true);
|
|
private static void Finish(object sender, CommandEventArgs args, bool failed, bool cancelled)
|
|
{
|
|
Guard(() =>
|
|
{
|
|
var kind = failed ? "Failed" : cancelled ? "Cancelled" : "Ended";
|
|
commandEvents.Add(kind + ":" + args.GlobalCommandName);
|
|
var correlation = Correlate(kind, sender, args.GlobalCommandName, runs.Count > 0);
|
|
correlations.Add(correlation);
|
|
if (correlation.RejectionReason is not null) return;
|
|
var last = runs[^1];
|
|
if (last.Ended || last.Failed || last.Cancelled) return;
|
|
runs[^1] = last with { Ended = !failed && !cancelled, Failed = failed, Cancelled = cancelled, DbmodAfter = Dbmod(), After = Counts(database!) };
|
|
transitions.Add(failed ? "PxpOaFailed" : cancelled ? "PxpOaCancelled" : "PxpOaEnded:" + last.Sequence);
|
|
Write(false, null);
|
|
});
|
|
}
|
|
private static AutomationCommandCorrelationEvidence Correlate(string kind, object sender, string rawName, bool sequenceAccepted)
|
|
{
|
|
var normalized = rawName.Trim();
|
|
var command = string.Equals(normalized, "PXP-OA", StringComparison.OrdinalIgnoreCase);
|
|
var state = prepared && !terminal && config is not null && fixture is not null && database is not null;
|
|
var senderDocument = sender as Document;
|
|
var senderPath = senderDocument?.Name;
|
|
var expectedPath = config?.OrthoDrawingPath;
|
|
var activePath = AcadApplication.DocumentManager.MdiActiveDocument?.Name;
|
|
var fixturePath = senderPath is not null && expectedPath is not null && SamePath(senderPath, expectedPath);
|
|
var activeFixture = activePath is not null && expectedPath is not null && SamePath(activePath, expectedPath);
|
|
var document = fixturePath && activeFixture;
|
|
var databaseMatch = senderDocument?.Database is not null && database is not null && SamePath(senderDocument.Database.Filename, database.Filename);
|
|
var rejection = !command ? "COMMAND_NAME_MISMATCH" : !state ? "NOT_PREPARED" : !document ? "DOCUMENT_IDENTITY_MISMATCH" : !databaseMatch ? "DATABASE_IDENTITY_MISMATCH" : !sequenceAccepted ? "UNEXPECTED_SEQUENCE" : null;
|
|
return new(kind, rawName, normalized, command, state, document, databaseMatch, fixturePath, sequenceAccepted, rejection, sender.GetType().FullName, senderPath, expectedPath, activePath, runs.Count, DateTimeOffset.UtcNow);
|
|
}
|
|
private static void Guard(Action action) { try { if (!terminal) action(); } catch (System.Exception ex) { Fail("AUTOMATION_EVENT_HANDLER_FAILED", ex); } }
|
|
private static void Fail(string code, System.Exception exception) { if (terminal) return; terminal = true; transitions.Add("Failed:" + code); try { Write(false, code + ":" + exception); } finally { Unsubscribe(); } }
|
|
private static void Unsubscribe()
|
|
{
|
|
if (fixture is not null) try { fixture.CommandWillStart -= OnWillStart; fixture.CommandEnded -= OnEnded; fixture.CommandFailed -= OnFailed; fixture.CommandCancelled -= OnCancelled; } catch { }
|
|
preparedContext = null;
|
|
selectedTargetSnapshotId = null;
|
|
}
|
|
private static int? Dbmod() { try { return Convert.ToInt32(AcadApplication.GetSystemVariable("DBMOD")); } catch { return null; } }
|
|
private static AutomationEntityCounts Counts(Database db)
|
|
{
|
|
using var tx = db.TransactionManager.StartTransaction();
|
|
var space = (BlockTableRecord)tx.GetObject(db.CurrentSpaceId, OpenMode.ForRead);
|
|
var total = 0; var pipes = 0; var xdata = 0; var owned = 0;
|
|
foreach (ObjectId id in space) { if (tx.GetObject(id, OpenMode.ForRead) is not Entity entity) continue; total++; if (entity is BlockReference br && string.Equals(br.Name, "PIPE", StringComparison.OrdinalIgnoreCase)) pipes++; if (entity.XData is not null) { foreach (TypedValue value in entity.XData) if (value.Value is string text && string.Equals(text, "PXP-OA", StringComparison.OrdinalIgnoreCase)) { xdata++; owned++; break; } } }
|
|
return new(total, pipes, xdata, owned);
|
|
}
|
|
private static Config ReadConfig()
|
|
{
|
|
var path = Environment.GetEnvironmentVariable("P_REC_ANNOT_AUTOMATION_CONFIG") ?? throw new InvalidOperationException("AUTOMATION_CONFIG_MISSING");
|
|
using var json = JsonDocument.Parse(File.ReadAllText(path)); var root = json.RootElement;
|
|
return new(root.GetProperty("phase").GetString() ?? "Preview", root.GetProperty("orthoDrawingPath").GetString() ?? throw new InvalidOperationException("AUTOMATION_ORTHO_PATH_REQUIRED"), root.GetProperty("evidencePath").GetString() ?? throw new InvalidOperationException("AUTOMATION_EVIDENCE_PATH_REQUIRED"), root.GetProperty("fixtureMarkerPath").GetString() ?? throw new InvalidOperationException("AUTOMATION_MARKER_PATH_REQUIRED"), root.GetProperty("entryAssemblySha256").GetString() ?? throw new InvalidOperationException("AUTOMATION_ENTRY_ASSEMBLY_HASH_REQUIRED"), root.TryGetProperty("diagnostic", out var diagnostic) && diagnostic.ValueKind == JsonValueKind.True);
|
|
}
|
|
private static void RequireGate(Config value)
|
|
{
|
|
if (!string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_AUTOMATION"), "FirstLimitedApplyRuntimeTest", StringComparison.Ordinal) || !string.Equals(Environment.GetEnvironmentVariable("P_REC_ANNOT_LAUNCHER_MODE"), "NextPilot", StringComparison.Ordinal) || !File.Exists(value.FixtureMarkerPath)) throw new InvalidOperationException("AUTOMATION_GATE_REJECTED");
|
|
}
|
|
private static bool SamePath(string left, string right) => string.Equals(Path.GetFullPath(left), Path.GetFullPath(right), StringComparison.OrdinalIgnoreCase);
|
|
private static void Write(bool completed, string? error)
|
|
{
|
|
if (config is null) return;
|
|
var first = runs.ElementAtOrDefault(0); var second = runs.ElementAtOrDefault(1);
|
|
var apply = string.Equals(config.Phase, "Apply", StringComparison.OrdinalIgnoreCase);
|
|
var afterUndo = apply && terminal ? Counts(database!) : null;
|
|
var evidence = new FirstApplyAutomationEvidence { Phase = config.Phase, Completed = completed, Prepared = prepared, FunctionalEvidenceCompleted = completed, ErrorCode = error, DbmodBefore = dbmodBaseline, DbmodAfterCommand1 = first?.DbmodAfter, DbmodAfterCommand2 = second?.DbmodAfter, DbmodAfterUndo = apply && terminal ? Dbmod() : null, Baseline = baseline, AfterCommand1 = first?.After, AfterCommand2 = second?.After, AfterUndo = afterUndo, CompletedCommands = runs.Where(x => x.Ended).Select(x => "PXP-OA").Concat(apply && commandEvents.Any(x => string.Equals(x, "Ended:UNDO", StringComparison.OrdinalIgnoreCase)) ? ["UNDO"] : []).ToArray(), PlanIdRun1 = first?.PlanId, PlanIdRun2 = second?.PlanId, PlanIdsEqual = first is not null && second is not null ? string.Equals(first.PlanId, second.PlanId, StringComparison.Ordinal) : null, EligibleCandidateCount = first?.Candidates.Count, SelectedCandidateHash = first?.Candidates.OrderBy(x => x, StringComparer.Ordinal).FirstOrDefault(), ViewHash = first?.View, CreateRun1 = first?.Create, CreateRun2 = second?.Create, SkipRun2 = second?.Skip, ApplyOutcomeRun1 = first?.ApplyOutcome, ApplyOutcomeRun2 = second?.ApplyOutcome, PermitAccepted = first?.PermitAccepted, CommandsCompleted = runs.Count == 2 && runs.All(x => x.Ended) && (!apply || commandEvents.Any(x => string.Equals(x, "Ended:UNDO", StringComparison.OrdinalIgnoreCase))), InspectorsCompleted = baseline is not null && first?.After is not null && second?.After is not null && (!apply || afterUndo is not null), EvidenceFlushed = true, ExceptionText = applyExceptionText, CurrentState = terminal ? (completed ? "Completed" : "Failed") : "Prepared", StateTransitions = transitions, PxpOaDiscovery = discovery, Sentinels = sentinels, CommandEvents = commandEvents, CommandCorrelations = correlations };
|
|
Directory.CreateDirectory(Path.GetDirectoryName(config.EvidencePath)!);
|
|
var temp = config.EvidencePath + ".tmp"; File.WriteAllText(temp, JsonSerializer.Serialize(evidence)); File.Move(temp, config.EvidencePath, true);
|
|
}
|
|
|
|
private static PxpOaDiscoveryEvidence DiscoverPxpOa(Config value)
|
|
{
|
|
var entry = typeof(EntryPoint).Assembly;
|
|
var loaded = AppDomain.CurrentDomain.GetAssemblies().Any(x => ReferenceEquals(x, entry));
|
|
var location = entry.Location;
|
|
var hash = File.Exists(location) ? Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(location))) : null;
|
|
var declarations = AppDomain.CurrentDomain.GetAssemblies().SelectMany(Declarations).Where(x => string.Equals(x.Name, "PXP-OA", StringComparison.OrdinalIgnoreCase)).ToArray();
|
|
var owner = declarations.SingleOrDefault(x => x.Assembly == entry);
|
|
var commandClass = entry.GetCustomAttributesData().Any(x => string.Equals(x.AttributeType.FullName, "Autodesk.AutoCAD.Runtime.CommandClassAttribute", StringComparison.Ordinal) && x.ConstructorArguments.Any(a => string.Equals(a.Value as Type, typeof(EntryPoint))));
|
|
return new(owner is not null, owner?.Name, owner?.Group, owner?.Flags, owner?.Type.FullName, owner?.Assembly.GetName().Name, location, hash, loaded, commandClass, hash is not null && string.Equals(hash, value.ExpectedEntryAssemblySha256, StringComparison.OrdinalIgnoreCase), declarations.Length);
|
|
}
|
|
private sealed record Declaration(string Name, string? Group, string? Flags, Type Type, Assembly Assembly);
|
|
private static IEnumerable<Declaration> Declarations(Assembly assembly)
|
|
{
|
|
Type[] types; try { types = assembly.GetTypes(); } catch (ReflectionTypeLoadException exception) { types = exception.Types.Where(x => x is not null).Cast<Type>().ToArray(); }
|
|
foreach (var type in types) foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)) foreach (var attribute in method.GetCustomAttributesData().Where(x => string.Equals(x.AttributeType.FullName, "Autodesk.AutoCAD.Runtime.CommandMethodAttribute", StringComparison.Ordinal)))
|
|
{
|
|
var name = attribute.ConstructorArguments.FirstOrDefault().Value as string;
|
|
if (string.IsNullOrWhiteSpace(name)) continue;
|
|
var group = attribute.NamedArguments.FirstOrDefault(x => x.MemberName == "GroupName").TypedValue.Value as string;
|
|
var flags = attribute.NamedArguments.FirstOrDefault(x => x.MemberName == "Flags").TypedValue.Value?.ToString();
|
|
yield return new(name, group, flags, type, assembly);
|
|
}
|
|
}
|
|
private static void RequireDiscovery(PxpOaDiscoveryEvidence value)
|
|
{
|
|
if (!value.AssemblyLoaded) throw new InvalidOperationException("PXP_OA_ASSEMBLY_NOT_LOADED");
|
|
if (!value.BundleHashMatched) throw new InvalidOperationException("PXP_OA_BUNDLE_HASH_MISMATCH");
|
|
if (!value.CommandClassIncluded) throw new InvalidOperationException("PXP_OA_COMMANDCLASS_NOT_REGISTERED");
|
|
if (value.DeclarationCount > 1) throw new InvalidOperationException("PXP_OA_COMMAND_COLLISION");
|
|
if (value.DeclarationCount == 0 || !value.Found) throw new InvalidOperationException("PXP_OA_COMMAND_NOT_FOUND");
|
|
if (!string.Equals(value.GlobalName, "PXP-OA", StringComparison.Ordinal)) throw new InvalidOperationException("PXP_OA_GLOBAL_NAME_MISMATCH");
|
|
}
|
|
}
|