Function client_process

redis-server/src/main.rs:29–182

(
    mut r: FramedRead<R, RedisCodec>,
    mut w: FramedWrite<W, RedisCodec>,
    client_address: net::SocketAddr,
    mut shutdown_rx: broadcast::Receiver<()>,
    cache: Arc<CacheT>,
)

#[instrument(level = "debug", skip_all)]
async fn client_process<W: AsyncWrite + Unpin, R: AsyncRead + Unpin>(
    mut r: FramedRead<R, RedisCodec>,
    mut w: FramedWrite<W, RedisCodec>,
    client_address: net::SocketAddr,
    mut shutdown_rx: broadcast::Receiver<()>,
    cache: Arc<CacheT>,
) {
    info!(?client_address, "connect");

    'outer: loop {
        tokio::select! {
                Ok(()) = (&mut shutdown_rx).recv() => {
                    break;
                }
                res = r.next() => {
                    let rmsg =
                    match res {
                        None => {
                            info!(?client_address, "none disconnect");
                            break;
                        }
                        Some(Err(e)) => {
                            error!(?e);
                            info!(?client_address, "err disconnect");
                            break;
                        }
                        Some(Ok(rmsg)) => {
                            rmsg
                        }
                    };

                    match rmsg {
                        RedisClientMsg::Auth(_passwd) => {
                            debug!("Handling Auth");
                            if let Err(e) = w.send(RedisServerMsg::Ok).await {
                                error!(?e);
                                break;
                            }
                        }
                        RedisClientMsg::Ping => {
                            debug!("Handling Ping");
                            if let Err(e) = w.send(RedisServerMsg::Pong).await {
                                error!(?e);
                                break;
                            }
                        }

                        RedisClientMsg::Info => {
                            debug!("Handling Info");
                            let stats = cache.view_stats();
                            let used_memory = stats.freq + stats.recent;
                            if let Err(e) = w.send(
                            RedisServerMsg::Info { used_memory }
                            ).await {
                                error!(?e);
                                break;
                            }
                        }