chore: organize solution into module folders (Core/Server/Drivers/Client/Tooling)

Group all 69 projects into category subfolders under src/ and tests/ so the Rider Solution Explorer mirrors the module structure. Folders: Core, Server, Drivers (with a nested Driver CLIs subfolder), Client, Tooling. - Move every project folder on disk with git mv (history preserved as renames). - Recompute relative paths in 57 .csproj files: cross-category ProjectReferences, the lib/ HintPath+None refs in Driver.Historian.Wonderware, and the external mxaccessgw refs in Driver.Galaxy and its test project. - Rebuild ZB.MOM.WW.OtOpcUa.slnx with nested solution folders. - Re-prefix project paths in functional scripts (e2e, compliance, smoke SQL, integration, install). Build green (0 errors); unit tests pass. Docs left for a separate pass. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-17 01:55:28 -04:00
parent 69f02fed7f
commit a25593a9c6
1044 changed files with 365 additions and 343 deletions
@@ -0,0 +1,86 @@
+using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
+
+namespace ZB.MOM.WW.OtOpcUa.Core.Hosting;
+
+/// <summary>
+///     Process-singleton registry of <see cref="IDriver"/> factories keyed by
+///     <c>DriverInstance.DriverType</c> string. Each driver project ships a DI
+///     extension (e.g. <c>services.AddGalaxyProxyDriverFactory()</c>) that registers
+///     its factory at startup; the bootstrapper looks up the factory by
+///     <c>DriverInstance.DriverType</c> + invokes it with the row's
+///     <c>DriverInstanceId</c> + <c>DriverConfig</c> JSON.
+/// </summary>
+/// <remarks>
+///     Closes the gap surfaced by task #240 live smoke — DriverInstance rows in
+///     the central config DB had no path to materialise as registered <see cref="IDriver"/>
+///     instances. The factory registry is the seam.
+/// </remarks>
+public sealed class DriverFactoryRegistry
+{
+    private readonly Dictionary<string, Func<string, string, IDriver>> _factories
+        = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, DriverTier> _tiers
+        = new(StringComparer.OrdinalIgnoreCase);
+    private readonly object _lock = new();
+
+    /// <summary>
+    ///     Register a factory for <paramref name="driverType"/>. Throws if a factory is
+    ///     already registered for that type — drivers are singletons by type-name in
+    ///     this process.
+    /// </summary>
+    /// <param name="driverType">Matches <c>DriverInstance.DriverType</c>.</param>
+    /// <param name="factory">
+    ///     Receives <c>(driverInstanceId, driverConfigJson)</c>; returns a new
+    ///     <see cref="IDriver"/>. Must NOT call <see cref="IDriver.InitializeAsync"/>
+    ///     itself — the bootstrapper calls it via <see cref="DriverHost.RegisterAsync"/>
+    ///     so the host's per-driver retry semantics apply uniformly.
+    /// </param>
+    /// <param name="tier">
+    ///     Stability tier per <c>docs/v2/driver-stability.md</c>. Defaults to
+    ///     <see cref="DriverTier.A"/> (in-process, lowest recycle footprint); Tier C
+    ///     drivers SHOULD pass this explicitly so the scheduled-recycle wiring in
+    ///     <c>DriverInstanceBootstrapper</c> can skip in-process drivers by tier check
+    ///     rather than by driver-type allow-list.
+    /// </param>
+    public void Register(string driverType, Func<string, string, IDriver> factory,
+        DriverTier tier = DriverTier.A)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(driverType);
+        ArgumentNullException.ThrowIfNull(factory);
+        lock (_lock)
+        {
+            if (_factories.ContainsKey(driverType))
+                throw new InvalidOperationException(
+                    $"DriverType '{driverType}' factory already registered for this process");
+            _factories[driverType] = factory;
+            _tiers[driverType] = tier;
+        }
+    }
+
+    /// <summary>
+    ///     Try to look up the factory for <paramref name="driverType"/>. Returns null
+    ///     if no driver assembly registered one — bootstrapper logs + skips so a
+    ///     missing-assembly deployment doesn't take down the whole server.
+    /// </summary>
+    public Func<string, string, IDriver>? TryGet(string driverType)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(driverType);
+        lock (_lock) return _factories.GetValueOrDefault(driverType);
+    }
+
+    /// <summary>
+    ///     Look up the tier recorded alongside the factory. Returns <see cref="DriverTier.A"/>
+    ///     for unknown driver types — a missing registration is already a skipped-bootstrap
+    ///     case upstream; we don't double-surface that failure here.
+    /// </summary>
+    public DriverTier GetTier(string driverType)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(driverType);
+        lock (_lock) return _tiers.GetValueOrDefault(driverType, DriverTier.A);
+    }
+
+    public IReadOnlyCollection<string> RegisteredTypes
+    {
+        get { lock (_lock) return [.. _factories.Keys]; }
+    }
+}
@@ -0,0 +1,91 @@
+using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
+
+namespace ZB.MOM.WW.OtOpcUa.Core.Hosting;
+
+/// <summary>
+///     Process-local registry + lifecycle manager for loaded <see cref="IDriver"/> instances
+///     (decision #65). Phase 1 scaffold — per-process isolation for Tier C drivers (Galaxy, FOCAS)
+///     is implemented in Phase 2 via named-pipe RPC; this class handles in-process drivers today
+///     and exposes the same registration interface so the Tier C wrapper can slot in later.
+/// </summary>
+public sealed class DriverHost : IAsyncDisposable
+{
+    private readonly Dictionary<string, IDriver> _drivers = new();
+    private readonly object _lock = new();
+
+    public IReadOnlyCollection<string> RegisteredDriverIds
+    {
+        get { lock (_lock) return [.. _drivers.Keys]; }
+    }
+
+    public DriverHealth? GetHealth(string driverInstanceId)
+    {
+        lock (_lock)
+            return _drivers.TryGetValue(driverInstanceId, out var d) ? d.GetHealth() : null;
+    }
+
+    /// <summary>
+    ///     Look up a registered driver by instance id. Used by the OPC UA server runtime
+    ///     (<c>OtOpcUaServer</c>) to instantiate one <c>DriverNodeManager</c> per driver at
+    ///     startup. Returns null when the driver is not registered.
+    /// </summary>
+    public IDriver? GetDriver(string driverInstanceId)
+    {
+        lock (_lock)
+            return _drivers.TryGetValue(driverInstanceId, out var d) ? d : null;
+    }
+
+    /// <summary>
+    ///     Registers the driver and calls <see cref="IDriver.InitializeAsync"/>. If initialization
+    ///     throws, the driver is kept in the registry so the operator can retry; quality on its
+    ///     nodes will reflect <see cref="DriverState.Faulted"/> until <c>Reinitialize</c> succeeds.
+    /// </summary>
+    public async Task RegisterAsync(IDriver driver, string driverConfigJson, CancellationToken ct)
+    {
+        ArgumentNullException.ThrowIfNull(driver);
+        var id = driver.DriverInstanceId;
+
+        lock (_lock)
+        {
+            if (_drivers.ContainsKey(id))
+                throw new InvalidOperationException($"Driver '{id}' is already registered.");
+            _drivers[id] = driver;
+        }
+
+        try { await driver.InitializeAsync(driverConfigJson, ct); }
+        catch
+        {
+            // Keep the driver registered — operator will see Faulted state and can reinitialize.
+            throw;
+        }
+    }
+
+    public async Task UnregisterAsync(string driverInstanceId, CancellationToken ct)
+    {
+        IDriver? driver;
+        lock (_lock)
+        {
+            if (!_drivers.TryGetValue(driverInstanceId, out driver)) return;
+            _drivers.Remove(driverInstanceId);
+        }
+
+        try { await driver.ShutdownAsync(ct); }
+        catch { /* shutdown is best-effort; logs elsewhere */ }
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        List<IDriver> snapshot;
+        lock (_lock)
+        {
+            snapshot = [.. _drivers.Values];
+            _drivers.Clear();
+        }
+
+        foreach (var driver in snapshot)
+        {
+            try { await driver.ShutdownAsync(CancellationToken.None); } catch { /* ignore */ }
+            (driver as IDisposable)?.Dispose();
+        }
+    }
+}