Is there any way to wait for actor to be completely stopped?

Question

As I know, all operations in Akka.Net are asynchronous, and Context.Stop() simply sends a Stop message to the actor. That means, actor will be alive for some time before it completely shuts down.

And if I'll call Context.Child() right after Context.Stop() with the name of the actor I just stopped, I will get the same actor.

Here is the example code

var actor = context.Child(actorName);

if (actor.Equals(ActorRefs.Nobody))
{
    actor = CreateNewActor();
}

Context.Stop(actor)
actor = context.Child(actorName);
// what do we get here, same actor or ActorRefs.Nobody ?

My application creates actors to process events from terminals. Each time new terminal connected, I create new actor by calling Context.Child() using terminal name. When terminal disconnects, I stop the actor.

Problem is that some times I receive Connect message right after Disconnect for same terminal, and as result I get actor that's going be stopped. Is there any way to check that actor received Stop message and will be stopped soon?

You should read about: * Lifecycle Monitoring aka DeathWatch * Shutdown With Confirmation: GracefulStop — Igor Berman, Jan 07 '17 at 12:18
One of propositions that comes to my mind is also an [FSM](http://getakka.net/docs/FSM). After, actor receives a Disconnect message, you switch to new state and change the behavior. Therefore, Connect message will not be processed in a regular way. And you can also define what the actor should do when Connect message is unhandled. — Branislav Lazic, Jan 08 '17 at 00:28

Yury Glushkov · Answer 1 · 2017-01-09T08:03:18.230

1

You can use

var shutdown = actor.GracefulStop(TimeSpan.FromSeconds(42));

It returns a task whose result confirms shutdown within 42 seconds

UPDATE

But, in case, if you want to recreate actor later with the same name, you should listen to Terminated message within actor's supervisor.

edited Jan 09 '17 at 08:03

answered Jan 07 '17 at 20:30

Yury Glushkov

711
6
16

1

As I understand the note [here](http://getakka.net/docs/Working%20with%20actors#graceful-stop), it wont help me: **Warning** _Keep in mind that an actor stopping and its name being deregistered are separate events which happen asynchronously from each other. Therefore it may be that you will find the name still in use after GracefulStop() returned. In order to guarantee proper deregistration, only reuse names from within a supervisor you control and only in response to a Terminated message, i.e. not for top-level actors._ – bonzaster Jan 09 '17 at 07:50
Oh, sorry. I misunderstood your original question. Yes, Grasfull top will not guarantee you, that actor name is deregistered. In your case you should listen to Terminated messages, in actor, that supervises your actors with terminal names. – Yury Glushkov Jan 09 '17 at 07:57

bonzaster · Accepted Answer · 2017-01-09T14:38:06.847

I decide to finish up with handling Terminated messages.

After receiving Disconnect message and stopping an actor, I keep it's name in ActorsToBeStopped HashSet, and before creating a new actor on receiving Connect message, I check if it exists there. If so, I keep this Connect message in dictionary with actor name as key and Connect message as value and process it after receiving Terminated message for corresponding actor.

Something like this:

private readonly Dictionary<string, Connect> postponedConnectMessages = new Dictionary<string, Connect>();
private readonly HashSet<string> actorsToBeStopped = new HashSet<string>();

// ...

Receive<Disconnected>(t => 
{
    var actor = GetActorByName(t.Name);
    Context.Stop(actor);
    actorsToBeStopped.Add(actor.Path.Name);
});

Receive<Connected>(t =>
{
    var actor = GetActorByName(t.Name);

    if (actorsToBeStopped.Contains(actor.Path.Name))
    {
        postponedConnectMessages[actor.Path.Name] = t;
        return;
    }
    // work with actor
}

Receive<Terminated>(t =>
{
    var deadActorName = t.ActorRef.Path.Name;
    actorsToBeStopped.Remove(deadActorName);
    if (postponedConnectMessages.ContainsKey(deadActorName))
    {
        var connectMessage = postponedConnectMessages[deadActorName];
        postponedConnectMessages.Remove(deadActorName);
        var actor = GetActorByName(connectMessage.Name);
        // we sure we have new actor here
        // work with actor
    }
}

EDIT

Sad thing here is that I can't write test for it, because Akka.TestKit doesn't allow me to create TestActor with same name even after it was stopped:

public void StopTest()
{ 
    var t = CreateTestActor("AAAA");
    Watch(t);
    Sys.Stop(t);
    ExpectTerminated(t, TimeSpan.FromSeconds(10));
    var t2 = CreateTestActor("AAAA"); // test fails here
}

Or, maybe it wasn't stopped after ExpectTerminated, but anyway I don't know how to wait it's termination.

Is there any way to wait for actor to be completely stopped?

2 Answers2