Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

cargo-fmt & clippy #1883

Open
wants to merge 9 commits into
base: master
Choose a base branch
from
Open

cargo-fmt & clippy #1883

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
4c5af3c
fmt: fix generate code for services
fanatid Jan 3, 2021
5d54127
fmt
fanatid Jan 3, 2021
b562555
clippy: service_crategen
fanatid Jan 3, 2021
c039eeb
clippy: rusoto
fanatid Jan 3, 2021
37c221d
clippy: services (custom)
fanatid Jan 3, 2021
558ab3a
clippy: services (generated), remove redundant import
fanatid Jan 3, 2021
567c92f
clippy: services (generated), use is_empty/push
fanatid Jan 3, 2021
fb317a8
clippy: services (generated), do not return empty result
fanatid Jan 3, 2021
7cc5b80
clippy: services (generated), try_err
fanatid Jan 3, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
The table of contents is too big for display.
Diff view
Diff view
  •  
  •  
  •  
110 changes: 65 additions & 45 deletions helpers/src/dynamodb.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,10 +8,12 @@ use rusoto_dynamodb::*;

// Make getting values out of nested Option objects less verbose.
macro_rules! try_opt {
($expr:expr) => (match $expr {
::std::option::Option::Some(ref val) => val,
::std::option::Option::None => return None
})
($expr:expr) => {
match $expr {
::std::option::Option::Some(ref val) => val,
::std::option::Option::None => return None,
}
};
}

