com.lightbend.akka.sbr

Class SplitBrainResolver.Strategy

java.lang.Object

com.lightbend.akka.sbr.SplitBrainResolver.Strategy

All Implemented Interfaces:

akka.actor.NoSerializationVerificationNeeded

Direct Known Subclasses:

SplitBrainResolver.DownAllNodes, SplitBrainResolver.KeepMajority, SplitBrainResolver.KeepOldest, SplitBrainResolver.KeepReferee, SplitBrainResolver.LeaseMajority, SplitBrainResolver.StaticQuorum

Enclosing class:

SplitBrainResolver

public abstract static class SplitBrainResolver.Strategy
extends java.lang.Object
implements akka.actor.NoSerializationVerificationNeeded

Constructor Summary

Constructors

Constructor and Description
Strategy(java.lang.String selfDc)

Method Summary

Modifier and Type	Method and Description
void	add(akka.cluster.Member m)
void	addReachable(akka.cluster.Member m)
void	addUnreachable(akka.cluster.Member m)
scala.collection.immutable.SortedSet<akka.cluster.Member>	allMembersInDC()
abstract SplitBrainResolver.Decision	decide()
boolean	hasIndirectlyConnected()
scala.collection.immutable.Set<akka.cluster.UniqueAddress>	indirectlyConnected() Nodes that are marked as unreachable but can communicate with gossip via a 3rd party.
boolean	isAllUnreachableDownOrExiting()
scala.collection.immutable.SortedSet<akka.cluster.Member>	joining()
scala.Option<akka.coordination.lease.scaladsl.Lease>	lease()
scala.collection.immutable.SortedSet<akka.cluster.Member>	members() All members in self DC, but doesn't contain Joining, WeaklyUp, Down and Exiting.
scala.collection.immutable.SortedSet<akka.cluster.Member>	members(boolean includingPossiblyUp, boolean excludingPossiblyExiting) All members in self DC, but doesn't contain Joining, WeaklyUp, Down and Exiting.
scala.collection.immutable.SortedSet<akka.cluster.Member>	membersWithRole()
scala.collection.immutable.SortedSet<akka.cluster.Member>	membersWithRole(boolean includingPossiblyUp, boolean excludingPossiblyExiting)
scala.collection.immutable.Set<akka.cluster.UniqueAddress>	nodesToDown(SplitBrainResolver.Decision decision)
SplitBrainResolver.Decision	nodesToDown$default$1()
protected scala.math.Ordering<akka.cluster.Member>	ordering()
akka.cluster.Reachability	reachability()
scala.collection.immutable.SortedSet<akka.cluster.Member>	reachableMembers()
scala.collection.immutable.SortedSet<akka.cluster.Member>	reachableMembers(boolean includingPossiblyUp, boolean excludingPossiblyExiting)
scala.collection.immutable.SortedSet<akka.cluster.Member>	reachableMembersWithRole()
scala.collection.immutable.SortedSet<akka.cluster.Member>	reachableMembersWithRole(boolean includingPossiblyUp, boolean excludingPossiblyExiting)
void	remove(akka.cluster.Member m)
SplitBrainResolver.Decision	reverseDecision(SplitBrainResolver.Decision decision)
abstract scala.Option<java.lang.String>	role()
scala.collection.immutable.Set<akka.actor.Address>	seenBy()
java.lang.String	selfDc()
boolean	setReachability(akka.cluster.Reachability r)
void	setSeenBy(scala.collection.immutable.Set<akka.actor.Address> s)
scala.collection.immutable.Set<akka.cluster.UniqueAddress>	unreachable()
boolean	unreachable(akka.cluster.Member m)
scala.collection.immutable.Set<akka.cluster.UniqueAddress>	unreachableButNotIndirectlyConnected()
scala.collection.immutable.SortedSet<akka.cluster.Member>	unreachableMembers()
scala.collection.immutable.SortedSet<akka.cluster.Member>	unreachableMembers(boolean includingPossiblyUp, boolean excludingPossiblyExiting)
scala.collection.immutable.SortedSet<akka.cluster.Member>	unreachableMembersWithRole()
scala.collection.immutable.SortedSet<akka.cluster.Member>	unreachableMembersWithRole(boolean includingPossiblyUp, boolean excludingPossiblyExiting)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Strategy

public Strategy(java.lang.String selfDc)

Method Detail

add

public void add(akka.cluster.Member m)

addReachable

public void addReachable(akka.cluster.Member m)

addUnreachable

public void addUnreachable(akka.cluster.Member m)

allMembersInDC

public scala.collection.immutable.SortedSet<akka.cluster.Member> allMembersInDC()

