Handle updates to Rust nullability from smithy-lang/smithy-rs#2916

DavidSouther · Sep 28, 2023 · beb9c3d · beb9c3d
1 parent 206a13f
commit beb9c3d
Show file tree

Hide file tree

Showing 43 changed files with 259 additions and 258 deletions.
diff --git a/rust_dev_preview/cross_service/Cargo.toml b/rust_dev_preview/cross_service/Cargo.toml
@@ -1,6 +1,7 @@
 # Note: this workspace exists solely for the convenience of 
 # compiling/auto-formatting/testing all the AWS Rust SDK examples together.
 [workspace]
+resolver = "2"
 members = [
     "detect_faces",
     "detect_labels",

diff --git a/rust_dev_preview/cross_service/rest_ses/src/report.rs b/rust_dev_preview/cross_service/rest_ses/src/report.rs
@@ -92,7 +92,12 @@ pub async fn send_report(
 
     let email = ses
         .send_raw_email()
-        .raw_message(RawMessage::builder().data(data).build())
+        .raw_message(
+            RawMessage::builder()
+                .data(data)
+                .build()
+                .expect("building RawMessage"),
+        )
         .send()
         .await
         .map_err(|err| ReportError::SesError(err.into()))?;

diff --git a/rust_dev_preview/examples/Cargo.toml b/rust_dev_preview/examples/Cargo.toml
@@ -1,6 +1,9 @@
 # Note: this workspace exists solely for the convenience of 
 # compiling/auto-formatting/testing all the AWS Rust SDK examples together.
 [workspace]
+
+resolver = "2"
+
 members = [
     "apigateway",
     "apigatewaymanagement",

diff --git a/rust_dev_preview/examples/autoscaling/src/bin/list-autoscaling-groups.rs b/rust_dev_preview/examples/autoscaling/src/bin/list-autoscaling-groups.rs
@@ -27,21 +27,15 @@ async fn list_groups(client: &Client) -> Result<(), Error> {
 
     println!("Groups:");
 
-    let groups = resp.auto_scaling_groups().unwrap_or_default();
+    let groups = resp.auto_scaling_groups();
 
     for group in groups {
-        println!(
-            "Name:  {}",
-            group.auto_scaling_group_name().unwrap_or("Unknown"),
-        );
+        println!("Name:  {}", group.auto_scaling_group_name(),);
         println!(
             "Arn:   {}",
             group.auto_scaling_group_arn().unwrap_or("unknown"),
         );
-        println!(
-            "Zones: {:?}",
-            group.availability_zones().unwrap_or_default(),
-        );
+        println!("Zones: {:?}", group.availability_zones(),);
         println!();
     }
 

diff --git a/rust_dev_preview/examples/batch/src/bin/batch-helloworld.rs b/rust_dev_preview/examples/batch/src/bin/batch-helloworld.rs
@@ -28,8 +28,8 @@ async fn show_envs(client: &Client) -> Result<(), Error> {
     let compute_envs = rsp.compute_environments().unwrap_or_default();
     println!("Found {} compute environments:", compute_envs.len());
     for env in compute_envs {
-        let arn = env.compute_environment_arn().unwrap_or_default();
-        let name = env.compute_environment_name().unwrap_or_default();
+        let arn = env.compute_environment_arn();
+        let name = env.compute_environment_name();
 
         println!("  Name : {}", name);
         println!("  ARN:   {}", arn);

diff --git a/rust_dev_preview/examples/cloudformation/src/bin/describe-stack.rs b/rust_dev_preview/examples/cloudformation/src/bin/describe-stack.rs
@@ -39,7 +39,7 @@ async fn describe_stack(client: &Client, name: &str) -> Result<(), Error> {
         .unwrap()
         .stack_status();
 
-    println!("Stack status: {}", status.unwrap().as_ref());
+    println!("Stack status: {}", status.as_str());
 
     println!();
 

diff --git a/rust_dev_preview/examples/cloudformation/src/bin/list-stacks.rs b/rust_dev_preview/examples/cloudformation/src/bin/list-stacks.rs
@@ -26,8 +26,8 @@ async fn list_stacks(client: &Client) -> Result<(), Error> {
     let stacks = client.list_stacks().send().await?;
 
     for stack in stacks.stack_summaries().unwrap_or_default() {
-        println!("{}", stack.stack_name().unwrap_or_default());
-        println!("  Status: {:?}", stack.stack_status().unwrap());
+        println!("{}", stack.stack_name());
+        println!("  Status: {:?}", stack.stack_status());
         println!();
     }
 

diff --git a/rust_dev_preview/examples/cloudwatch/src/bin/list-metrics.rs b/rust_dev_preview/examples/cloudwatch/src/bin/list-metrics.rs
@@ -37,8 +37,8 @@ async fn show_metrics(
 
         if let Some(dimension) = metric.dimensions.as_ref() {
             for d in dimension {
-                println!("  Name:  {}", d.name().unwrap_or_default());
-                println!("  Value: {}", d.value().unwrap_or_default());
+                println!("  Name:  {}", d.name());
+                println!("  Value: {}", d.value());
                 println!();
             }
         }

diff --git a/rust_dev_preview/examples/cognitoidentity/src/bin/describe-identity-pool.rs b/rust_dev_preview/examples/cognitoidentity/src/bin/describe-identity-pool.rs
@@ -52,8 +52,8 @@ async fn describe_pool(client: &Client, id: &str) -> Result<(), Error> {
     }
 
     let developer_provider = response.developer_provider_name().unwrap_or_default();
-    let id = response.identity_pool_id().unwrap_or_default();
-    let name = response.identity_pool_name().unwrap_or_default();
+    let id = response.identity_pool_id();
+    let name = response.identity_pool_name();
 
     println!("  Developer provider:               {}", developer_provider);
     println!("  Identity pool ID:                 {}", id);

diff --git a/rust_dev_preview/examples/dynamodb/src/bin/crud.rs b/rust_dev_preview/examples/dynamodb/src/bin/crud.rs
@@ -56,17 +56,20 @@ async fn make_table(
     let ad = AttributeDefinition::builder()
         .attribute_name(key)
         .attribute_type(ScalarAttributeType::S)
-        .build();
+        .build()
+        .expect("creating AttributeDefinition");
 
     let ks = KeySchemaElement::builder()
         .attribute_name(key)
         .key_type(KeyType::Hash)
-        .build();
+        .build()
+        .expect("creating KeySchemaElement");
 
     let pt = ProvisionedThroughput::builder()
         .read_capacity_units(10)
         .write_capacity_units(5)
-        .build();
+        .build()
+        .expect("creating ProvisionedThroughput");
 
     match client
         .create_table()

diff --git a/rust_dev_preview/examples/dynamodb/src/bin/dynamodb-helloworld.rs b/rust_dev_preview/examples/dynamodb/src/bin/dynamodb-helloworld.rs
@@ -37,27 +37,30 @@ async fn list_tables(client: &Client) -> Result<(), Error> {
 // Creates the test-table table.
 // snippet-start:[dynamodb.rust.dynamodb-helloworld-create_table]
 async fn create_table(client: &Client) -> Result<(), Error> {
+    let ks = KeySchemaElement::builder()
+        .attribute_name("k")
+        .key_type(KeyType::Hash)
+        .build()
+        .expect("creating KeySchemaElement");
+
+    let ad = AttributeDefinition::builder()
+        .attribute_name("k")
+        .attribute_type(ScalarAttributeType::S)
+        .build()
+        .expect("creating AttributeDefinition");
+
+    let pt = ProvisionedThroughput::builder()
+        .write_capacity_units(10)
+        .read_capacity_units(10)
+        .build()
+        .expect("creating ProvisionedThroughput");
+
     let new_table = client
         .create_table()
         .table_name("test-table")
-        .key_schema(
-            KeySchemaElement::builder()
-                .attribute_name("k")
-                .key_type(KeyType::Hash)
-                .build(),
-        )
-        .attribute_definitions(
-            AttributeDefinition::builder()
-                .attribute_name("k")
-                .attribute_type(ScalarAttributeType::S)
-                .build(),
-        )
-        .provisioned_throughput(
-            ProvisionedThroughput::builder()
-                .write_capacity_units(10)
-                .read_capacity_units(10)
-                .build(),
-        )
+        .key_schema(ks)
+        .attribute_definitions(ad)
+        .provisioned_throughput(pt)
         .send()
         .await?;
     println!(

diff --git a/rust_dev_preview/examples/dynamodb/src/bin/partiql.rs b/rust_dev_preview/examples/dynamodb/src/bin/partiql.rs
@@ -56,17 +56,20 @@ async fn make_table(
     let ad = AttributeDefinition::builder()
         .attribute_name(key)
         .attribute_type(ScalarAttributeType::S)
-        .build();
+        .build()
+        .expect("creating AttributeDefinition");
 
     let ks = KeySchemaElement::builder()
         .attribute_name(key)
         .key_type(KeyType::Hash)
-        .build();
+        .build()
+        .expect("creating KeySchemaElement");
 
     let pt = ProvisionedThroughput::builder()
         .read_capacity_units(10)
         .write_capacity_units(5)
-        .build();
+        .build()
+        .expect("creating ProvisionedThroughput");
 
     match client
         .create_table()

diff --git a/rust_dev_preview/examples/dynamodb/src/scenario/create.rs b/rust_dev_preview/examples/dynamodb/src/scenario/create.rs
@@ -23,17 +23,20 @@ pub async fn create_table(
     let ad = AttributeDefinition::builder()
         .attribute_name(&a_name)
         .attribute_type(ScalarAttributeType::S)
-        .build();
+        .build()
+        .map_err(Error::BuildError)?;
 
     let ks = KeySchemaElement::builder()
         .attribute_name(&a_name)
         .key_type(KeyType::Hash)
-        .build();
+        .build()
+        .map_err(Error::BuildError)?;
 
     let pt = ProvisionedThroughput::builder()
         .read_capacity_units(10)
         .write_capacity_units(5)
-        .build();
+        .build()
+        .map_err(Error::BuildError)?;
 
     let create_table_response = client
         .create_table()

diff --git a/rust_dev_preview/examples/dynamodb/src/scenario/error.rs b/rust_dev_preview/examples/dynamodb/src/scenario/error.rs
@@ -5,10 +5,14 @@
 
 use std::error::Error as StdError;
 
+use aws_smithy_http::operation::error::BuildError;
+
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error("table was not ready after several attempts: {0}")]
     TableNotReady(String),
+    #[error("problem building schema key or element: {0}")]
+    BuildError(BuildError),
     #[error("unhandled error")]
     Unhandled(#[source] Box<dyn StdError + Send + Sync + 'static>),
 }

diff --git a/rust_dev_preview/examples/dynamodb/src/scenario/movies/mod.rs b/rust_dev_preview/examples/dynamodb/src/scenario/movies/mod.rs
@@ -1,5 +1,6 @@
 use aws_sdk_dynamodb::error::SdkError;
 use aws_sdk_dynamodb::types::{AttributeValue, PutRequest};
+use aws_smithy_http::operation::error::BuildError;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
@@ -140,8 +141,9 @@ impl From<&HashMap<String, AttributeValue>> for Movie {
     }
 }
 
-impl From<&Movie> for PutRequest {
-    fn from(movie: &Movie) -> Self {
+impl TryFrom<&Movie> for PutRequest {
+    type Error = BuildError;
+    fn try_from(movie: &Movie) -> Result<Self, Self::Error> {
         PutRequest::builder()
             .item("year", AttributeValue::N(movie.year.to_string()))
             .item("title", AttributeValue::S(movie.title.clone()))

diff --git a/rust_dev_preview/examples/dynamodb/src/scenario/movies/startup.rs b/rust_dev_preview/examples/dynamodb/src/scenario/movies/startup.rs
@@ -22,7 +22,7 @@ pub async fn initialize(client: &Client, table_name: &str) -> Result<(), Error>
         info!("Found existing table {table_name}");
     } else {
         info!("Table does not exist, creating {table_name}");
-        create_table(client, table_name, "year", "title", CAPACITY)
+        create_table(client, table_name, "year", "title", CAPACITY)?
             .send()
             .await?;
         await_table(client, table_name).await?;
@@ -54,41 +54,46 @@ pub fn create_table(
     primary_key: &str,
     sort_key: &str,
     capacity: i64,
-) -> CreateTableFluentBuilder {
+) -> Result<CreateTableFluentBuilder, Error> {
     info!("Creating table: {table_name} with capacity {capacity} and key structure {primary_key}:{sort_key}");
-    client
+    Ok(client
         .create_table()
         .table_name(table_name)
         .key_schema(
             KeySchemaElement::builder()
                 .attribute_name(primary_key)
                 .key_type(KeyType::Hash)
-                .build(),
+                .build()
+                .expect("Failed to build KeySchema"),
         )
         .attribute_definitions(
             AttributeDefinition::builder()
                 .attribute_name(primary_key)
                 .attribute_type(ScalarAttributeType::N)
-                .build(),
+                .build()
+                .expect("Failed to build attribute definition"),
         )
         .key_schema(
             KeySchemaElement::builder()
                 .attribute_name(sort_key)
                 .key_type(KeyType::Range)
-                .build(),
+                .build()
+                .expect("Failed to build KeySchema"),
         )
         .attribute_definitions(
             AttributeDefinition::builder()
                 .attribute_name(sort_key)
                 .attribute_type(ScalarAttributeType::S)
-                .build(),
+                .build()
+                .expect("Failed to build attribute definition"),
         )
         .provisioned_throughput(
             ProvisionedThroughput::builder()
                 .read_capacity_units(capacity)
                 .write_capacity_units(capacity)
-                .build(),
-        )
+                .build()
+                .expect("Failed to specify ProvisionedThroughput"),
+        ))
 }
 // snippet-end:[dynamodb.rust.movies-create_table_request]
 
@@ -133,7 +138,9 @@ pub async fn load_data(client: &Client, table_name: &str) -> Result<(), Error> {
         .iter()
         .map(|v| {
             WriteRequest::builder()
-                .set_put_request(Some(v.into()))
+                .set_put_request(Some(
+                    v.try_into().expect("Failed to convert movie to PutRequest"),
+                ))
                 .build()
         })
         .collect::<Vec<WriteRequest>>();

diff --git a/rust_dev_preview/examples/firehose/src/bin/put-records-batch.rs b/rust_dev_preview/examples/firehose/src/bin/put-records-batch.rs
@@ -33,12 +33,12 @@ struct Opt {
 async fn put_record_batch(
     client: &Client,
     stream: &str,
-    data: Option<Vec<Record>>,
+    data: Vec<Record>,
 ) -> Result<PutRecordBatchOutput, SdkError<PutRecordBatchError>> {
     client
         .put_record_batch()
         .delivery_stream_name(stream)
-        .set_records(data)
+        .set_records(Some(data))
         .send()
         .await
 }
@@ -83,9 +83,14 @@ async fn main() -> Result<(), Error> {
     let mut data = Vec::with_capacity(500);
     let payload = String::from("Some random payload");
     let tmp = Some(Blob::new(payload.to_string()));
-    data.push(Record::builder().set_data(tmp).build());
+    data.push(
+        Record::builder()
+            .set_data(tmp)
+            .build()
+            .expect("Failed to create a new record"),
+    );
 
-    let resp = put_record_batch(&client, &firehose_stream, Some(data)).await;
+    let resp = put_record_batch(&client, &firehose_stream, data).await;
     match resp {
         Ok(_) => Ok(()),
         Err(e) => Err(Error::from(e)),

diff --git a/rust_dev_preview/examples/glue/src/cleanup.rs b/rust_dev_preview/examples/glue/src/cleanup.rs
@@ -23,10 +23,7 @@ impl GlueScenario {
         // snippet-start:[rust.glue.delete_table]
         for t in &self.tables {
             glue.delete_table()
-                .name(
-                    t.name()
-                        .ok_or_else(|| GlueMvpError::Unknown("Couldn't find table".to_string()))?,
-                )
+                .name(t.name())
                 .database_name(self.database())
                 .send()
                 .await
@@ -106,9 +103,7 @@ impl GlueScenario {
             .to_owned();
 
         if let Some(database) = database.database() {
-            return Err(GlueMvpError::Cleanup(
-                database.name().unwrap_or_default().into(),
-            ));
+            return Err(GlueMvpError::Cleanup(database.name().into()));
         }
 
         let crawler = glue