Akka HTTP Websocket, how to identify connections inside of actor

Question

I'm working on simple mulitplayer game in scala that I would like to expose through websockets for JS clients.

Here is my WebsocketServer class

class WebsocketServer(actorRef: ActorRef, protocol: Protocol, system: ActorSystem, materializer: ActorMaterializer) extends Directives {

    val route = get {
      pathEndOrSingleSlash {
        handleWebSocketMessages(websocketFlow)
      }
    }

    def websocketFlow: Flow[Message, Message, Any] =
      Flow[Message]
        .map {
          case TextMessage.Strict(textMessage) => protocol.hydrate(textMessage)
        }
        .via(actorFlow)
        .map(event => TextMessage.Strict(protocol.serialize(event)))


    def actorFlow : Flow[Protocol.Message, Protocol.Event, Any] = {
      val sink =
        Flow[Protocol.Message]
          .to(Sink.actorRef[Protocol.Message](actorRef, Protocol.CloseConnection()))

      val source =
        Source.actorRef[Protocol.Event](1, OverflowStrategy.fail)
          .mapMaterializedValue(actor => actorRef ! Protocol.OpenConnection(actor))

      Flow.fromSinkAndSource(sink, source)
    }
}

This is simplified code of my actor that should receive messages from websocket server.

class GameActor() extends Actor {

  private var connections: List[ActorRef] = List()

  override def receive: Receive = {

    case message: Protocol.OpenConnection => {
      this.connections = message.connection :: this.connections
      message.connection ! Protocol.ConnectionEstablished()
    }

    case message: Protocol.CloseConnection => {
      // how can I remove actor from this.connections ?
    }

    case message: Protocol.DoSomething => {
      // how can I identify from which connection this message came in?
    }
  }
}

So far so good, currently I'm able to respond with simple WelcomeMessage to a client however I still don't know how to:

remove actor from connections list whenever actor receive CloseConnection message?
identify from which connection message came to the actor?

score 3 · Accepted Answer · answered Dec 01 '16 at 20:44

I think you need to have some sort of key or id to map with your connection actor.

def websocketFlow: Flow[Message, Message, Any] =
  val randomKey = Random.nextInt()
      Flow[Message]
        .map {
          case TextMessage.Strict(textMessage) => protocol.hydrate(textMessage)
        }
        .via(actorFlow(randomKey))
        .map(event => TextMessage.Strict(protocol.serialize(event)))


    def actorFlow(flowID: Int) : Flow[Protocol.Message, Protocol.Event, Any] = {
      val sink =
        Flow[Protocol.Message]
          .to(Sink.actorRef[Protocol.Message](actorRef, Protocol.CloseConnection(flowID)))

      val source =
        Source.actorRef[Protocol.Event](1, OverflowStrategy.fail)
          .mapMaterializedValue(actor => actorRef ! Protocol.OpenConnection(actor, flowID))

      Flow.fromSinkAndSource(sink, source)
    }

then in your actor you can store the connections in a Map instead of List, which also happen to be more efficient to be remove.

I was looking for some kind of built in mechanism and never thought about simplest solution ever, thanks! — Norbert Orzechowicz, Dec 02 '16 at 09:23

score 3 · Answer 2 · answered Oct 25 '17 at 19:59

This question has already been answered. For the Java people out there, here is the java version:

public class WebsocketRoutes extends AllDirectives {

private final ActorSystem actorSystem;
private final ActorRef connectionManager;

public WebsocketRoutes(final ActorSystem actorSystem, final ActorRef connectionManager) {
    this.actorSystem = actorSystem;
    this.connectionManager = connectionManager;
}

public Route handleWebsocket() {
    return path(PathMatchers.segment(compile("router_v\\d+")).slash(PathMatchers.segment("websocket")).slash(PathMatchers.segment(compile("[^\\\\/\\s]+"))), (version, routerId) ->
            handleWebSocketMessages(createWebsocketFlow(routerId))
    );
}

private Flow<Message, Message, NotUsed> createWebsocketFlow(final String routerId) {

    final ActorRef connection = actorSystem.actorOf(WebsocketConnectionActor.props(connectionManager));

    final Source<Message, NotUsed> source = Source.<RouterWireMessage.Outbound>actorRef(5, OverflowStrategy.fail())
            .map((outbound) -> (Message) TextMessage.create(new String(outbound.message, "utf-8")))
            .throttle(5, FiniteDuration.create(1, TimeUnit.SECONDS), 10, ThrottleMode.shaping())
            .mapMaterializedValue(destinationRef -> {
                connection.tell(new RouterConnected(routerId, destinationRef), ActorRef.noSender());
                return NotUsed.getInstance();
            });

    final Sink<Message, NotUsed> sink = Flow.<Message>create()
            .map((inbound) -> new RouterWireMessage.Inbound(inbound.asTextMessage().getStrictText().getBytes()))
            .throttle(5, FiniteDuration.create(1, TimeUnit.SECONDS), 10, ThrottleMode.shaping())
            .to(Sink.actorRef(connection, PoisonPill.getInstance()));

    return Flow.fromSinkAndSource(sink, source);
}
}

Akka HTTP Websocket, how to identify connections inside of actor

2 Answers2