Save body of a streaming future object to disk

Question

I'm using the PollyClient from rusoto, where I'm attemping to handle what I believe is a Future response of some type from the method synthesize_speech().

Here is a snippet of what I have that compiles and runs as-is:

extern crate rusoto_core;
extern crate rusoto_polly;

use std::default::Default;
use tokio::{io};

use rusoto_core::credential::{ProfileProvider, ProvideAwsCredentials};
use rusoto_core::Region;
use rusoto_core::ByteStream;
use rusoto_polly::{PollyClient, SynthesizeSpeechInput, Polly};
use std::fs::File;
use futures::AsyncBufRead;
use std::pin::Pin;
use futures::Future;

fn main() {

    let region = Region::UsEast1;
    let polly_client = PollyClient::new(region); // using default credenetials

    let speech_input = SynthesizeSpeechInput{
        engine: Option::from(String::from("neural")),
        language_code: None,
        lexicon_names: None,
        output_format: "mp3".to_string(),
        sample_rate: None,
        speech_mark_types: None,
        text: String::from("hello world!"),
        text_type: None,
        voice_id: String::from("Amy")
    };
    let mut response = polly_client.synthesize_speech(speech_input);

    println!("Now how to we handle this respones object...");

}

My goal is to save what should be MP3 binary data in the response. I have not shared any of the compiler errors, as I've gone through quite a few different ones. I'm brand new to Rust, and while was progressing with non-async code, this was my first encounter with it.

Do I need to wrap that synthesize_speech() method in a closure, such that I could wrap that in some kind of await block?

Any help or suggestions would be much appreciated.

Answer 1

I realize this is just a toy example, but after mimicing some of the tokio async pattern on main() from the rusoto documentation, was able to get this to work:

extern crate rusoto_core;
extern crate rusoto_polly;

// use rusoto_core::credential::{ProfileProvider, ProvideAwsCredentials};
use rusoto_core::{Region};
use rusoto_polly::{PollyClient, SynthesizeSpeechInput, Polly};
use std::fs;

#[tokio::main] // https://docs.rs/tokio/0.2.2/tokio/attr.main.html
async fn main() {

    let region = Region::UsEast1;
    let polly_client = PollyClient::new(region); // using default credentials

    let speech_input = SynthesizeSpeechInput{
        engine: Option::from(String::from("neural")),
        language_code: None,
        lexicon_names: None,
        output_format: "mp3".to_string(),
        sample_rate: None,
        speech_mark_types: None,
        text: String::from("Hello world, from Rust!"),
        text_type: None,
        voice_id: String::from("Amy")
    };

    match polly_client.synthesize_speech(speech_input).await {
        Ok(output) => match output.audio_stream{
            Some(audio_stream) => {
                println!("{}", audio_stream.len());
                fs::write("mp3/rstts.mp3", audio_stream).expect("Unable to write file");
            },
            None => println!("audio stream not found"),
        },
        Err(error) => {
            println!("error: {:?}", error);
        }
    }
}