feat(historian-gateway): alarm-write cutover — AddAlarmHistorian drains to GatewayAlarmHistorianWriter

Claude-Session: https://claude.ai/code/session_012SDSQ3AcaXqPcBtDESBRii

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Historian.Gateway/GatewayHistorianServiceCollectionExtensions.cs

@@ -2,16 +2,17 @@ using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
+using ZB.MOM.WW.OtOpcUa.Core.AlarmHistorian;
 using ZB.MOM.WW.OtOpcUa.Runtime.Historian;
 
 namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Gateway;
 
 /// <summary>
-///     Host-callable factory that builds the gateway-backed server-side HistoryRead data source. The
+///     Host-callable factories that build the gateway-backed historian seams against the single
-///     Host's <c>AddServerHistorian</c> wiring supplies <see cref="CreateDataSource"/> as its
+///     <c>ServerHistorian</c> gateway: <see cref="CreateDataSource"/> for the read path (the Host's
-///     <c>Func&lt;ServerHistorianOptions, IServiceProvider, IHistorianDataSource&gt;</c>, keeping the
+///     <c>AddServerHistorian</c> wiring) and <see cref="CreateAlarmWriter"/> for the alarm-write path
-///     concrete package-client dependency inside this driver project (the Host references only the
+///     (the Host's <c>AddAlarmHistorian</c> wiring). Both keep the concrete package-client dependency
-///     driver, not the package client directly).
+///     inside this driver project — the Host references only the driver, not the package client directly.
 /// </summary>
 public static class GatewayHistorian
 {
@@ -39,4 +40,42 @@ public static class GatewayHistorian
             HistorianGatewayClientAdapter.Create(options, loggerFactory),
             logger);
     }
+
+    /// <summary>
+    ///     Builds a <see cref="GatewayAlarmHistorianWriter"/> over a lazily connected
+    ///     <see cref="HistorianGatewayClientAdapter"/> mapped from the bound
+    ///     <see cref="ServerHistorianOptions"/> — the <b>same single gateway</b> the read path
+    ///     (<see cref="CreateDataSource"/>) targets. The Host's <c>AddAlarmHistorian</c> wiring supplies
+    ///     this as the concrete <see cref="IAlarmHistorianWriter"/> the durable
+    ///     <c>SqliteStoreAndForwardSink</c> drain worker delegates to, sourcing the connection from the
+    ///     <c>ServerHistorian</c> section (endpoint/key/TLS) rather than the legacy Wonderware-shaped
+    ///     <c>AlarmHistorian</c> host/port. Resolves an <see cref="ILoggerFactory"/> and the writer's
+    ///     <see cref="ILogger{TCategoryName}"/> from <paramref name="services"/>, falling back to the null
+    ///     implementations when absent. Performs no network I/O — the underlying channel dials on first send.
+    /// </summary>
+    /// <remarks>
+    ///     This deliberately constructs its <b>own</b> <see cref="HistorianGatewayClientAdapter"/> — a
+    ///     second gRPC channel to the same gateway as the read path. Collapsing the two onto one shared
+    ///     channel would require the container to own a singleton <see cref="IHistorianGatewayClient"/> and
+    ///     the read-side <see cref="GatewayHistorianDataSource"/> to stop owning + disposing its client,
+    ///     regressing the read cutover's dispose ownership (and its tests). A second channel to a co-located
+    ///     sidecar is cheap — the gateway pools and amortizes the underlying historian sessions server-side —
+    ///     so each path keeps its own channel with a clean, independent lifetime.
+    /// </remarks>
+    /// <param name="options">The bound <c>ServerHistorian</c> configuration (endpoint, key, TLS posture).</param>
+    /// <param name="services">The resolving service provider (used only to locate logging services).</param>
+    /// <returns>The gateway-backed <see cref="IAlarmHistorianWriter"/>.</returns>
+    public static IAlarmHistorianWriter CreateAlarmWriter(ServerHistorianOptions options, IServiceProvider services)
+    {
+        ArgumentNullException.ThrowIfNull(options);
+        ArgumentNullException.ThrowIfNull(services);
+
+        var loggerFactory = services.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance;
+        var logger = services.GetService<ILogger<GatewayAlarmHistorianWriter>>()
+            ?? NullLogger<GatewayAlarmHistorianWriter>.Instance;
+
+        return new GatewayAlarmHistorianWriter(
+            HistorianGatewayClientAdapter.Create(options, loggerFactory),
+            logger);
+    }
 }

src/Server/ZB.MOM.WW.OtOpcUa.Host/Program.cs

