private void ctrlBtnEventNew_Click(object sender, RoutedEventArgs e)
{
ClusterEventWindow Wnd = new ClusterEventWindow();
Wnd.WindowStartupLocation = WindowStartupLocation.CenterOwner;
Wnd.Owner = this;
Wnd.AvailableCategories = GetAvailableCategories();
Wnd.AvailableTypes = GetAvailableTypes();
Wnd.AvailableNames = GetAvailableNames();
bool?RetVal = Wnd.ShowDialog();
if (RetVal.HasValue && RetVal == true)
{
Dictionary <string, string> ArgMap = new Dictionary <string, string>();
ClusterEvent NewEvt = new ClusterEvent(Wnd.SelectedCategory, Wnd.SelectedType, Wnd.SelectedName, Wnd.GetArgDictionary());
NewEvt.RebuildJsonStringForGui();
ClusterEvents.Add(NewEvt);
RegistrySaver.AddRegistryValue(RegistrySaver.RegCategoryClusterEvents, NewEvt.SerializeToString());
AppLogger.Log("New cluster event stored: " + NewEvt.ToString());
}
else
{
// Nothing to do
}
}
public void DomainEvents_must_be_produced_for_members_becoming_reachable_after_unreachable()
{
var reachability1 = Reachability.Empty.
Unreachable(aUp.UniqueAddress, cUp.UniqueAddress).
Reachable(aUp.UniqueAddress, cUp.UniqueAddress).
Unreachable(aUp.UniqueAddress, eUp.UniqueAddress).
Unreachable(aUp.UniqueAddress, bUp.UniqueAddress);
var g1 = new Gossip(ImmutableSortedSet.Create(aUp, bUp, cUp, eUp), new GossipOverview(reachability1));
var reachability2 = reachability1.
Unreachable(aUp.UniqueAddress, cUp.UniqueAddress).
Reachable(aUp.UniqueAddress, bUp.UniqueAddress);
var g2 = new Gossip(ImmutableSortedSet.Create(aUp, cUp, bUp, eUp), new GossipOverview(reachability2));
ClusterEvent.DiffUnreachable(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.UnreachableMember(cUp)));
// never include self member in unreachable
ClusterEvent.DiffUnreachable(g1, g2, cUp.UniqueAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.UnreachableMember>());
ClusterEvent.DiffReachable(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.ReachableMember(bUp)));
// never include self member in reachable
ClusterEvent.DiffReachable(g1, g2, bUp.UniqueAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.ReachableMember>());
}
public void DomainEvents_must_be_produced_for_convergence_changes()
{
var g1 = new Gossip(ImmutableSortedSet.Create(aUp, bUp, eJoining))
.Seen(aUp.UniqueAddress)
.Seen(bUp.UniqueAddress)
.Seen(eJoining.UniqueAddress);
var g2 = new Gossip(ImmutableSortedSet.Create(aUp, bUp, eJoining))
.Seen(aUp.UniqueAddress)
.Seen(bUp.UniqueAddress);
ClusterEvent.DiffMemberEvents(g1, g2)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.IMemberEvent>());
ClusterEvent.DiffUnreachable(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.UnreachableMember>());
ClusterEvent.DiffSeen(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.SeenChanged(true, ImmutableHashSet.Create(aUp.Address, bUp.Address))));
ClusterEvent.DiffMemberEvents(g2, g1)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.IMemberEvent>());
ClusterEvent.DiffUnreachable(g1, g1, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.UnreachableMember>());
ClusterEvent.DiffSeen(g2, g1, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.SeenChanged(true, ImmutableHashSet.Create(aUp.Address, bUp.Address, eJoining.Address))));
}
public void DomainEvents_must_be_empty_for_the_same_gossip()
{
var g1 = new Gossip(ImmutableSortedSet.Create(aUp));
ClusterEvent.DiffUnreachable(g1, g1, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.UnreachableMember>());
}
public void DomainEventMustBeProducedForMembersInUnreachable()
{
var reachability1 = Reachability.Empty.
Unreachable(aUp.UniqueAddress, cUp.UniqueAddress).
Unreachable(aUp.UniqueAddress, eUp.UniqueAddress);
var g1 = new Gossip(ImmutableSortedSet.Create(aUp, bUp, cUp, eUp), new GossipOverview(reachability1));
var reachability2 = reachability1.
Unreachable(aUp.UniqueAddress, bDown.UniqueAddress);
var g2 = new Gossip(ImmutableSortedSet.Create(aUp, cUp, bDown, eDown), new GossipOverview(reachability2));
Assert.Equal(ImmutableList.Create(new ClusterEvent.UnreachableMember(bDown)), ClusterEvent.DiffUnreachable(g1, g2));
Assert.Equal(ImmutableList.Create <ClusterEvent.SeenChanged>(), ClusterEvent.DiffSeen(g1, g2, selfDummyAddress));
}
public void DomainEventMustBeProducedForChangedStatusOfMembers()
{
var t1 = Converge(new Gossip(ImmutableSortedSet.Create(aJoining, bUp, cUp)));
var t2 = Converge(new Gossip(ImmutableSortedSet.Create(aUp, bUp, cLeaving, eJoining)));
var g1 = t1.Item1;
var g2 = t2.Item1;
var s2 = t2.Item2;
Assert.Equal(ImmutableList.Create(new ClusterEvent.MemberUp(aUp)), ClusterEvent.DiffMemberEvents(g1, g2));
Assert.Equal(ImmutableList.Create <ClusterEvent.UnreachableMember>(), ClusterEvent.DiffUnreachable(g1, g2));
Assert.Equal(ImmutableList.Create(new ClusterEvent.SeenChanged(true, s2.Select(s => s.Address).ToImmutableHashSet())), ClusterEvent.DiffSeen(g1, g2, selfDummyAddress));
}
/// <summary>
/// Serializes the object to JSON.
/// </summary>
/// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
/// <param name="obj">The object to serialize to JSON.</param>
internal static void Serialize(JsonWriter writer, ClusterEvent obj)
{
// Required properties are always serialized, optional properties are serialized when not null.
writer.WriteStartObject();
writer.WriteProperty(obj.Kind.ToString(), "Kind", JsonWriterExtensions.WriteStringValue);
writer.WriteProperty(obj.EventInstanceId, "EventInstanceId", JsonWriterExtensions.WriteGuidValue);
writer.WriteProperty(obj.TimeStamp, "TimeStamp", JsonWriterExtensions.WriteDateTimeValue);
if (obj.HasCorrelatedEvents != null)
{
writer.WriteProperty(obj.HasCorrelatedEvents, "HasCorrelatedEvents", JsonWriterExtensions.WriteBoolValue);
}
writer.WriteEndObject();
}
public void DomainEventMustBeProducedForLeaderChanges()
{
var t1 = Converge(new Gossip(ImmutableSortedSet.Create(aUp, bUp, eJoining)));
var t2 = Converge(new Gossip(ImmutableSortedSet.Create(bUp, eJoining)));
var g1 = t1.Item1;
var g2 = t2.Item1;
var s2 = t2.Item2;
Assert.Equal(ImmutableList.Create(new ClusterEvent.MemberRemoved(aRemoved, MemberStatus.Up)), ClusterEvent.DiffMemberEvents(g1, g2));
Assert.Equal(ImmutableList.Create <ClusterEvent.UnreachableMember>(), ClusterEvent.DiffUnreachable(g1, g2));
Assert.Equal(ImmutableList.Create(new ClusterEvent.SeenChanged(true, s2.Select(a => a.Address).ToImmutableHashSet())), ClusterEvent.DiffSeen(g1, g2, selfDummyAddress));
Assert.Equal(ImmutableList.Create(new ClusterEvent.LeaderChanged(bUp.Address)), ClusterEvent.DiffLeader(g1, g2, selfDummyAddress));
}
public void DomainEventMustBeProducedForConvergenceChanges()
{
var g1 =
new Gossip(ImmutableSortedSet.Create(aUp, bUp, eJoining)).Seen(aUp.UniqueAddress)
.Seen(bUp.UniqueAddress)
.Seen(eJoining.UniqueAddress);
var g2 = new Gossip(ImmutableSortedSet.Create(aUp, bUp, eJoining)).Seen(aUp.UniqueAddress).Seen(bUp.UniqueAddress);
Assert.Equal(ImmutableList.Create <ClusterEvent.IMemberEvent>(), ClusterEvent.DiffMemberEvents(g1, g2));
Assert.Equal(ImmutableList.Create <ClusterEvent.UnreachableMember>(), ClusterEvent.DiffUnreachable(g1, g2));
Assert.Equal(ImmutableList.Create(new ClusterEvent.SeenChanged(true, ImmutableHashSet.Create(aUp.Address, bUp.Address))), ClusterEvent.DiffSeen(g1, g2, selfDummyAddress));
Assert.Equal(ImmutableList.Create <ClusterEvent.IMemberEvent>(), ClusterEvent.DiffMemberEvents(g2, g1));
Assert.Equal(ImmutableList.Create <ClusterEvent.UnreachableMember>(), ClusterEvent.DiffUnreachable(g2, g1));
Assert.Equal(ImmutableList.Create(new ClusterEvent.SeenChanged(true, ImmutableHashSet.Create(aUp.Address, bUp.Address, eJoining.Address))), ClusterEvent.DiffSeen(g2, g1, selfDummyAddress));
}
public void DomainEvents_must_be_produced_for_downed_members()
{
var t1 = Converge(new Gossip(ImmutableSortedSet.Create(aUp, eUp)));
var t2 = Converge(new Gossip(ImmutableSortedSet.Create(aUp, eDown)));
var g1 = t1.Item1;
var g2 = t2.Item1;
ClusterEvent.DiffMemberEvents(g1, g2)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.IMemberEvent>(new ClusterEvent.MemberDowned(eDown)));
ClusterEvent.DiffUnreachable(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.UnreachableMember>());
}
private void Handle(ClusterEvent.MemberUp m)
{
if (_cluster != null)
{
if (_cluster.SelfUniqueAddress == m.Member.UniqueAddress)
{
var roles = string.Join(", ", _cluster.SelfRoles);
_log.Info($"Cluster.Up: {_cluster.SelfUniqueAddress} Role={roles}");
}
else
{
var remoteDiscoveryActor = Context.ActorSelection(m.Member.Address + "/user/" + _name);
remoteDiscoveryActor.Tell(
new ClusterActorDiscoveryMessage.RegisterCluster(
_cluster.SelfUniqueAddress,
_actorItems.Select(a => new ClusterActorDiscoveryMessage.ClusterActorUp(a.Actor, a.Tag)).ToList()));
}
}
}
private void InitializeEvents()
{
List <string> SavedEvents = RegistrySaver.ReadStringsFromRegistry(RegistrySaver.RegCategoryClusterEvents);
foreach (string SavedEventStr in SavedEvents)
{
ClusterEvent RestoredEvent = new ClusterEvent();
RestoredEvent.DeserializeFromString(SavedEventStr);
ClusterEvents.Add(RestoredEvent);
}
ctrlListClusterEvents.ItemsSource = ClusterEvents;
CollectionView view = (CollectionView)CollectionViewSource.GetDefaultView(ctrlListClusterEvents.ItemsSource);
view.SortDescriptions.Add(new SortDescription("Category", ListSortDirection.Ascending));
view.SortDescriptions.Add(new SortDescription("Type", ListSortDirection.Ascending));
view.SortDescriptions.Add(new SortDescription("Name", ListSortDirection.Ascending));
}
private void ctrlBtnEventModify_Click(object sender, RoutedEventArgs e)
{
if (ctrlListClusterEvents.SelectedItems.Count > 0)
{
List <ClusterEvent> ItemsToModify = new List <ClusterEvent>();
foreach (ClusterEvent Evt in ctrlListClusterEvents.SelectedItems)
{
ItemsToModify.Add(Evt);
}
foreach (ClusterEvent Evt in ItemsToModify)
{
int Idx = ClusterEvents.IndexOf(Evt);
if (Idx >= 0)
{
ClusterEventWindow Wnd = new ClusterEventWindow();
Wnd.WindowStartupLocation = WindowStartupLocation.CenterOwner;
Wnd.Owner = this;
Wnd.AvailableCategories = GetAvailableCategories();
Wnd.AvailableTypes = GetAvailableTypes();
Wnd.AvailableNames = GetAvailableNames();
Wnd.SelectedCategory = Evt.Category;
Wnd.SelectedType = Evt.Type;
Wnd.SelectedName = Evt.Name;
Wnd.SetArgDictionary(Evt.Parameters);
bool?RetVal = Wnd.ShowDialog();
if (RetVal.HasValue && RetVal == true)
{
RegistrySaver.RemoveRegistryValue(RegistrySaver.RegCategoryClusterEvents, ClusterEvents[Idx].SerializeToString());
ClusterEvents[Idx] = new ClusterEvent(Wnd.SelectedCategory, Wnd.SelectedType, Wnd.SelectedName, Wnd.GetArgDictionary());
RegistrySaver.AddRegistryValue(RegistrySaver.RegCategoryClusterEvents, ClusterEvents[Idx].SerializeToString());
}
}
}
UpdateJsonInfo();
}
}
public void DomainEvents_must_be_produced_for_changed_status_of_members()
{
var t1 = Converge(new Gossip(ImmutableSortedSet.Create(aJoining, bUp, cUp)));
var t2 = Converge(new Gossip(ImmutableSortedSet.Create(aUp, bUp, cLeaving, eJoining)));
var g1 = t1.Item1;
var g2 = t2.Item1;
var s2 = t2.Item2;
ClusterEvent.DiffMemberEvents(g1, g2)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.IMemberEvent>(new ClusterEvent.MemberUp(aUp), new ClusterEvent.MemberLeft(cLeaving), new ClusterEvent.MemberJoined(eJoining)));
ClusterEvent.DiffUnreachable(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.UnreachableMember>());
ClusterEvent.DiffSeen(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.SeenChanged(true, s2.Select(s => s.Address).ToImmutableHashSet())));
}
public void DomainEvents_must_be_produced_for_removed_members()
{
var t1 = Converge(new Gossip(ImmutableSortedSet.Create(aUp, dExiting)));
var t2 = Converge(new Gossip(ImmutableSortedSet.Create(aUp)));
var g1 = t1.Item1;
var g2 = t2.Item1;
var s2 = t2.Item2;
ClusterEvent.DiffMemberEvents(g1, g2)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.IMemberEvent>(new ClusterEvent.MemberRemoved(dRemoved, MemberStatus.Exiting)));
ClusterEvent.DiffUnreachable(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.UnreachableMember>());
ClusterEvent.DiffSeen(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.SeenChanged(true, s2.Select(s => s.Address).ToImmutableHashSet())));
}
public void DomainEvents_must_be_produced_for_leader_changes()
{
var t1 = Converge(new Gossip(ImmutableSortedSet.Create(aUp, bUp, eJoining)));
var t2 = Converge(new Gossip(ImmutableSortedSet.Create(bUp, eJoining)));
var g1 = t1.Item1;
var g2 = t2.Item1;
var s2 = t2.Item2;
ClusterEvent.DiffMemberEvents(g1, g2)
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.MemberRemoved(aRemoved, MemberStatus.Up)));
ClusterEvent.DiffUnreachable(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.UnreachableMember>());
ClusterEvent.DiffSeen(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.SeenChanged(true, s2.Select(a => a.Address).ToImmutableHashSet())));
ClusterEvent.DiffLeader(g1, g2, selfDummyAddress)
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.LeaderChanged(bUp.Address)));
}
public void DomainEvents_must_be_produced_for_members_in_unreachable()
{
var reachability1 = Reachability.Empty.
Unreachable(aUp.UniqueAddress, cUp.UniqueAddress).
Unreachable(aUp.UniqueAddress, eUp.UniqueAddress);
var g1 = new Gossip(ImmutableSortedSet.Create(aUp, bUp, cUp, eUp), new GossipOverview(reachability1));
var reachability2 = reachability1.
Unreachable(aUp.UniqueAddress, bDown.UniqueAddress);
var g2 = new Gossip(ImmutableSortedSet.Create(aUp, cUp, bDown, eDown), new GossipOverview(reachability2));
ClusterEvent.DiffUnreachable(State(g1), State(g2))
.Should()
.BeEquivalentTo(ImmutableList.Create(new ClusterEvent.UnreachableMember(bDown)));
// never include self member in unreachable
ClusterEvent.DiffUnreachable(new MembershipState(g1, bDown.UniqueAddress), new MembershipState(g2, bDown.UniqueAddress))
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.UnreachableMember>());
ClusterEvent.DiffSeen(State(g1), State(g2))
.Should()
.BeEquivalentTo(ImmutableList.Create <ClusterEvent.SeenChanged>());
}
public void DomainEvents_must_be_produced_for_role_leader_changes()
{
var g0 = Gossip.Empty;
var g1 = new Gossip(ImmutableSortedSet.Create(aUp, bUp, cUp, dLeaving, eJoining));
var g2 = new Gossip(ImmutableSortedSet.Create(bUp, cUp, dExiting, eJoining));
var expected = ImmutableHashSet.Create(
new ClusterEvent.RoleLeaderChanged("AA", aUp.Address),
new ClusterEvent.RoleLeaderChanged("AB", aUp.Address),
new ClusterEvent.RoleLeaderChanged("BB", bUp.Address),
new ClusterEvent.RoleLeaderChanged("DD", dLeaving.Address),
new ClusterEvent.RoleLeaderChanged("DE", dLeaving.Address),
new ClusterEvent.RoleLeaderChanged("EE", eUp.Address));
ClusterEvent.DiffRolesLeader(g0, g1, selfDummyAddress).Should().BeEquivalentTo(expected);
var expected2 = ImmutableHashSet.Create(
new ClusterEvent.RoleLeaderChanged("AA", null),
new ClusterEvent.RoleLeaderChanged("AB", bUp.Address),
new ClusterEvent.RoleLeaderChanged("DE", eJoining.Address));
ClusterEvent.DiffRolesLeader(g1, g2, selfDummyAddress).Should().BeEquivalentTo(expected2);
}
public void DomainEventMustBeProducedForRoleLeaderChanges()
{
var g0 = Gossip.Empty;
var g1 = new Gossip(ImmutableSortedSet.Create(aUp, bUp, cUp, dLeaving, eJoining));
var g2 = new Gossip(ImmutableSortedSet.Create(bUp, cUp, dExiting, eJoining));
var expected = ImmutableHashSet.Create(
new ClusterEvent.RoleLeaderChanged("AA", aUp.Address),
new ClusterEvent.RoleLeaderChanged("AB", aUp.Address),
new ClusterEvent.RoleLeaderChanged("BB", bUp.Address),
new ClusterEvent.RoleLeaderChanged("DD", dLeaving.Address),
new ClusterEvent.RoleLeaderChanged("DE", dLeaving.Address),
new ClusterEvent.RoleLeaderChanged("EE", eUp.Address)
);
Assert.Equal(expected, ClusterEvent.DiffRolesLeader(g0, g1, selfDummyAddress));
var expected2 = ImmutableHashSet.Create(
new ClusterEvent.RoleLeaderChanged("AA", null),
new ClusterEvent.RoleLeaderChanged("AB", bUp.Address),
new ClusterEvent.RoleLeaderChanged("DE", eJoining.Address)
);
Assert.Equal(expected2, ClusterEvent.DiffRolesLeader(g1, g2, selfDummyAddress));
}
public void DomainEventsMustBeEmptyForTheSameGossip()
{
var g1 = new Gossip(ImmutableSortedSet.Create(aUp));
Assert.Equal(ImmutableSortedSet.Create <object>(), ClusterEvent.DiffUnreachable(g1, g1));
}
private void HandleInitial(ClusterEvent.CurrentClusterState state)
{
_membersByAge = state.Members
.Where(m => (m.Status == MemberStatus.Up || m.Status == MemberStatus.Leaving) && MatchingRole(m))
.ToImmutableSortedSet(MemberAgeOrdering.Descending);
var safeToBeOldest = !state.Members.Any(m => m.Status == MemberStatus.Down || m.Status == MemberStatus.Exiting);
var initial = new InitialOldestState(MemberAddressOrDefault(_membersByAge.FirstOrDefault()), safeToBeOldest);
_changes = _changes.Enqueue(initial);
}
private void HandleInitial(ClusterEvent.CurrentClusterState state)
{
TrackChanges(() => _membersByAge = state.Members.Where(m => m.Status == MemberStatus.Up && MatchingRole(m)).ToImmutableSortedSet(MemberAgeOrdering.Descending));
}
public void DomainEventMustBeProducedForMembersBecomingReachableAfterUnreachable()
{
var reachability1 = Reachability.Empty.
Unreachable(aUp.UniqueAddress, cUp.UniqueAddress).Reachable(aUp.UniqueAddress, cUp.UniqueAddress).
Unreachable(aUp.UniqueAddress, eUp.UniqueAddress).
Unreachable(aUp.UniqueAddress, bUp.UniqueAddress);
var g1 = new Gossip(ImmutableSortedSet.Create(aUp, bUp, cUp, eUp), new GossipOverview(reachability1));
var reachability2 = reachability1.
Unreachable(aUp.UniqueAddress, cUp.UniqueAddress).
Reachable(aUp.UniqueAddress, bUp.UniqueAddress);
var g2 = new Gossip(ImmutableSortedSet.Create(aUp, cUp, bUp, eUp), new GossipOverview(reachability2));
Assert.Equal(ImmutableList.Create(new ClusterEvent.UnreachableMember(cUp)), ClusterEvent.DiffUnreachable(g1, g2));
Assert.Equal(ImmutableList.Create(new ClusterEvent.ReachableMember(bUp)), ClusterEvent.DiffReachable(g1, g2));
}
public void DomainEvents_must_be_empty_for_the_same_gossip()
{
var g1 = new Gossip(ImmutableSortedSet.Create(aUp));
Assert.Equal(ImmutableSortedSet.Create <object>(), ClusterEvent.DiffUnreachable(g1, g1));
}
private void Handle(ClusterEvent.UnreachableMember m)
{
_log.Info($"Cluster.Unreachable: {m.Member.Address} Role={string.Join(",", m.Member.Roles)}");
var item = _nodeMap.FirstOrDefault(i => i.Value.ClusterAddress == m.Member.UniqueAddress);
if (item.Key != null)
RemoveNode(item.Key);
}
