private void AddMember(Member m)
{
if (!m.UniqueAddress.Equals(_cluster.SelfUniqueAddress) && !_state.Contains(m.UniqueAddress))
{
_state = _state.AddMember(m.UniqueAddress);
}
}
private void AddMember(Member m)
{
if (m.UniqueAddress != _cluster.SelfUniqueAddress)
{
_state = _state.AddMember(m.UniqueAddress);
}
}
private void Init(ClusterEvent.CurrentClusterState snapshot)
{
var nodes = snapshot.Members.Select(x => x.UniqueAddress).ToImmutableHashSet();
var unreachable = snapshot.Unreachable.Select(c => c.UniqueAddress).ToImmutableHashSet();
_state = _state.Init(nodes, unreachable);
}
/// <summary>
/// TBD
/// </summary>
public ClusterHeartbeatSender()
{
_cluster = Cluster.Get(Context.System);
// the failureDetector is only updated by this actor, but read from other places
_failureDetector = _cluster.FailureDetector;
_selfHeartbeat = new Heartbeat(_cluster.SelfAddress);
_state = new ClusterHeartbeatSenderState(
ring: new HeartbeatNodeRing(
_cluster.SelfUniqueAddress,
ImmutableHashSet.Create(_cluster.SelfUniqueAddress),
ImmutableHashSet <UniqueAddress> .Empty,
_cluster.Settings.MonitoredByNrOfMembers),
oldReceiversNowUnreachable: ImmutableHashSet <UniqueAddress> .Empty,
failureDetector: _failureDetector);
// start periodic heartbeat to other nodes in cluster
_heartbeatTask = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
_cluster.Settings.PeriodicTasksInitialDelay.Max(_cluster.Settings.HeartbeatInterval),
_cluster.Settings.HeartbeatInterval,
Self,
new HeartbeatTick(),
Self);
Initializing();
}
private void DoHeartbeatRsp(UniqueAddress from)
{
if (_cluster.Settings.VerboseHeartbeatLogging)
{
_log.Debug("Cluster Node [{0}] - Heartbeat response from [{1}]", _cluster.SelfAddress, from.Address);
}
_state = _state.HeartbeatRsp(from);
}
private void DoHeartbeatRsp(HeartbeatRsp rsp)
{
if (_cluster.Settings.VerboseHeartbeatLogging)
{
// TODO: log response time and validate sequence nrs once serialisation of sendTime is released
_log.Debug("Cluster Node [{0}] - Heartbeat response from [{1}]", _cluster.SelfAddress, rsp.From.Address);
}
_state = _state.HeartbeatRsp(rsp.From);
}
private void RemoveMember(Member m)
{
if (m.UniqueAddress.Equals(_cluster.SelfUniqueAddress))
{
// This cluster node will be shutdown, but stop this actor immediately
// to avoid further updates
Context.Stop(Self);
}
else
{
_state = _state.RemoveMember(m.UniqueAddress);
}
}
public ClusterHeartbeatSender()
{
_cluster = Cluster.Get(Context.System);
_selfHeartbeat = new Heartbeat(_cluster.SelfAddress);
_state = new ClusterHeartbeatSenderState(
new HeartbeatNodeRing(_cluster.SelfUniqueAddress, new[] { _cluster.SelfUniqueAddress },
_cluster.Settings.MonitoredByNrOfMembers),
ImmutableHashSet.Create <UniqueAddress>(),
FailureDetector);
//stat perioidic heartbeat to other nodes in cluster
_heartbeatTask = new CancellationTokenSource();
Context.System.Scheduler.Schedule(
_cluster.Settings.PeriodicTasksInitialDelay.Max(_cluster.Settings.HeartbeatInterval),
_cluster.Settings.HeartbeatInterval, Self, new HeartbeatTick());
Initializing();
}
public ClusterHeartbeatSender()
{
_cluster = Cluster.Get(Context.System);
_selfHeartbeat = new Heartbeat(_cluster.SelfAddress);
_state = new ClusterHeartbeatSenderState(
new HeartbeatNodeRing(_cluster.SelfUniqueAddress, new[] { _cluster.SelfUniqueAddress },
_cluster.Settings.MonitoredByNrOfMembers),
ImmutableHashSet.Create<UniqueAddress>(),
FailureDetector);
//start periodic heartbeat to other nodes in cluster
_heartbeatTask =
Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
_cluster.Settings.PeriodicTasksInitialDelay.Max(_cluster.Settings.HeartbeatInterval),
_cluster.Settings.HeartbeatInterval, Self, new HeartbeatTick(), Self);
Initializing();
}
private void DoHeartbeatRsp(UniqueAddress from)
{
if (_cluster.Settings.VerboseHeartbeatLogging)
{
_log.Debug("Cluster Node [{0}] - Heartbeat response from [{1}]", _cluster.SelfAddress, from.Address);
}
_state = _state.HeartbeatRsp(from);
}
private void RemoveMember(Member m)
{
if (m.UniqueAddress == _cluster.SelfUniqueAddress)
{
// This cluster node will be shutdown, but stop this actor immediately
// to avoid further updates
Context.Stop(Self);
}
else
{
_state = _state.RemoveMember(m.UniqueAddress);
}
}
private void DoHeartbeatRsp(UniqueAddress from)
{
_log.Debug("Cluster Node [{0}] - Heartbeat response from [{1}]", _cluster.SelfAddress, from.Address);
_state = _state.HeartbeatRsp(from);
}
private void AddMember(Member m)
{
if (m.UniqueAddress != _cluster.SelfUniqueAddress)
_state = _state.AddMember(m.UniqueAddress);
}
private void Init(ClusterEvent.CurrentClusterState snapshot)
{
var nodes = snapshot.Members.Where(x => x.Status == MemberStatus.Up).Select(x => x.UniqueAddress).ToImmutableHashSet();
_state = _state.Init(nodes);
}
private void Init(ClusterEvent.CurrentClusterState snapshot)
{
var nodes = snapshot.Members.Where(x => x.Status == MemberStatus.Up).Select(x => x.UniqueAddress).ToImmutableHashSet();
_state = _state.Init(nodes);
}
private void DoHeartbeatRsp(UniqueAddress from)
{
Log.Debug("Cluster Node [{0}] - Heartbeat response from [{1}]", _cluster.SelfAddress, from.Address);
_state = _state.HeartbeatRsp(from);
}
private void ReachableMember(Member m)
{
_state = _state.ReachableMember(m.UniqueAddress);
}