decide

public abstract SplitBrainResolver.Decision decide()

hasIndirectlyConnected

public boolean hasIndirectlyConnected()

indirectlyConnected

public scala.collection.immutable.Set<akka.cluster.UniqueAddress> indirectlyConnected()

Nodes that are marked as unreachable but can communicate with gossip via a 3rd party.

Cycle in unreachability graph corresponds to that some node is both observing another node as unreachable, and is also observed as unreachable by someone else.

Another indication of indirectly connected nodes is if a node is marked as unreachable, but it has still marked current gossip state as seen.

Those cases will not happen for clean splits and crashed nodes.

Returns:

(undocumented)

isAllUnreachableDownOrExiting

public boolean isAllUnreachableDownOrExiting()

joining

public scala.collection.immutable.SortedSet<akka.cluster.Member> joining()

lease

public scala.Option<akka.coordination.lease.scaladsl.Lease> lease()

members

public scala.collection.immutable.SortedSet<akka.cluster.Member> members()

All members in self DC, but doesn't contain Joining, WeaklyUp, Down and Exiting.

Returns:

(undocumented)

members

public scala.collection.immutable.SortedSet<akka.cluster.Member> members(boolean includingPossiblyUp,
                                                                         boolean excludingPossiblyExiting)

All members in self DC, but doesn't contain Joining, WeaklyUp, Down and Exiting.

When includingPossiblyUp=true it also includes Joining and WeaklyUp members that could have been changed to Up on the other side of a partition.

When excludingPossiblyExiting=true it doesn't include Leaving members that could have been changed to Exiting on the other side of the partition.

Parameters:

includingPossiblyUp - (undocumented)

excludingPossiblyExiting - (undocumented)

Returns:

(undocumented)

membersWithRole

public scala.collection.immutable.SortedSet<akka.cluster.Member> membersWithRole()

membersWithRole

public scala.collection.immutable.SortedSet<akka.cluster.Member> membersWithRole(boolean includingPossiblyUp,
                                                                                 boolean excludingPossiblyExiting)

nodesToDown

public scala.collection.immutable.Set<akka.cluster.UniqueAddress> nodesToDown(SplitBrainResolver.Decision decision)

nodesToDown$default$1

public SplitBrainResolver.Decision nodesToDown$default$1()

ordering

protected scala.math.Ordering<akka.cluster.Member> ordering()

reachability

public akka.cluster.Reachability reachability()

reachableMembers

public scala.collection.immutable.SortedSet<akka.cluster.Member> reachableMembers()

reachableMembers

public scala.collection.immutable.SortedSet<akka.cluster.Member> reachableMembers(boolean includingPossiblyUp,
                                                                                  boolean excludingPossiblyExiting)

reachableMembersWithRole

public scala.collection.immutable.SortedSet<akka.cluster.Member> reachableMembersWithRole()

reachableMembersWithRole

public scala.collection.immutable.SortedSet<akka.cluster.Member> reachableMembersWithRole(boolean includingPossiblyUp,
                                                                                          boolean excludingPossiblyExiting)

remove

public void remove(akka.cluster.Member m)

reverseDecision

public SplitBrainResolver.Decision reverseDecision(SplitBrainResolver.Decision decision)

role

public abstract scala.Option<java.lang.String> role()

seenBy

public scala.collection.immutable.Set<akka.actor.Address> seenBy()

selfDc

public java.lang.String selfDc()

setReachability

public boolean setReachability(akka.cluster.Reachability r)

Parameters:

r - (undocumented)

Returns:

true if it was changed

setSeenBy

public void setSeenBy(scala.collection.immutable.Set<akka.actor.Address> s)

unreachable

public scala.collection.immutable.Set<akka.cluster.UniqueAddress> unreachable()

unreachable

public boolean unreachable(akka.cluster.Member m)

unreachableButNotIndirectlyConnected

public scala.collection.immutable.Set<akka.cluster.UniqueAddress> unreachableButNotIndirectlyConnected()

unreachableMembers

public scala.collection.immutable.SortedSet<akka.cluster.Member> unreachableMembers()

unreachableMembers

public scala.collection.immutable.SortedSet<akka.cluster.Member> unreachableMembers(boolean includingPossiblyUp,
                                                                                    boolean excludingPossiblyExiting)

unreachableMembersWithRole

public scala.collection.immutable.SortedSet<akka.cluster.Member> unreachableMembersWithRole()

unreachableMembersWithRole

public scala.collection.immutable.SortedSet<akka.cluster.Member> unreachableMembersWithRole(boolean includingPossiblyUp,
                                                                                            boolean excludingPossiblyExiting)