@@ -23,7 +23,6 @@ using ZB.MOM.WW.OtOpcUa.Host.Logging;
 using ZB.MOM.WW.OtOpcUa.Host.Observability;
 using ZB.MOM.WW.OtOpcUa.Host.OpcUa;
 using ZB.MOM.WW.OtOpcUa.Driver.Historian.Gateway;
-using ZB.MOM.WW.OtOpcUa.Driver.Historian.Wonderware.Client;
 using ZB.MOM.WW.OtOpcUa.OpcUaServer;
 using ZB.MOM.WW.OtOpcUa.Runtime.Historian;
 using ZB.MOM.WW.OtOpcUa.Runtime.Scripting;
@@ -96,17 +95,23 @@ if (hasDriver)
 
     // Config-gated durable alarm-historian sink. When the AlarmHistorian section is enabled this
     // overrides the NullAlarmHistorianSink default from AddOtOpcUaRuntime (last registration wins)
-    // with a SqliteStoreAndForwardSink draining to the Wonderware TCP writer. The writer is
+    // with a SqliteStoreAndForwardSink draining to the gateway SendEvent writer. The alarm-write path
-    // injected here because the Host is the only project that references the Wonderware client —
+    // targets the SAME single gateway as the read path, so its connection (endpoint/key/TLS) is sourced
-    // Runtime owns the gating + Sqlite construction, the Host supplies the concrete downstream.
+    // from the ServerHistorian section — NOT the legacy Wonderware-shaped AlarmHistorian host/port.
+    // AlarmHistorianOptions still supplies the Enabled gate + the SQLite store-and-forward knobs
+    // (consumed inside AddAlarmHistorian), so its Wonderware connection fields are intentionally unused.
+    // Runtime owns the gating + Sqlite construction; the Host supplies the concrete gateway downstream
+    // via the driver factory (which owns the package-client adapter). The writer builds its OWN gateway
+    // channel — a second channel to the same sidecar: sharing one channel with the read path would force
+    // the read-side GatewayHistorianDataSource to stop owning + disposing its client (regressing the read
+    // cutover), and a second channel to a co-located sidecar is cheap (the gateway pools the historian
+    // sessions server-side).
+    var serverHistorianOptions = builder.Configuration
+        .GetSection(ServerHistorianOptions.SectionName).Get<ServerHistorianOptions>()
+        ?? new ServerHistorianOptions();
     builder.Services.AddAlarmHistorian(
         builder.Configuration,
-        (opts, sp) => new WonderwareHistorianClient(
+        (_, sp) => GatewayHistorian.CreateAlarmWriter(serverHistorianOptions, sp));
-            new WonderwareHistorianClientOptions(opts.Host, opts.Port, opts.SharedSecret)
-            {
-                UseTls = opts.UseTls, ServerCertThumbprint = opts.ServerCertThumbprint,
-            },
-            sp.GetService<ILogger<WonderwareHistorianClient>>()));
 
     // Config-gated server-side HistoryRead backend. When the ServerHistorian section is enabled this
     // overrides the NullHistorianDataSource default from AddOtOpcUaRuntime (last registration wins) with

tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Historian.Gateway.Tests/GatewayAlarmWriterFactoryTests.cs

@@ -0,0 +1,28 @@
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Core.AlarmHistorian;
+using ZB.MOM.WW.OtOpcUa.Runtime.Historian;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Gateway.Tests;
+
+/// <summary>
+/// Alarm-write cutover seam test (T13). The Host's <c>AddAlarmHistorian</c> wiring drains the durable
+/// <c>SqliteStoreAndForwardSink</c> through this factory, so it must yield the gateway-backed writer —
+/// sourcing the single gateway's connection from <see cref="ServerHistorianOptions"/> (endpoint/key/TLS),
+/// not the legacy Wonderware-shaped <c>AlarmHistorian</c> host/port. Built offline: the underlying
+/// channel dials lazily, so both the factory and the writer ctor perform no network I/O (a bogus,
+/// unreachable endpoint must construct without throwing or connecting).
+/// </summary>
+public sealed class GatewayAlarmWriterFactoryTests
+{
+    [Fact]
+    public void Factory_builds_GatewayAlarmHistorianWriter()
+    {
+        var opts = new ServerHistorianOptions { Enabled = true, Endpoint = "https://localhost:5222", ApiKey = "histgw_x_y" };
+        using var services = new ServiceCollection().BuildServiceProvider();
+
+        IAlarmHistorianWriter writer = GatewayHistorian.CreateAlarmWriter(opts, services);
+
+        Assert.IsType<GatewayAlarmHistorianWriter>(writer);
+    }
+}