public void Props_created_with_strategy_must_have_it_set() { var strategy = new OneForOneStrategy(_ => Directive.Stop); var props = Props.Create(() => new PropsTestActor(), strategy); Assert.Equal(strategy, props.SupervisorStrategy); }
public void Serialization_must_serialize_and_deserialize_DaemonMsgCreate_with_Deploy_and_RouterConfig() { var supervisorStrategy = new OneForOneStrategy(3, TimeSpan.FromSeconds(10), exception => Directive.Escalate); var deploy1 = new Deploy("path1", ConfigurationFactory.ParseString("a=1"), new RoundRobinPool(5, null, supervisorStrategy, null), new RemoteScope(new Address("akka", "Test", "host1", 1921)), "mydispatcher"); var deploy2 = new Deploy("path2", ConfigurationFactory.ParseString("a=2"), FromConfig.Instance, new RemoteScope(new Address("akka", "Test", "host2", 1922)), Deploy.NoDispatcherGiven); VerifySerialization(new DaemonMsgCreate(Props.Create<MyActor>().WithDispatcher("my-disp").WithDeploy(deploy1), deploy2, "foo", _supervisor)); }
public void Cluster_aware_routers_must_use_provided_supervisor_strategy() { var escalator = new OneForOneStrategy( exception => { TestActor.Tell("supervised"); return Directive.Stop; }); var settings = new ClusterRouterPoolSettings(1, 1, true); var router = Sys.ActorOf( new ClusterRouterPool(new RoundRobinPool(1, null, escalator, Dispatchers.DefaultDispatcherId), settings) .Props(Props.Create(() => new KillableActor(TestActor))), "therouter"); router.Tell("go away"); ExpectMsg("supervised"); }
public void An_actor_Must_process_stashed_messages_after_restart() { SupervisorStrategy strategy = new OneForOneStrategy(2, TimeSpan.FromSeconds(1), e => Directive.Restart); var boss = ActorOf(() => new Supervisor(strategy)); var restartLatch = CreateTestLatch(); var hasMsgLatch = CreateTestLatch(); var slaveProps = Props.Create(() => new SlaveActor(restartLatch, hasMsgLatch, "stashme")); //Send the props to supervisor, which will create an actor and return the ActorRef var slave = boss.AskAndWait<IActorRef>(slaveProps, TestKitSettings.DefaultTimeout); //send a message that will be stashed slave.Tell("stashme"); //this will crash the slave. slave.Tell("crash"); //During preRestart restartLatch is opened //After that the cell will unstash "stashme", it should be received by the slave and open hasMsgLatch restartLatch.Ready(TimeSpan.FromSeconds(10)); hasMsgLatch.Ready(TimeSpan.FromSeconds(10)); }
public void RemoteRouter_must_set_supplied_SupervisorStrategy() { var probe = CreateTestProbe(masterActorSystem); var escalator = new OneForOneStrategy(ex => { probe.Ref.Tell(ex); return Directive.Escalate; }); var router = masterActorSystem.ActorOf( new RemoteRouterConfig(new RoundRobinPool(1, null, escalator, null), new[] { new Address("akka.tcp", sysName, "localhost", port) }) .Props(Props.Empty), "blub3"); router.Tell(new GetRoutees(), probe.Ref); // Need to be able to bind EventFilter to additional actor system (masterActorSystem in this case) before this code works // EventFilter.Exception<ActorKilledException>().ExpectOne(() => probe.ExpectMsg<Routees>().Members.Head().Send(Kill.Instance, TestActor); //); probe.ExpectMsg<ActorKilledException>(); }
public void A_constructed_AllForOne_supervisor_strategy_with_nullable_timeouts_and_a_decider_has_the_expected_properties(TimeSpan? timeout, int expectedTimeoutMilliseconds) { var uut = new OneForOneStrategy(-1, timeout, Decider.From(Directive.Restart)); Assert.Equal(uut.WithinTimeRangeMilliseconds, expectedTimeoutMilliseconds); }
public void A_constructed_AllForOne_supervisor_strategy_with_nullable_retries_and_a_decider_has_the_expected_properties(int? retries, int expectedRetries) { var uut = new OneForOneStrategy(retries, null, Decider.From(Directive.Restart)); Assert.Equal(uut.MaxNumberOfRetries, expectedRetries); }
private RootGuardianActorRef CreateRootGuardian(ActorSystemImpl system) { var supervisor = new RootGuardianSupervisor(_rootPath, this, _terminationPromise, _log); var rootGuardianStrategy = new OneForOneStrategy(ex => { _log.Error(ex, "Guardian failed. Shutting down system"); return Directive.Stop; }); var props = Props.Create<GuardianActor>(rootGuardianStrategy); var rootGuardian = new RootGuardianActorRef(system, props, DefaultDispatcher, _defaultMailbox, supervisor, _rootPath, _deadLetters, _extraNames); return rootGuardian; }
public void An_actor_that_clears_the_stash_on_preRestart_Must_not_receive_previously_stashed_messages() { SupervisorStrategy strategy = new OneForOneStrategy(2, TimeSpan.FromSeconds(1), e => Directive.Restart); var boss = ActorOf(() => new Supervisor(strategy)); var restartLatch = CreateTestLatch(); var slaveProps = Props.Create(() => new ActorsThatClearsStashOnPreRestart(restartLatch)); //Send the props to supervisor, which will create an actor and return the ActorRef var slave = boss.AskAndWait<IActorRef>(slaveProps, TestKitSettings.DefaultTimeout); //send messages that will be stashed slave.Tell("stashme 1"); slave.Tell("stashme 2"); slave.Tell("stashme 3"); //this will crash the slave. slave.Tell("crash"); //send a message that should not be stashed slave.Tell("this should bounce back"); //During preRestart restartLatch is opened //After that the cell will clear the stash //So when the cell tries to unstash, it will not unstash messages. If it would TestActor //would receive all stashme messages instead of "this should bounce back" restartLatch.Ready(TimeSpan.FromSeconds(1110)); ExpectMsg("this should bounce back"); }
/// <summary> /// Creates a ZipActor pool. /// </summary> /// <remarks> /// We use a pool to avoid a build up of messages in the <see cref="ZipActor"/>, zip being a long-running operation. /// </remarks> private void CreateZipActorPool() { SupervisorStrategy strategy = new OneForOneStrategy( maxNrOfRetries: 0, withinTimeMilliseconds: 0, decider: Decider.From(exception => { if (exception is IOException) { Logger.Warning("{0}{1} - {2}", LogMessageParts.SkippingFolder, Sender.Path.Name, exception.Message); IncrementFolderCount(); return Directive.Resume; } else { Logger.Error("{0}{1} - {2}", LogMessageParts.ApplicationTerminating, Sender.Path.Name, exception.Message); return Directive.Stop; } }), loggingEnabled: false); _zipActor = Context .ActorOf(Props.Create<ZipActor>() .WithRouter((new RoundRobinPool(_numberOfFolders)) .WithSupervisorStrategy(strategy)), "Zip"); }
public void A_supervisor_hierarchy_must_Restart_Manager_And_Workers_In_AllForOne() { var countDown = new CountdownEvent(4); SupervisorStrategy strategy = new OneForOneStrategy(_ => Directive.Restart); var boss = ActorOf(Props.Create(() => new Supervisor(strategy)), "boss"); Func<Exception, Directive> decider = _ => { return Directive.Escalate; }; var managerProps = new PropsWithName(Props.Create(() => new CountDownActor(countDown, new AllForOneStrategy(decider))), "manager"); var manager = boss.Ask<IActorRef>(managerProps, TestKitSettings.DefaultTimeout).Result; var workerProps = Props.Create(() => new CountDownActor(countDown, SupervisorStrategy.DefaultStrategy)); var worker1 = manager.Ask<IActorRef>(new PropsWithName(workerProps, "worker1"), TestKitSettings.DefaultTimeout).Result; var worker2 = manager.Ask<IActorRef>(new PropsWithName(workerProps, "worker2"), TestKitSettings.DefaultTimeout).Result; var worker3 = manager.Ask<IActorRef>(new PropsWithName(workerProps, "worker3"), TestKitSettings.DefaultTimeout).Result; EventFilter.Exception<ActorKilledException>().ExpectOne(() => { worker1.Tell(Kill.Instance); // manager + all workers should be restarted by only killing a worker // manager doesn't trap exits, so boss will restart manager countDown.Wait(TimeSpan.FromSeconds(5)).ShouldBe(true); }); }
public void Routers_in_general_must_default_to_all_for_one_always_escalate_strategy() { var restarter = new OneForOneStrategy(e => { TestActor.Tell(e); return Directive.Restart; }); var supervisor = Sys.ActorOf(Props.Create(() => new Supervisor(restarter))); supervisor.Tell(new RoundRobinPool(3).Props(Props.Create(() => new RestartActor(TestActor)))); var router = ExpectMsg<IActorRef>(); EventFilter.Exception<ArgumentException>("die").ExpectOne(() => { router.Tell("die"); }); ExpectMsg<ArgumentException>().Message.Should().Be("die"); ExpectMsg("restarted"); ExpectMsg("restarted"); ExpectMsg("restarted"); }
public void Routers_in_general_must_set_supplied_supervisorStrategy_for_FromConfig() { var escalator = new OneForOneStrategy(e => { TestActor.Tell(e); return Directive.Escalate; }); var router = Sys.ActorOf(FromConfig.Instance.WithSupervisorStrategy(escalator).Props(Props.Create<BlackHoleActor>()), "router1"); router.Tell(new GetRoutees()); EventFilter.Exception<ActorKilledException>().ExpectOne(() => { ExpectMsg<Routees>().Members.First().Send(Kill.Instance, TestActor); }); ExpectMsg<ActorKilledException>(); }
public void Routers_in_general_must_set_supplied_supervisorStrategy() { var escalator = new OneForOneStrategy(e => { TestActor.Tell(e); return Directive.Escalate; }); var router = Sys.ActorOf(new RoundRobinPool(1, null, escalator, Dispatchers.DefaultDispatcherId).Props(Props.Create<BlackHoleActor>())); router.Tell(new GetRoutees()); EventFilter.Exception<ActorKilledException>().ExpectOne(() => { ExpectMsg<Routees>().Members.First().Send(Kill.Instance, TestActor); }); ExpectMsg<ActorKilledException>(); var router2 = Sys.ActorOf(new RoundRobinPool(1).WithSupervisorStrategy(escalator).Props(Props.Create<BlackHoleActor>())); router2.Tell(new GetRoutees()); EventFilter.Exception<ActorKilledException>().ExpectOne(() => { ExpectMsg<Routees>().Members.First().Send(Kill.Instance, TestActor); }); ExpectMsg<ActorKilledException>(); }