lmxopcua/src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Health/DbHealthProbeActor.cs

using Akka.Actor;
using Akka.Event;
using Microsoft.EntityFrameworkCore;
using ZB.MOM.WW.OtOpcUa.Configuration;

namespace ZB.MOM.WW.OtOpcUa.Runtime.Health;

/// <summary>
/// Single-flight cached health probe against the ConfigDb. Reads cached state via
/// <c>Ask&lt;DbHealthStatus&gt;</c>; a single SELECT runs at most every <c>RefreshInterval</c>.
/// Consumed by both the host's <c>/health/ready</c> endpoint and
/// <c>RedundancyStateActor</c>'s stale calc.
/// </summary>
/// <remarks>
///     The probe runs OFF the mailbox (a thread-pool task that pipes its outcome back), with a bounded
///     command timeout. It used to run synchronously on the actor thread, relying on SqlClient's implicit
///     15 s connect / 30 s command timeouts — so a hanging SQL Server pinned a dispatcher thread for up to
///     30 s per tick, later ticks queued behind it, and the cached <see cref="GetStatus"/> answer was
///     unreachable for exactly as long as the database was. Single-flight: a tick that lands while a probe
///     is still running is skipped rather than stacked.
/// </remarks>
public sealed class DbHealthProbeActor : ReceiveActor, IWithTimers
{
    public static readonly TimeSpan RefreshInterval = TimeSpan.FromSeconds(5);

    /// <summary>Bound on the probe's SQL command, relational providers only (the in-memory provider the
    /// actor tests run against has no command timeout).</summary>
    public static readonly TimeSpan CommandTimeout = TimeSpan.FromSeconds(2);

    public sealed class GetStatus { public static readonly GetStatus Instance = new(); private GetStatus() { } }
    public sealed record DbHealthStatus(bool Reachable, DateTime AsOfUtc, string? LastError);
    public sealed class Tick { public static readonly Tick Instance = new(); private Tick() { } }

    /// <summary>Piped back by the off-thread probe with its outcome.</summary>
    private sealed record ProbeCompleted(DbHealthStatus Status);

    private readonly IDbContextFactory<OtOpcUaConfigDbContext> _dbFactory;
    private readonly ILoggingAdapter _log = Context.GetLogger();
    private DbHealthStatus _last = new(false, DateTime.MinValue, "not probed yet");
    private bool _probeInFlight;

    /// <summary>Gets or sets the timer scheduler for periodic health probes.</summary>
    public ITimerScheduler Timers { get; set; } = null!;

    /// <summary>Creates a Props instance for the DbHealthProbeActor.</summary>
    /// <param name="dbFactory">The factory for creating ConfigDb contexts.</param>
    /// <returns>The Akka <see cref="Akka.Actor.Props"/> for creating this actor.</returns>
    public static Props Props(IDbContextFactory<OtOpcUaConfigDbContext> dbFactory) =>
        Akka.Actor.Props.Create(() => new DbHealthProbeActor(dbFactory));

    /// <summary>Initializes a new instance of the <see cref="DbHealthProbeActor"/> class.</summary>
    /// <param name="dbFactory">The factory for creating ConfigDb contexts.</param>
    public DbHealthProbeActor(IDbContextFactory<OtOpcUaConfigDbContext> dbFactory)
    {
        _dbFactory = dbFactory;
        Receive<GetStatus>(_ => Sender.Tell(_last));
        Receive<Tick>(_ => StartProbe());
        Receive<ProbeCompleted>(msg =>
        {
            _probeInFlight = false;
            _last = msg.Status;
            if (!msg.Status.Reachable)
                _log.Warning("DbHealthProbe: probe failed: {Error}", msg.Status.LastError);
        });
    }

    /// <inheritdoc />
    protected override void PreStart()
    {
        StartProbe();
        Timers.StartPeriodicTimer("probe", Tick.Instance, RefreshInterval);
    }

    private void StartProbe()
    {
        if (_probeInFlight)
        {
            _log.Debug("DbHealthProbe: previous probe still running; skipping this tick");
            return;
        }

        _probeInFlight = true;
        var factory = _dbFactory;
        // Never touches actor state; the outcome comes back as a message.
        Task.Run(() => Probe(factory)).PipeTo(
            Self,
            success: status => new ProbeCompleted(status),
            failure: ex => new ProbeCompleted(new DbHealthStatus(false, DateTime.UtcNow, ex.Message)));
    }

    private static DbHealthStatus Probe(IDbContextFactory<OtOpcUaConfigDbContext> factory)
    {
        try
        {
            using var db = factory.CreateDbContext();
            // Local to this lease — the pool resets it on return (see DriverHostActor.LoadArtifactBlob).
            if (db.Database.IsRelational())
                db.Database.SetCommandTimeout(CommandTimeout);
            _ = db.Deployments.AsNoTracking().Take(1).ToList();
            return new DbHealthStatus(true, DateTime.UtcNow, null);
        }
        catch (Exception ex)
        {
            return new DbHealthStatus(false, DateTime.UtcNow, ex.Message);
        }
    }
}