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>
This commit is contained in:
Joseph Doherty
@@ -0,0 +1,247 @@
|
||||
using System.Net;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Hosting;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Observability;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Modbus;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Server.Observability;
|
||||
|
||||
/// <summary>
|
||||
/// Standalone <see cref="HttpListener"/> host for <c>/healthz</c> and <c>/readyz</c>
|
||||
/// separate from the OPC UA binding. Per <c>docs/v2/implementation/phase-6-1-resilience-
|
||||
/// and-observability.md</c> §Stream C.1.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Binds to <c>http://localhost:4841</c> by default — loopback avoids the Windows URL-ACL
|
||||
/// elevation requirement that binding to <c>http://+:4841</c> (wildcard) would impose.
|
||||
/// When a deployment needs remote probing, a reverse proxy or explicit netsh urlacl grant
|
||||
/// is the expected path; documented in <c>docs/v2/Server-Deployment.md</c> in a follow-up.
|
||||
/// </remarks>
|
||||
public sealed class HealthEndpointsHost : IAsyncDisposable
|
||||
{
|
||||
private readonly string _prefix;
|
||||
private readonly DriverHost _driverHost;
|
||||
private readonly Func<bool> _configDbHealthy;
|
||||
private readonly Func<bool> _usingStaleConfig;
|
||||
private readonly ILogger<HealthEndpointsHost> _logger;
|
||||
private readonly HttpListener _listener = new();
|
||||
private readonly DateTime _startedUtc = DateTime.UtcNow;
|
||||
private CancellationTokenSource? _cts;
|
||||
private Task? _acceptLoop;
|
||||
private bool _disposed;
|
||||
|
||||
public HealthEndpointsHost(
|
||||
DriverHost driverHost,
|
||||
ILogger<HealthEndpointsHost> logger,
|
||||
Func<bool>? configDbHealthy = null,
|
||||
Func<bool>? usingStaleConfig = null,
|
||||
string prefix = "http://localhost:4841/")
|
||||
{
|
||||
_driverHost = driverHost;
|
||||
_logger = logger;
|
||||
_configDbHealthy = configDbHealthy ?? (() => true);
|
||||
_usingStaleConfig = usingStaleConfig ?? (() => false);
|
||||
_prefix = prefix.EndsWith('/') ? prefix : prefix + "/";
|
||||
_listener.Prefixes.Add(_prefix);
|
||||
}
|
||||
|
||||
public void Start()
|
||||
{
|
||||
_listener.Start();
|
||||
_cts = new CancellationTokenSource();
|
||||
_acceptLoop = Task.Run(() => AcceptLoopAsync(_cts.Token));
|
||||
_logger.LogInformation("Health endpoints listening on {Prefix}", _prefix);
|
||||
}
|
||||
|
||||
private async Task AcceptLoopAsync(CancellationToken ct)
|
||||
{
|
||||
while (!ct.IsCancellationRequested)
|
||||
{
|
||||
HttpListenerContext ctx;
|
||||
try
|
||||
{
|
||||
ctx = await _listener.GetContextAsync().ConfigureAwait(false);
|
||||
}
|
||||
catch (HttpListenerException) when (ct.IsCancellationRequested) { break; }
|
||||
catch (ObjectDisposedException) { break; }
|
||||
|
||||
_ = Task.Run(() => HandleAsync(ctx), ct);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task HandleAsync(HttpListenerContext ctx)
|
||||
{
|
||||
try
|
||||
{
|
||||
var path = ctx.Request.Url?.AbsolutePath ?? "/";
|
||||
switch (path)
|
||||
{
|
||||
case "/healthz":
|
||||
await WriteHealthzAsync(ctx).ConfigureAwait(false);
|
||||
break;
|
||||
case "/readyz":
|
||||
await WriteReadyzAsync(ctx).ConfigureAwait(false);
|
||||
break;
|
||||
default:
|
||||
// #154 — driver-diagnostics path family. URL shape:
|
||||
// /diagnostics/drivers/{driverInstanceId}/modbus/auto-prohibited
|
||||
// Driver-agnostic at the URL level so future driver types (S7, AbCip,
|
||||
// FOCAS) can add their own per-type subpaths.
|
||||
if (path.StartsWith("/diagnostics/drivers/", StringComparison.Ordinal))
|
||||
await WriteDriverDiagnosticsAsync(ctx, path).ConfigureAwait(false);
|
||||
else
|
||||
ctx.Response.StatusCode = 404;
|
||||
break;
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex, "Health endpoint handler failure");
|
||||
try { ctx.Response.StatusCode = 500; } catch { /* ignore */ }
|
||||
}
|
||||
finally
|
||||
{
|
||||
try { ctx.Response.Close(); } catch { /* ignore */ }
|
||||
}
|
||||
}
|
||||
|
||||
private async Task WriteHealthzAsync(HttpListenerContext ctx)
|
||||
{
|
||||
var configHealthy = _configDbHealthy();
|
||||
var staleConfig = _usingStaleConfig();
|
||||
// /healthz is 200 when process alive + (config DB reachable OR cache-warm).
|
||||
// Stale-config still serves 200 so the process isn't flagged dead when the DB
|
||||
// blips; the body surfaces the stale flag for operators.
|
||||
var healthy = configHealthy || staleConfig;
|
||||
ctx.Response.StatusCode = healthy ? 200 : 503;
|
||||
|
||||
var body = JsonSerializer.Serialize(new
|
||||
{
|
||||
status = healthy ? "healthy" : "unhealthy",
|
||||
uptimeSeconds = (int)(DateTime.UtcNow - _startedUtc).TotalSeconds,
|
||||
configDbReachable = configHealthy,
|
||||
usingStaleConfig = staleConfig,
|
||||
});
|
||||
await WriteBodyAsync(ctx, body).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task WriteReadyzAsync(HttpListenerContext ctx)
|
||||
{
|
||||
var snapshots = BuildSnapshots();
|
||||
var verdict = DriverHealthReport.Aggregate(snapshots);
|
||||
ctx.Response.StatusCode = DriverHealthReport.HttpStatus(verdict);
|
||||
|
||||
var body = JsonSerializer.Serialize(new
|
||||
{
|
||||
verdict = verdict.ToString(),
|
||||
uptimeSeconds = (int)(DateTime.UtcNow - _startedUtc).TotalSeconds,
|
||||
drivers = snapshots.Select(d => new
|
||||
{
|
||||
id = d.DriverInstanceId,
|
||||
state = d.State.ToString(),
|
||||
detail = d.DetailMessage,
|
||||
}).ToArray(),
|
||||
degradedDrivers = snapshots
|
||||
.Where(d => d.State == DriverState.Degraded || d.State == DriverState.Reconnecting)
|
||||
.Select(d => d.DriverInstanceId)
|
||||
.ToArray(),
|
||||
});
|
||||
await WriteBodyAsync(ctx, body).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private IReadOnlyList<DriverHealthSnapshot> BuildSnapshots()
|
||||
{
|
||||
var list = new List<DriverHealthSnapshot>();
|
||||
foreach (var id in _driverHost.RegisteredDriverIds)
|
||||
{
|
||||
var driver = _driverHost.GetDriver(id);
|
||||
if (driver is null) continue;
|
||||
var health = driver.GetHealth();
|
||||
list.Add(new DriverHealthSnapshot(driver.DriverInstanceId, health.State, health.LastError));
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// #154 — driver-diagnostics endpoint family. Routes
|
||||
/// <c>/diagnostics/drivers/{driverId}/modbus/auto-prohibited</c> to the live
|
||||
/// <see cref="ModbusDriver"/> instance's <see cref="ModbusDriver.GetAutoProhibitedRanges"/>.
|
||||
/// 404 when the driver instance doesn't exist; 400 when it exists but isn't a Modbus
|
||||
/// driver (the per-type endpoint is wrong for this row).
|
||||
/// </summary>
|
||||
private async Task WriteDriverDiagnosticsAsync(HttpListenerContext ctx, string path)
|
||||
{
|
||||
// Path shape: /diagnostics/drivers/{id}/modbus/auto-prohibited
|
||||
var segments = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
|
||||
if (segments.Length < 4 || segments[0] != "diagnostics" || segments[1] != "drivers")
|
||||
{
|
||||
ctx.Response.StatusCode = 404;
|
||||
return;
|
||||
}
|
||||
|
||||
var driverId = segments[2];
|
||||
var driver = _driverHost.GetDriver(driverId);
|
||||
if (driver is null)
|
||||
{
|
||||
ctx.Response.StatusCode = 404;
|
||||
await WriteBodyAsync(ctx, JsonSerializer.Serialize(new { error = $"Driver '{driverId}' not found" })).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
|
||||
// Per-driver-type subpath dispatch. Today only Modbus is wired; future drivers add
|
||||
// their own segments[3] cases.
|
||||
if (segments.Length >= 5 && segments[3] == "modbus" && segments[4] == "auto-prohibited")
|
||||
{
|
||||
if (driver is not ModbusDriver modbus)
|
||||
{
|
||||
ctx.Response.StatusCode = 400;
|
||||
await WriteBodyAsync(ctx, JsonSerializer.Serialize(new { error = $"Driver '{driverId}' is not a Modbus driver (type: {driver.DriverType})" })).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
var ranges = modbus.GetAutoProhibitedRanges();
|
||||
ctx.Response.StatusCode = 200;
|
||||
await WriteBodyAsync(ctx, JsonSerializer.Serialize(new
|
||||
{
|
||||
driverInstanceId = driverId,
|
||||
count = ranges.Count,
|
||||
ranges = ranges.Select(r => new
|
||||
{
|
||||
unitId = r.UnitId,
|
||||
region = r.Region.ToString(),
|
||||
startAddress = r.StartAddress,
|
||||
endAddress = r.EndAddress,
|
||||
lastProbedUtc = r.LastProbedUtc,
|
||||
bisectionPending = r.BisectionPending,
|
||||
}).ToArray(),
|
||||
})).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
|
||||
ctx.Response.StatusCode = 404;
|
||||
}
|
||||
|
||||
private static async Task WriteBodyAsync(HttpListenerContext ctx, string body)
|
||||
{
|
||||
var bytes = Encoding.UTF8.GetBytes(body);
|
||||
ctx.Response.ContentType = "application/json; charset=utf-8";
|
||||
ctx.Response.ContentLength64 = bytes.LongLength;
|
||||
await ctx.Response.OutputStream.WriteAsync(bytes).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
if (_disposed) return;
|
||||
_disposed = true;
|
||||
_cts?.Cancel();
|
||||
try { _listener.Stop(); } catch { /* ignore */ }
|
||||
if (_acceptLoop is not null)
|
||||
{
|
||||
try { await _acceptLoop.ConfigureAwait(false); } catch { /* ignore */ }
|
||||
}
|
||||
_listener.Close();
|
||||
_cts?.Dispose();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user