fix(address-space): numeric array writes convert (checked) to the node element type; array-to-scalar refusal only for Modbus/S7 (#610 review R6)

MAJOR-1: R4's exact element-type match refused ScadaBridge's CLR-list writes (its element types are only Boolean/Int32/Float/Double/String/ DateTime) to every Int16/UInt16/Byte/UInt32/Int64/UInt64 array node and a Double list to a Float array. EvaluateEquipmentWriteStructure now converts a numeric array of another numeric element type element-wise, CHECKED, into the node's element type and hands the converted array back through OnEquipmentTagWrite's ref value, so the node stores and the driver receives the node's own type. Any out-of-range, fractional-to-integer, NaN/Inf-to- integer or Float-overflowing element refuses the whole write BadTypeMismatch (nothing dispatched) - so the UInt32 -> Int32 bit reinterpretation stays closed. Non-numeric mismatches stay refused. The wrong 'no client relies on a looser rule' comment is corrected. MINOR-1: the array-value-to-scalar-node refusal broke writes back to browse-committed array tags (committed scalar, isArray never set) on pass-through drivers. It now applies only when the owning driver's scalar encoder cannot take an array (DriverArrayWriteSupport. RefusesArrayValueOnScalarTag: Modbus, S7), carried RawTagPlan. ScalarRefusesArrayValue / UnsReferenceVariable.BackingScalarRefusesArrayValue -> EnsureVariable(refuseArrayOnScalar) -> a per-node set in the node manager. OpcUaClient/Galaxy/others keep pre-#610 dispatch. Not on the classifier whitelist (driver-type edit rebuilds); a mirror whose flag changes is recreated, not updated in place. Claude-Session: https://claude.ai/code/session_01Ef2ozxS7QPanGT8uoATbTe
2026-10-08 08:31:46 -04:00
parent a702875d41
commit 52708bff52
27 changed files with 509 additions and 97 deletions
@@ -63,8 +63,8 @@ public sealed class DeferredAddressSpaceSink : IOpcUaAddressSpaceSink, ISurgical
        => _inner.EnsureFolder(folderNodeId, parentNodeId, displayName, realm);

    /// <inheritdoc />
-    public void EnsureVariable(string variableNodeId, string? parentFolderNodeId, string displayName, string dataType, bool writable, AddressSpaceRealm realm, string? historianTagname = null, bool isArray = false, uint? arrayLength = null)
-        => _inner.EnsureVariable(variableNodeId, parentFolderNodeId, displayName, dataType, writable, realm, historianTagname, isArray, arrayLength);
+    public void EnsureVariable(string variableNodeId, string? parentFolderNodeId, string displayName, string dataType, bool writable, AddressSpaceRealm realm, string? historianTagname = null, bool isArray = false, uint? arrayLength = null, bool refuseArrayOnScalar = false)
+        => _inner.EnsureVariable(variableNodeId, parentFolderNodeId, displayName, dataType, writable, realm, historianTagname, isArray, arrayLength, refuseArrayOnScalar);

    /// <inheritdoc />
    public void RebuildAddressSpace() => _inner.RebuildAddressSpace();
@@ -172,7 +172,12 @@ public interface IOpcUaAddressSpaceSink
    /// <param name="realm">The namespace realm the variable (and its <paramref name="parentFolderNodeId"/>) live
    /// in. A historized UNS reference node registers the SAME <paramref name="historianTagname"/> as its backing
    /// raw node — both NodeIds map to one tagname — so this call carries the shared tagname per realm.</param>
-    void EnsureVariable(string variableNodeId, string? parentFolderNodeId, string displayName, string dataType, bool writable, AddressSpaceRealm realm, string? historianTagname = null, bool isArray = false, uint? arrayLength = null);
+    /// <param name="refuseArrayOnScalar">Gitea #610 review (R6): when true and the node is SCALAR, a client write
+    /// of an array value is refused inline (<c>BadTypeMismatch</c>, nothing dispatched) because the owning
+    /// driver's scalar encoder cannot take one (Modbus / S7). False (default) keeps the pre-#610 behaviour — the
+    /// write is dispatched and the driver decides (OpcUaClient forwards it to the upstream server, Galaxy encodes
+    /// it). Fixed at creation; an existing node keeps the value it was created with.</param>
+    void EnsureVariable(string variableNodeId, string? parentFolderNodeId, string displayName, string dataType, bool writable, AddressSpaceRealm realm, string? historianTagname = null, bool isArray = false, uint? arrayLength = null, bool refuseArrayOnScalar = false);

    /// <summary>
    ///     Tear down + repopulate the address space. Called by <c>OpcUaPublishActor</c> after a
@@ -273,7 +278,7 @@ public sealed class NullOpcUaAddressSpaceSink : IOpcUaAddressSpaceSink
    public void EnsureFolder(string folderNodeId, string? parentNodeId, string displayName, AddressSpaceRealm realm) { }

    /// <inheritdoc />
-    public void EnsureVariable(string variableNodeId, string? parentFolderNodeId, string displayName, string dataType, bool writable, AddressSpaceRealm realm, string? historianTagname = null, bool isArray = false, uint? arrayLength = null) { }
+    public void EnsureVariable(string variableNodeId, string? parentFolderNodeId, string displayName, string dataType, bool writable, AddressSpaceRealm realm, string? historianTagname = null, bool isArray = false, uint? arrayLength = null, bool refuseArrayOnScalar = false) { }

    /// <inheritdoc />
    public void RebuildAddressSpace() { }
@@ -124,6 +124,26 @@ public static class DriverArrayWriteSupport
        }
    }

+    /// <summary>
+    ///     Gitea #610 review (R6 MINOR-1) — whether a driver of <paramref name="driverType"/> is known to REFUSE an
+    ///     array value written to one of its SCALAR tags, so the node manager may refuse such a write inline
+    ///     (<c>BadTypeMismatch</c>, nothing dispatched) instead of storing it optimistically, dispatching it, and
+    ///     reverting it when the scalar encoder throws.
+    ///     <para>
+    ///         Only Modbus and S7 qualify: their scalar encoders <c>Convert.ToXxx</c> the value, which throws on an
+    ///         array. Every other driver keeps the pre-#610 behaviour — the write is dispatched and the driver
+    ///         decides. That matters for the pass-through drivers: a browse-committed array attribute is committed
+    ///         as a SCALAR tag (the <c>/raw</c> commit never sets <c>isArray</c>), the driver publishes an array into
+    ///         it, and writing that array back worked before #610 — <c>OpcUaClient</c> forwards the
+    ///         <c>Variant</c> unchanged (the upstream server arbitrates shape) and Galaxy's <c>MxValueEncoder</c>
+    ///         encodes the array. An unknown / null driver type is not listed ⇒ <see langword="false"/>.
+    ///     </para>
+    /// </summary>
+    /// <param name="driverType">The owning driver instance's <c>DriverType</c>.</param>
+    /// <returns><see langword="true"/> only when the driver's scalar write path cannot take an array value.</returns>
+    public static bool RefusesArrayValueOnScalarTag(string? driverType) =>
+        driverType is DriverTypeNames.Modbus or DriverTypeNames.S7;
+
    // The smallest Modbus write cap configured in any config; none configured (absent / non-positive) ⇒ the driver
    // default (123). The key is matched case-insensitively, like the driver's DTO binding.
    private static int ModbusMaxRegistersPerWrite(string?[]? driverConfigs)