How to clean up Channels on disconnect?

[thurn]

I am implementing a turn-based game server using tonic. I use gRPC streaming for the game so that players get sent updates about the moves their opponents make once they connect, more or less like this (simplified):

service Game {
    rpc Connect(ConnectRequest) returns (stream CommandList);
    rpc PerformAction(GameRequest) returns (CommandList);
}

The way I currently handle this is that I store a Sender object for each player that connects, so that I can update them later:

static CHANNELS: Lazy<DashMap<PlayerId, Sender<Result<CommandList, Status>>>> = (...)

#[tonic::async_trait]
impl MyGame for GameService {
    type ConnectStream = ReceiverStream<Result<CommandList, Status>>;

    async fn connect(
        &self,
        request: Request<ConnectRequest>,
    ) -> Result<Response<Self::ConnectStream>, Status> {
        let (tx, rx) = mpsc::channel(4);
        // Store channel to provide future updates:
        CHANNELS.insert(player_id, tx);
        Ok(Response::new(ReceiverStream::new(rx)))
    }
}

This way, when game actions come in, I can check the CHANNELS map to see which opponents are connected and send them an update with the new game state:

async fn perform_action(
    &self,
    request: Request<GameRequest>,
) -> Result<Response<CommandList>, Status> {
    if let Some(channel) = CHANNELS.get(&player_id) {
        // Send update to opponent
    }
}

This approach is generally working quite well. One immediate problem, however, is that the CHANNELS map grows infinitely in size as players connect, I haven't been able to find an explicit callback in tonic when users disconnect from their gRPC streaming session where I could clean up the map. Does something like that exist? Alternatively, is this a complete misuse of the API and I should be doing something totally different? :)

(question mirrored with https://stackoverflow.com/questions/72841806)

[LucioFranco]

So with tonic's channels and hyper's client its not possible to really detect when the tcp connection is disconnected unless you try to send a message and it fails (but usually it'll try to reconnect). What I would do instead is create a grpc streaming request. That will notify you when the client has disconnected via the incoming stream ending.

[adamchalmers]

Couldn't you use a Tower middleware to run code after the stream ends? You could have the endpoint set a connection ID in an extension on the response, and have the middleware read that extension and clean up the map keys.

[thurn]

@LucioFranco are you basically saying to switch to bidirectional streaming from the client to the server? And then when stream.next returns an error the client is disconnected, similar to this example?

@adamchalmers I'm not familiar with advanced tower middleware, is it possible to make a Service which is aware of streams instead of being request-based? I guess some kind of adapter from the request-level poll_ready method on middleware to observe the poll_next method on streams?

[adamchalmers]

Just a normal Tower Middleware should be called before the stream is initiated, and then after the stream closes.

[thurn]

hm, I only get poll_ready() and call() on the initial connection. This is http1/tonic_web, maybe that's why.

[LucioFranco]

Yes, this line here is what you're looking for https://github.com/hyperium/tonic/blob/master/examples/src/streaming/server.rs#L119