Joseph Doherty
542 lines
24 KiB
C#
542 lines
24 KiB
C#
using Akka.Actor;
|
|
using Akka.Cluster;
|
|
using Akka.Cluster.Tools.Client;
|
|
using Akka.Event;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Artifacts;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Audit;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.DebugView;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Deployment;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Health;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.InboundApi;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Integration;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Lifecycle;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Notification;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.RemoteQuery;
|
|
|
|
namespace ZB.MOM.WW.ScadaBridge.Communication.Actors;
|
|
|
|
/// <summary>
|
|
/// Site-side actor that receives messages from central via ClusterClient and routes
|
|
/// them to the appropriate local actors. Also sends heartbeats and health reports
|
|
/// to central via the registered ClusterClient.
|
|
///
|
|
/// Routes all 8 message patterns to local handlers.
|
|
/// </summary>
|
|
public class SiteCommunicationActor : ReceiveActor, IWithTimers
|
|
{
|
|
private readonly ILoggingAdapter _log = Context.GetLogger();
|
|
private readonly string _siteId;
|
|
private readonly CommunicationOptions _options;
|
|
|
|
/// <summary>
|
|
/// Predicate that returns <c>true</c> when this node is
|
|
/// the active member of the local site cluster (used to stamp
|
|
/// <see cref="HeartbeatMessage.IsActive"/>). Production builds default to
|
|
/// the Akka <see cref="Cluster"/> leader check; tests inject a stub so they
|
|
/// do not need a real cluster.
|
|
/// </summary>
|
|
private readonly Func<bool> _isActiveCheck;
|
|
|
|
/// <summary>
|
|
/// Reference to the local Deployment Manager singleton proxy.
|
|
/// </summary>
|
|
private readonly IActorRef _deploymentManagerProxy;
|
|
|
|
/// <summary>
|
|
/// ClusterClient reference for sending messages to the central cluster.
|
|
/// Set via RegisterCentralClient message.
|
|
/// </summary>
|
|
private IActorRef? _centralClient;
|
|
|
|
/// <summary>
|
|
/// Local actor references for routing specific message patterns.
|
|
/// Populated via registration messages.
|
|
/// </summary>
|
|
private IActorRef? _eventLogHandler;
|
|
private IActorRef? _parkedMessageHandler;
|
|
private IActorRef? _integrationHandler;
|
|
private IActorRef? _artifactHandler;
|
|
|
|
/// <summary>Akka timer scheduler injected by the framework via <see cref="IWithTimers"/>.</summary>
|
|
public ITimerScheduler Timers { get; set; } = null!;
|
|
|
|
/// <summary>Initializes the actor, wires all message pattern handlers, and schedules the periodic heartbeat.</summary>
|
|
/// <param name="siteId">The site identifier included in outbound messages.</param>
|
|
/// <param name="options">Communication options including heartbeat interval and transport settings.</param>
|
|
/// <param name="deploymentManagerProxy">Local reference to the Deployment Manager singleton proxy.</param>
|
|
/// <param name="isActiveCheck">
|
|
/// Optional override returning <c>true</c> when this node
|
|
/// is the active member of the site cluster. <c>null</c> uses the shared oldest-Up
|
|
/// evaluator (production wiring passes the Host's singleton-host delegate); tests
|
|
/// pass a stub so they do not need to load Akka.Cluster into the <c>TestKit</c>
|
|
/// ActorSystem.
|
|
/// </param>
|
|
public SiteCommunicationActor(
|
|
string siteId,
|
|
CommunicationOptions options,
|
|
IActorRef deploymentManagerProxy,
|
|
Func<bool>? isActiveCheck = null)
|
|
{
|
|
_siteId = siteId;
|
|
_options = options;
|
|
_deploymentManagerProxy = deploymentManagerProxy;
|
|
_isActiveCheck = isActiveCheck ?? DefaultIsActiveCheck;
|
|
|
|
// Registration
|
|
Receive<RegisterCentralClient>(msg =>
|
|
{
|
|
_centralClient = msg.Client;
|
|
_log.Info("Registered central ClusterClient");
|
|
});
|
|
Receive<RegisterLocalHandler>(HandleRegisterLocalHandler);
|
|
|
|
// Pattern 1: Instance Deployment — forward to Deployment Manager
|
|
Receive<RefreshDeploymentCommand>(msg =>
|
|
{
|
|
_log.Debug("Routing RefreshDeploymentCommand for {0} to DeploymentManager", msg.InstanceUniqueName);
|
|
_deploymentManagerProxy.Forward(msg);
|
|
});
|
|
|
|
// Pattern 2: Lifecycle — forward to Deployment Manager
|
|
Receive<DisableInstanceCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
Receive<EnableInstanceCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
Receive<DeleteInstanceCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// Query-the-site-before-redeploy — forward to
|
|
// the Deployment Manager, which owns the deployed-config store and
|
|
// answers with the instance's currently-applied deployment identity.
|
|
Receive<DeploymentStateQueryRequest>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// Pattern 3: Artifact Deployment — forward to artifact handler if registered
|
|
Receive<DeployArtifactsCommand>(msg =>
|
|
{
|
|
if (_artifactHandler != null)
|
|
_artifactHandler.Forward(msg);
|
|
else
|
|
{
|
|
_log.Warning("No artifact handler registered, replying with failure");
|
|
Sender.Tell(new ArtifactDeploymentResponse(
|
|
msg.DeploymentId, _siteId, false, "Artifact handler not available", DateTimeOffset.UtcNow));
|
|
}
|
|
});
|
|
|
|
// Pattern 4: Integration Routing — forward to integration handler
|
|
Receive<IntegrationCallRequest>(msg =>
|
|
{
|
|
if (_integrationHandler != null)
|
|
_integrationHandler.Forward(msg);
|
|
else
|
|
{
|
|
Sender.Tell(new IntegrationCallResponse(
|
|
msg.CorrelationId, _siteId, false, null, "Integration handler not available", DateTimeOffset.UtcNow));
|
|
}
|
|
});
|
|
|
|
// Pattern 5: Debug View — forward to Deployment Manager (which routes to Instance Actor)
|
|
Receive<SubscribeDebugViewRequest>(msg => _deploymentManagerProxy.Forward(msg));
|
|
Receive<UnsubscribeDebugViewRequest>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// Pattern 6a: Debug Snapshot (one-shot) — forward to Deployment Manager
|
|
Receive<DebugSnapshotRequest>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// Inbound API Route.To() — forward to Deployment Manager for instance routing
|
|
Receive<RouteToCallRequest>(msg => _deploymentManagerProxy.Forward(msg));
|
|
Receive<RouteToGetAttributesRequest>(msg => _deploymentManagerProxy.Forward(msg));
|
|
Receive<RouteToSetAttributesRequest>(msg => _deploymentManagerProxy.Forward(msg));
|
|
Receive<RouteToWaitForAttributeRequest>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// OPC UA Tag Browser (interactive design-time query) — forward to the
|
|
// Deployment Manager singleton, which always lands on the active site
|
|
// node. Routing to the site-local /user/dcl-manager directly is wrong
|
|
// because the standby node has a dcl-manager too, but its
|
|
// DataConnectionActor children (which own the live OPC UA sessions)
|
|
// only exist on the singleton's node. The singleton then re-forwards
|
|
// to its own /user/dcl-manager, which DOES have the connection.
|
|
Receive<BrowseNodeCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// Test Bindings (interactive design-time read) — same routing rationale
|
|
// as BrowseNodeCommand above: the singleton always lands on the
|
|
// active site node, which is the node that owns the DataConnectionActor
|
|
// children holding the live OPC UA sessions.
|
|
Receive<ReadTagValuesCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// OPC UA tag-picker address-space search and secured-write execute
|
|
// — same singleton routing rationale as BrowseNodeCommand above: the
|
|
// DataConnectionActor children that own the live OPC UA sessions exist only
|
|
// on the singleton's (active) node, so these must hop through the Deployment
|
|
// Manager proxy too. Without these forwards the commands dead-letter and the
|
|
// central Ask times out. Forward preserves the central Ask sender so the
|
|
// result routes straight back to the waiting Ask.
|
|
Receive<SearchAddressSpaceCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
Receive<Commons.Messages.DataConnection.WriteTagRequest>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// OPC UA endpoint Verify — probes a (possibly unsaved) endpoint config
|
|
// WITHOUT persisting it. The Deployment Manager singleton's dcl-manager runs
|
|
// the probe directly (no existing connection required), so — like the
|
|
// commands above — Verify routes through the singleton's active node.
|
|
Receive<VerifyEndpointCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// OPC UA server-certificate trust management — forward to the
|
|
// Deployment Manager singleton, which owns the cross-node trust broadcast.
|
|
// The trusted-peer PKI store is node-wide per site node, so a trust/remove
|
|
// decision must reach BOTH nodes' CertStoreActor; the singleton broadcasts
|
|
// to every site node (list answers from the singleton's own node). The
|
|
// singleton always lands on the active node, the same routing rationale as
|
|
// BrowseNodeCommand above. Forward preserves the central Ask sender so the
|
|
// CertTrustResult routes straight back to the waiting Ask.
|
|
Receive<TrustServerCertCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
Receive<ListServerCertsCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
Receive<RemoveServerCertCommand>(msg => _deploymentManagerProxy.Forward(msg));
|
|
|
|
// Pattern 7: Remote Queries
|
|
Receive<EventLogQueryRequest>(msg =>
|
|
{
|
|
if (_eventLogHandler != null)
|
|
_eventLogHandler.Forward(msg);
|
|
else
|
|
{
|
|
Sender.Tell(new EventLogQueryResponse(
|
|
msg.CorrelationId, _siteId, [], null, false, false,
|
|
"Event log handler not available", DateTimeOffset.UtcNow));
|
|
}
|
|
});
|
|
|
|
Receive<ParkedMessageQueryRequest>(msg =>
|
|
{
|
|
if (_parkedMessageHandler != null)
|
|
_parkedMessageHandler.Forward(msg);
|
|
else
|
|
{
|
|
Sender.Tell(new ParkedMessageQueryResponse(
|
|
msg.CorrelationId, _siteId, [], 0, msg.PageNumber, msg.PageSize, false,
|
|
"Parked message handler not available", DateTimeOffset.UtcNow));
|
|
}
|
|
});
|
|
|
|
Receive<ParkedMessageRetryRequest>(msg =>
|
|
{
|
|
if (_parkedMessageHandler != null)
|
|
_parkedMessageHandler.Forward(msg);
|
|
else
|
|
{
|
|
Sender.Tell(new ParkedMessageRetryResponse(
|
|
msg.CorrelationId, false, "Parked message handler not available"));
|
|
}
|
|
});
|
|
|
|
Receive<ParkedMessageDiscardRequest>(msg =>
|
|
{
|
|
if (_parkedMessageHandler != null)
|
|
_parkedMessageHandler.Forward(msg);
|
|
else
|
|
{
|
|
Sender.Tell(new ParkedMessageDiscardResponse(
|
|
msg.CorrelationId, false, "Parked message handler not available"));
|
|
}
|
|
});
|
|
|
|
// Central→site Retry/Discard relay for parked cached
|
|
// operations. SiteCallAuditActor relays these over the command/control
|
|
// channel; the parked-message handler executes them against the local
|
|
// S&F buffer and replies a ParkedOperationActionAck that routes back to
|
|
// the relaying SiteCallAuditActor's Ask.
|
|
Receive<RetryParkedOperation>(msg =>
|
|
{
|
|
if (_parkedMessageHandler != null)
|
|
_parkedMessageHandler.Forward(msg);
|
|
else
|
|
{
|
|
Sender.Tell(new ParkedOperationActionAck(
|
|
msg.CorrelationId, Applied: false, "Parked message handler not available"));
|
|
}
|
|
});
|
|
|
|
Receive<DiscardParkedOperation>(msg =>
|
|
{
|
|
if (_parkedMessageHandler != null)
|
|
_parkedMessageHandler.Forward(msg);
|
|
else
|
|
{
|
|
Sender.Tell(new ParkedOperationActionAck(
|
|
msg.CorrelationId, Applied: false, "Parked message handler not available"));
|
|
}
|
|
});
|
|
|
|
// Notification Outbox: forward a buffered notification submitted by the site
|
|
// Store-and-Forward Engine to the central cluster. The original Sender (the
|
|
// S&F forwarder's Ask) is forwarded as the ClusterClient.Send sender so the
|
|
// NotificationSubmitAck routes straight back to the waiting Ask, not here.
|
|
Receive<NotificationSubmit>(msg =>
|
|
{
|
|
if (_centralClient == null)
|
|
{
|
|
// No ClusterClient registered yet (e.g. central contact points not
|
|
// configured, or registration not yet completed). A non-accepted ack
|
|
// makes the S&F forwarder treat this as transient and retry later.
|
|
_log.Warning(
|
|
"Cannot forward NotificationSubmit {0} — no central ClusterClient registered",
|
|
msg.NotificationId);
|
|
Sender.Tell(new NotificationSubmitAck(
|
|
msg.NotificationId, Accepted: false, Error: "Central ClusterClient not registered"));
|
|
return;
|
|
}
|
|
|
|
_log.Debug("Forwarding NotificationSubmit {0} to central", msg.NotificationId);
|
|
_centralClient.Tell(
|
|
new ClusterClient.Send("/user/central-communication", msg), Sender);
|
|
});
|
|
|
|
// Notification Outbox: forward a Notify.Status query to the central cluster.
|
|
// The original Sender (the Notify helper's Ask) is forwarded as the
|
|
// ClusterClient.Send sender so the NotificationStatusResponse routes straight
|
|
// back to the waiting Ask, not here.
|
|
Receive<NotificationStatusQuery>(msg =>
|
|
{
|
|
if (_centralClient == null)
|
|
{
|
|
// No ClusterClient registered yet. Reply Found: false so Notify.Status
|
|
// falls back to the site S&F buffer to decide Forwarding vs Unknown.
|
|
_log.Warning(
|
|
"Cannot forward NotificationStatusQuery {0} — no central ClusterClient registered",
|
|
msg.NotificationId);
|
|
Sender.Tell(new NotificationStatusResponse(
|
|
msg.CorrelationId, Found: false, Status: "Unknown",
|
|
RetryCount: 0, LastError: null, DeliveredAt: null));
|
|
return;
|
|
}
|
|
|
|
_log.Debug("Forwarding NotificationStatusQuery {0} to central", msg.NotificationId);
|
|
_centralClient.Tell(
|
|
new ClusterClient.Send("/user/central-communication", msg), Sender);
|
|
});
|
|
|
|
// Audit Log: forward a batch of site-local audit events to the
|
|
// central cluster. The site SiteAuditTelemetryActor drains its SQLite
|
|
// Pending queue through the ClusterClientSiteAuditClient, which Asks
|
|
// this actor; the original Sender (that Ask) is passed as the
|
|
// ClusterClient.Send sender so the IngestAuditEventsReply routes
|
|
// straight back to the waiting Ask, not here. Mirrors NotificationSubmit.
|
|
Receive<IngestAuditEventsCommand>(msg =>
|
|
{
|
|
if (_centralClient == null)
|
|
{
|
|
// No ClusterClient registered yet (e.g. central contact points
|
|
// not configured, or registration not yet completed). Faulting
|
|
// the Ask makes the SiteAuditTelemetryActor drain loop treat
|
|
// this as transient and keep the rows Pending for the next tick.
|
|
_log.Warning(
|
|
"Cannot forward IngestAuditEventsCommand ({0} events) — no central ClusterClient registered",
|
|
msg.Events.Count);
|
|
Sender.Tell(new Status.Failure(
|
|
new InvalidOperationException("Central ClusterClient not registered")));
|
|
return;
|
|
}
|
|
|
|
_log.Debug("Forwarding IngestAuditEventsCommand ({0} events) to central", msg.Events.Count);
|
|
_centralClient.Tell(
|
|
new ClusterClient.Send("/user/central-communication", msg), Sender);
|
|
});
|
|
|
|
// Audit Log: forward a batch of combined cached-call telemetry
|
|
// packets to the central cluster. Same forward + reply-routing pattern
|
|
// as IngestAuditEventsCommand; central replies with an
|
|
// IngestCachedTelemetryReply.
|
|
Receive<IngestCachedTelemetryCommand>(msg =>
|
|
{
|
|
if (_centralClient == null)
|
|
{
|
|
_log.Warning(
|
|
"Cannot forward IngestCachedTelemetryCommand ({0} entries) — no central ClusterClient registered",
|
|
msg.Entries.Count);
|
|
Sender.Tell(new Status.Failure(
|
|
new InvalidOperationException("Central ClusterClient not registered")));
|
|
return;
|
|
}
|
|
|
|
_log.Debug("Forwarding IngestCachedTelemetryCommand ({0} entries) to central", msg.Entries.Count);
|
|
_centralClient.Tell(
|
|
new ClusterClient.Send("/user/central-communication", msg), Sender);
|
|
});
|
|
|
|
// Site startup reconciliation: forward the node's local-inventory
|
|
// ReconcileSiteRequest to the central cluster. The original Sender (the
|
|
// SiteReconciliationActor's Ask) is passed as the ClusterClient.Send sender so
|
|
// the ReconcileSiteResponse routes straight back to the waiting Ask, not here.
|
|
// Mirrors IngestAuditEventsCommand.
|
|
Receive<ReconcileSiteRequest>(msg =>
|
|
{
|
|
if (_centralClient == null)
|
|
{
|
|
// No ClusterClient registered yet (e.g. central contact points not
|
|
// configured, or registration not yet completed). Faulting the Ask makes
|
|
// the SiteReconciliationActor treat the pass as best-effort-failed; it
|
|
// logs a warning and retries reconcile on the next node startup.
|
|
_log.Warning(
|
|
"Cannot forward ReconcileSiteRequest for site {0} node {1} — no central ClusterClient registered",
|
|
msg.SiteIdentifier, msg.NodeId);
|
|
Sender.Tell(new Status.Failure(
|
|
new InvalidOperationException("Central ClusterClient not registered")));
|
|
return;
|
|
}
|
|
|
|
_log.Debug(
|
|
"Forwarding ReconcileSiteRequest for site {0} node {1} ({2} local instance(s)) to central",
|
|
msg.SiteIdentifier, msg.NodeId, msg.LocalNameToRevisionHash.Count);
|
|
_centralClient.Tell(
|
|
new ClusterClient.Send("/user/central-communication", msg), Sender);
|
|
});
|
|
|
|
// Internal: send heartbeat tick
|
|
Receive<SendHeartbeat>(_ => SendHeartbeatToCentral());
|
|
|
|
// Internal: forward health report to central. The original Sender (the
|
|
// AkkaHealthReportTransport's Ask) is forwarded as the ClusterClient.Send
|
|
// sender so the central SiteHealthReportAck routes straight back to the
|
|
// waiting Ask — making report delivery observable end-to-end (review 01
|
|
// [Medium]). Mirrors the NotificationSubmit ack pattern above.
|
|
Receive<SiteHealthReport>(msg =>
|
|
{
|
|
if (_centralClient == null)
|
|
{
|
|
// No ClusterClient registered yet. A non-accepted ack makes the
|
|
// sender's counter-restore path treat this tick as a loss.
|
|
_log.Warning(
|
|
"Cannot forward SiteHealthReport #{0} — no central ClusterClient registered",
|
|
msg.SequenceNumber);
|
|
Sender.Tell(new SiteHealthReportAck(
|
|
msg.SiteId, msg.SequenceNumber, Accepted: false,
|
|
Error: "Central ClusterClient not registered"));
|
|
return;
|
|
}
|
|
|
|
_centralClient.Tell(
|
|
new ClusterClient.Send("/user/central-communication", msg), Sender);
|
|
});
|
|
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
protected override SupervisorStrategy SupervisorStrategy()
|
|
{
|
|
return new OneForOneStrategy(
|
|
maxNrOfRetries: -1,
|
|
withinTimeRange: Timeout.InfiniteTimeSpan,
|
|
decider: Decider.From(ex =>
|
|
{
|
|
_log.Warning(ex, "Child actor of SiteCommunicationActor faulted, resuming (state preserved)");
|
|
return Directive.Resume;
|
|
}));
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
protected override void PreStart()
|
|
{
|
|
_log.Info("SiteCommunicationActor started for site {0}", _siteId);
|
|
|
|
// Schedule periodic heartbeat to central. Uses the application heartbeat
|
|
// cadence — distinct from the Akka.Remote transport failure-detector
|
|
// interval — so the two can be tuned independently.
|
|
Timers.StartPeriodicTimer(
|
|
"heartbeat",
|
|
new SendHeartbeat(),
|
|
TimeSpan.FromSeconds(1), // initial delay
|
|
_options.ApplicationHeartbeatInterval);
|
|
}
|
|
|
|
private void HandleRegisterLocalHandler(RegisterLocalHandler msg)
|
|
{
|
|
switch (msg.HandlerType)
|
|
{
|
|
case LocalHandlerType.EventLog:
|
|
_eventLogHandler = msg.Handler;
|
|
break;
|
|
case LocalHandlerType.ParkedMessages:
|
|
_parkedMessageHandler = msg.Handler;
|
|
break;
|
|
case LocalHandlerType.Integration:
|
|
_integrationHandler = msg.Handler;
|
|
break;
|
|
case LocalHandlerType.Artifacts:
|
|
_artifactHandler = msg.Handler;
|
|
break;
|
|
}
|
|
|
|
_log.Info("Registered local handler for {0}", msg.HandlerType);
|
|
}
|
|
|
|
private void SendHeartbeatToCentral()
|
|
{
|
|
if (_centralClient == null)
|
|
return;
|
|
|
|
var hostname = Environment.MachineName;
|
|
|
|
// Stamp HeartbeatMessage.IsActive with this node's
|
|
// true active/standby role rather than hard-coding `true`. The field is
|
|
// part of the wire contract (additive-only-evolution) so a future
|
|
// central health dashboard can distinguish "active node down, standby
|
|
// up" from "site fully offline" without a new message type.
|
|
bool isActive;
|
|
try
|
|
{
|
|
isActive = _isActiveCheck();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Defensive: never let a cluster-state read failure abort the
|
|
// heartbeat itself (heartbeats are health signal — their absence is
|
|
// already meaningful). Fall back to the safest non-claiming value:
|
|
// standby. Logged at Debug because this path normally only fires
|
|
// during ActorSystem warm-up.
|
|
_log.Debug(ex,
|
|
"Active-node check threw while sending heartbeat for site {0}; reporting IsActive=false",
|
|
_siteId);
|
|
isActive = false;
|
|
}
|
|
|
|
var heartbeat = new HeartbeatMessage(
|
|
_siteId,
|
|
hostname,
|
|
IsActive: isActive,
|
|
DateTimeOffset.UtcNow);
|
|
|
|
_centralClient.Tell(
|
|
new ClusterClient.Send("/user/central-communication", heartbeat), Self);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Default active-node check used when no override is supplied: oldest-Up member
|
|
/// semantics via the shared <see cref="ClusterState.ActiveNodeEvaluator"/> — the
|
|
/// same predicate as the S&F delivery gate and the replication resync authority
|
|
/// (review 02 round 2, N1). Unscoped by role: a site cluster's members all carry
|
|
/// the site role, so role scoping is a no-op here; production wiring passes the
|
|
/// Host's role-scoped IClusterNodeProvider delegate anyway. Any other state
|
|
/// (still joining, leaving) reports standby — safe-by-default.
|
|
/// </summary>
|
|
private bool DefaultIsActiveCheck() =>
|
|
ClusterState.ActiveNodeEvaluator.SelfIsOldestUp(Cluster.Get(Context.System));
|
|
|
|
// ── Internal messages ──
|
|
|
|
internal record SendHeartbeat;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Command to register a ClusterClient for communicating with the central cluster.
|
|
/// </summary>
|
|
public record RegisterCentralClient(IActorRef Client);
|
|
|
|
/// <summary>
|
|
/// Command to register a local actor as a handler for a specific message pattern.
|
|
/// </summary>
|
|
public record RegisterLocalHandler(LocalHandlerType HandlerType, IActorRef Handler);
|
|
|
|
public enum LocalHandlerType
|
|
{
|
|
EventLog,
|
|
ParkedMessages,
|
|
Integration,
|
|
Artifacts
|
|
}
|