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); }