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>
/// The current snapshot state corresponding to latest gossip
/// to mimic what you would have seen if you were listening to the events.
/// </summary>
private void SendCurrentClusterState(ActorRef receiver)
{
var state = new ClusterEvent.CurrentClusterState(
_latestGossip.Members,
_latestGossip.Overview.Reachability.AllUnreachableOrTerminated.Select(_latestGossip.GetMember)
.ToImmutableHashSet(),
_latestGossip.SeenBy.Select(s => s.Address).ToImmutableHashSet(),
_latestGossip.Leader == null ? null : _latestGossip.Leader.Address,
_latestGossip.AllRoles.ToImmutableDictionary(r => r, r => _latestGossip.RoleLeader(r).Address)
);
receiver.Tell(state);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="cluster">TBD</param>
public ClusterReadView(Cluster cluster)
{
_cluster = cluster;
_state = new ClusterEvent.CurrentClusterState();
_reachability = Reachability.Empty;
_latestStats = new ClusterEvent.CurrentInternalStats(new GossipStats(), new VectorClockStats());
_selfAddress = cluster.SelfAddress;
_eventBusListener =
cluster.System.SystemActorOf(
Props.Create(() => new EventBusListener(cluster, this))
.WithDispatcher(cluster.Settings.UseDispatcher)
.WithDeploy(Deploy.Local), "clusterEventBusListener");
}
public ClusterReadView(Cluster cluster)
{
_cluster = cluster;
_state = new ClusterEvent.CurrentClusterState();
_reachability = Reachability.Empty;
_latestStats = new ClusterEvent.CurrentInternalStats(new GossipStats(), new VectorClockStats());
_selfAddress = cluster.SelfAddress;
_eventBusListener =
cluster.System.SystemActorOf(
Props.Create(() => new EventBusListener(cluster, this))
.WithDispatcher(cluster.Settings.UseDispatcher)
.WithDeploy(Deploy.Local), "clusterEventBusListener");
}
public HttpResponseMessage Get(string id)
{
var t1 = Program.ClusterStatus.Ask(new ClusterStatus.GetClusterState(), TimeSpan.FromSeconds(2))
.ContinueWith(
tr =>
{
ClusterState = (ClusterEvent.CurrentClusterState)tr.Result;
}, TaskContinuationOptions.AttachedToParent & TaskContinuationOptions.ExecuteSynchronously);
t1.Wait(TimeSpan.FromSeconds(2));
var retval = Request.CreateResponse(HttpStatusCode.OK, new
{
clusterState = ClusterState
});
return retval;
}
/// <summary>
/// The current snapshot state corresponding to latest gossip
/// to mimic what you would have seen if you were listening to the events.
/// </summary>
private void SendCurrentClusterState(IActorRef receiver)
{
var unreachable = _latestGossip.Overview.Reachability.AllUnreachableOrTerminated
.Where(node => !node.Equals(_selfUniqueAddress))
.Select(node => _latestGossip.GetMember(node))
.ToImmutableHashSet();
var state = new ClusterEvent.CurrentClusterState(
members: _latestGossip.Members,
unreachable: unreachable,
seenBy: _latestGossip.SeenBy.Select(s => s.Address).ToImmutableHashSet(),
leader: _latestGossip.Leader(_selfUniqueAddress) == null ? null : _latestGossip.Leader(_selfUniqueAddress).Address,
roleLeaderMap: _latestGossip.AllRoles.ToImmutableDictionary(r => r, r =>
{
var leader = _latestGossip.RoleLeader(r, _selfUniqueAddress);
return leader == null ? null : leader.Address;
}));
receiver.Tell(state);
}
/// <summary>
/// The current snapshot state corresponding to latest gossip
/// to mimic what you would have seen if you were listening to the events.
/// </summary>
private void SendCurrentClusterState(IActorRef receiver)
{
var unreachable = _membershipState.LatestGossip.Overview.Reachability
.AllUnreachableOrTerminated.Where(x => x != _selfUniqueAddress)
.Select(x => _membershipState.LatestGossip.GetMember(x))
.ToImmutableHashSet();
var state = new ClusterEvent.CurrentClusterState(
members: _membershipState.Members,
unreachable: unreachable,
seenBy: _membershipState.LatestGossip.SeenBy.Select(s => s.Address).ToImmutableHashSet(),
leader: _membershipState.Leader?.Address,
roleLeaderMap: _membershipState.LatestGossip.AllRoles
.ToImmutableDictionary(r => r, r =>
{
var leader = _membershipState.RoleLeader(r);
return(leader?.Address);
}));
receiver.Tell(state);
}
public EventBusListener(Cluster cluster, ClusterReadView readView)
{
_cluster = cluster;
_readView = readView;
Receive<ClusterEvent.IClusterDomainEvent>(clusterDomainEvent =>
{
clusterDomainEvent.Match()
.With<ClusterEvent.SeenChanged>(changed =>
{
State = State.Copy(seenBy: changed.SeenBy);
})
.With<ClusterEvent.ReachabilityChanged>(changed =>
{
_readView._reachability = changed.Reachability;
})
.With<ClusterEvent.MemberRemoved>(removed =>
{
State = State.Copy(members: State.Members.Remove(removed.Member),
unreachable: State.Unreachable.Remove(removed.Member));
})
.With<ClusterEvent.UnreachableMember>(member =>
{
// replace current member with new member (might have different status, only address is used in == comparison)
State = State.Copy(unreachable: State.Unreachable.Remove(member.Member).Add(member.Member));
})
.With<ClusterEvent.ReachableMember>(member =>
{
State = State.Copy(unreachable: State.Unreachable.Remove(member.Member));
})
.With<ClusterEvent.IMemberEvent>(memberEvent =>
{
var newUnreachable = State.Unreachable;
// replace current member with new member (might have different status, only address is used in == comparison)
if (State.Unreachable.Contains(memberEvent.Member))
newUnreachable = State.Unreachable.Remove(memberEvent.Member).Add(memberEvent.Member);
State = State.Copy(
members: State.Members.Remove(memberEvent.Member).Add(memberEvent.Member),
unreachable: newUnreachable);
})
.With<ClusterEvent.LeaderChanged>(changed =>
{
State = State.Copy(leader: changed.Leader);
})
.With<ClusterEvent.RoleLeaderChanged>(changed =>
{
State = State.Copy(roleLeaderMap: State.RoleLeaderMap.SetItem(changed.Role, changed.Leader));
})
.With<ClusterEvent.CurrentInternalStats>(stats =>
{
readView._latestStats = stats;
})
.With<ClusterEvent.ClusterMetricsChanged>(changed =>
{
readView._clusterMetrics = changed.NodeMetrics;
})
.With<ClusterEvent.ClusterShuttingDown>(_ => { });
});
Receive<ClusterEvent.CurrentClusterState>(state =>
{
State = state;
});
}
/// <summary>
/// Update the initial node ring for those nodes that are <see cref="MemberStatus.Up"/>
/// </summary>
private void ReceiveState(ClusterEvent.CurrentClusterState state)
{
Nodes = state.Members.Where(x => x.Status == MemberStatus.Up).Select(x => x.Address).ToImmutableHashSet();
}
public EventBusListener(Cluster cluster, ClusterReadView readView)
{
_cluster = cluster;
_readView = readView;
Receive <ClusterEvent.IClusterDomainEvent>(clusterDomainEvent =>
{
clusterDomainEvent.Match()
.With <ClusterEvent.SeenChanged>(changed =>
{
State = State.Copy(seenBy: changed.SeenBy);
})
.With <ClusterEvent.ReachabilityChanged>(changed =>
{
_readView._reachability = changed.Reachability;
})
.With <ClusterEvent.MemberRemoved>(removed =>
{
State = State.Copy(members: State.Members.Remove(removed.Member),
unreachable: State.Unreachable.Remove(removed.Member));
})
.With <ClusterEvent.UnreachableMember>(member =>
{
// replace current member with new member (might have different status, only address is used in == comparison)
State = State.Copy(unreachable: State.Unreachable.Remove(member.Member).Add(member.Member));
})
.With <ClusterEvent.ReachableMember>(member =>
{
State = State.Copy(unreachable: State.Unreachable.Remove(member.Member));
})
.With <ClusterEvent.IMemberEvent>(memberEvent =>
{
var newUnreachable = State.Unreachable;
// replace current member with new member (might have different status, only address is used in == comparison)
if (State.Unreachable.Contains(memberEvent.Member))
{
newUnreachable = State.Unreachable.Remove(memberEvent.Member).Add(memberEvent.Member);
}
State = State.Copy(
members: State.Members.Remove(memberEvent.Member).Add(memberEvent.Member),
unreachable: newUnreachable);
})
.With <ClusterEvent.LeaderChanged>(changed =>
{
State = State.Copy(leader: changed.Leader);
})
.With <ClusterEvent.RoleLeaderChanged>(changed =>
{
State = State.Copy(roleLeaderMap: State.RoleLeaderMap.SetItem(changed.Role, changed.Leader));
})
.With <ClusterEvent.CurrentInternalStats>(stats =>
{
readView._latestStats = stats;
})
.With <ClusterEvent.ClusterShuttingDown>(_ => { });
});
Receive <ClusterEvent.CurrentClusterState>(state =>
{
State = state;
});
}
/// <summary>
/// The current snapshot state corresponding to latest gossip
/// to mimic what you would have seen if you were listening to the events.
/// </summary>
private void SendCurrentClusterState(IActorRef receiver)
{
var unreachable = _latestGossip.Overview.Reachability.AllUnreachableOrTerminated
.Where(node => node != _selfUniqueAddress)
.Select(_latestGossip.GetMember)
.ToImmutableHashSet();
var state = new ClusterEvent.CurrentClusterState(
_latestGossip.Members,
unreachable,
_latestGossip.SeenBy.Select(s => s.Address).ToImmutableHashSet(),
_latestGossip.Leader(_selfUniqueAddress) == null ? null : _latestGossip.Leader(_selfUniqueAddress).Address,
_latestGossip.AllRoles.ToImmutableDictionary(r => r, r =>
{
var leader = _latestGossip.RoleLeader(r, _selfUniqueAddress);
return leader == null ? null : leader.Address;
}));
receiver.Tell(state);
}
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 Ready()
{
Receive<SubscribeToManager>(ic =>
{
if (!_clients.Contains(Sender))
{
_clients.Add(this.Sender);
Sender.Tell(new ClusterMessage(string.Format("Subscribed to cluster events : {0}", Sender.ToString())));
return;
}
Sender.Tell(new ClusterMessage(string.Format("You have already subscribed to cluster events : {0}", Sender.ToString())));
});
Receive<UnSubscribeFromManager>(ic =>
{
if (_clients.Contains(Sender))
{
_clients.Remove(this.Sender);
Sender.Tell(new ClusterMessage(string.Format("Unsubscribed to cluster events : {0}", Sender.ToString())));
return;
}
Sender.Tell(new ClusterMessage(string.Format("You must subscribe before you can unsubscribe : {0}", Sender.ToString())));
});
Receive<MemberDown>(ic =>
{
var message = string.Format("User {0} is forcing the following member down: {1}", ic.UserName, ic.Address.ToString());
_logger.Warning(message);
Sender.Tell(new ClusterMessage(message));
Cluster.Down(ic.Address);
Thread.Sleep(5000);
});
Receive<MemberLeave>(ic =>
{
var message = string.Format("User {0} is asking the following member to leave the cluster: {1}", ic.UserName, ic.Address.ToString());
_logger.Warning(message);
Sender.Tell(new ClusterMessage(message));
Cluster.Leave(ic.Address);
Thread.Sleep(5000);
});
Receive<ClusterEvent.CurrentClusterState>(state =>
{
_currentClusterState = state;
foreach (var client in _clients)
{
_logger.Info("Sending ClusterState to {0}", this.Sender.ToString());
client.Tell(_currentClusterState, Self);
}
});
Receive<GetClusterState>(ic =>
{
_logger.Info("Sending ClusterState to {0}", this.Sender.ToString());
Sender.Tell(_currentClusterState, Self);
});
Receive<ClusterEvent.IReachabilityEvent>(mem =>
{
foreach (var client in _clients)
{
client.Tell(mem, Self);
}
});
Receive<ClusterEvent.IMemberEvent>(mem =>
{
foreach (var client in _clients)
{
client.Tell(mem, Self);
}
});
Receive<SendCurrentClusterState>(ic =>
{
Cluster.SendCurrentClusterState(Self);
});
ReceiveAny(task =>
{
_logger.Error("Oh Snap! ClusterSender.Ready.ReceiveAny: \r\n{0}", task);
});
}
/// <summary>
/// The current snapshot state corresponding to latest gossip
/// to mimic what you would have seen if you were listening to the events.
/// </summary>
private void SendCurrentClusterState(ActorRef receiver)
{
var state = new ClusterEvent.CurrentClusterState(
_latestGossip.Members,
_latestGossip.Overview.Reachability.AllUnreachableOrTerminated.Select(_latestGossip.GetMember)
.ToImmutableHashSet(),
_latestGossip.SeenBy.Select(s => s.Address).ToImmutableHashSet(),
_latestGossip.Leader == null ? null : _latestGossip.Leader.Address,
_latestGossip.AllRoles.ToImmutableDictionary(r => r, r => _latestGossip.RoleLeader(r).Address)
);
receiver.Tell(state);
}
private void Ready()
{
Receive<GetClusterState>(ic =>
{
List<ClusterRoleLeader> clusterRoleLeaders = new List<ClusterRoleLeader>();
foreach (var member in _clusterState.Members)
{
var role = member.Roles.First();
var address = _clusterState.RoleLeader(role);
clusterRoleLeaders.Add(new ClusterRoleLeader(role, address));
}
var currentClusterStatus = new CurrentClusterStatus(clusterRoleLeaders, Cluster.SelfAddress,
_clusterState);
Sender.Tell(currentClusterStatus);
});
Receive<ClusterEvent.CurrentClusterState>(state =>
{
_clusterState = state;
// Check Cluster Leader
if (state.Leader == null)
{
_logger.Warning("ClusterLeader is null");
}
else
{
_logger.Debug("ClusterLeader : {0}", state.Leader.ToString());
}
// Check Role Leaders
var roles = _clusterState.Members.Where(y => y.Status == MemberStatus.Up).Select(x => x.Roles.First()).Distinct().ToList();
foreach (var role in roles)
{
var address = state.RoleLeader(role);
if (address == null)
{
_logger.Warning("RoleLeader: {0}, No leader found!", role);
}
else
{
_logger.Debug("RoleLeader: {0}, Address:{1}", role, address);
}
}
// Check Unreachable Members?
foreach (var member in state.Unreachable)
{
_logger.Warning("Unreachable Member; Role: {0}, Status: {1}, Address: {2}, ", member.Roles.Join(";"), member.Status, member.Address.ToString());
}
// Check who I am seen by?
foreach (var seenBy in state.SeenBy)
{
if (_clusterState.Members.Any(x => x.Address == seenBy))
{
_logger.Debug("SeenBy Members; Role: {0}, Status: {1}, Address: {2}, ",
_clusterState.Members.First(x => x.Address == seenBy).Roles.Join(";"),
_clusterState.Members.First(x => x.Address == seenBy).Status,
_clusterState.Members.First(x => x.Address == seenBy).Address.ToString());
}
else
{
_logger.Debug("SeenBy Members; Role: null, Status: null, Address: {0}, ",
_clusterState.Members.First(x => x.Address == seenBy).Address.ToString());
}
}
});
Receive<SendCurrentClusterState>(ic =>
{
Cluster.SendCurrentClusterState(Self);
});
Receive<ClusterEvent.MemberUp>(mem =>
{
_logger.Info("MemberUp: {0}, Role(s): {1}", mem.Member, mem.Member.Roles.Join(","));
});
Receive<ClusterEvent.UnreachableMember>(mem =>
{
_logger.Info("UnreachableMember: {0}, Role(s): {1}", mem.Member, mem.Member.Roles.Join(","));
});
Receive<ClusterEvent.ReachableMember>(mem =>
{
_logger.Info("ReachableMember: {0}, Role(s): {1}", mem.Member, mem.Member.Roles.Join(","));
});
Receive<ClusterEvent.MemberRemoved>(mem =>
{
_logger.Info("MemberRemoved: {0}, Role(s): {1}", mem.Member, mem.Member.Roles.Join(","));
// Check to see if we have been removed?
if (Cluster.SelfAddress.Equals(mem.Member.Address))
{
ClusterNeedsToRestart(string.Format("This member has been removed from the cluster. This system needs to be restarted. Address:{0} ", Cluster.SelfAddress));
}
});
Receive<ClusterEvent.IMemberEvent>(mem =>
{
_logger.Info("IMemberEvent: {0}, Role(s): {1}", mem.Member, mem.Member.Roles.Join(","));
});
Receive<ClusterEvent.ClusterShuttingDown>(cluster =>
{
_logger.Warning("ClusterShuttingDown");
});
ReceiveAny(task =>
{
_logger.Error("{{EventId:999}} [x] Oh Snap! ClusterStatus.Ready.ReceiveAny: \r\n{0}", task);
});
}
