sqs error using rusoto 0.6.0

sqs-error-rusoto060.md

Environment

• os: Windows 10 (64bit)
• rust: 1.11.0 (64bit MSVC ABI, GNU ABI)
• aws credentials: ~/.aws/credentials (uses DefaultCredentialsProvider)

Cargo.toml

[package]
name = "test-sqs"
version = "0.1.0"
authors = ["Yoshihito Hirakawa"]

[dependencies.rusoto]
version = "0.16.0"
features = ["sqs"]

[dependencies.hyper]
version = "0.9.10"

main.rs

extern crate rusoto;
extern crate hyper;

use rusoto::DefaultCredentialsProvider;
use rusoto::Region;

use rusoto::sqs::SqsClient;
use rusoto::sqs::MessageList;
use rusoto::sqs::{GetQueueUrlRequest, GetQueueUrlResult, GetQueueUrlError};
use rusoto::sqs::{ReceiveMessageRequest, ReceiveMessageResult, ReceiveMessageError};

use hyper::client::Client;


#[derive(Debug)]
enum SqsError {
    GetQueueUrl(GetQueueUrlError),
    ReceiveMessage(ReceiveMessageError),
}


impl From<GetQueueUrlError> for SqsError {
    fn from(e: GetQueueUrlError) -> SqsError {
        SqsError::GetQueueUrl(e)
    }
}


impl From<ReceiveMessageError> for SqsError {
    fn from(e: ReceiveMessageError) -> SqsError {
        SqsError::ReceiveMessage(e)
    }
}


type SqsResult<T> = Result<T, SqsError>;


struct SqsHelper {
    client: SqsClient<DefaultCredentialsProvider, Client>,
}


impl SqsHelper {
    fn new(region: Region) -> SqsHelper {
        let credentials = DefaultCredentialsProvider::new().unwrap();
        let client = SqsClient::new(credentials, region);
        SqsHelper {
            client: client,
        }
    }

    fn get_url(&self, queue_name: &str) -> SqsResult<String> {
        let mut req = GetQueueUrlRequest::default();
        req.queue_name = queue_name.to_string();

        let result = try!(self.client.get_queue_url(&req));
        match result.queue_url {
            Some(url) => Ok(url),
            None => Ok(String::new()),
        }
    }

    fn receive_messages(&self, queue_url: &str, message_num: i32) -> SqsResult<MessageList> {
        let mut req = ReceiveMessageRequest::default();
        req.queue_url = queue_url.to_string();
        req.max_number_of_messages = Some(message_num);

        let result = try!(self.client.receive_message(&req));
        match result.messages {
            Some(messages) => Ok(messages),
            None => Ok(vec![]),
        }
    }
}


fn test_sqs() -> SqsResult<()> {
    let helper = SqsHelper::new(Region::ApNortheast1);

    // get url => works fine
    let queue_name = "QUEUE_NAME_HERE";
    let queue_url = try!(helper.get_url(queue_name));
    println!("url={}", queue_url);

    // receive messages => error, SignatureDoesNotMatch
    let messages = try!(helper.receive_messages(&queue_url, 10));
    println!("messages={:?}", messages);

    Ok(())
}


fn main() {
    match test_sqs() {
        Ok(()) => { println!("ok"); },
        Err(e) => { println!("error, e={:?}", e); },
    }
}