pub struct DynamoDbHelper {
Expand All @@ -20,35 +22,52 @@ pub struct DynamoDbHelper {

impl DynamoDbHelper {
pub fn new(region: Region) -> DynamoDbHelper {
DynamoDbHelper { client: DynamoDbClient::new(region) }
DynamoDbHelper {
client: DynamoDbClient::new(region),
}
}

pub async fn list_tables(&mut self) -> RusotoResult<ListTablesOutput, ListTablesError> {
let mut req = ListTablesInput::default();
self.client.list_tables(req).await
}

pub async fn create_table(&mut self, input: CreateTableInput) -> RusotoResult<CreateTableOutput, CreateTableError> {
pub async fn create_table(
&mut self,
input: CreateTableInput,
) -> RusotoResult<CreateTableOutput, CreateTableError> {
self.client.create_table(input).await
}

pub async fn describe_table(&mut self, name: &str) -> RusotoResult<DescribeTableOutput, DescribeTableError> {
pub async fn describe_table(
&mut self,
name: &str,
) -> RusotoResult<DescribeTableOutput, DescribeTableError> {
let mut input = DescribeTableInput::default();
input.table_name = String::from(name);
self.client.describe_table(input).await
}

pub async fn delete_table(&mut self, name: &str) -> RusotoResult<DeleteTableOutput, DeleteTableError> {
pub async fn delete_table(
&mut self,
name: &str,
) -> RusotoResult<DeleteTableOutput, DeleteTableError> {
let mut input = DeleteTableInput::default();
input.table_name = String::from(name);
self.client.delete_table(input).await
}

pub async fn put_item(&mut self, input: PutItemInput) -> RusotoResult<PutItemOutput, PutItemError> {
pub async fn put_item(
&mut self,
input: PutItemInput,
) -> RusotoResult<PutItemOutput, PutItemError> {
self.client.put_item(input).await
}

pub async fn get_item(&mut self, input: GetItemInput) -> RusotoResult<GetItemOutput, GetItemError> {
pub async fn get_item(
&mut self,
input: GetItemInput,
) -> RusotoResult<GetItemOutput, GetItemError> {
self.client.get_item(input).await
}
}
Expand All @@ -66,13 +85,18 @@ impl PutItemInputHelper for PutItemInput {
pub trait CreateTableInputHelper {
fn new() -> CreateTableInput;
fn with_name(self, table_name: &str) -> CreateTableInput;
fn with_provisioned_capacity(self, write_capacity_units: i64, read_capacity_units: i64) -> CreateTableInput;
fn with_provisioned_capacity(
self,
write_capacity_units: i64,
read_capacity_units: i64,
) -> CreateTableInput;
fn with_attributes(self, attributes: Vec<AttributeDefinition>) -> CreateTableInput;
fn with_key_schema(self, key_schema: Vec<KeySchemaElement>) -> CreateTableInput;
fn add_attribute<N: Into<String>, T: Into<String>>(self,
name: N,
attr_type: T)
-> CreateTableInput;
fn add_attribute<N: Into<String>, T: Into<String>>(
self,
name: N,
attr_type: T,
) -> CreateTableInput;
}

impl CreateTableInputHelper for CreateTableInput {
Expand All @@ -85,8 +109,12 @@ impl CreateTableInputHelper for CreateTableInput {
self
}

fn with_provisioned_capacity(mut self, write_capacity_units: i64, read_capacity_units: i64) -> CreateTableInput {
self.provisioned_throughput = Some(ProvisionedThroughput{
fn with_provisioned_capacity(
mut self,
write_capacity_units: i64,
read_capacity_units: i64,
) -> CreateTableInput {
self.provisioned_throughput = Some(ProvisionedThroughput {
read_capacity_units,
write_capacity_units,
});
Expand All @@ -103,10 +131,11 @@ impl CreateTableInputHelper for CreateTableInput {
self
}

fn add_attribute<N: Into<String>, T: Into<String>>(mut self,
name: N,
attr_type: T)
-> CreateTableInput {
fn add_attribute<N: Into<String>, T: Into<String>>(
mut self,
name: N,
attr_type: T,
) -> CreateTableInput {
self.attribute_definitions.push(AttributeDefinition {
attribute_name: name.into(),
attribute_type: attr_type.into(),
Expand All @@ -126,9 +155,6 @@ impl DescribeTableOutputHelper for DescribeTableOutput {
}
}




#[macro_export]
macro_rules! attributes {
($($val:expr => $attr_type:expr),*) => {
Expand Down Expand Up @@ -157,27 +183,21 @@ macro_rules! key_schema {

#[macro_export]
macro_rules! val {
(B => $val:expr) => (
{
let mut attr = AttributeValue::default();
attr.b = Some($val);
attr
}
);
(S => $val:expr) => (
{
let mut attr = AttributeValue::default();
attr.s = Some($val.to_string());
attr
}
);
(N => $val:expr) => (
{
let mut attr = AttributeValue::default();
attr.n = Some($val.to_string());
attr
}
);
(B => $val:expr) => {{
let mut attr = AttributeValue::default();
attr.b = Some($val);
attr
}};
(S => $val:expr) => {{
let mut attr = AttributeValue::default();
attr.s = Some($val.to_string());
attr
}};
(N => $val:expr) => {{
let mut attr = AttributeValue::default();
attr.n = Some($val.to_string());
attr
}};
}

// TODO: make a macro from this?
Expand Down
10 changes: 2 additions & 8 deletions helpers/src/kms.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,13 +1,7 @@
//! KMS helper types.

use rusoto_core::{Region, RusotoResult};
use rusoto_kms::{
Kms,
KmsClient,
ListKeysError,
ListKeysRequest,
ListKeysResponse,
};
use rusoto_kms::{Kms, KmsClient, ListKeysError, ListKeysRequest, ListKeysResponse};

pub struct KmsHelper {
client: KmsClient,
Expand All @@ -17,7 +11,7 @@ impl KmsHelper {
/// Create a new KMS helper.
pub fn new(region: Region) -> KmsHelper {
KmsHelper {
client: KmsClient::new(region)
client: KmsClient::new(region),
}
}

Expand Down
72 changes: 45 additions & 27 deletions helpers/src/sqs.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,7 +14,9 @@ pub struct SqsHelper {
impl SqsHelper {
/// Creates a new SQS helper
pub fn new(region: Region) -> SqsHelper {
SqsHelper { client: SqsClient::new(region) }
SqsHelper {
client: SqsClient::new(region),
}
}

/// Lists queues
Expand All @@ -23,73 +25,88 @@ impl SqsHelper {
}

/// Creates a new queue with given name
pub async fn create_queue(&mut self, queue_name: &str) -> RusotoResult<CreateQueueResult, CreateQueueError> {
pub async fn create_queue(
&mut self,
queue_name: &str,
) -> RusotoResult<CreateQueueResult, CreateQueueError> {
let mut req = CreateQueueRequest::default();
req.queue_name = queue_name.to_string();
self.create_queue_with_request(req).await
}

/// Create queue with options specified in request
pub async fn create_queue_with_request(&mut self,
request: CreateQueueRequest)
-> RusotoResult<CreateQueueResult, CreateQueueError> {
pub async fn create_queue_with_request(
&mut self,
request: CreateQueueRequest,
) -> RusotoResult<CreateQueueResult, CreateQueueError> {
self.client.create_queue(request).await
}

/// Gets a queue URL by the queue's name
pub async fn get_queue_url(&mut self, queue_name: &str) -> RusotoResult<GetQueueUrlResult, GetQueueUrlError> {
pub async fn get_queue_url(
&mut self,
queue_name: &str,
) -> RusotoResult<GetQueueUrlResult, GetQueueUrlError> {
let mut req = GetQueueUrlRequest::default();
req.queue_name = queue_name.to_string();
self.client.get_queue_url(req).await
}

/// Send message to specified queue
pub async fn send_message(&mut self,
queue_url: &str,
message_body: &str)
-> RusotoResult<SendMessageResult, SendMessageError> {
pub async fn send_message(
&mut self,
queue_url: &str,
message_body: &str,
) -> RusotoResult<SendMessageResult, SendMessageError> {
let mut req = SendMessageRequest::default();
req.queue_url = queue_url.to_string();
req.message_body = message_body.to_string();
self.send_message_with_request(req).await
}

/// Send message with specified request options
pub async fn send_message_with_request(&mut self,
request: SendMessageRequest)
-> RusotoResult<SendMessageResult, SendMessageError> {
pub async fn send_message_with_request(
&mut self,
request: SendMessageRequest,
) -> RusotoResult<SendMessageResult, SendMessageError> {
self.client.send_message(request).await
}

/// Receive a message from specified queue
pub async fn receive_message(&mut self, queue_url: &str) -> RusotoResult<ReceiveMessageResult, ReceiveMessageError> {
pub async fn receive_message(
&mut self,
queue_url: &str,
) -> RusotoResult<ReceiveMessageResult, ReceiveMessageError> {
let mut req = ReceiveMessageRequest::default();
req.queue_url = queue_url.to_string();
self.receive_message_with_request(req).await
}

/// Receive message with specified request options
pub async fn receive_message_with_request(&mut self,
request: ReceiveMessageRequest)
-> RusotoResult<ReceiveMessageResult, ReceiveMessageError> {
pub async fn receive_message_with_request(
&mut self,
request: ReceiveMessageRequest,
) -> RusotoResult<ReceiveMessageResult, ReceiveMessageError> {
self.client.receive_message(request).await
}

/// Delete a message from the specified queue
pub async fn delete_message(&mut self,
queue_url: &str,
receipt_handle: &str)
-> RusotoResult<(), DeleteMessageError> {
pub async fn delete_message(
&mut self,
queue_url: &str,
receipt_handle: &str,
) -> RusotoResult<(), DeleteMessageError> {
let mut req = DeleteMessageRequest::default();
req.queue_url = queue_url.to_string();
req.receipt_handle = receipt_handle.to_string();
self.delete_message_with_request(req).await
}

/// Delete message with specified request options
pub async fn delete_message_with_request(&mut self,
request: DeleteMessageRequest)
-> RusotoResult<(), DeleteMessageError> {
pub async fn delete_message_with_request(
&mut self,
request: DeleteMessageRequest,
) -> RusotoResult<(), DeleteMessageError> {
self.client.delete_message(request).await
}

Expand All @@ -101,9 +118,10 @@ impl SqsHelper {
}

/// Delete the queue with specified request options
pub async fn delete_queue_with_request(&mut self,
request: DeleteQueueRequest)
-> RusotoResult<(), DeleteQueueError> {
pub async fn delete_queue_with_request(
&mut self,
request: DeleteQueueRequest,
) -> RusotoResult<(), DeleteQueueError> {
self.client.delete_queue(request).await
}
}