Why does downloading a file from S3 using Rusoto sometimes return a blank string?

Question

I'm trying to get the body from an existing file in an S3 bucket using rusoto. My body.unwrap returns a blank string and I don't understand why. I don't have any issues or error, and my file is well.

It looks like I sometimes receive empty content from S3. This is a quick and dirty patch, is there another better way? Like using S3 hash?

pub fn get_object(
    access_key_id: &str,
    secret_access_key: &str,
    region: &Region,
    bucket_name: &str,
    object_key: &str,
) -> Result<FileContent, Error> {
    let credentials = StaticProvider::new(
        access_key_id.to_string(),
        secret_access_key.to_string(),
        None,
        None,
    );

    let client = Client::new_with(credentials, HttpClient::new().unwrap());
    let s3_client = S3Client::new_with_client(client, region.clone());

    let mut or = GetObjectRequest::default();
    or.bucket = bucket_name.to_string();
    or.key = object_key.to_string();
    let _ = env_logger::try_init();
    let get_object_output = s3_client.get_object(or);
    let r = async_run(get_object_output);

    let _err = Error::new(
        ErrorKind::Other,
        format!(
            "something goes wrong while getting object {} in the S3 bucket {}",
            object_key, bucket_name
        ),
    );

    match r {
        Err(err) => {
            warn!("{}", err);
            Err(_err)
        }

        Ok(x) => {
            let mut s = String::new();
            x.body.unwrap().into_blocking_read().read_to_string(&mut s);

            if s.is_empty() {
                // It looks like we receive sometimes empty content from s3. This is a quick and dirty patch, is there another better way ? Like using s3 Hash ?
                return Err(Error::new(
                    ErrorKind::InvalidData,
                    "file content is empty - which is not the expected content - what's wrong?",
                ));
            }

            Ok(s)
        }
    }
}

This is my Tokio integration:

use std::future::Future;
use tokio::runtime::Runtime;

pub fn async_run<F: Future>(future: F) -> F::Output {
    // TODO improve - is it efficient to create a Runtime at each exec?
    let mut runtime = Runtime::new().expect("unable to create a tokio runtime");
    runtime.block_on(future)
}

It seems Tokio does not work as expected.

I resolve my issues: My internet speed is very low, I use the AWS CLI in case of multiple fails from rusoto.