Private Communication between client and server using websockets play 2.3.x - scala

Question

I am newbie to scala and can't figure out sending private message to client using websocket.
Here is my controller:
object Client extends Controller {
def socket(uuid: String) = WebSocket.acceptWithActor[String, String] { request =>
out => ClientWebSocket.props(uuid)
}
// Test Method to send message to websocket connected client
def sendMessage(guid: String) = Action { implicit request =>
val system = ActorSystem("default")
val out = system.actorOf(Props(classOf[ClientWebSocket], guid))
out ! SendUpdate("Message Recieved")
Ok
}
}
Here is my actor class:
object ClientWebSocket {
def props(uuid: String) = Props(new ClientWebSocket(uuid))
case class SendUpdate(msg:String)
}
class ClientWebSocket(uuid: String) extends Actor {
import ClientWebSocket._
def receive = {
case SendUpdate(msg:String) =>
sender ! "Message is " + msg
}
}
When I call sendMessage with uuid of client, I am getting akka dead letters encountered error.
Any help is really appreciated.

Answer 1

First off, in your WebSocket method, you need to use the provided ActorRef instead of sender. sender is probably something else in the hierarchy.
class ClientWebSocket(uuid: String, out: ActorRef) extends Actor {
import ClientWebSocket._
def receive = {
case SendUpdate(msg: String) =>
out ! s"Message is $msg"
}
}
Second, you are receiving dead letters in sendMessage because you are replying to your controller, which unfortunately is not an Actor.
The problem is that you cannot get hold of the ActorRef and since you don't know the name of the actor, you cannot use an ActorSelection. So you would need to make a WebSocket call to your own app, call it from web browser / JavaScript or do some hacking with the action to get to the actor.
Edit
Your ClientWebSocket could register (e.g. in preStart via ActorSelection or via an ActorRef as props parameter) with another actor that keeps a Map[String, ActorRef] reference to all websockets and in turn monitors them using death watch. That actor would then forward your SendUpdate to the correct websocket actor. Since you can only return Props in acceptWithActor, you are not able to form a real hierarchy.

Answer 2

The out parameter is an ActorRef, you will use it to send messages to the Client, therefore you need to keep it in your Actor.
object Client extends Controller {
def socket(uuid: String) = WebSocket.acceptWithActor[String, String] { request =>
// out is an actor to what the outbound messages should go to respond to remote client
out => ClientWebSocket.props(uuid, out)
}
}
Your ClientWebSocket actor is as follows:
class ClientWebSocket(uuid: String, out: ActorRef) extends Actor ...
And the companion object is as follows
object ClientWebSocket {
def props(uuid: String, out: ActorRef) = Props(classOf[ClientWebSocket], uuid, out)
}
In the ClientWenSocket you can Register/Deregister the Actor with a CentralWebSocketControl Actor as:
class ClientWebSocket(uuid: String, out: ActorRef) extends Actor {
#throws[Exception](classOf[Exception])
override def preStart(): Unit = {
super.preStart()
CentralWebSocketControl.instance ! RegisterMe(uuid)
}
#throws[Exception](classOf[Exception])
override def postStop(): Unit = {
CentralWebSocketControl.instance ! UnregisterMe(uuid)
super.postStop()
}
}
The CentralWebSocketControl Actor can be as:
class CentralWebSocketControl extends Actor {
val clientActors = scala.collection.mutable.HashMap[String, ActorRef]()
override def receive: Actor.Receive = {
case RegisterMe(uuid) =>
clientActors += uuid -> sender()
case UnregisterMe(uuid) =>
clientActors -= uuid
}
}
object CentralWebSocketControl {
val instance = Akka.system.actorOf(Props(classOf[CentralWebSocketControl]), name = "CentralWebSocketControl")
}
To send a message to a given ClientWebSocket identified by an uuid, you can send a message to CentralWebSocketControl that may delegate the message to the registered ClientWebSocket.
class CentralWebSocketControl extends Actor {
val clientActors = scala.collection.mutable.HashMap[String, ActorRef]()
override def receive: Actor.Receive = {
...
case SendUpdateTo(uuid: String, msg: String) =>
clientActors.get(uuid) match {
case Some(actor) =>
actor ! SendUpdate(msg)
case None =>
???
}
}
}
and finally
class ClientWebSocket(uuid: String, out: ActorRef) extends Actor {
override def receive: Receive = {
case SendUpdate(msg) =>
out ! msg
}
...
}