/// <summary>
/// The set of Akka.Cluster nodes designated for receiving heartbeats from this node.
/// </summary>
/// <param name="sender">The node sending heartbeats.</param>
/// <returns>An organized ring of unique nodes.</returns>
public IImmutableSet <UniqueAddress> Receivers(UniqueAddress sender)
{
if (_useAllAsReceivers)
{
return(NodeRing.Remove(sender));
}
else
{
// Pick nodes from the iterator until n nodes that are not unreachable have been selected.
// Intermediate unreachable nodes up to `monitoredByNrOfMembers` are also included in the result.
// The reason for not limiting it to strictly monitoredByNrOfMembers is that the leader must
// be able to continue its duties (e.g. removal of downed nodes) when many nodes are shutdown
// at the same time and nobody in the remaining cluster is monitoring some of the shutdown nodes.
(int, ImmutableSortedSet <UniqueAddress>) Take(int n, IEnumerator <UniqueAddress> iter, ImmutableSortedSet <UniqueAddress> acc, ImmutableHashSet <UniqueAddress> unreachable, int monitoredByNumberOfNodes)
{
while (true)
{
if (iter.MoveNext() == false || n == 0)
{
iter.Dispose(); // dispose enumerator
return(n, acc);
}
else
{
var next = iter.Current;
var isUnreachable = unreachable.Contains(next);
if (isUnreachable && acc.Count >= monitoredByNumberOfNodes)
{
}
else if (isUnreachable)
{
acc = acc.Add(next);
}
else
{
n = n - 1;
acc = acc.Add(next);
}
}
}
}
var(remaining, slice1) = Take(MonitoredByNumberOfNodes, NodeRing.From(sender).Skip(1).GetEnumerator(), ImmutableSortedSet <UniqueAddress> .Empty, Unreachable, MonitoredByNumberOfNodes);
IImmutableSet <UniqueAddress> slice = remaining == 0
? slice1 // or, wrap-around
: Take(remaining, NodeRing.TakeWhile(x => x != sender).GetEnumerator(), slice1, Unreachable, MonitoredByNumberOfNodes).Item2;
return(slice);
}
}
public ImmutableHashSet <UniqueAddress> Receivers(UniqueAddress sender)
{
if (_useAllAsReceivers)
{
return(NodeRing.Remove(sender).ToImmutableHashSet());
}
var slice = NodeRing.From(sender).Skip(1).Take(MonitoredByNumberOfNodes).ToList(); //grab members furthest from this peer
if (slice.Count < MonitoredByNumberOfNodes)
{
slice = slice.Concat(NodeRing.Take(MonitoredByNumberOfNodes - slice.Count)).ToList();
}
return(slice.ToImmutableHashSet());
}
public override Node Release(CanvasHolder canvasHolder, Generators.IDGenerator generator)
{
Node generatedNode = new Node(x, y, width);
generatedNode.Title = title;
foreach (NodeRingHolder nodeRingHolder in canvasHolder.nodeRingHolders)
{
if (nodeRingHolder.parentId == this.id)
{
nodeRingHolder.SetParent(generatedNode);
NodeRing generatedNodeRing = nodeRingHolder.Release(canvasHolder, generator);
generatedNode.AddElement(generatedNodeRing);
}
}
generator.Add(id, generatedNode);
return(generatedNode);
}
public CanvasHolder(Canvas canvas)
{
var canvasDrawables = canvas.Drawbles;
translation = canvas.Translation;
List <NodeHolder> nodeHoldersList = new List <NodeHolder>();
List <NodeRingHolder> nodeRingHoldersList = new List <NodeRingHolder>();
List <WireHolder> wireHoldersList = new List <WireHolder>();
IDGenerator idGenerator = new IDGenerator();
foreach (Drawable d in canvasDrawables)
{
if (d.GetType() == typeof(Node))
{
Node node = (Node)d;
ID nodeId = idGenerator.Add(node);
List <Drawable> nodeElements = node.Elements;
int[] nodeHolderElements = new int[nodeElements.Count];
for (int i = 0; i < nodeElements.Count; i++)
{
NodeRing nodeRing = (NodeRing)nodeElements[i];
ID nodeRingId = idGenerator.Add(nodeRing);
nodeHolderElements[i] = nodeRingId.value;
nodeRingHoldersList.Add(new NodeRingHolder(nodeRingId.value, nodeId.value, nodeRing.Title, nodeRing.Color, nodeRing.Direction));
}
nodeHoldersList.Add(new NodeHolder(nodeId.value, node.BoundingBox.X, node.BoundingBox.Y, node.BoundingBox.Width, node.Title, nodeHolderElements));
}
}
foreach (Drawable d in canvasDrawables)
{
if (d.GetType() == typeof(Wire))
{
Wire wire = (Wire)d;
ID wireId = idGenerator.Add(wire);
wireHoldersList.Add(new WireHolder(wireId.value, idGenerator.Find(wire.Start.Drawable).value, idGenerator.Find(wire.End.Drawable).value));
}
}
nodeHolders = nodeHoldersList.ToArray();
nodeRingHolders = nodeRingHoldersList.ToArray();
wireHolders = wireHoldersList.ToArray();
}
public NodeRingIndex(NodeRing nodeRing, int newIndex)
{
this.nodeRing = nodeRing;
this.newIndex = newIndex;
}
