Akka HTTP Websocket, jak zidentyfikować połączenia wewnątrz aktora

Question

Pracuję nad prostą grą multiplayer w scala, którą chciałbym udostępnić poprzez strony internetowe dla klientów JS.

Oto moja klasa WebsocketServer

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) 
    } 
} 

To jest uproszczony kod mojego aktora, który powinien odbierać wiadomości z serwera websocket.

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? 
    } 
    } 
} 

tej pory tak dobry, obecnie jestem w stanie odpowiedzieć z prostym WelcomeMessage do klienta jednak ja nadal nie wiem, jak:

• aktor usuń z listy połączeń, gdy aktor otrzyma CloseConnection wiadomość?
• określić, z której wiadomości o połączeniu doszła wiadomość do aktora?

Answer 1

myślę, że trzeba mieć jakieś key lub id mapowania z aktorem połączenia.

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) 
    } 

Następnie w twoim aktoru możesz przechowywać połączenia w Mapie zamiast na Liście, które również są skuteczniejsze do usunięcia.

Answer 2

To pytanie zostało już wysłane. Dla osób pracujących w Javie, tutaj jest wersja Java:

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); 
} 
}