private void HandleInitial(ClusterEvent.CurrentClusterState state)
{
TrackChanges(() =>
_membersByAge = state.Members
.Where(m => m.Status == MemberStatus.Up && MatchingRole(m))
.ToImmutableSortedSet(MemberAgeOrdering.Descending));
}
/// <summary>
/// Updates the initial node ring for those nodes that are <see cref="MemberStatus"/> `Up`.
/// </summary>
private void ReceiveState(ClusterEvent.CurrentClusterState state)
{
_nodes = state.Members.Except(state.Unreachable)
.Where(m => m.Status == MemberStatus.Up || m.Status == MemberStatus.WeaklyUp)
.Select(m => m.Address)
.ToImmutableSortedSet();
}
private void HandleClusterState(ClusterEvent.CurrentClusterState state)
{
var builder = ImmutableSortedSet <Member> .Empty.ToBuilder();
builder.KeyComparer = AgeOrdering;
var members = builder.ToImmutable()
.Union(state.Members.Where(m => m.Status == MemberStatus.Up && MatchingRole(m)));
ChangeMembers(members);
}
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(_membersByAge.FirstOrDefault()?.UniqueAddress, safeToBeOldest);
_changes = _changes.Enqueue(initial);
}
public IEnumerable <Member> GetVictims(ClusterEvent.CurrentClusterState clusterState)
{
//Example configuration access
var config = this.system.Settings.Config.GetConfig($"akka.cluster.{MyDowningProvider.RootConfigElement}");
var exampleSetting = config.GetInt("example-config-entry");
this.system.Log.Info($"Example logging of example setting: {exampleSetting}");
//Decide what do based off the the passed in current cluster state.
//Whatever is returned, will be downed
return(Enumerable.Empty <Member>());
}
private void Handle(ClusterEvent.CurrentClusterState msg)
{
_log.Info(">>> ClusterEvent.CurrentClusterState");
var state = (ClusterEvent.CurrentClusterState)msg;
foreach (var member in state.Members)
{
_log.Info($">>> ClusterEvent.CurrentClusterState : {member.Address}");
if (member.Status == MemberStatus.Up)
{
Register(member);
}
}
}
private void HandleInitial(ClusterEvent.CurrentClusterState state)
{
_membersByAge = state.Members
.Where(m => (m.Status == MemberStatus.Up) && MatchingRole(m))
.ToImmutableSortedSet(MemberAgeOrdering.Descending);
// If there is some removal in progress of an older node it's not safe to immediately become oldest,
// removal of younger nodes doesn't matter. Note that it can also be started via restart after
// ClusterSingletonManagerIsStuck.
int selfUpNumber = state.Members.Where(m => m.UniqueAddress == _cluster.SelfUniqueAddress).Select(m => (int?)m.UpNumber).FirstOrDefault() ?? int.MaxValue;
var safeToBeOldest = !state.Members.Any(m => (m.UpNumber < selfUpNumber && MatchingRole(m)) && (m.Status == MemberStatus.Down || m.Status == MemberStatus.Exiting || m.Status == MemberStatus.Leaving));
var initial = new InitialOldestState(_membersByAge.FirstOrDefault()?.UniqueAddress, safeToBeOldest);
_changes = _changes.Enqueue(initial);
}
public void PushClusterState(ClusterEvent.CurrentClusterState clusterState, Address currentClusterAddress)
{
// Push ClusterState x to subscribed client.
// So if client A subscibes to ClusterState A then it should only get A and not B.
// TODO:
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 context = GlobalHost.ConnectionManager.GetHubContext <ClusterStateHub>();
dynamic allClients = context.Clients.All.broadcastClusterState(clusterState, clusterRoleLeaders, currentClusterAddress);
}
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);
}
public CurrentClusterStatus(List <ClusterRoleLeader> clusterRoleLeaders, Address currentClusterAddress, ClusterEvent.CurrentClusterState clusterState)
{
ClusterRoleLeaders = clusterRoleLeaders;
CurrentClusterAddress = currentClusterAddress;
ClusterState = clusterState;
}
private void HandleClusterState(ClusterEvent.CurrentClusterState state)
{
var members = ImmutableSortedSet <Member> .Empty.WithComparer(AgeOrdering).Union(state.Members.Where(m => m.Status == MemberStatus.Up && MatchingRole(m)));
ChangeMembers(members);
}
private void HandleCurrentClusterStateEvent(ClusterEvent.CurrentClusterState message)
{
_currentState = message;
}
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);
});
}
private void ReceiveMessage(ClusterEvent.CurrentClusterState message)
{
Console.WriteLine($">>>>>>> {Self} : {message}");
}
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);
});
}