public void A_UnfoldResourceAsyncSource_must_close_resource_when_stream_is_abruptly_termianted() { var closeLatch = new TestLatch(1); var materializer = ActorMaterializer.Create(Sys); var p = Source.UnfoldResourceAsync(_open, Read, reader => { closeLatch.CountDown(); return(Task.FromResult(0)); }).RunWith(Sink.AsPublisher <string>(false), materializer); var c = this.CreateManualSubscriberProbe <string>(); p.Subscribe(c); materializer.Shutdown(); closeLatch.Ready(TimeSpan.FromSeconds(10)); }
public void Random_pool_must_deliver_a_broadcast_message_using_the_Tell() { const int routeeCount = 6; var helloLatch = new TestLatch(routeeCount); var stopLatch = new TestLatch(routeeCount); var actor = Sys.ActorOf(new RandomPool(routeeCount) .Props(Props.Create(() => new RandomBroadcastActor(helloLatch, stopLatch))), "random-broadcast"); actor.Tell(new Broadcast("hello")); helloLatch.Ready(5.Seconds()); Sys.Stop(actor); stopLatch.Ready(5.Seconds()); }
public void DefaultResizer_must_be_possible_to_define_programmatically() { var latch = new TestLatch(3); var resizer = new DefaultResizer(2, 3); var router = Sys.ActorOf(Props.Create <ResizerTestActor>().WithRouter(new RoundRobinPool(0, resizer))); router.Tell(latch); router.Tell(latch); router.Tell(latch); latch.Ready(TestKitSettings.DefaultTimeout); //messagesPerResize is 10 so there is no risk of additional resize (RouteeSize(router)).ShouldBe(2); }
public void BTActor_SequenceReceiveSequenceReceive() { var pipe = new List<string>(); var latch = new TestLatch(); var bt = Sys.ActorOf(Props.Create(() => new SequenceReceiveSequenceReceive(pipe, latch))); bt.Tell("1"); bt.Tell("3"); bt.Tell("4"); latch.Ready(); Assert.Equal(new[] { "1", "2", "3", "4" }, pipe); }
public async Task Scatter_gather_router_must_return_response_even_if_one_of_the_actors_has_stopped() { var shutdownLatch = new TestLatch(1); var actor1 = Sys.ActorOf(Props.Create(() => new StopActor(1))); var actor2 = Sys.ActorOf(Props.Create(() => new StopActor(14))); var paths = new [] { actor1, actor2 }; var routedActor = Sys.ActorOf(new ScatterGatherFirstCompletedGroup(paths, TimeSpan.FromSeconds(3)).Props()); routedActor.Tell(new Broadcast(new Stop(1))); shutdownLatch.Open(); var res = await routedActor.Ask <int>(0, TimeSpan.FromSeconds(10)); res.ShouldBe(14); }
public ShortTimeoutLongTask(TestLatch latch, AtomicCounter counter) { StartWith( Loop( ReceiveAny(s => s.Equals("RUN"), After( Timeout(TimeSpan.FromMilliseconds(100), Delay(5.Seconds(), Execute(_ => counter.GetAndIncrement())), Execute(_ => { counter.GetAndDecrement(); Sender.Tell("TIMEOUT"); })), Execute(_ => latch.CountDown())))), null); }
public void BTActor_BecomePingPong() { var pipe = new List<string>(); var latch = new TestLatch(5); var bt = Sys.ActorOf(Props.Create(() => new BecomePingPong(pipe, latch))); bt.Tell("RUN", TestActor); bt.Tell("PING", TestActor); latch.Ready(); ExpectMsg("DONE"); Assert.Equal(new[] { "PING", "PONG", "PING", "PONG" }, pipe); }
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 SlowlyFailingActor(TestLatch latch) { _latch = latch; Receive <string>(str => str.Equals("THROW"), msg => { Sender.Tell("THROWN"); throw new NormalException(); return; }); Receive <string>(str => str.Equals("PING"), msg => { Sender.Tell("PONG"); }); }
public void An_actor_with_receive_timeout_must_be_able_to_turn_on_timeout_in_NotInfluenceReceiveTimeout_message_handler() { var timeoutLatch = new TestLatch(); Action <IActorDsl> actor = d => { d.Receive <TransparentTick>((_, c) => c.SetReceiveTimeout(500.Milliseconds())); d.Receive <ReceiveTimeout>((_, __) => timeoutLatch.Open()); }; var timeoutActor = Sys.ActorOf(Props.Create(() => new Act(actor))); timeoutActor.Tell(new TransparentTick()); timeoutLatch.Ready(TestKitSettings.DefaultTimeout); Sys.Stop(timeoutActor); }
public void DefaultResizer_must_be_possible_to_define_programmatically() { var latch = new TestLatch(3); var resizer = new DefaultResizer(lower: 2, upper: 3); var router = Sys.ActorOf(new RoundRobinPool(0, resizer).Props(Props.Create <ResizerTestActor>())); router.Tell(latch); router.Tell(latch); router.Tell(latch); latch.Ready(RemainingOrDefault); // MessagesPerResize is 10 so there is no risk of additional resize RouteeSize(router).Should().Be(2); }
public void Conflate_must_restart_when_seed_throws_and_a_RestartDescider_is_used() { var sourceProbe = this.CreatePublisherProbe <int>(); var sinkProbe = this.CreateManualSubscriberProbe <int>(); var exceptionlath = new TestLatch(); var graph = Source.FromPublisher(sourceProbe).ConflateWithSeed(i => { if (i % 2 == 0) { exceptionlath.Open(); throw new TestException("I hate even seed numbers"); } return(i); }, (sum, i) => sum + i) .WithAttributes(ActorAttributes.CreateSupervisionStrategy(Deciders.RestartingDecider)) .To(Sink.FromSubscriber(sinkProbe)) .WithAttributes(Attributes.CreateInputBuffer(1, 1)); RunnableGraph.FromGraph(graph).Run(Materializer); var sub = sourceProbe.ExpectSubscription(); var sinkSub = sinkProbe.ExpectSubscription(); // push the first value sub.ExpectRequest(1); sub.SendNext(1); // and consume it, so that the next element // will trigger seed sinkSub.Request(1); sinkProbe.ExpectNext(1); sub.ExpectRequest(1); sub.SendNext(2); // make sure the seed exception happened // before going any further exceptionlath.Ready(TimeSpan.FromSeconds(3)); sub.ExpectRequest(1); sub.SendNext(3); // now we should have lost the 2 and the accumulated state sinkSub.Request(1); sinkProbe.ExpectNext(3); }
public void An_actor_with_receive_timeout_must_be_able_to_turn_off_timeout_in_NotInfluenceReceiveTimeout_message_handler() { var timeoutLatch = new TestLatch(); Action <IActorDsl> actor = d => { d.OnPreStart = c => c.SetReceiveTimeout(500.Milliseconds()); d.Receive <TransparentTick>((_, c) => c.SetReceiveTimeout(null)); d.Receive <ReceiveTimeout>((_, __) => timeoutLatch.Open()); }; var timeoutActor = Sys.ActorOf(Props.Create(() => new Act(actor))); timeoutActor.Tell(new TransparentTick()); Intercept <TimeoutException>(() => timeoutLatch.Ready(1.Seconds())); Sys.Stop(timeoutActor); }
public void BTActor_ParallelLoopReceive() { var counter = new AtomicCounter(0); var latch = new TestLatch(); var bt = Sys.ActorOf(Props.Create(() => new ParallelLoopReceive(latch))); bt.Tell("A", TestActor); bt.Tell("B", TestActor); ExpectMsg("1A2A"); ExpectMsg("1B2B"); bt.Tell("C"); ExpectMsg("1C2C"); bt.Tell("D"); ExpectMsg("1D2D"); }
public void BTActor_Short_Timeout_Long_Delay() { TestLatch latch = new TestLatch(2); AtomicCounter counter = new AtomicCounter(0); var bt = Sys.ActorOf(Props.Create(() => new ShortTimeoutLongTask(latch, counter))); bt.Tell("RUN", TestActor); ExpectMsg("TIMEOUT"); bt.Tell("RUN", TestActor); ExpectMsg("TIMEOUT"); latch.Ready(); Assert.Equal(-2, counter.Current); ExpectNoMsg(100); }
public void BTActor_Long_Timeout_Short_Delay() { TestLatch latch = new TestLatch(); AtomicCounter counter = new AtomicCounter(0); var bt = Sys.ActorOf(Props.Create(() => new LongTimeoutShortTask(latch, counter))); bt.Tell("RUN", TestActor); latch.Ready(); latch.Reset(); bt.Tell("RUN", TestActor); latch.Ready(); Assert.Equal(2, counter.Current); ExpectNoMsg(200); }
public async Task Supervisor_with_Random_Group_router_should_handle_multiple_child_failure() { const int connectionCount = 10; var doneLatch = new TestLatch(connectionCount); var replies = new Dictionary <string, int>(); for (int i = 1; i <= connectionCount; i++) { replies["target-" + i] = 0; } var paths = Enumerable.Range(1, connectionCount).Select(n => { var routee = Sys.ActorOf(Props.Create(() => new SimpleActor()), "target-" + n); return(routee.Path.ToStringWithoutAddress()); }); var groupProps = Props.Empty .WithRouter(new RandomGroup(paths)) .WithSupervisorStrategy(new OneForOneStrategy(Decider.From(Directive.Escalate))); var groupActorRef = Sys.ActorOf(groupProps, "random-group1"); // rapidly fail children. the router should handle children failing // while itself is still being recreated for (var i = 0; i < 20; i++) { groupActorRef.Tell(1); } var failCount = 0; for (var i = 0; i < 20; i++) { try { await groupActorRef.Ask <int>(2, _delay); } catch { failCount++; } } failCount.Should().Be(0); }
public void Set_of_connected_cluster_systems_must_when_three_nodes_after_cluster_convergence_updates_membership_table_then_all_MembershipChangeListeners_should_be_triggered() { var latch = new TestLatch(); var expectedAddresses = ImmutableList.Create(GetAddress(_config.First), GetAddress(_config.Second), GetAddress(_config.Third)); var listener = Sys.ActorOf(Props.Create(() => new Listener(latch, expectedAddresses)).WithDeploy(Deploy.Local)); Cluster.Subscribe(listener, new[] { typeof(ClusterEvent.IMemberEvent) }); EnterBarrier("listener-2-registered"); RunOn(() => { Cluster.Join(GetAddress(_config.First)); }, _config.Third); latch.Ready(); EnterBarrier("after-2"); }
public void GracefulStop_must_complete_Task_with_TaskCanceledException_when_actor_not_terminated_within_timeout() { //arrange var target = Sys.ActorOf <TargetActor>(); var latch = new TestLatch(); //act target.Tell(Tuple.Create(latch, TimeSpan.FromSeconds(2))); //assert XAssert.Throws <TaskCanceledException>(() => { var task = target.GracefulStop(TimeSpan.FromMilliseconds(500)); task.Wait(); var result = task.Result; }); latch.Open(); }
public void BroadcastGroup_router_must_broadcast_message_using_Ask() { var doneLatch = new TestLatch(Sys, 2); var counter1 = new AtomicCounter(0); var counter2 = new AtomicCounter(0); var actor1 = Sys.ActorOf(Props.Create(() => new BroadcastTarget(doneLatch, counter1))); var actor2 = Sys.ActorOf(Props.Create(() => new BroadcastTarget(doneLatch, counter2))); var routedActor = Sys.ActorOf(Props.Create <TestActor>().WithRouter(new BroadcastGroup(actor1.Path.ToString(), actor2.Path.ToString()))); routedActor.Ask(new Broadcast(1)); routedActor.Tell(new Broadcast("end")); doneLatch.Ready(TimeSpan.FromSeconds(1)); counter1.Current.ShouldBe(1); counter2.Current.ShouldBe(1); }
public async Task Scatter_gather_group_must_return_response_even_if_one_of_the_actors_has_stopped() { var shutdownLatch = new TestLatch(1); var actor1 = Sys.ActorOf(Props.Create(() => new StopActor(1, shutdownLatch))); var actor2 = Sys.ActorOf(Props.Create(() => new StopActor(14, shutdownLatch))); var paths = new List <string> { actor1.Path.ToString(), actor2.Path.ToString() }; var routedActor = Sys.ActorOf(new ScatterGatherFirstCompletedGroup(paths, TimeSpan.FromSeconds(3)).Props()); routedActor.Tell(new Broadcast(new Stop(1))); shutdownLatch.Ready(TestKitSettings.DefaultTimeout); var res = await routedActor.Ask <int>(0, TimeSpan.FromSeconds(10)); res.Should().Be(14); }
public void Scatter_gather_router_must_deliver_a_broadcast_message_using_tell() { var doneLatch = new TestLatch(sys, 2); var counter1 = new AtomicInteger(0); var counter2 = new AtomicInteger(0); var actor1 = sys.ActorOf(Props.Create(() => new BroadcastTarget(doneLatch, counter1))); var actor2 = sys.ActorOf(Props.Create(() => new BroadcastTarget(doneLatch, counter2))); var routedActor = sys.ActorOf(Props.Create <TestActor>().WithRouter(new ScatterGatherFirstCompletedGroup(TimeSpan.FromSeconds(1), actor1.Path.ToString(), actor2.Path.ToString()))); routedActor.Tell(new Broadcast(1)); routedActor.Tell(new Broadcast("end")); doneLatch.Ready(TimeSpan.FromSeconds(1)); counter1.Value.ShouldBe(1); counter2.Value.ShouldBe(1); }
public void An_actor_with_receive_timeout_must_get_timeout_while_receiving_only_NotInfluenceReceiveTimeout_messages() { var timeoutLatch = new TestLatch(2); Action <IActorDsl> actor = d => { d.OnPreStart = c => c.SetReceiveTimeout(TimeSpan.FromSeconds(1)); d.Receive <ReceiveTimeout>((o, c) => { c.Self.Tell(new TransparentTick()); timeoutLatch.CountDown(); }); d.Receive <TransparentTick>((_, __) => { }); }; var timeoutActor = Sys.ActorOf(Props.Create(() => new Act(actor))); timeoutLatch.Ready(TestKitSettings.DefaultTimeout); Sys.Stop(timeoutActor); }
public void Routers_in_general_must_not_terminate_when_resizer_is_used() { var latch = new TestLatch(1); var resizer = new TestResizer(latch); var router = Sys.ActorOf(new RoundRobinPool(0, resizer).Props(Props.Create <BlackHoleActor>())); Watch(router); latch.Ready(RemainingOrDefault); router.Tell(new GetRoutees()); var routees = ExpectMsg <Routees>().Members.ToList(); routees.Count.Should().Be(2); routees.ForEach(r => r.Send(PoisonPill.Instance, TestActor)); // expect no Terminated ExpectNoMsg(2.Seconds()); }
protected override void OnReceive(object message) { message.Match() .With <Tuple <TestLatch, TestLatch> >(t => { TestLatch busy = t.Item1, receivedLatch = t.Item2; usedActors.TryAdd(0, Self.Path.ToString()); Self.Tell("another in busy mailbox"); receivedLatch.CountDown(); busy.Ready(TestLatch.DefaultTimeout); }) .With <Tuple <int, TestLatch> >(t => { var msg = t.Item1; var receivedLatch = t.Item2; usedActors.TryAdd(msg, Self.Path.ToString()); receivedLatch.CountDown(); }) .With <string>(t => { }); }
public void An_actor_with_receive_timeout_must_get_timeout_while_receiving_NotInfluenceReceiveTimeout_messages() { var timeoutLatch = new TestLatch(); var timeoutActor = Sys.ActorOf(Props.Create(() => new TimeoutActor(timeoutLatch, TimeSpan.FromSeconds(1)))); var cancellationToken = new CancellationTokenSource(); Sys.Scheduler.Schedule( TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100), () => { timeoutActor.Tell(new TransparentTick()); timeoutActor.Tell(new Identify(null)); }, cancellationToken.Token); timeoutLatch.Ready(TestKitSettings.DefaultTimeout); cancellationToken.Cancel(); Sys.Stop(timeoutActor); }
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 Router_in_general_must_not_terminate_when_resizer_is_used() { var latch = new TestLatch(Sys, 1); var resizer = new TestResizer(latch); var router = Sys.ActorOf(new RoundRobinPool(0, resizer, SupervisorStrategy.DefaultStrategy, "").Props(Props.Create <NoOpActor>())); Watch(router); latch.Open(); //Await.ready(latch, remainingOrDefault); //TODO: what is remainingOrDefault router.Tell(new GetRoutees(), TestActor); var routees = ExpectMsg <Routees>().Members.ToList(); routees.Count().ShouldBe(2); routees.ForEach(r => r.Send(PoisonPill.Instance, TestActor)); // expect no Terminated ExpectNoMsg(TimeSpan.FromSeconds(2)); }
public void ActorGraphInterpreter_should_trigger_PostStop_in_all_stages_when_abruptly_terminated_and_no_upstream_boundaries() { this.AssertAllStagesStopped(() => { var materializer = ActorMaterializer.Create(Sys); var gotStop = new TestLatch(1); var downstream = this.CreateSubscriberProbe <string>(); Source.Repeat("whatever") .Via(new PostStopSnitchFlow(gotStop)) .To(Sink.FromSubscriber(downstream)).Run(materializer); downstream.RequestNext(); materializer.Shutdown(); gotStop.Ready(RemainingOrDefault); downstream.ExpectError().Should().BeOfType <AbruptTerminationException>(); }, Materializer); }
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); }