You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: main.rs
    path of file: ./repos/muddle-run/bins/matchmaker/src
    
    the code of the file until where you have to start completion: #![feature(int_roundings)]
#![feature(async_closure)]

mod game_server_allocation;
mod jwks;
mod persistence;

use crate::{
    game_server_allocation::{post_game_server_allocation, PostGameServerAllocationParams},
    jwks::poll_jwks,
    persistence::get_registered_user,
};
use future::FutureExt;
use futures
    
async fn watch_game_servers(client: Client, tx: Sender<MatchmakerMessage>, servers: Servers) {
    let game_servers: Api<GameServer> = Api::namespaced(client, "default");
    log::info!("Watching GameServer updates...");
    let mut stream = init_stream_and_watch(game_servers.clone(), servers.clone()).await;

    loop {
        let status = match stream
            .try_next()
            .await
            .expect("Failed to read from the k8s stream")
        {
            Some(status) => status,
            None => {
                log::info!("The k8s stream has ended, re-subscribing");
                stream = init_stream_and_watch(game_servers.clone(), servers.clone()).await;
                continue;
            }
        };

        let message = match status {
            WatchEvent::Added(resource) | WatchEvent::Modified(resource) => {
                if let Some(server_command) = server_command_from_resource(&resource) {
                    log::info!("Resource updated: {:?}", resource.status);
                    match server_command {
                        ServerCommand::Update(server) => {
                            servers.add(server.clone()).await;
                            Some(MatchmakerMessage::ServerUpdated(server))
                        }
                        ServerCommand::Delete(server_name) => {
                            if servers.remove(&server_name).await.is_some() {
                                Some(MatchmakerMessage::ServerRemoved(server_name))
                            } else {
                                None
                            }
                        }
                    }
                } else {
                    None
                }
            }
            WatchEvent::Deleted(resource) => {
                if let Some(server_command) = server_command_from_resource(&resource) {
                    log::info!("Resource deleted: {:?}", server_command);
                    match server_command {
                        ServerCommand::Update(server) => {
                            servers.remove(&server.name).await;
                            Some(MatchmakerMessage::ServerRemoved(server.name))
                        }
                        ServerCommand::Delete(server_name) => {
                            if servers.remove(&server_name).await.is_some() {
                                Some(MatchmakerMessage::ServerRemoved(server_name))
                            } else {
                                None
                            }
                        }
                    }
                } else {
                    None
                }
            }
            WatchEvent::Error(err) => {
                log::error!("Error event: {:?}", err);
                None
            }
            WatchEvent::Bookmark(_) => None,
        };

        if let Some(message) = message {
            let _ = tx.send(message);
        }
    }
}