该实例的Akka Actor Path

Question

I am using Java Play Framework. I am using web sockets for client server interaction. On the server side we have aka actors which respond to the client request. The problem i am facing : I want ,that when the client opens a web socket connection with the Hakka actor on the server, it actually opens a pool for that actor, and then i need to trace the actor client path for that instance ,so that whenever some other action takes place in some other class, that class informs this actor (using the instance path which was traced) that the action has occurred and then this actor informs the user (client) that this action has occurred. I am actually using

String ClientPushActorPath = akka.serialization.Serialization.serializedActorPath(self());

the above to keep get the path for that instance of client user. But the next time when i try to hit this actor using this path , I am unable to find this actor. The way i am trying to hit the actor from another actor is :

PushCacheManager cache = PushCacheManager.getInstance();
cache.load(qiid);
String ActorPath = cache.get("ClientPushActorPath");
ActorSelection ClientPushActor = system.actorSelection(ActorPath);
ClientPushActor.tell(m4, getSelf());

So the above code simply says that first i go and get the scots path from the cache (it was cached in memory for future use) and then i try to pass that path to actor selection .Once i get the object for actor selection i use that to tell the other actor the message i need to pass which is m4. Please correct me where i am going wrong. I am not able to see the actor using this path. I feel , the way i am tracking the path is wrong. Please correct me . Than

Answer 1

Please bear with me, it will take some time to go through this but it should give you a good idea of what to do. Note: I am assuming that you still use Play 2.4.x and have not updated to Play 2.5.x yet. And also that you use Java (although if you are able to switch, I would recommend the Akka Scala API).

---

Step 1: defining the actor which is handling the WebSocket connection

In your controller you would write this:

public static WebSocket<String> socket() {
    return WebSocket.withActor(MyWebSocketActor::props);
}

This means that every WebSocket connection will be handled by an actor instance of type MyWebSocketActor . You will then have to implement the actor like this:

import akka.actor.*;

public class MyWebSocketActor extends UntypedActor {

    public static Props props(ActorRef out) {
        return Props.create(MyWebSocketActor.class, out);
    }

    private final ActorRef out;

    public MyWebSocketActor(ActorRef out) {
        this.out = out;
    }

    public void onReceive(Object message) throws Exception {
        if (message instanceof String) {
            out.tell("I received your message: " + message, self());
        }
    }
}

The ActorRef out parameter that you see is actually the underlying actor (generated from Play). You don't need to do anything with it, just remember that once you send something to this out actor, he will handle it to the client.

You also have to define a proper route in your routes file:

GET /ws controllers.Application.socket()

Step 2: defining how to manage all the WebSocket actors

In general you have two options - either you "look up" the actors created above or you provide some kind of mechanism to manage them (kind of registry)

• Step 2.1: looking up the WebSocket actors

  The advantage here is that you don't need an extra registry/manager or similar. The disadvantage is that it is really hard to know which actor serves which WebSocket connection.

  You would use actorSelection for this:

  system.actorSelection("system/websockets/*/handler");

  This works because as I mentioned earlier there are connection handler actors generated by Play - so their addresses are like this: akka://application/system/websockets/42/handler . Again, this way you can get all the actors but not single ones (because you don't know their handler number).

• Step 2b: managing the WebSocket actors The advantage here is that you can totally manage the actors and assign various information to them. The disadvantage is that you have one more actor to take care of (although not really a problem, Akka is pretty good at this)

You would create a new actor like:

 public class ManagerActor extends UntypedActor {

    List<ActorRef> slaves;

    public MyWebSocketActor() {
        this.slaves = new ArrayList<>();
    }

    public void onReceive(Object message) throws Exception {
        if (message instanceof RegisterMe) {
            // a new WebSocket was created so we can register him
            slaves.add(sender());

            // also register a DeathWatch so that we know when the WebSocket actor dies 
            context.watch(sender());
        } else if (message instanceof Terminated) {
            // remove from the list
            ...
        }
    }
 }

Step 3: putting all together

Now, remember our WebSocket actor from above? He should somehow register itself with the Manager. Again, you can do this in two ways: you can "look up" the Manager with context.system.actorSelection("user/manager") or if you already have a reference (an ActorRef ) to the Manager, you can provide it as a constructor parameter when creating the WebSocket actor

You could make use of the preStart method which is available to every actor and do your registration:

public class MyWebSocketActor extends UntypedActor {

   ....

   @Override
   public void preStart() throws Exception {
       context().system().actorSelection("user/manager").tell(RegisterMe, self());
       super.preStart();
   }
}

---

Now that you have all the WebSocket actors managed by the ... Manager, you can define new messages which he can handle and tell him that he has to forward the m4 to the clients. Note that you can use something like a Map inside the Manager - where the ActorRef is the key and the value is some user-specific property or whatever you want.