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/agones/test/sdk/rust/src
    
    the code of the file until where you have to start completion: // Copyright 2018 Google LLC All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use std::{env, thread, time::Duration};

#[tokio::main(flavor = "multi_thread", worker_threads = 4)]
async fn main() {
    println!("Rust Game Server has started!");

    ::std::process::exit(match run().await {
        Ok(_) => {
            println!("Rust Game Server finished.");
            0
        }
        Err(msg) => {
            println!("rust: {}", msg);
            1
        }
    });
}

async fn run() -> Result<(), String> {
    let env_run_async = env::var("RUN_ASYNC").unwrap_or_default();
    if env_run_async.contains("true") {
        println!("rust: RUN_ASYNC is set to true, so run test for async functions");
        run_async().await
    } else {
        tokio::task::block_in_place(run_sync)
    }
}

fn run_sync() -> Result<(), String> {
    use tokio::runtime::Handle;

    println!("rust: Creating SDK instance");
    let mut sdk = Handle::current().block_on(async move {
        agones::Sdk::new(None /* default port */, None /* keep_alive */)
            .await
            .map_err(|e| format!("unable to create sdk client: {}", e))
    })?;

    // Spawn a task that will send health checks every 2 seconds. If this current
    // thread/task panics or dropped, the health check will also be stopped
    let _health = {
        let health_tx = sdk.health_check();
        let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();

        Handle::current().spawn(async move {
            let mut interval = tokio::time::interval(Duration::from_secs(2));

            loop {
                tokio::select! {
                    _ = interval.tick() => {
                        if health_tx
                            .send(())
                            .await.is_err() {
                            eprintln!("Health check receiver was dropped");
                            break;
                        }
                    }
                    _ = &mut rx => {
                        println!("Health check task canceled");
                        break;
                    }
                }
            }
        });

        tx
    };

    let _watch = {
        let mut watch_client = sdk.clone();
        let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();

        tokio::task::spawn(async move {
            println!("rust: Starting to watch GameServer updates...");
            let mut once = true;
            match watch_client.watch_gameserver().await {
                Err(e) => eprintln!("rust: Failed to watch for GameServer updates: {}", e),
                Ok(mut stream) => loop {
                    tokio::select! {
                        gs = stream.message() => {
                            match gs {
                                Ok(Some(gs)) => {
                                    let om = gs.object_meta.unwrap();
                                    println!("rust: GameServer Update, name: {}", om.name);
                                    println!("rust: GameServer Update, state: {}", gs.status.unwrap().state);

                                    if once {
                                        println!("rust: Setting an annotation");
                                        let uid = om.uid.clone();

                                        if let Err(e) = watch_client.set_annotation("test-annotation", uid).await {
                                            eprintln!("rust: Failed to set annotation from watch task: {}", e);
                                        }

                                        once = false;
                                    }
                                }
                                Ok(None) => {
                                    println!("rust: Server closed the GameServer watch stream");
                                    break;
                                }
                                Err(e) => {
                                    eprintln!("rust: GameServer Update stream encountered an error: {}", e);
                                }
                            }

                        }
                        _ = &mut rx => {
          
    
fn run_sync() -> Result<(), String> {
    use tokio::runtime::Handle;

    println!("rust: Creating SDK instance");
    let mut sdk = Handle::current().block_on(async move {
        agones::Sdk::new(None /* default port */, None /* keep_alive */)
            .await
            .map_err(|e| format!("unable to create sdk client: {}", e))
    })?;

    // Spawn a task that will send health checks every 2 seconds. If this current
    // thread/task panics or dropped, the health check will also be stopped
    let _health = {
        let health_tx = sdk.health_check();
        let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();

        Handle::current().spawn(async move {
            let mut interval = tokio::time::interval(Duration::from_secs(2));

            loop {
                tokio::select! {
                    _ = interval.tick() => {
                        if health_tx
                            .send(())
                            .await.is_err() {
                            eprintln!("Health check receiver was dropped");
                            break;
                        }
                    }
                    _ = &mut rx => {
                        println!("Health check task canceled");
                        break;
                    }
                }
            }
        });

        tx
    };

    let _watch = {
        let mut watch_client = sdk.clone();
        let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();

        tokio::task::spawn(async move {
            println!("rust: Starting to watch GameServer updates...");
            let mut once = true;
            match watch_client.watch_gameserver().await {
                Err(e) => eprintln!("rust: Failed to watch for GameServer updates: {}", e),
                Ok(mut stream) => loop {
                    tokio::select! {
                        gs = stream.message() => {
                            match gs {
                                Ok(Some(gs)) => {
                                    let om = gs.object_meta.unwrap();
                                    println!("rust: GameServer Update, name: {}", om.name);
                                    println!("rust: GameServer Update, state: {}", gs.status.unwrap().state);

                                    if once {
                                        println!("rust: Setting an annotation");
                                        let uid = om.uid.clone();

                                        if let Err(e) = watch_client.set_annotation("test-annotation", uid).await {
                                            eprintln!("rust: Failed to set annotation from watch task: {}", e);
                                        }

                                        once = false;
                                    }
                                }
                                Ok(None) => {
                                    println!("rust: Server closed the GameServer watch stream");
                                    break;
                                }
                                Err(e) => {
                                    eprintln!("rust: GameServer Update stream encountered an error: {}", e);
                                }
                            }

                        }
                        _ = &mut rx => {
                            println!("rust: Shutting down GameServer watch loop");
                            break;
                        }
                    }
                },
            }
        });

        tx
    };

    // Waiting for a thread to spawn
    thread::sleep(Duration::from_secs(2));

    println!("rust: Marking server as ready...");
    Handle::current().block_on(async {
        sdk.ready()
            .await
            .map_err(|e| format!("Could not run Ready(): {}. Exiting!", e))
    })?;

    println!("rust: ...marked Ready");

    println!("rust: Reserving for 5 seconds");
    Handle::current().block_on(async {
        sdk.reserve(Duration::from_secs(5))
            .await
            .map_err(|e| format!("Could not run Reserve(): {}. Exiting!", e))
    })?;
    println!("rust: ...Reserved");

    println!("rust: Allocate game server ...");
    Handle::current().block_on(async {
        sdk.allocate()
            .await
            .map_err(|e| format!("Could not run Allocate(): {}. Exiting!", e))
    })?;

    println!("rust: ...marked Allocated");

    println!("rust: Getting GameServer details...");
    let gameserver = Handle::current().block_on(async {
        sdk.get_gameserver()
            .await
            .map_err(|e| format!("Could not run GameServer(): {}. Exiting!", e))
    })?;

    println!(
        "rust: GameServer name: {}",
        gameserver.object_meta.clone().unwrap().name
    );

    println!("rust: Setting a label");
    let creation_ts = gameserver.object_meta.unwrap().creation_timestamp;
    Handle::current().block_on(async {
        sdk.set_label("test-label", &creation_ts.to_string())
            .await
            .map_err(|e| format!("Could not run SetLabel(): {}. Exiting!", e))
    })?;

    let feature_gates = env::var("FEATURE_GATES").unwrap_or_default();
    if feature_gates.contains("PlayerTracking=true") {
        run_player_tracking_features(sdk.alpha().clone())?;
    }

    for i in 0..1 {
        let time = i * 5;
        println!("rust: Running for {} seconds", time);

        thread::sleep(Duration::from_secs(5));
    }

    println!("rust: Shutting down...");
    Handle::current().block_on(async {
        sdk.shutdown()
            .await
            .map_err(|e| format!("Could not run Shutdown: {}. Exiting!", e))
    })?;
    println!("rust: ...marked for Shutdown");

    Ok(())
}