feat(grpc): tool the WCF-only config ops over the gRPC transport

Wire the config operations that previously only worked over WCF onto RemoteGrpc, reusing the proven 2020 byte serializers verbatim inside the protobuf bytes fields (keyed by the Open2 session handle). Live-verified against a real 2023 R2 server where noted. Read ops (live-verified): - GetRuntimeParameterAsync -> StatusService.GetRuntimeParameter (GETRP serializer) - GetTagExtendedPropertiesAsync -> RetrievalService.GetTagExtendedPropertiesFromName (GetTepByNm serializer + sequence paging; page-0 FillBufferFromVector is the benign no-data terminator, matched to the WCF break-and-return-empty semantics) Server-walled (bounded with captured evidence): - ExecuteSqlCommandAsync -> RetrievalService.ExecuteSqlCommand. The request rides the RPC but the server-side CSrvDbConnection.ExecuteSqlCommand faults (IndexOutOfRange / native err 38) on a DB-connection precondition the pure managed gRPC session doesn't establish (same class as OpenStorageConnection). Surfaced as ProtocolEvidenceMissingException. Write ops (tooled + routed, sandbox-gated — not run destructively live): - EnsureTagAsync / DeleteTagAsync / RenameTagsAsync / AddTagExtendedPropertiesAsync via HistoryService.EnsureTags / DeleteTags / StartJob / AddTagExtendedProperties on a write-enabled (0x401) session, reusing the WCF golden serializers. The WCF priming discovery-dance is omitted (the M3 gRPC write probe worked without it); add it first if a live sandbox run is rejected. Routed in Historian2020ProtocolDialect / HistorianClient on the RemoteGrpc branch. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01B6mcaT2PjRFKcogzp9UkfC
2026-06-22 01:26:33 -04:00
parent 035d8a92f2
commit ef68016c7a
6 changed files with 448 additions and 7 deletions
@@ -0,0 +1,114 @@
+using Google.Protobuf;
+using AVEVA.Historian.Client.Models;
+using AVEVA.Historian.Client.Protocol;
+using AVEVA.Historian.Client.Wcf;
+using GrpcRetrieval = ArchestrA.Grpc.Contract.Retrieval;
+
+namespace AVEVA.Historian.Client.Grpc;
+
+/// <summary>
+/// Executes SQL commands over the 2023 R2 gRPC transport (HCAL R1.1), mirroring
+/// <see cref="HistorianWcfSqlClient"/>'s two-op <c>ExeC</c>/<c>GetR</c> flow. The 2020 WCF path uses a
+/// dedicated <c>GetRecordSetByteStream</c> op; the gRPC front door has no such RPC, so the NRBF
+/// recordset stream would be fetched through the generic <c>RetrievalService.GetNextQueryResultBuffer</c>
+/// keyed by the query handle <c>ExecuteSqlCommand</c> returns. <c>ExecuteSqlCommand</c> takes the
+/// uppercase string session handle; the result-buffer fetch takes the transient <c>uint</c> client
+/// handle (both come from the one Open2 session).
+/// <para>
+/// <b>SERVER-WALLED (captured 2026-06-22).</b> The 2023 R2 front-door
+/// <c>RetrievalService.ExecuteSqlCommand</c> faults server-side before returning a query handle:
+/// the response carries native error 38 wrapping a managed
+/// <c>System.IndexOutOfRangeException ... at aahClientAccessPoint.CSrvDbConnection.ExecuteSqlCommand</c>.
+/// This is a server-side <c>CSrvDbConnection</c> (SQL DB-connection) precondition that the pure
+/// managed gRPC session does not establish — the same class of wall as
+/// <c>StorageService.OpenStorageConnection</c> (whose real precondition is the front-door
+/// <c>HistoryService.RegisterTags</c> family). Priming <c>Retr.GetV</c> does not clear it. The request
+/// framing here is the captured/expected shape; the op stays bounded behind
+/// <see cref="ProtocolEvidenceMissingException"/> until the DB-connection registration is reproduced.
+/// </para>
+/// </summary>
+internal static class HistorianGrpcSqlClient
+{
+    // GetNextQueryResultBuffer is byte-stream-paged; a small record set returns in one page. Runaway guard.
+    private const int MaxPages = 4096;
+
+    public static Task<HistorianSqlResult> ExecuteSqlCommandAsync(
+        HistorianClientOptions options,
+        string command,
+        HistorianSqlExecuteOption option,
+        CancellationToken cancellationToken)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(command);
+        return Task.Run(() => ExecuteSqlCommand(options, command, option, cancellationToken), cancellationToken);
+    }
+
+    private static HistorianSqlResult ExecuteSqlCommand(
+        HistorianClientOptions options,
+        string command,
+        HistorianSqlExecuteOption option,
+        CancellationToken cancellationToken)
+    {
+        using HistorianGrpcConnection connection = HistorianGrpcChannelFactory.Create(options);
+        HistorianGrpcHandshake.Session session = HistorianGrpcHandshake.OpenSession(connection, options, cancellationToken);
+        var retrievalClient = new GrpcRetrieval.RetrievalService.RetrievalServiceClient(connection.Channel);
+        DateTime Deadline() => DateTime.UtcNow.Add(options.RequestTimeout);
+
+        // Prime the Retrieval service version handshake (Retr.GetV) before the string-handle SQL op, as
+        // the native WCF SQL path does — the server-side ExecuteSqlCommand otherwise faults.
+        retrievalClient.GetRetrievalInterfaceVersion(
+            new GrpcRetrieval.GetRetrievalInterfaceVersionRequest(), connection.Metadata, Deadline(), cancellationToken);
+
+        GrpcRetrieval.ExecuteSqlCommandResponse exec = retrievalClient.ExecuteSqlCommand(
+            new GrpcRetrieval.ExecuteSqlCommandRequest
+            {
+                StrHandle = session.StringHandle,
+                StrCommand = command,
+                UiOption = (uint)option,
+                UiQueryHandle = 0
+            },
+            connection.Metadata,
+            Deadline(),
+            cancellationToken);
+
+        if (!(exec.Status?.BSuccess ?? false))
+        {
+            // Captured 2026-06-22: the server-side CSrvDbConnection.ExecuteSqlCommand throws
+            // IndexOutOfRange (native error 38) — a DB-connection precondition the pure managed gRPC
+            // session doesn't establish. Surface the SDK's evidence-missing signal rather than a raw
+            // server fault. See the class remarks.
+            throw new ProtocolEvidenceMissingException(
+                "ExecuteSqlCommand over gRPC: server-side CSrvDbConnection.ExecuteSqlCommand faults " +
+                "(IndexOutOfRange / native error 38) — an unmet DB-connection precondition (gRPC transport). Use WCF.");
+        }
+
+        int returnValue = exec.IRetValue;
+        uint queryHandle = exec.UiQueryHandle;
+
+        using MemoryStream accumulated = new();
+        for (int page = 0; page < MaxPages; page++)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            GrpcRetrieval.GetNextQueryResultBufferResponse buffer = retrievalClient.GetNextQueryResultBuffer(
+                new GrpcRetrieval.GetNextQueryResultBufferRequest { UiHandle = session.ClientHandle, UiQueryHandle = queryHandle },
+                connection.Metadata,
+                Deadline(),
+                cancellationToken);
+
+            byte[] resultBuffer = buffer.BtQueryResult?.ToByteArray() ?? [];
+
+            // GetR is false-even-on-success: the final page returns false with the data still in the
+            // buffer, so always consume the buffer first, then stop on a false status or an empty page.
+            if (resultBuffer.Length > 0)
+            {
+                accumulated.Write(resultBuffer, 0, resultBuffer.Length);
+            }
+
+            if (!(buffer.Status?.BSuccess ?? false) || resultBuffer.Length == 0)
+            {
+                break;
+            }
+        }
+
+        return HistorianSqlResultProtocol.Parse(accumulated.ToArray(), returnValue);
+    }
+}