public void Smallest_mailbox_pool_must_deliver_messages_to_idle_actor() { var usedActors = new ConcurrentDictionary<int, string>(); var router = Sys.ActorOf(new SmallestMailboxPool(3).Props(Props.Create(() => new SmallestMailboxActor(usedActors)))); var busy = new TestLatch(1); var received0 = new TestLatch(1); router.Tell(Tuple.Create(busy, received0)); received0.Ready(TestKitSettings.DefaultTimeout); var received1 = new TestLatch(1); router.Tell(Tuple.Create(1, received1)); received1.Ready(TestKitSettings.DefaultTimeout); var received2 = new TestLatch(1); router.Tell(Tuple.Create(2, received2)); received2.Ready(TestKitSettings.DefaultTimeout); var received3 = new TestLatch(1); router.Tell(Tuple.Create(3, received3)); received3.Ready(TestKitSettings.DefaultTimeout); busy.CountDown(); var busyPath = usedActors[0]; busyPath.Should().NotBeNull(); var path1 = usedActors[1]; var path2 = usedActors[2]; var path3 = usedActors[3]; path1.Should().NotBeNull(busyPath); path2.Should().NotBeNull(busyPath); path3.Should().NotBeNull(busyPath); }
public RoundRobinPoolBroadcastActor(TestLatch helloLatch, TestLatch stopLatch) { _helloLatch = helloLatch; _stopLatch = stopLatch; Receive<string>(s => s == "hello", c => _helloLatch.CountDown()); }
public Watcher(TestLatch exitingLatch, TestLatch removedLatch, Address secondAddress) { _exitingLatch = exitingLatch; _removedLatch = removedLatch; _secondAddress = secondAddress; Receive<ClusterEvent.CurrentClusterState>(state => { if (state.Members.Any(m => m.Address == _secondAddress && m.Status == MemberStatus.Exiting)) _exitingLatch.CountDown(); }); Receive<ClusterEvent.MemberExited>(m => { if (m.Member.Address == secondAddress) { exitingLatch.CountDown(); } }); Receive<ClusterEvent.MemberRemoved>(m => { if (m.Member.Address == secondAddress) { _removedLatch.CountDown(); } }); }
public BroadcastTarget(TestLatch doneLatch, AtomicCounter counter) { _doneLatch = doneLatch; _counter = counter; Receive<string>(s => s == "end", c => _doneLatch.CountDown()); Receive<int>(msg => _counter.AddAndGet(msg)); }
public RoundRobinPoolActor(TestLatch doneLatch, AtomicCounter counter) { _doneLatch = doneLatch; _counter = counter; Receive<string>(s => s == "hit", c => Sender.Tell(id.Value)); Receive<string>(s => s == "end", c => _doneLatch.CountDown()); }
public Listener(TestLatch latch, ImmutableList<Address> expectedAddresses) { _latch = latch; _expectedAddresses = expectedAddresses; Receive<ClusterEvent.CurrentClusterState>(state => { _members = state.Members; }); Receive<ClusterEvent.MemberUp>(m => { _members = _members.Remove(m.Member).Add(m.Member); if (!_members.Select(c => c.Address).Except(_expectedAddresses).Any()) _latch.CountDown(); }); }
public void Smallest_mailbox_router_must_deliver_messages_to_idle_actor() { var usedActors = new ConcurrentDictionary<int, string>(); var router = Sys.ActorOf(new SmallestMailboxPool(3).Props(Props.Create(() => new SmallestMailboxActor(usedActors)))); var busy = new TestLatch(1); var received0 = new TestLatch(1); router.Tell(Tuple.Create(busy, received0)); received0.Ready(TestLatch.DefaultTimeout); var received1 = new TestLatch(1); router.Tell(Tuple.Create(1, received1)); received1.Ready(TestLatch.DefaultTimeout); var received2 = new TestLatch(1); router.Tell(Tuple.Create(2, received2)); received2.Ready(TestLatch.DefaultTimeout); var received3 = new TestLatch(1); router.Tell(Tuple.Create(3, received3)); received3.Ready(TestLatch.DefaultTimeout); busy.CountDown(); var busyPath = usedActors[0]; Assert.NotEqual(busyPath, null); Assert.Equal(usedActors.Count, 4); var path1 = usedActors[1]; var path2 = usedActors[2]; var path3 = usedActors[3]; Assert.NotEqual(path1, busyPath); Assert.NotEqual(path2, busyPath); Assert.NotEqual(path3, busyPath); }
public void PersistentActor_should_preserve_order_of_incoming_messages() { var pref = ActorOf(Props.Create(() => new StressOrdering(Name))); pref.Tell(new Cmd("a")); var latch = new TestLatch(1); pref.Tell(new LatchCmd(latch, "b")); pref.Tell("c"); ExpectMsg("a"); ExpectMsg("b"); pref.Tell("d"); latch.CountDown(); ExpectMsg("c"); ExpectMsg("d"); }
public void A_Flow_with_SelectAsyncUnordered_must_signal_error_from_SelectAsyncUnordered() { this.AssertAllStagesStopped(() => { var latch = new TestLatch(1); var c = this.CreateManualSubscriberProbe<int>(); Source.From(Enumerable.Range(1, 5)) .SelectAsyncUnordered(4, n => { if (n == 3) throw new TestException("err2"); return Task.Run(() => { latch.Ready(TimeSpan.FromSeconds(10)); return n; }); }) .RunWith(Sink.FromSubscriber(c), Materializer); var sub = c.ExpectSubscription(); sub.Request(10); c.ExpectError().Message.Should().Be("err2"); latch.CountDown(); }, Materializer); }
public RoundRobinGroupActor(TestLatch doneLatch) { _doneLatch = doneLatch; Receive<string>(s => s == "hit", c => Sender.Tell(Self.Path.Name)); Receive<string>(s => s == "end", c => _doneLatch.CountDown()); }
public void InputStreamSource_must_emit_as_soon_as_read() { this.AssertAllStagesStopped(() => { var latch = new TestLatch(1); var probe = StreamConverters.FromInputStream(() => new EmittedInputStream(latch), chunkSize: 1) .RunWith(this.SinkProbe<ByteString>(), _materializer); probe.Request(4); probe.ExpectNext(ByteString.FromString("M")); latch.CountDown(); probe.ExpectComplete(); }, _materializer); }
public void A_Flow_with_SelectAsync_must_signal_task_failure() { this.AssertAllStagesStopped(() => { var latch = new TestLatch(1); var c = TestSubscriber.CreateManualProbe<int>(this); Source.From(Enumerable.Range(1, 5)) .SelectAsync(4, n => Task.Run(() => { if (n == 3) throw new TestException("err1"); latch.Ready(TimeSpan.FromSeconds(10)); return n; })) .To(Sink.FromSubscriber(c)).Run(Materializer); var sub = c.ExpectSubscription(); sub.Request(10); c.ExpectError().InnerException.Message.Should().Be("err1"); latch.CountDown(); }, Materializer); }
public void A_FlattenMerge_must_cancel_substreams_when_failing_map_function() { var settings = ActorMaterializerSettings.Create(Sys).WithSyncProcessingLimit(1); var materializer = ActorMaterializer.Create(Sys, settings); var p = TestPublisher.CreateProbe<int>(this); var ex = new TestException("buh"); var latch = new TestLatch(); Source.From(Enumerable.Range(1, 3)).MergeMany(10, i => { if (i == 1) return Source.FromPublisher(p); latch.Ready(TimeSpan.FromSeconds(3)); throw ex; }).RunWith(Sink.First<int>(), materializer); p.ExpectRequest(); latch.CountDown(); p.ExpectCancellation(); }
public void A_ForeachParallel_must_resume_after_function_failure() { this.AssertAllStagesStopped(() => { var probe = CreateTestProbe(); var latch = new TestLatch(1); var p = Source.From(Enumerable.Range(1, 5)).RunWith(Sink.ForEachParallel<int>(4, n => { if (n == 3) throw new TestException("err1"); probe.Ref.Tell(n); latch.Ready(TimeSpan.FromSeconds(10)); }).WithAttributes(ActorAttributes.CreateSupervisionStrategy(Deciders.ResumingDecider)), Materializer); latch.CountDown(); probe.ExpectMsgAllOf(1, 2, 4, 5); p.Wait(TimeSpan.FromSeconds(5)).Should().BeTrue(); }, Materializer); }
public void A_ForeachParallel_must_finish_after_function_thrown_exception() { this.AssertAllStagesStopped(() => { var probe = CreateTestProbe(); var latch = new TestLatch(1); var p = Source.From(Enumerable.Range(1, 5)).RunWith(Sink.ForEachParallel<int>(3, n => { if (n == 3) throw new TestException("err2"); probe.Ref.Tell(n); latch.Ready(TimeSpan.FromSeconds(10)); }).WithAttributes(ActorAttributes.CreateSupervisionStrategy(Deciders.StoppingDecider)), Materializer); // make sure the stream is up and running, otherwise the latch is maybe ready before the third message arrives Thread.Sleep(500); latch.CountDown(); probe.ExpectMsgAllOf(1, 2); var ex = p.Invoking(t => t.Wait(TimeSpan.FromSeconds(1))).ShouldThrow<AggregateException>().Which; ex.Flatten().InnerException.Should().BeOfType<TestException>(); ex.Flatten().InnerException.Message.Should().Be("err2"); p.IsCompleted.Should().BeTrue(); }, Materializer); }
public Observer(ActorPath path2, ActorPath path3, TestLatch watchEstablished, IActorRef testActorRef) { _watchEstablished = watchEstablished; _testActorRef = testActorRef; Receive<ActorIdentity>(identity => identity.MessageId.Equals(path2), identity => { Context.Watch(identity.Subject); _watchEstablished.CountDown(); }); Receive<ActorIdentity>(identity => identity.MessageId.Equals(path3), identity => { Context.Watch(identity.Subject); _watchEstablished.CountDown(); }); Receive<Terminated>(terminated => { _testActorRef.Tell(terminated.ActorRef.Path); }); Context.ActorSelection(path2).Tell(new Identify(path2)); Context.ActorSelection(path3).Tell(new Identify(path3)); }
public TestProducer(TestLatch lp, TestLatch la) { latchActor = la; lp.Reset(); lp.CountDown(); }
protected void TestWaitMovingMembersToUp() { var onUpLatch = new TestLatch(1); Cluster.RegisterOnMemberUp(() => { onUpLatch.CountDown(); }); RunOn(() => { Cluster.Join(GetAddress(Myself)); AwaitAssert(() => { ClusterView.RefreshCurrentState(); ClusterView.Status.ShouldBe(MemberStatus.Joining); }); }, First); EnterBarrier("first-started"); onUpLatch.IsOpen.ShouldBeFalse(); RunOn(() => { Cluster.Join(GetAddress(First)); }, Second); RunOn(() => { var expectedAddresses = new List<Address> { GetAddress(First), GetAddress(Second) }; AwaitAssert(() => { ClusterView.RefreshCurrentState(); ClusterView.Members.Select(c => c.Address).Except(expectedAddresses).Count().ShouldBe(0); }); ClusterView.Members.All(c => c.Status == MemberStatus.Joining).ShouldBeTrue(); // and it should not change foreach (var _ in Enumerable.Range(1, 5)) { Thread.Sleep(1000); ClusterView.Members.Select(c => c.Address).Except(expectedAddresses).Count().ShouldBe(0); ClusterView.Members.All(c => c.Status == MemberStatus.Joining).ShouldBeTrue(); } }, First, Second); EnterBarrier("second-joined"); RunOn(() => { Cluster.Join(GetAddress(First)); }, Third); AwaitClusterUp(First, Second, Third); onUpLatch.Ready(TestKitSettings.DefaultTimeout); EnterBarrier("after-1"); }