public Record(UniqueAddress observer, UniqueAddress subject, ReachabilityStatus status, long version)
{
_observer = observer;
_subject = subject;
_status = status;
_version = version;
}
public EchoConsumerActor(ClusterNodeContext context)
{
_clusterContext = context;
_clusterUniqueAddress = Cluster.Get(Context.System).SelfUniqueAddress;
Receive<string>(m => OnMessage(m));
}
private FailureDetectorStub Fd(ClusterHeartbeatSenderState state, UniqueAddress node)
{
return
state.FailureDetector.AsInstanceOf<DefaultFailureDetectorRegistry<Address>>()
.GetFailureDetector(node.Address)
.AsInstanceOf<FailureDetectorStub>();
}
/// <summary>
/// Creates a member from internal Akka method
/// </summary>
/// <returns>The new member</returns>
public static Member MemberCreate(UniqueAddress uniqueAddress, int upNumber, MemberStatus status, ImmutableHashSet<string> roles)
{
var createMethod =
typeof(Member).GetMethods(BindingFlags.NonPublic | BindingFlags.Static)
.First(m => m.Name == "Create" && m.GetParameters().Length == 4);
return (Member)createMethod.Invoke(null, new object[] { uniqueAddress, upNumber, status, roles });
}
public void ClusterMessages_must_be_serializable()
{
var address = new Address("akka.tcp", "system", "some.host.org", 4711);
var uniqueAddress = new UniqueAddress(address, 17);
var address2 = new Address("akka.tcp", "system", "other.host.org", 4711);
var uniqueAddress2 = new UniqueAddress(address2, 18);
CheckSerialization(new InternalClusterAction.Join(uniqueAddress, ImmutableHashSet.Create("foo","bar")));
CheckSerialization(new ClusterUserAction.Leave(address));
CheckSerialization(new ClusterUserAction.Down(address));
CheckSerialization(new InternalClusterAction.InitJoin());
CheckSerialization(new InternalClusterAction.InitJoinAck(address));
CheckSerialization(new InternalClusterAction.InitJoinNack(address));
CheckSerialization(new ClusterHeartbeatSender.Heartbeat(address));
CheckSerialization(new ClusterHeartbeatSender.HeartbeatRsp(uniqueAddress));
var node1 = new VectorClock.Node("node1");
var node2 = new VectorClock.Node("node2");
var node3 = new VectorClock.Node("node3");
var node4 = new VectorClock.Node("node4");
var g1 =
new Gossip(ImmutableSortedSet.Create(a1, b1, c1, d1)).Increment(node1)
.Increment(node2)
.Seen(a1.UniqueAddress)
.Seen(b1.UniqueAddress);
var g2 = g1.Increment(node3).Increment(node4).Seen(a1.UniqueAddress).Seen(c1.UniqueAddress);
var reachability3 =
Reachability.Empty.Unreachable(a1.UniqueAddress, e1.UniqueAddress)
.Unreachable(b1.UniqueAddress, e1.UniqueAddress);
var g3 = g2.Copy(members: ImmutableSortedSet.Create(a1, b1, c1, d1, e1),
overview: g2.Overview.Copy(reachability: reachability3));
CheckSerialization(new GossipEnvelope(a1.UniqueAddress, uniqueAddress2, g1));
CheckSerialization(new GossipEnvelope(a1.UniqueAddress, uniqueAddress2, g2));
CheckSerialization(new GossipEnvelope(a1.UniqueAddress, uniqueAddress2, g3));
CheckSerialization(new GossipStatus(a1.UniqueAddress, g1.Version));
CheckSerialization(new GossipStatus(a1.UniqueAddress, g2.Version));
CheckSerialization(new GossipStatus(a1.UniqueAddress, g3.Version));
CheckSerialization(new InternalClusterAction.Welcome(uniqueAddress, g2));
var mg = new MetricsGossip(ImmutableHashSet.Create<NodeMetrics>(new[]
{
new NodeMetrics(a1.Address, 4711, ImmutableHashSet.Create<Metric>(new Metric("foo", 1.2, null))),
new NodeMetrics(b1.Address, 4712,
ImmutableHashSet.Create<Metric>(new Metric("foo", 2.1, new EWMA(100.0, 0.18))
, new Metric("bar1", Double.MinValue, null), new Metric("bar2", float.MaxValue, null),
new Metric("bar3", int.MaxValue, null), new Metric("bar4", long.MaxValue, null),
new Metric("bar5", double.MaxValue, null)))
}));
CheckSerialization(new MetricsGossipEnvelope(a1.Address, mg, true));
}
public void ClusterMessages_must_be_serializable()
{
var address = new Address("akka.tcp", "system", "some.host.org", 4711);
var uniqueAddress = new UniqueAddress(address, 17);
var address2 = new Address("akka.tcp", "system", "other.host.org", 4711);
var uniqueAddress2 = new UniqueAddress(address2, 18);
CheckSerialization(new InternalClusterAction.Join(uniqueAddress, ImmutableHashSet.Create("foo","bar")));
CheckSerialization(new ClusterUserAction.Leave(address));
CheckSerialization(new ClusterUserAction.Down(address));
CheckSerialization(new InternalClusterAction.InitJoin());
CheckSerialization(new InternalClusterAction.InitJoinAck(address));
CheckSerialization(new InternalClusterAction.InitJoinNack(address));
CheckSerialization(new ClusterHeartbeatSender.Heartbeat(address));
CheckSerialization(new ClusterHeartbeatSender.HeartbeatRsp(uniqueAddress));
var node1 = new VectorClock.Node("node1");
var node2 = new VectorClock.Node("node2");
var node3 = new VectorClock.Node("node3");
var node4 = new VectorClock.Node("node4");
var g1 =
new Gossip(ImmutableSortedSet.Create(a1, b1, c1, d1)).Increment(node1)
.Increment(node2)
.Seen(a1.UniqueAddress)
.Seen(b1.UniqueAddress);
var g2 = g1.Increment(node3).Increment(node4).Seen(a1.UniqueAddress).Seen(c1.UniqueAddress);
var reachability3 =
Reachability.Empty.Unreachable(a1.UniqueAddress, e1.UniqueAddress)
.Unreachable(b1.UniqueAddress, e1.UniqueAddress);
var g3 = g2.Copy(members: ImmutableSortedSet.Create(a1, b1, c1, d1, e1),
overview: g2.Overview.Copy(reachability: reachability3));
CheckSerialization(new GossipEnvelope(a1.UniqueAddress, uniqueAddress2, g1));
CheckSerialization(new GossipEnvelope(a1.UniqueAddress, uniqueAddress2, g2));
CheckSerialization(new GossipEnvelope(a1.UniqueAddress, uniqueAddress2, g3));
CheckSerialization(new GossipStatus(a1.UniqueAddress, g1.Version));
CheckSerialization(new GossipStatus(a1.UniqueAddress, g2.Version));
CheckSerialization(new GossipStatus(a1.UniqueAddress, g3.Version));
CheckSerialization(new InternalClusterAction.Welcome(uniqueAddress, g2));
}
IReplicatedData IRemovedNodePruning.PruningCleanup(UniqueAddress removedNode) => PruningCleanup(removedNode);
public ReachabilityStatus Status(UniqueAddress node)
{
if (_cache.Value.AllTerminated.Contains(node)) return ReachabilityStatus.Terminated;
if (_cache.Value.AllUnreachable.Contains(node)) return ReachabilityStatus.Unreachable;
return ReachabilityStatus.Reachable;
}
public ImmutableList<Record> RecordsFrom(UniqueAddress observer)
{
var rows = ObserverRows(observer);
if (rows == null) return ImmutableList.Create<Record>();
return rows.Values.ToImmutableList();
}
/// <summary> /// Removes an entry from the map. /// Note that if there is a conflicting update on another node the entry will /// not be removed after merge. /// </summary> public LWWDictionary <TKey, TValue> Remove(UniqueAddress node, TKey key) => new LWWDictionary <TKey, TValue>(Underlying.Remove(node, key));
long CurrentVersion(UniqueAddress observer)
{
long version;
return _versions.TryGetValue(observer, out version) ? version : 0;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="node">TBD</param>
/// <param name="initial">TBD</param>
public LWWRegister(UniqueAddress node, T initial)
{
UpdatedBy = node;
Value = initial;
Timestamp = DefaultClock(0L, initial);
}
public HeartbeatNodeRing(UniqueAddress selfAddress, ImmutableSortedSet<UniqueAddress> nodes, int monitoredByNumberOfNodes)
{
MonitoredByNumberOfNodes = monitoredByNumberOfNodes;
NodeRing = nodes;
SelfAddress = selfAddress;
_useAllAsReceivers = MonitoredByNumberOfNodes >= (NodeRing.Count - 1);
MyReceivers = new Lazy<ImmutableHashSet<UniqueAddress>>(() => Receivers(SelfAddress));
}
/// <summary>
/// TBD
/// </summary>
/// <param name="node">TBD</param>
/// <param name="initial">TBD</param>
/// <param name="clock">TBD</param>
public LWWRegister(UniqueAddress node, T initial, Clock <T> clock)
{
UpdatedBy = node;
Value = initial;
Timestamp = clock(0L, initial);
}
/// <summary>
/// Change the value of the register.
///
/// You can provide your <paramref name="clock"/> implementation instead of using timestamps based
/// on DateTime.UtcNow.Ticks time. The timestamp can for example be an
/// increasing version number from a database record that is used for optimistic
/// concurrency control.
/// </summary>
/// <param name="node">TBD</param>
/// <param name="value">TBD</param>
/// <param name="clock">TBD</param>
/// <returns>TBD</returns>
public LWWRegister <T> WithValue(UniqueAddress node, T value, Clock <T> clock = null)
{
var c = clock ?? DefaultClock;
return(new LWWRegister <T>(node, value, c(Timestamp, value)));
}
/// <summary> /// TBD /// </summary> /// <param name="removedNode">TBD</param> /// <returns>TBD</returns> public LWWDictionary <TKey, TValue> PruningCleanup(UniqueAddress removedNode) => new LWWDictionary <TKey, TValue>(Underlying.PruningCleanup(removedNode));
/// <summary> /// TBD /// </summary> /// <param name="removedNode">TBD</param> /// <param name="collapseInto">TBD</param> /// <returns>TBD</returns> public LWWDictionary <TKey, TValue> Prune(UniqueAddress removedNode, UniqueAddress collapseInto) => new LWWDictionary <TKey, TValue>(Underlying.Prune(removedNode, collapseInto));
IReplicatedData IRemovedNodePruning.Prune(UniqueAddress removedNode, UniqueAddress collapseInto) => Prune(removedNode, collapseInto);
public ClusterHeartbeatSenderState AddMember(UniqueAddress node)
{
return MembershipChange(Ring + node);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="node">TBD</param>
/// <param name="value">TBD</param>
/// <param name="timestamp">TBD</param>
public LWWRegister(UniqueAddress node, T value, long timestamp)
{
UpdatedBy = node;
Value = value;
Timestamp = timestamp;
}
public ClusterHeartbeatSenderState HeartbeatRsp(UniqueAddress from)
{
if (ActiveReceivers.Contains(from))
{
FailureDetector.Heartbeat(from.Address);
if (Unreachable.Contains(from))
{
//back from unreachable, ok to stop heartbeating to it
if (!Ring.MyReceivers.Value.Contains(from))
{
FailureDetector.Remove(from.Address);
}
return Copy(unreachable: Unreachable.Remove(from));
}
return this;
}
return this;
}
public void JoinClusterWithOneOfflineSeedNode()
{
Within(TimeSpan.FromSeconds(30), () =>
{
RunOn(() =>
{
Sys.ActorOf(c => c.Receive <UniqueAddress>((address, ctx) =>
{
_seedUniqueAddress = address;
ctx.Sender.Tell("ok");
}), "address-receiver");
Sys.ActorOf(Props.Create(() => new DomainEventLogger()), "cluster-logger");
}, _config.NonSeed);
EnterBarrier("addr-receiver-ready");
RunOn(() =>
{
_seedUniqueAddress = Cluster.Get(_seedSystem.Value).SelfUniqueAddress;
_seedSystem.Value.ActorOf(Props.Create(() => new DomainEventLogger()), "clusterLogger");
var probe = CreateTestProbe(_seedSystem.Value);
_seedSystem.Value.ActorSelection(new RootActorPath(GetAddress(_config.NonSeed)) / "user" / "address-receiver").Tell(_seedUniqueAddress, probe.Ref);
probe.ExpectMsg("ok", TimeSpan.FromSeconds(5));
}, _config.Seed);
EnterBarrier("addr-transferred");
RunOn(() =>
{
Cluster.Get(_seedSystem.Value).JoinSeedNodes(SeedNodes);
AwaitCondition(() => Cluster.Get(_seedSystem.Value).ReadView.IsSingletonCluster);
_seedSystem.Value.ActorOf(Props.Create(() => new LeaderSynchronizer()), "leader-sync");
}, _config.Seed);
EnterBarrier("seed-self-joined");
RunOn(() =>
{
var unreachableNodeAddress = Cluster.Get(_unavailableSeedSystem.Value).SelfAddress;
// terminate the unreachableSeedNode
Shutdown(_unavailableSeedSystem.Value, RemainingOrDefault);
Cluster.JoinSeedNodes(SeedNodes.Add(unreachableNodeAddress)); // append the unreachable node address
AwaitMembersUp(2);
Sys.ActorOf(Props.Create(() => new LeaderSynchronizer()), "leader-sync");
}, _config.NonSeed);
EnterBarrier("formed-cluster");
/*
* Verify that both nodes agree on who the leader is
*/
RunOn(() =>
{
var addr2 = GetAddress(_config.NonSeed);
var probe2 = CreateTestProbe(_seedSystem.Value);
AwaitAssert(() =>
{
_seedSystem.Value.ActorSelection(new RootActorPath(addr2) / "user" / "leader-sync")
.Tell("leader", probe2.Ref);
_verifiedLeader = probe2.ExpectMsg <Address>();
_verifiedLeader.Should().Be(Cluster.Get(_seedSystem.Value).State.Leader);
});
}, _config.Seed);
RunOn(() =>
{
AwaitAssert(() =>
{
_verifiedLeader =
Sys.ActorSelection(new RootActorPath(SeedUniqueAddress.Address) / "user" / "leader-sync")
.Ask <Address>("leader")
.Result;
_verifiedLeader.Should().Be(Cluster.State.Leader);
});
}, _config.NonSeed);
EnterBarrier("verified-leader");
});
}
public HeartbeatNodeRing Copy(UniqueAddress selfAddress = null, IEnumerable<UniqueAddress> nodes = null,
int? monitoredByNumberOfNodes = null)
{
return new HeartbeatNodeRing(selfAddress ?? SelfAddress,
nodes ?? NodeRing,
monitoredByNumberOfNodes.HasValue ? monitoredByNumberOfNodes.Value : MonitoredByNumberOfNodes);
}
public PruningInitialized(UniqueAddress owner, params Address[] seen)
: this(owner, seen.ToImmutableHashSet())
{
}
public Reachability Reachable(UniqueAddress observer, UniqueAddress subject)
{
return Change(observer, subject, ReachabilityStatus.Reachable);
}
public PruningInitialized(UniqueAddress owner, IImmutableSet <Address> seen)
{
Owner = owner;
Seen = seen;
}
private Reachability Change(UniqueAddress observer, UniqueAddress subject, ReachabilityStatus status)
{
var v = NextVersion(observer);
var newVersions = _versions.SetItem(observer, v);
var newRecord = new Record(observer, subject, status, v);
var oldObserverRows = ObserverRows(observer);
if (oldObserverRows == null && status == ReachabilityStatus.Reachable) return this;
if (oldObserverRows == null) return new Reachability(_records.Add(newRecord), newVersions);
Record oldRecord = null;
oldObserverRows.TryGetValue(subject, out oldRecord);
if (oldRecord == null)
{
if (status == ReachabilityStatus.Reachable &&
oldObserverRows.Values.All(r => r.Status == ReachabilityStatus.Reachable))
{
return new Reachability(_records.FindAll(r => !r.Observer.Equals(observer)), newVersions);
}
return new Reachability(_records.Add(newRecord), newVersions);
}
if (oldRecord.Status == ReachabilityStatus.Terminated || oldRecord.Status == status)
return this;
if(status == ReachabilityStatus.Reachable &&
oldObserverRows.Values.All(r => r.Status == ReachabilityStatus.Reachable || r.Subject.Equals(subject)))
return new Reachability(_records.FindAll(r => !r.Observer.Equals(observer)), newVersions);
var newRecords = _records.SetItem(_records.IndexOf(oldRecord), newRecord);
return new Reachability(newRecords, newVersions);
}
public PNCounterSpec(ITestOutputHelper output)
{
_address1 = new UniqueAddress(new Actor.Address("akka.tcp", "PNCounterSpec", "some.host.org", 112), 1);
_address2 = new UniqueAddress(new Actor.Address("akka.tcp", "PNCounterSpec2", "other.host.org", 112), 2);
}
public bool IsReachable(UniqueAddress observer, UniqueAddress subject)
{
return Status(observer, subject) == ReachabilityStatus.Reachable;
}
private void DoHeartbeatRsp(UniqueAddress from)
{
_log.Debug("Cluster Node [{0}] - Heartbeat response from [{1}]", _cluster.SelfAddress, from.Address);
_state = _state.HeartbeatRsp(from);
}
/// <summary> /// TBD /// </summary> /// <typeparam name="TKey">TBD</typeparam> /// <typeparam name="TValue">TBD</typeparam> /// <param name="node">TBD</param> /// <param name="key">TBD</param> /// <param name="value">TBD</param> /// <param name="clock">TBD</param> /// <returns>TBD</returns> public static LWWDictionary <TKey, TValue> Create <TKey, TValue>(UniqueAddress node, TKey key, TValue value, Clock <TValue> clock = null) => LWWDictionary <TKey, TValue> .Empty.SetItem(node, key, value, clock);
public HeartbeatRsp(UniqueAddress @from)
{
From = @from;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="oldest">TBD</param>
public YoungerData(UniqueAddress oldest)
{
Oldest = oldest;
}
/// <summary> /// TBD /// </summary> /// <param name="removedNode">TBD</param> /// <returns>TBD</returns> public bool NeedPruningFrom(UniqueAddress removedNode) => Underlying.NeedPruningFrom(removedNode);
private void TriggerFirstHeart(UniqueAddress from)
{
if (_state.ActiveReceivers.Contains(from) && !FailureDetector.IsMonitoring(from.Address))
{
_log.Debug("Cluster Node [{0}] - Trigger extra expected heartbeat from [{1}]", _cluster.SelfAddress, from.Address);
FailureDetector.Heartbeat(from.Address);
}
}
/// <summary>
/// TBD
/// </summary>
/// <param name="previousOldest">TBD</param>
public BecomingOldestData(UniqueAddress previousOldest)
{
PreviousOldest = previousOldest;
}
public ExpectedFirstHeartbeat(UniqueAddress @from)
{
From = @from;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="singleton">TBD</param>
/// <param name="singletonTerminated">TBD</param>
/// <param name="newOldest">TBD</param>
public WasOldestData(IActorRef singleton, bool singletonTerminated, UniqueAddress newOldest)
{
Singleton = singleton;
SingletonTerminated = singletonTerminated;
NewOldest = newOldest;
}
public ClusterHeartbeatSenderState RemoveMember(UniqueAddress node)
{
var newState = MembershipChange(Ring - node);
FailureDetector.Remove(node.Address);
if (newState.Unreachable.Contains(node))
return newState.Copy(unreachable: newState.Unreachable.Remove(node));
return newState;
}
private void AddRemoved(UniqueAddress node)
{
_removed = _removed.Add(node, Deadline.Now + TimeSpan.FromMinutes(15.0));
}
public HeartbeatNodeRing(UniqueAddress selfAddress, IEnumerable<UniqueAddress> nodes,
int monitoredByNumberOfNodes)
: this(selfAddress, ImmutableSortedSet.Create(nodes.ToArray()), monitoredByNumberOfNodes)
{
}
private byte[] UniqueAddressToProtoByteArray(UniqueAddress uniqueAddress)
{
return(UniqueAddressToProto(uniqueAddress).Build().ToByteArray());
}
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();
}
private Msg.Join JoinToProto(UniqueAddress node, ImmutableHashSet <string> roles)
{
return(Msg.Join.CreateBuilder().SetNode(UniqueAddressToProto(node)).AddRangeRoles(roles).Build());
}
private static ClusterHeartbeatSenderState EmptyState(UniqueAddress selfUniqueAddress)
{
return new ClusterHeartbeatSenderState(new HeartbeatNodeRing(selfUniqueAddress, new[] { selfUniqueAddress }, 3),
ImmutableHashSet.Create<UniqueAddress>(), new DefaultFailureDetectorRegistry<Address>(() => new FailureDetectorStub()));
}
private Msg.Welcome WelcomeToProto(UniqueAddress node, Gossip gossip)
{
return(Msg.Welcome.CreateBuilder().SetFrom(UniqueAddressToProto(node))
.SetGossip(GossipToProto(gossip)).Build());
}
ImmutableDictionary<UniqueAddress, Record> ObserverRows(UniqueAddress observer)
{
ImmutableDictionary<UniqueAddress, Record> observerRows = null;
_cache.Value.ObserverRowMap.TryGetValue(observer, out observerRows);
return observerRows;
}
public TestSelector(UniqueAddress selfUniqueAddress, ImmutableArray <Address> allNodes)
{
this.selfUniqueAddress = selfUniqueAddress;
AllNodes = allNodes;
}
public Reachability Terminated(UniqueAddress observer, UniqueAddress subject)
{
return Change(observer, subject, ReachabilityStatus.Terminated);
}
public TestSelector2(UniqueAddress selfUniqueAddress, ImmutableArray <Address> allNodes) : base(selfUniqueAddress, allNodes)
{
}
long NextVersion(UniqueAddress observer)
{
return CurrentVersion(observer) + 1;
}
public void Pair(DualShockDeviceDescriptor device, UniqueAddress host)
{
DevicePairingRequested?.Invoke(device, new DevicePairingRequestedEventArgs(host));
}
public ReachabilityStatus Status(UniqueAddress observer, UniqueAddress subject)
{
var observerRows = ObserverRows(observer);
if (observerRows == null) return ReachabilityStatus.Reachable;
Record record;
observerRows.TryGetValue(subject, out record);
if (record == null) return ReachabilityStatus.Reachable;
return record.Status;
}
static async Task Main(string[] args)
{
UniqueAddress[] _nodes;
string[] _elements;
// has data from all nodes
ORSet <string> _c1 = ORSet <String> .Empty;
// has additional items from all nodes
ORSet <string> _c2 = ORSet <String> .Empty;
// has removed items from all nodes
ORSet <string> _c3 = ORSet <String> .Empty;
var newNodes = new List <UniqueAddress>(NumNodes);
foreach (var i in Enumerable.Range(0, NumNodes))
{
var address = new Address("akka.tcp", "Sys", "localhost", 2552 + i);
var uniqueAddress = new UniqueAddress(address, i);
newNodes.Add(uniqueAddress);
}
_nodes = newNodes.ToArray();
var newElements = new List <string>(NumNodes);
foreach (var i in Enumerable.Range(0, NumElements))
{
newElements.Add(i.ToString());
}
_elements = newElements.ToArray();
_c1 = ORSet <String> .Empty;
foreach (var node in _nodes)
{
_c1 = _c1.Add(node, _elements[0]);
}
// add some data that _c2 doesn't have
_c2 = _c1;
foreach (var node in _nodes.Skip(NumNodes / 2))
{
_c2 = _c2.Add(node, _elements[1]);
}
_c3 = _c1;
foreach (var node in _nodes.Take(NumNodes / 2))
{
_c3 = _c3.Remove(node, _elements[0]);
}
var init = ORSet <string> .Empty;
foreach (var element in _elements)
{
foreach (var node in _nodes)
{
init = init.Add(node, element);
}
}
_c1.Merge(init).Merge(_c2).Merge(_c3);
await Task.Delay(5000);
}
public bool IsReachable(UniqueAddress node)
{
return IsAllReachable || !AllUnreachableOrTerminated.Contains(node);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="currentNode">TBD</param>
/// <param name="crdt">TBD</param>
internal LocalGCounter(UniqueAddress currentNode, GCounter crdt) : this()
{
_currentNode = currentNode;
_crdt = crdt;
}
public ImmutableHashSet<UniqueAddress> AllUnreachableFrom(UniqueAddress observer)
{
var observerRows = ObserverRows(observer);
if (observerRows == null) return ImmutableHashSet.Create<UniqueAddress>();
return
ImmutableHashSet.CreateRange(
observerRows.Where(p => p.Value.Status == ReachabilityStatus.Unreachable).Select(p => p.Key));
}
public ORMultiDictionarySpec(ITestOutputHelper output)
{
_node1 = new UniqueAddress(new Address("akka.tcp", "Sys", "localhost", 2551), 1);
_node2 = new UniqueAddress(new Address("akka.tcp", "Sys", "localhost", 2552), 2);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="oldest">TBD</param>
public OldestChanged(UniqueAddress oldest)
{
Oldest = oldest;
}
public static ORSet <T> Create <T>(UniqueAddress node, T element) => ORSet <T> .Empty.Add(node, element);
