feat(controlplane): deploy-gate TagConfig strictness — Warn default, Error opt-in at the draft gate (R2-11, 05/CONV-2)

src/Server/ZB.MOM.WW.OtOpcUa.ControlPlane/AdminOperations/AdminOperationsActor.cs

@@ -25,31 +25,37 @@ public sealed class AdminOperationsActor : ReceiveActor
     private readonly IDbContextFactory<OtOpcUaConfigDbContext> _dbFactory;
     private readonly IActorRef _coordinator;
     private readonly IReadOnlyDictionary<string, IDriverProbe> _probesByType;
+    private readonly TagConfigValidationMode _tagConfigValidationMode;
     private readonly ILoggingAdapter _log = Context.GetLogger();
 
     /// <summary>Creates actor props for the admin operations actor.</summary>
     /// <param name="dbFactory">Factory for creating config database contexts.</param>
     /// <param name="coordinator">Reference to the deployment coordinator actor.</param>
     /// <param name="probes">Driver probes registered in DI; keyed by DriverType (case-insensitive).</param>
+    /// <param name="tagConfigValidationMode">Deploy-gate TagConfig strictness mode (Warn default | Error opt-in).</param>
     /// <returns>Props configured to create an AdminOperationsActor.</returns>
     public static Props Props(
         IDbContextFactory<OtOpcUaConfigDbContext> dbFactory,
         IActorRef coordinator,
-        IEnumerable<IDriverProbe> probes) =>
-        Akka.Actor.Props.Create(() => new AdminOperationsActor(dbFactory, coordinator, probes));
+        IEnumerable<IDriverProbe> probes,
+        TagConfigValidationMode tagConfigValidationMode = TagConfigValidationMode.Warn) =>
+        Akka.Actor.Props.Create(() => new AdminOperationsActor(dbFactory, coordinator, probes, tagConfigValidationMode));
 
     /// <summary>Initializes a new instance of the AdminOperationsActor.</summary>
     /// <param name="dbFactory">Factory for creating config database contexts.</param>
     /// <param name="coordinator">Reference to the deployment coordinator actor.</param>
     /// <param name="probes">Driver probes registered in DI; keyed by DriverType (case-insensitive).</param>
+    /// <param name="tagConfigValidationMode">Deploy-gate TagConfig strictness mode (Warn default | Error opt-in).</param>
     public AdminOperationsActor(
         IDbContextFactory<OtOpcUaConfigDbContext> dbFactory,
         IActorRef coordinator,
-        IEnumerable<IDriverProbe> probes)
+        IEnumerable<IDriverProbe> probes,
+        TagConfigValidationMode tagConfigValidationMode = TagConfigValidationMode.Warn)
     {
         _dbFactory = dbFactory;
         _coordinator = coordinator;
         _probesByType = probes.ToDictionary(p => p.DriverType, StringComparer.OrdinalIgnoreCase);
+        _tagConfigValidationMode = tagConfigValidationMode;
 
         ReceiveAsync<StartDeployment>(HandleStartDeploymentAsync);
         ReceiveAsync<TestDriverConnect>(HandleTestDriverConnectAsync);
@@ -202,6 +208,31 @@ public sealed class AdminOperationsActor : ReceiveActor
                 errors.AddRange(DraftValidator.ValidateClusterTopology(cluster, nodes));
             }
 
+            // R2-11 (05/CONV-2): deploy-time TagConfig strictness inspection over equipment tags. The
+            // driver-typed EquipmentTagConfigInspector surfaces present-but-invalid enum values (which the
+            // lenient runtime silently defaults) + structurally-unparseable TagConfig. In Warn mode
+            // (default) these are non-blocking (logged + appended to the accepted result Message); in Error
+            // mode they fold into the reject list so a typo'd config cannot be re-deployed until fixed.
+            // Running servers are untouched either way — the gate only sees re-deploys.
+            var driverTypeById = draft.DriverInstances
+                .GroupBy(d => d.DriverInstanceId, StringComparer.Ordinal)
+                .ToDictionary(g => g.Key, g => g.First().DriverType, StringComparer.Ordinal);
+            var tagConfigWarnings = new List<(string TagId, string Text)>();
+            foreach (var t in draft.Tags.Where(t => t.EquipmentId is not null))
+            {
+                if (!driverTypeById.TryGetValue(t.DriverInstanceId, out var driverType)) continue;
+                foreach (var w in EquipmentTagConfigInspector.Inspect(driverType, t.TagConfig))
+                    tagConfigWarnings.Add((t.TagId, $"tag '{t.TagId}' (equipment '{t.EquipmentId}'): {w}"));
+            }
+            if (tagConfigWarnings.Count > 0)
+            {
+                if (_tagConfigValidationMode == TagConfigValidationMode.Error)
+                    errors.AddRange(tagConfigWarnings.Select(x => new ValidationError("TagConfigInvalid", x.Text, x.TagId)));
+                else
+                    foreach (var x in tagConfigWarnings)
+                        _log.Warning("StartDeployment: TagConfig warning (Warn mode, non-blocking): {Warning}", x.Text);
+            }
+
             if (errors.Count > 0)
             {
                 var summary = string.Join("; ", errors.Select(e => $"[{e.Code}] {e.Message}"));
@@ -277,11 +308,18 @@ public sealed class AdminOperationsActor : ReceiveActor
 
             _coordinator.Tell(new DispatchDeployment(deploymentId, revHash, msg.CorrelationId));
 
+            // Accepted message = the compile-cost advisory (if any) + any Warn-mode TagConfig warnings, so
+            // the operator sees the non-blocking strictness findings on a successful deploy.
+            var messageParts = new List<string>();
+            if (advisory is not null) messageParts.Add(advisory);
+            messageParts.AddRange(tagConfigWarnings.Select(x => x.Text));
+            var acceptedMessage = messageParts.Count > 0 ? string.Join("; ", messageParts) : null;
+
             replyTo.Tell(new StartDeploymentResult(
                 StartDeploymentOutcome.Accepted,
                 deploymentId,
                 revHash,
-                Message: advisory,
+                Message: acceptedMessage,
                 msg.CorrelationId));
         }
         catch (Exception ex)