Merge re/r1.4-gethi-finding: R1.1 ExecuteSqlCommand + R1.4 GetHistorianInfo (bounded)

# Conflicts: # docs/plans/hcal-roadmap.md # src/AVEVA.Historian.Client/HistorianClient.cs # src/AVEVA.Historian.Client/Protocol/Historian2020ProtocolDialect.cs # tests/AVEVA.Historian.Client.Tests/HistorianClientIntegrationTests.cs # tools/AVEVA.Historian.NativeTraceHarness/Program.cs
2026-06-21 16:18:01 -04:00
parent c1b1b3d23b fbd839077b
commit 4de222c950
19 changed files with 1118 additions and 14 deletions
@@ -66,6 +66,80 @@ public sealed class StringHandleProbeDiagnosticTests
        });
    }

+    /// <summary>
+    /// R1.4 probe: GETHI on 2020 WCF is a named-value query (capture showed the native client
+    /// only ever asks for "HistorianVersion"; the 518-byte struct + EventStorageMode@514 is the
+    /// 2023R2 HCAL-native/gRPC model). This probes whether the 2020 server exposes any
+    /// storage-mode / extended info value through GETHI under other parameter names, so we can
+    /// decide honestly what GetHistorianInfoAsync can return over WCF.
+    /// </summary>
+    [Fact]
+    public void GETHI_CandidateInfoNames_AgainstLocalHistorian()
+    {
+        if (!ShouldRun(out string host)) return;
+
+        HistorianClientOptions options = new()
+        {
+            Host = host,
+            IntegratedSecurity = true,
+            Transport = HistorianTransport.LocalPipe
+        };
+
+        string[] candidates =
+        {
+            "HistorianVersion", "EventStorageMode", "EventStorageType", "StorageType",
+            "HistorianEventStorageMode", "EventStorage", "StorageMode", "HistorianInfo",
+        };
+
+        Dictionary<string, (bool ok, int respLen)> results = new();
+        ProbeOnStatusChannel(options, (channel, handle) =>
+        {
+            foreach (string name in candidates)
+            {
+                using MemoryStream ms = new();
+                using (BinaryWriter w = new(ms, Encoding.Unicode, leaveOpen: true))
+                {
+                    w.Write(new byte[] { 0x53, 0x67, 0x02, 0x00 });
+                    w.Write((uint)name.Length);
+                    w.Write(Encoding.Unicode.GetBytes(name));
+                }
+                byte[] req = ms.ToArray();
+                byte[]? resp = null;
+                byte[]? err = null;
+                bool ok;
+                try
+                {
+                    ok = channel.GetHistorianInfo(handle, req, out resp, out err);
+                }
+                catch (Exception ex)
+                {
+                    _output.WriteLine($"  {name,-26} EXCEPTION {ex.GetType().Name}: {ex.Message}");
+                    results[name] = (false, -1);
+                    continue;
+                }
+                string respHex = resp is { Length: > 0 }
+                    ? Convert.ToHexString(resp.AsSpan(0, Math.Min(48, resp.Length)))
+                    : "(empty)";
+                _output.WriteLine($"  {name,-26} ok={ok} respLen={resp?.Length ?? 0} errLen={err?.Length ?? 0} resp={respHex}");
+                results[name] = (ok, resp?.Length ?? 0);
+            }
+        });
+
+        // Locked finding (2026-06-20): on 2020 WCF, GETHI is a named-value query whose only
+        // working key is HistorianVersion. No storage-mode key is honored — EventStorageMode is
+        // not on the 2020 WCF wire (it is the 2023R2 HCAL-native/gRPC 518-byte-struct path).
+        Assert.True(results["HistorianVersion"].ok);
+        Assert.True(results["HistorianVersion"].respLen > 0);
+        foreach (string storageName in new[]
+                 {
+                     "EventStorageMode", "EventStorageType", "StorageType",
+                     "HistorianEventStorageMode", "EventStorage", "StorageMode",
+                 })
+        {
+            Assert.False(results[storageName].ok, $"unexpected: GETHI honored '{storageName}'");
+        }
+    }
+
    [Fact]
    public void ExeC_WithUppercaseStorageGuid_AgainstLocalHistorian()
    {