histsdk/tests/AVEVA.Historian.Client.Tests/StringHandleProbeDiagnosticTests.cs

using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Text;
using System.Runtime.Versioning;
using AVEVA.Historian.Client.Wcf;
using AVEVA.Historian.Client.Wcf.Contracts;
using Xunit.Abstractions;

namespace AVEVA.Historian.Client.Tests;

/// <summary>
/// Diagnostic: retest the "string-handle wall" ops (GETHI / ExeC) using the Open2
/// storage-session GUID formatted UPPERCASE (the format the native client sends, and the
/// one that made GETRP punch through). Not an assertion test — it prints the server's
/// return code / buffer lengths so we can judge whether the wall is a handle-format issue.
/// </summary>
[SupportedOSPlatform("windows")]
public sealed class StringHandleProbeDiagnosticTests
{
    private readonly ITestOutputHelper _output;

    public StringHandleProbeDiagnosticTests(ITestOutputHelper output)
    {
        _output = output;
    }

    private static bool ShouldRun(out string host)
    {
        host = Environment.GetEnvironmentVariable("HISTORIAN_HOST") ?? string.Empty;
        return !string.IsNullOrWhiteSpace(host)
            && string.Equals(host, "localhost", StringComparison.OrdinalIgnoreCase)
            && OperatingSystem.IsWindows();
    }

    [Fact]
    public void GETHI_WithUppercaseStorageGuid_AgainstLocalHistorian()
    {
        if (!ShouldRun(out string host)) return;

        HistorianClientOptions options = new()
        {
            Host = host,
            IntegratedSecurity = true,
            Transport = HistorianTransport.LocalPipe
        };

        // Native GETHI pRequestBuff: 53 67 02 00 (sig 0x6753 + version 2) + uint charCount + UTF-16 name.
        const string name = "HistorianVersion";
        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[] requestBuffer = ms.ToArray();

        ProbeOnStatusChannel(options, (channel, handle) =>
        {
            bool ok = channel.GetHistorianInfo(handle, requestBuffer, out byte[] resp, out byte[] err);
            _output.WriteLine($"GETHI returned={ok} respLen={resp?.Length ?? 0} errLen={err?.Length ?? 0}");
            if (resp is { Length: > 0 })
            {
                _output.WriteLine("  resp[0..64]=" + Convert.ToHexString(resp.AsSpan(0, Math.Min(64, resp.Length))));
            }
        });
    }

    /// <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()
    {
        if (!ShouldRun(out string host)) return;

        HistorianClientOptions options = new()
        {
            Host = host,
            IntegratedSecurity = true,
            Transport = HistorianTransport.LocalPipe
        };

        Guid contextKey = Guid.NewGuid();
        var (histBinding, histEndpoint, retrBinding, retrEndpoint) = HistorianWcfBindingFactory.CreateBindingPair(options);

        HistorianWcfAuthChainHelper.OpenAuthenticatedConnection(
            options, histBinding, histEndpoint, contextKey, CancellationToken.None,
            additionalSetup: (_, context) =>
            {
                string handle = context.StorageSessionId.ToString("D").ToUpperInvariant();
                ChannelFactory<IRetrievalServiceContract3> factory = new(retrBinding, retrEndpoint);
                HistorianWcfClientCredentialsHelper.Configure(factory, options);
                IRetrievalServiceContract3 channel = factory.CreateChannel();
                ICommunicationObject co = (ICommunicationObject)channel;
                try
                {
                    // Prime the Retr service version handshake (Retr.GetV), as the native client does.
                    channel.GetInterfaceVersion(out uint retrVersion);
                    _output.WriteLine($"Retr.GetV version={retrVersion}");

                    uint queryHandle = 0;
                    bool execOk = channel.ExecuteSqlCommand(
                        handle, "SELECT 1 AS ProbeValue", 0u, ref queryHandle,
                        out int retValue, out uint errSize, out byte[] errBuf);
                    _output.WriteLine($"ExeC returned={execOk} retValue={retValue} queryHandle={queryHandle} errSize={errSize} errLen={errBuf?.Length ?? 0}");

                    if (execOk)
                    {
                        uint sequence = 0;
                        bool getrOk = channel.GetRecordSetByteStream(
                            handle, queryHandle, ref sequence,
                            out uint resultSize, out byte[] resultBuf, out uint gErrSize, out byte[] gErrBuf);
                        _output.WriteLine($"GetR returned={getrOk} resultSize={resultSize} resultLen={resultBuf?.Length ?? 0} sequence={sequence}");
                        if (resultBuf is { Length: > 0 })
                        {
                            _output.WriteLine("  result[0..96]=" + Convert.ToHexString(resultBuf.AsSpan(0, Math.Min(96, resultBuf.Length))));
                        }
                    }
                }
                finally
                {
                    try { if (co.State == CommunicationState.Faulted) co.Abort(); else co.Close(); } catch { try { co.Abort(); } catch { } }
                    try { if (factory.State == CommunicationState.Faulted) factory.Abort(); else factory.Close(); } catch { try { factory.Abort(); } catch { } }
                }
            });
    }

    private static void ProbeOnStatusChannel(HistorianClientOptions options, Action<IStatusServiceContract2, string> probe)
    {
        Guid contextKey = Guid.NewGuid();
        var (histBinding, histEndpoint, _, _) = HistorianWcfBindingFactory.CreateBindingPair(options);
        Binding statusBinding = HistorianWcfBindingFactory.CreateAuxiliaryBinding(options);
        EndpointAddress statusEndpoint = HistorianWcfBindingFactory.CreateAuxiliaryEndpointAddress(options, HistorianWcfServiceNames.Status);

        HistorianWcfAuthChainHelper.OpenAuthenticatedConnection(
            options, histBinding, histEndpoint, contextKey, CancellationToken.None,
            additionalSetup: (_, context) =>
            {
                string handle = context.StorageSessionId.ToString("D").ToUpperInvariant();
                ChannelFactory<IStatusServiceContract2> factory = new(statusBinding, statusEndpoint);
                IStatusServiceContract2 channel = factory.CreateChannel();
                ICommunicationObject co = (ICommunicationObject)channel;
                try
                {
                    probe(channel, handle);
                }
                catch (Exception ex)
                {
                    throw new InvalidOperationException($"probe raised: {ex.GetType().Name}: {ex.Message}", ex);
                }
                finally
                {
                    try { if (co.State == CommunicationState.Faulted) co.Abort(); else co.Close(); } catch { try { co.Abort(); } catch { } }
                    try { if (factory.State == CommunicationState.Faulted) factory.Abort(); else factory.Close(); } catch { try { factory.Abort(); } catch { } }
                }
            });
    }
}