Extract historian into a runtime-loaded plugin so hosts without the Wonderware SDK can run with Historian.Enabled=false

The aahClientManaged SDK is now isolated in ZB.MOM.WW.LmxOpcUa.Historian.Aveva and loaded via HistorianPluginLoader from a Historian/ subfolder only when enabled, removing the SDK from Host's compile-time and deploy-time surface.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

src/ZB.MOM.WW.LmxOpcUa.Host/Historian/HistorianPluginLoader.cs

@@ -0,0 +1,114 @@
+using System;
+using System.IO;
+using System.Reflection;
+using Serilog;
+using ZB.MOM.WW.LmxOpcUa.Host.Configuration;
+
+namespace ZB.MOM.WW.LmxOpcUa.Host.Historian
+{
+    /// <summary>
+    ///     Loads the Wonderware historian plugin assembly from the Historian/ subfolder next to
+    ///     the host executable. Used so the aahClientManaged SDK is not needed on hosts that run
+    ///     with Historian.Enabled=false.
+    /// </summary>
+    public static class HistorianPluginLoader
+    {
+        private const string PluginSubfolder = "Historian";
+        private const string PluginAssemblyName = "ZB.MOM.WW.LmxOpcUa.Historian.Aveva";
+        private const string PluginEntryType = "ZB.MOM.WW.LmxOpcUa.Historian.Aveva.AvevaHistorianPluginEntry";
+        private const string PluginEntryMethod = "Create";
+
+        private static readonly ILogger Log = Serilog.Log.ForContext(typeof(HistorianPluginLoader));
+        private static readonly object ResolverGate = new object();
+        private static bool _resolverInstalled;
+        private static string? _resolvedProbeDirectory;
+
+        /// <summary>
+        ///     Attempts to load the historian plugin and construct an <see cref="IHistorianDataSource"/>.
+        ///     Returns null on any failure so the server can continue with history unsupported.
+        /// </summary>
+        public static IHistorianDataSource? TryLoad(HistorianConfiguration config)
+        {
+            var pluginDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, PluginSubfolder);
+            var pluginPath = Path.Combine(pluginDirectory, PluginAssemblyName + ".dll");
+
+            if (!File.Exists(pluginPath))
+            {
+                Log.Warning(
+                    "Historian plugin not found at {PluginPath} — history read operations will return BadHistoryOperationUnsupported",
+                    pluginPath);
+                return null;
+            }
+
+            EnsureAssemblyResolverInstalled(pluginDirectory);
+
+            try
+            {
+                var assembly = Assembly.LoadFrom(pluginPath);
+                var entryType = assembly.GetType(PluginEntryType, throwOnError: false);
+                if (entryType == null)
+                {
+                    Log.Warning("Historian plugin {PluginPath} does not expose {EntryType}", pluginPath, PluginEntryType);
+                    return null;
+                }
+
+                var create = entryType.GetMethod(PluginEntryMethod, BindingFlags.Public | BindingFlags.Static);
+                if (create == null)
+                {
+                    Log.Warning("Historian plugin entry type {EntryType} missing static {Method}", PluginEntryType, PluginEntryMethod);
+                    return null;
+                }
+
+                var result = create.Invoke(null, new object[] { config });
+                if (result is IHistorianDataSource dataSource)
+                {
+                    Log.Information("Historian plugin loaded from {PluginPath}", pluginPath);
+                    return dataSource;
+                }
+
+                Log.Warning("Historian plugin {PluginPath} returned an object that does not implement IHistorianDataSource", pluginPath);
+                return null;
+            }
+            catch (Exception ex)
+            {
+                Log.Warning(ex, "Failed to load historian plugin from {PluginPath} — history disabled", pluginPath);
+                return null;
+            }
+        }
+
+        private static void EnsureAssemblyResolverInstalled(string pluginDirectory)
+        {
+            lock (ResolverGate)
+            {
+                _resolvedProbeDirectory = pluginDirectory;
+                if (_resolverInstalled)
+                    return;
+
+                AppDomain.CurrentDomain.AssemblyResolve += ResolveFromPluginDirectory;
+                _resolverInstalled = true;
+            }
+        }
+
+        private static Assembly? ResolveFromPluginDirectory(object? sender, ResolveEventArgs args)
+        {
+            var probeDirectory = _resolvedProbeDirectory;
+            if (string.IsNullOrEmpty(probeDirectory))
+                return null;
+
+            var requested = new AssemblyName(args.Name);
+            var candidate = Path.Combine(probeDirectory!, requested.Name + ".dll");
+            if (!File.Exists(candidate))
+                return null;
+
+            try
+            {
+                return Assembly.LoadFrom(candidate);
+            }
+            catch (Exception ex)
+            {
+                Log.Debug(ex, "Historian plugin resolver failed to load {Candidate}", candidate);
+                return null;
+            }
+        }
+    }
+}