Re: [akka-user] Re: is there a way to know when really an actor has stopped

'Konstantinos Kougios' via Akka User List Mon, 12 Oct 2015 13:52:48 -0700

well, it could, but requires more work and it is more complex thanhaving any actor .watch() for events.

Especially in my case that I need to watch for termination across thecluster, I would need a round trip to all parents (where as now I amjust doing the round trip to the actors straight away)

Basically, my db "driver" issues a DropIndex msg to one of the dbservers. That server then needs to monitor the whole process, makingsure the drop index indeed occurred for all the cluster


On 09/10/15 18:21, Patrik Nordwall wrote:

Thanks for elaborating. I still don't understand why thedatabaseServer can't watch its index children and recreate them whenit receives Terminated.

Regarding recreating the databaseServer itself (top level I guess) intests I would not reuse the name.fre 9 okt. 2015 kl. 18:54 skrev 'Konstantinos Kougios' via Akka UserList <[email protected] <mailto:[email protected]>>:


    A solution like this could work, but it is a lot more complicated
    (complexity added just to handle actor termination).

    The databaseServer actor is not affected by the deaths of the indexes.

    Btw, all my Terminated actors are local (same ActorSystem, same
    jvm) to the watcher, does that help?


    On 09/10/15 17:36, Michael Frank wrote:

    instead of using actor paths to send directly to the index actor,
    why not send your message to the /databaseServer actor, which
    then forwards the message to the appropriate index actor?  the
    databaseServer actor would contain a Map[String,ActorRef] which
    maps index name to index actor (which are its children), and
    would register deathwatch on each child, so it would be notified
    when an index goes away and update its state.

    -Michael

    On 10/09/15 08:58, 'Konstantinos Kougios' via Akka User List wrote:

    well, I am using actor paths to find the actors, which are
    unique per ActorSystem.

    I.e. paths are

    ../databaseServer

    ../databaseServer/index:x1

    ../databaseServer/index:x2

    I am using the akka cluster, so each "server" will have these paths.

    Now when I do a "dropIndex" and drop index x1, actors
    ../databaseServer/index:x1 on each server must terminate. I
    would like to know precisely when that occurred, because a
    drop/recreate will have the issue of the same actor name.

    Now I could, for tests, use a unique index name each time. But
    some tests need to drop/recreate the /databaseServer (and
    remember I refer to the indexes by ../databaseServer/index:x1)

    Cheers


    On 09/10/15 12:30, Patrik Nordwall wrote:

    it's probably easies to not reuse the name

    On Fri, Oct 9, 2015 at 1:23 PM, 'Konstantinos Kougios' via Akka
    User List <[email protected]
    <mailto:[email protected]>> wrote:

        Well, I have this component based on 1 actor. It is the
        "flow" thing I was talking a few months ago, anyway it does
        take care of a process between different actors. One thing
        it does is to stop an other actor and wait till it is
        terminated. I need to make sure the other actor is really
        terminated because further down an actor with the same name
        is created - which randomly & rarely fails with "actor name
        [databaseServer] is not unique!"


        On 09/10/15 12:17, Patrik Nordwall wrote:



        On Fri, Oct 9, 2015 at 12:59 PM, 'Konstantinos Kougios'
        via Akka User List <[email protected]
        <mailto:[email protected]>> wrote:

            oh... in that case my code changes won't work. The
            watcher is not the parent of the actor.

            Will it work if the watcher is child of the same
            parent of the Terminated actor?


        no, but what would a sibling do? it can't recreate the
        actor, it is only the parent that can create child actor
        with same name




            On 09/10/15 06:08, Patrik Nordwall wrote:

            Note that this advice is correct but only when the
            parent actor receives the Terminated, i.e. it does
            not hold for top level actors where you can only
            watch from the "outside".
            tors 8 okt. 2015 kl. 11:46 skrev Kostas kougios
            <[email protected]
            <mailto:[email protected]>>:

                Thanks, I am doing that now and hopefully it
                works (the issue occurred very rarely, so I have
                to wait and see)


                On Friday, 2 October 2015 17:16:35 UTC+1, Ryan
                Tanner wrote:

                    Don't create the replacement actor until
                    you've received a Terminated message for the
                    original actor.

                    On Friday, October 2, 2015 at 8:58:54 AM
                    UTC-6, Kostas kougios wrote:

                        I create a named actor, stop it and
                        recreate it with the same name. Because
                        stop is async, I end up with exceptions like

                        akka.actor.InvalidActorNameException:
                        actor name [databaseServer] is not unique!
                        [info]   at
                        
akka.actor.dungeon.ChildrenContainer$NormalChildrenContainer.reserve(ChildrenContainer.scala:130)
                        [info]   at
                        
akka.actor.dungeon.Children$class.reserveChild(Children.scala:77)
                        [info]   at
                        akka.actor.ActorCell.reserveChild(ActorCell.scala:373)
                        [info]   at
                        
akka.actor.dungeon.Children$class.makeChild(Children.scala:215)
                        [info]   at
                        
akka.actor.dungeon.Children$class.attachChild(Children.scala:42)
                        [info]   at
                        akka.actor.ActorCell.attachChild(ActorCell.scala:373)
                        [info]   at
                        
akka.actor.ActorSystemImpl.actorOf(ActorSystem.scala:586)
                        [info]   at
                        
org.distributedrange.actors.StreamActor$$anonfun$2.apply(StreamActor.scala:122)

                        I get the same exception even if I set an
                        AtomicBoolean to true at:

                        override def postStop() = {
                            stopped.set(true)
                            super.postStop()
                        }


                        and then

                        while (!stopped.get) {
                            Thread.sleep(1)
                          }


                        Is there a way to "block" and wait till
                        the actor stops?
                        (don't worry about the block part, it is
                        only for test cases)

                        Thanks