services/terraform/.gitignore
1–34 ↗	(On Diff #11288)	Is this file copied from somewhere?
services/terraform/dynamodb-test.tf
66–79 ↗	(On Diff #11288)	Agree. Is there a reason for including it?
services/terraform/dynamodb.tf
5–6 ↗	(On Diff #11288)	Does that mean that only 10 clients can connect to the db at a time? Is our db configured in the same way currently?
services/terraform/s3.tf
8 ↗	(On Diff #11288)	I'm not sure if we should include personal buckets here

This revision now requires changes to proceed.Apr 26 2022, 10:44 AM

• karol requested review of this revision.Apr 27 2022, 6:29 AM

• karol added inline comments.

services/terraform/.gitignore
1–34 ↗	(On Diff #11288)	Yes, from here https://github.com/github/gitignore/blob/d0b80a469983a7beece8fa1f5c48a8242318b531/Terraform.gitignore Sorry I didn't post a source earlier.
services/terraform/dynamodb-test.tf
66–79 ↗	(On Diff #11288)	We can remove them. I just thought we could have them so we later know the "full schema". The problem is, terraform doesn't want a full schema, it just wants the necessary minimum set of fields. So, I don't have a problem having them here but if you think they shouldn't be here, I can remove them.
services/terraform/dynamodb.tf
5–6 ↗	(On Diff #11288)	From the docs: A read capacity unit represents one strongly consistent read per second, or two eventually consistent reads per second, for an item up to 4 KB in size. For example, suppose that you create a table with 10 provisioned read capacity units. This allows you to perform 10 strongly consistent reads per second, or 20 eventually consistent reads per second, for items up to 4 KB. A write capacity unit represents one write per second, for an item up to 1 KB in size. For example, suppose that you create a table with 10 write capacity units. This allows you to perform 10 writes per second, for items up to 1 KB in size per second. Yes, this is copied from the settings on our cloud. At a first glance, it does not seem to be plenty. I think we can get back to this when doing performance tests. I created a task for this: https://linear.app/comm/issue/ENG-1054/think-about-readwrite-capacity-for-dynamodb-tables
services/terraform/s3.tf
8 ↗	(On Diff #11288)	Hmm, right, I just copied what was on the cloud. Actually, I think we should only have `commapp-blob` here.

ashoat requested changes to this revision.Apr 27 2022, 2:20 PM

ashoat added inline comments.

services/terraform/s3.tf
8 ↗	(On Diff #11288)	Let's change this then? Back to your queue

This revision now requires changes to proceed.Apr 27 2022, 2:20 PM

removed commented out fields

removed redundant buckets

Harbormaster completed remote builds in B8639: Diff 12029.Apr 28 2022, 1:23 AM

Looks ok

Accepting, but I don't have much context here – would be great if @jimpo could take a look

@jimpo when can we expect a review of this? You're a blocking reviewer and the rest of this stack's accepted. Thanks.

You should add a required_providers declaration somewhere like providers.tf. See https://registry.terraform.io/providers/hashicorp/aws/latest/docs.

Also add a package.json npm script to run terraform/run.sh, right?

services/terraform/localstack.tf
2 ↗	(On Diff #12029)	This should have a default value as the port mapping is defined in docker-compose.yml
5 ↗	(On Diff #12029)	Please add comment with link to terraform documentation on localstack https://registry.terraform.io/providers/hashicorp/aws/latest/docs/guides/custom-service-endpoints#localstack
services/terraform/run.sh
7 ↗	(On Diff #12029)	Prefer `-var "HOST=http://localhost:4566"` to `TF_VAR_HOST` env var

This revision now requires changes to proceed.May 4 2022, 6:47 AM

You should add a required_providers declaration somewhere like providers.tf. See https://registry.terraform.io/providers/hashicorp/aws/latest/docs.

Sure, thanks!

Also add a package.json npm script to run terraform/run.sh, right?

It's added in D3694

services/terraform/localstack.tf
2 ↗	(On Diff #12029)	I'm not sure why. We make sure to set this variable in the running bash script. I also do not understand what port mapping in docker-compose has to do with this. What should be the default value? Why exactly should we set the default value?
5 ↗	(On Diff #12029)	Why should we do this? What is so unclear here? If something really is, the code reader can easily google the necessary information. We don't add comments to every piece of config/code that uses a certain technology (the same we could stuff up `Dockerfile`s or `docker-compose.yml` with links to docker docs).
services/terraform/run.sh
7 ↗	(On Diff #12029)	Ok, will change, personally, there is no difference for me (yeah, maybe `-var` is more readable)

changes after review

Harbormaster completed remote builds in B8801: Diff 12260.May 5 2022, 1:34 AM

• jim requested changes to this revision.May 5 2022, 7:25 AM

• jim added inline comments.

services/terraform/localstack.tf
2 ↗	(On Diff #12029)	The default value should be `http://localhost:4566`. The port mapping is relevant because it sets the port to 4566 so we can safely make it the default here. Why? So that the configuration isn't split between terraform and a wrapper script. I'm really not sure why you like to depend so heavily on two line wrapper scripts because it limits flexibility. What if I want to do `terraform plan`? Then I need to look in the script and figure out what extra stuff it's doing like setting variables to a static string to get my command right. Why not also put the region in the wrapper script? Because there's no good reason to put more config there.
5 ↗	(On Diff #12029)	To help future readers of the code and reviewers. As a reviewer it's something that I needed to look up and I'm almost certain that you got the config options from that page. If it was one flag like `skip_credentials_validation` that the reader shouldn't be expected to know it would also be nice to leave a comment with the rationale but you could more reasonably expect them to look it up. This is a set of options coming from a very particular source and it would be helpful to link to that source. Another general rule of them for documentation is that if a reviewer finds something unclear enough it request clarification or a link to docs, I generally add it because comments are cheap.
services/terraform/run.sh
7 ↗	(On Diff #12029)	That is the recommended way of setting variables from the command line. Environment variables are a fallback. https://www.terraform.io/language/values/variables#variables-on-the-command-line

This revision now requires changes to proceed.May 5 2022, 7:25 AM

• karol added inline comments.May 5 2022, 7:38 AM

services/terraform/localstack.tf
2 ↗	(On Diff #12029)	I see but then what's the point of providing this value at the same time in the bash script? I don't see why we would have it in two places at the same time. I think we can delete this in the bash script if we have it here as a default because in the script we're not overriding to a different value.
5 ↗	(On Diff #12029)	Ok, I'm going to add the comment as I personally do not mind. Curious for @ashoat's thoughts.

address feedback

Harbormaster completed remote builds in B8818: Diff 12285.May 5 2022, 7:45 AM

• jim accepted this revision.May 5 2022, 8:49 AM

This revision is now accepted and ready to land.May 5 2022, 8:49 AM

Awesome, this looks great!

services/terraform/localstack.tf
5 ↗	(On Diff #12029)	Agree with @jimpo's thoughts here – if it's confusing enough that a reviewer asks for clarification, it's probably worth a code comment. The context in which I usually oppose single-line comments is when they're making up for poorly readable code... I always prefer restructuring code / renaming variables to writing comments
services/terraform/s3.tf
9–10 ↗	(On Diff #12285)	Why are there so many spaces before the `=`?

decrease number of spaces before =

This revision was landed with ongoing or failed builds.May 6 2022, 1:46 AM

Closed by commit rCOMM474b3296954b: [services] Dev mode - Add terraform (authored by • karol). · Explain Why

This revision was automatically updated to reflect the committed changes.

• karol added a commit: rCOMM474b3296954b: [services] Dev mode - Add terraform.

Harbormaster completed remote builds in B8840: Diff 12324.May 6 2022, 1:52 AM

Revision Contents
Changeset List

Path

Size

services/

terraform/

34 lines

22 lines

87 lines

87 lines

20 lines

8 lines

7 lines

11 lines

Diff 12324

View Options

services/terraform/.gitignore

use aws_sdk_dynamodb::types::AttributeValue;		use aws_sdk_dynamodb::types::AttributeValue;
use aws_sdk_dynamodb::Error as DynamoDBError;		use aws_sdk_dynamodb::Error as DynamoDBError;
use chrono::{DateTime, Utc};		use chrono::{DateTime, Utc};
use std::collections::HashMap;		use std::collections::HashMap;
use std::fmt::{Display, Formatter};		use std::fmt::{Display, Formatter};
use std::num::ParseIntError;		use std::num::ParseIntError;
		use std::str::FromStr;

#[derive(		#[derive(
Debug, derive_more::Display, derive_more::From, derive_more::Error,		Debug, derive_more::Display, derive_more::From, derive_more::Error,
)]		)]
pub enum Error {		pub enum Error {
#[display(...)]		#[display(...)]
AwsSdk(DynamoDBError),		AwsSdk(DynamoDBError),
#[display(...)]		#[display(...)]
Show All 35 Lines

#[derive(Debug, derive_more::Display, derive_more::Error)]		#[derive(Debug, derive_more::Display, derive_more::Error)]
pub enum DBItemAttributeError {		pub enum DBItemAttributeError {
#[display(...)]		#[display(...)]
Missing,		Missing,
#[display(...)]		#[display(...)]
IncorrectType,		IncorrectType,
#[display(...)]		#[display(...)]
		TimestampOutOfRange,
		#[display(...)]
InvalidTimestamp(chrono::ParseError),		InvalidTimestamp(chrono::ParseError),
#[display(...)]		#[display(...)]
InvalidNumberFormat(ParseIntError),		InvalidNumberFormat(ParseIntError),
}		}

pub fn parse_string_attribute(		pub fn parse_string_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
Show All 27 Lines	match attribute_value {
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

		pub fn parse_int_attribute<T>(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<T, DBItemError>
		where
		T: FromStr<Err = ParseIntError>,
		{
		match &attribute_value {
		Some(AttributeValue::N(numeric_str)) => {
		parse_integer(attribute_name, &numeric_str)
		}
		Some(_) => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::IncorrectType,
		)),
		None => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::Missing,
		)),
		}
		}

pub fn parse_datetime_attribute(		pub fn parse_datetime_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<DateTime<Utc>, DBItemError> {		) -> Result<DateTime<Utc>, DBItemError> {
if let Some(AttributeValue::S(datetime)) = &attribute_value {		if let Some(AttributeValue::S(datetime)) = &attribute_value {
// parse() accepts a relaxed RFC3339 string		// parse() accepts a relaxed RFC3339 string
datetime.parse().map_err(\|e\| {		datetime.parse().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::InvalidTimestamp(e),		DBItemAttributeError::InvalidTimestamp(e),
)		)
})		})
} else {		} else {
Err(DBItemError::new(		Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
))		))
}		}
}		}

		/// Parses the UTC timestamp in milliseconds from a DynamoDB numeric attribute
		pub fn parse_timestamp_attribute(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<DateTime<Utc>, DBItemError> {
		let timestamp =
		parse_int_attribute::<i64>(attribute_name, attribute_value.clone())?;
		let naive_datetime = chrono::NaiveDateTime::from_timestamp_millis(timestamp)
		.ok_or_else(\|\| {
		DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::TimestampOutOfRange,
		)
		})?;
		Ok(DateTime::from_utc(naive_datetime, Utc))
		}

pub fn parse_map_attribute(		pub fn parse_map_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<HashMap<String, AttributeValue>, DBItemError> {		) -> Result<HashMap<String, AttributeValue>, DBItemError> {
match attribute_value {		match attribute_value {
Some(AttributeValue::M(map)) => Ok(map),		Some(AttributeValue::M(map)) => Ok(map),
Some(_) => Err(DBItemError::new(		Some(_) => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::IncorrectType,		DBItemAttributeError::IncorrectType,
)),		)),
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

pub fn parse_number(		pub fn parse_integer<T>(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: &str,		attribute_value: &str,
) -> Result<i32, DBItemError> {		) -> Result<T, DBItemError>
attribute_value.parse::<i32>().map_err(\|e\| {		where
		T: FromStr<Err = ParseIntError>,
		{
		attribute_value.parse::<T>().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::String(attribute_value.to_string()),		Value::String(attribute_value.to_string()),
DBItemAttributeError::InvalidNumberFormat(e),		DBItemAttributeError::InvalidNumberFormat(e),
)		)
})		})
}		}

		#[cfg(test)]

		mod tests {
		use super::*;

		#[test]
		fn test_parse_integer() {
		assert!(parse_integer::<i32>("some_attr", "123").is_ok());
		assert!(parse_integer::<i32>("negative", "-123").is_ok());

		assert!(parse_integer::<i32>("float", "3.14").is_err());
		assert!(parse_integer::<i32>("NaN", "foo").is_err());

		assert!(parse_integer::<u32>("negative_uint", "-123").is_err());
		assert!(parse_integer::<u8>("too_large", "65536").is_err());
		}

		#[test]
		fn test_parse_timestamp() {
		let timestamp = Utc::now().timestamp_millis();
		let attr = AttributeValue::N(timestamp.to_string());

		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));

		assert!(parsed_timestamp.is_ok());
		assert_eq!(parsed_timestamp.unwrap().timestamp_millis(), timestamp);
		}

		#[test]
		fn test_parse_invalid_timestamp() {
		let attr = AttributeValue::N("foo".to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		}

		#[test]
		fn test_parse_timestamp_out_of_range() {
		let attr = AttributeValue::N(i64::MAX.to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		assert!(matches!(
		parsed_timestamp.unwrap_err().attribute_error,
		DBItemAttributeError::TimestampOutOfRange
		));
		}
		}

View Options

services/terraform/.terraform.lock.hcl

use aws_sdk_dynamodb::types::AttributeValue;		use aws_sdk_dynamodb::types::AttributeValue;
use aws_sdk_dynamodb::Error as DynamoDBError;		use aws_sdk_dynamodb::Error as DynamoDBError;
use chrono::{DateTime, Utc};		use chrono::{DateTime, Utc};
use std::collections::HashMap;		use std::collections::HashMap;
use std::fmt::{Display, Formatter};		use std::fmt::{Display, Formatter};
use std::num::ParseIntError;		use std::num::ParseIntError;
		use std::str::FromStr;

#[derive(		#[derive(
Debug, derive_more::Display, derive_more::From, derive_more::Error,		Debug, derive_more::Display, derive_more::From, derive_more::Error,
)]		)]
pub enum Error {		pub enum Error {
#[display(...)]		#[display(...)]
AwsSdk(DynamoDBError),		AwsSdk(DynamoDBError),
#[display(...)]		#[display(...)]
Show All 35 Lines

#[derive(Debug, derive_more::Display, derive_more::Error)]		#[derive(Debug, derive_more::Display, derive_more::Error)]
pub enum DBItemAttributeError {		pub enum DBItemAttributeError {
#[display(...)]		#[display(...)]
Missing,		Missing,
#[display(...)]		#[display(...)]
IncorrectType,		IncorrectType,
#[display(...)]		#[display(...)]
		TimestampOutOfRange,
		#[display(...)]
InvalidTimestamp(chrono::ParseError),		InvalidTimestamp(chrono::ParseError),
#[display(...)]		#[display(...)]
InvalidNumberFormat(ParseIntError),		InvalidNumberFormat(ParseIntError),
}		}

pub fn parse_string_attribute(		pub fn parse_string_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
Show All 27 Lines	match attribute_value {
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

		pub fn parse_int_attribute<T>(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<T, DBItemError>
		where
		T: FromStr<Err = ParseIntError>,
		{
		match &attribute_value {
		Some(AttributeValue::N(numeric_str)) => {
		parse_integer(attribute_name, &numeric_str)
		}
		Some(_) => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::IncorrectType,
		)),
		None => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::Missing,
		)),
		}
		}

pub fn parse_datetime_attribute(		pub fn parse_datetime_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<DateTime<Utc>, DBItemError> {		) -> Result<DateTime<Utc>, DBItemError> {
if let Some(AttributeValue::S(datetime)) = &attribute_value {		if let Some(AttributeValue::S(datetime)) = &attribute_value {
// parse() accepts a relaxed RFC3339 string		// parse() accepts a relaxed RFC3339 string
datetime.parse().map_err(\|e\| {		datetime.parse().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::InvalidTimestamp(e),		DBItemAttributeError::InvalidTimestamp(e),
)		)
})		})
} else {		} else {
Err(DBItemError::new(		Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
))		))
}		}
}		}

		/// Parses the UTC timestamp in milliseconds from a DynamoDB numeric attribute
		pub fn parse_timestamp_attribute(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<DateTime<Utc>, DBItemError> {
		let timestamp =
		parse_int_attribute::<i64>(attribute_name, attribute_value.clone())?;
		let naive_datetime = chrono::NaiveDateTime::from_timestamp_millis(timestamp)
		.ok_or_else(\|\| {
		DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::TimestampOutOfRange,
		)
		})?;
		Ok(DateTime::from_utc(naive_datetime, Utc))
		}

pub fn parse_map_attribute(		pub fn parse_map_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<HashMap<String, AttributeValue>, DBItemError> {		) -> Result<HashMap<String, AttributeValue>, DBItemError> {
match attribute_value {		match attribute_value {
Some(AttributeValue::M(map)) => Ok(map),		Some(AttributeValue::M(map)) => Ok(map),
Some(_) => Err(DBItemError::new(		Some(_) => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::IncorrectType,		DBItemAttributeError::IncorrectType,
)),		)),
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

pub fn parse_number(		pub fn parse_integer<T>(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: &str,		attribute_value: &str,
) -> Result<i32, DBItemError> {		) -> Result<T, DBItemError>
attribute_value.parse::<i32>().map_err(\|e\| {		where
		T: FromStr<Err = ParseIntError>,
		{
		attribute_value.parse::<T>().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::String(attribute_value.to_string()),		Value::String(attribute_value.to_string()),
DBItemAttributeError::InvalidNumberFormat(e),		DBItemAttributeError::InvalidNumberFormat(e),
)		)
})		})
}		}

		#[cfg(test)]

		mod tests {
		use super::*;

		#[test]
		fn test_parse_integer() {
		assert!(parse_integer::<i32>("some_attr", "123").is_ok());
		assert!(parse_integer::<i32>("negative", "-123").is_ok());

		assert!(parse_integer::<i32>("float", "3.14").is_err());
		assert!(parse_integer::<i32>("NaN", "foo").is_err());

		assert!(parse_integer::<u32>("negative_uint", "-123").is_err());
		assert!(parse_integer::<u8>("too_large", "65536").is_err());
		}

		#[test]
		fn test_parse_timestamp() {
		let timestamp = Utc::now().timestamp_millis();
		let attr = AttributeValue::N(timestamp.to_string());

		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));

		assert!(parsed_timestamp.is_ok());
		assert_eq!(parsed_timestamp.unwrap().timestamp_millis(), timestamp);
		}

		#[test]
		fn test_parse_invalid_timestamp() {
		let attr = AttributeValue::N("foo".to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		}

		#[test]
		fn test_parse_timestamp_out_of_range() {
		let attr = AttributeValue::N(i64::MAX.to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		assert!(matches!(
		parsed_timestamp.unwrap_err().attribute_error,
		DBItemAttributeError::TimestampOutOfRange
		));
		}
		}

View Options

services/terraform/dynamodb-test.tf

use aws_sdk_dynamodb::types::AttributeValue;		use aws_sdk_dynamodb::types::AttributeValue;
use aws_sdk_dynamodb::Error as DynamoDBError;		use aws_sdk_dynamodb::Error as DynamoDBError;
use chrono::{DateTime, Utc};		use chrono::{DateTime, Utc};
use std::collections::HashMap;		use std::collections::HashMap;
use std::fmt::{Display, Formatter};		use std::fmt::{Display, Formatter};
use std::num::ParseIntError;		use std::num::ParseIntError;
		use std::str::FromStr;

#[derive(		#[derive(
Debug, derive_more::Display, derive_more::From, derive_more::Error,		Debug, derive_more::Display, derive_more::From, derive_more::Error,
)]		)]
pub enum Error {		pub enum Error {
#[display(...)]		#[display(...)]
AwsSdk(DynamoDBError),		AwsSdk(DynamoDBError),
#[display(...)]		#[display(...)]
Show All 35 Lines

#[derive(Debug, derive_more::Display, derive_more::Error)]		#[derive(Debug, derive_more::Display, derive_more::Error)]
pub enum DBItemAttributeError {		pub enum DBItemAttributeError {
#[display(...)]		#[display(...)]
Missing,		Missing,
#[display(...)]		#[display(...)]
IncorrectType,		IncorrectType,
#[display(...)]		#[display(...)]
		TimestampOutOfRange,
		#[display(...)]
InvalidTimestamp(chrono::ParseError),		InvalidTimestamp(chrono::ParseError),
#[display(...)]		#[display(...)]
InvalidNumberFormat(ParseIntError),		InvalidNumberFormat(ParseIntError),
}		}

pub fn parse_string_attribute(		pub fn parse_string_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
Show All 27 Lines	match attribute_value {
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

		pub fn parse_int_attribute<T>(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<T, DBItemError>
		where
		T: FromStr<Err = ParseIntError>,
		{
		match &attribute_value {
		Some(AttributeValue::N(numeric_str)) => {
		parse_integer(attribute_name, &numeric_str)
		}
		Some(_) => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::IncorrectType,
		)),
		None => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::Missing,
		)),
		}
		}

pub fn parse_datetime_attribute(		pub fn parse_datetime_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<DateTime<Utc>, DBItemError> {		) -> Result<DateTime<Utc>, DBItemError> {
if let Some(AttributeValue::S(datetime)) = &attribute_value {		if let Some(AttributeValue::S(datetime)) = &attribute_value {
// parse() accepts a relaxed RFC3339 string		// parse() accepts a relaxed RFC3339 string
datetime.parse().map_err(\|e\| {		datetime.parse().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::InvalidTimestamp(e),		DBItemAttributeError::InvalidTimestamp(e),
)		)
})		})
} else {		} else {
Err(DBItemError::new(		Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
))		))
}		}
}		}

		/// Parses the UTC timestamp in milliseconds from a DynamoDB numeric attribute
		pub fn parse_timestamp_attribute(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<DateTime<Utc>, DBItemError> {
		let timestamp =
		parse_int_attribute::<i64>(attribute_name, attribute_value.clone())?;
		let naive_datetime = chrono::NaiveDateTime::from_timestamp_millis(timestamp)
		.ok_or_else(\|\| {
		DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::TimestampOutOfRange,
		)
		})?;
		Ok(DateTime::from_utc(naive_datetime, Utc))
		}

pub fn parse_map_attribute(		pub fn parse_map_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<HashMap<String, AttributeValue>, DBItemError> {		) -> Result<HashMap<String, AttributeValue>, DBItemError> {
match attribute_value {		match attribute_value {
Some(AttributeValue::M(map)) => Ok(map),		Some(AttributeValue::M(map)) => Ok(map),
Some(_) => Err(DBItemError::new(		Some(_) => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::IncorrectType,		DBItemAttributeError::IncorrectType,
)),		)),
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

pub fn parse_number(		pub fn parse_integer<T>(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: &str,		attribute_value: &str,
) -> Result<i32, DBItemError> {		) -> Result<T, DBItemError>
attribute_value.parse::<i32>().map_err(\|e\| {		where
		T: FromStr<Err = ParseIntError>,
		{
		attribute_value.parse::<T>().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::String(attribute_value.to_string()),		Value::String(attribute_value.to_string()),
DBItemAttributeError::InvalidNumberFormat(e),		DBItemAttributeError::InvalidNumberFormat(e),
)		)
})		})
}		}

		#[cfg(test)]

		mod tests {
		use super::*;

		#[test]
		fn test_parse_integer() {
		assert!(parse_integer::<i32>("some_attr", "123").is_ok());
		assert!(parse_integer::<i32>("negative", "-123").is_ok());

		assert!(parse_integer::<i32>("float", "3.14").is_err());
		assert!(parse_integer::<i32>("NaN", "foo").is_err());

		assert!(parse_integer::<u32>("negative_uint", "-123").is_err());
		assert!(parse_integer::<u8>("too_large", "65536").is_err());
		}

		#[test]
		fn test_parse_timestamp() {
		let timestamp = Utc::now().timestamp_millis();
		let attr = AttributeValue::N(timestamp.to_string());

		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));

		assert!(parsed_timestamp.is_ok());
		assert_eq!(parsed_timestamp.unwrap().timestamp_millis(), timestamp);
		}

		#[test]
		fn test_parse_invalid_timestamp() {
		let attr = AttributeValue::N("foo".to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		}

		#[test]
		fn test_parse_timestamp_out_of_range() {
		let attr = AttributeValue::N(i64::MAX.to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		assert!(matches!(
		parsed_timestamp.unwrap_err().attribute_error,
		DBItemAttributeError::TimestampOutOfRange
		));
		}
		}

View Options

services/terraform/dynamodb.tf

use aws_sdk_dynamodb::types::AttributeValue;		use aws_sdk_dynamodb::types::AttributeValue;
use aws_sdk_dynamodb::Error as DynamoDBError;		use aws_sdk_dynamodb::Error as DynamoDBError;
use chrono::{DateTime, Utc};		use chrono::{DateTime, Utc};
use std::collections::HashMap;		use std::collections::HashMap;
use std::fmt::{Display, Formatter};		use std::fmt::{Display, Formatter};
use std::num::ParseIntError;		use std::num::ParseIntError;
		use std::str::FromStr;

#[derive(		#[derive(
Debug, derive_more::Display, derive_more::From, derive_more::Error,		Debug, derive_more::Display, derive_more::From, derive_more::Error,
)]		)]
pub enum Error {		pub enum Error {
#[display(...)]		#[display(...)]
AwsSdk(DynamoDBError),		AwsSdk(DynamoDBError),
#[display(...)]		#[display(...)]
Show All 35 Lines

#[derive(Debug, derive_more::Display, derive_more::Error)]		#[derive(Debug, derive_more::Display, derive_more::Error)]
pub enum DBItemAttributeError {		pub enum DBItemAttributeError {
#[display(...)]		#[display(...)]
Missing,		Missing,
#[display(...)]		#[display(...)]
IncorrectType,		IncorrectType,
#[display(...)]		#[display(...)]
		TimestampOutOfRange,
		#[display(...)]
InvalidTimestamp(chrono::ParseError),		InvalidTimestamp(chrono::ParseError),
#[display(...)]		#[display(...)]
InvalidNumberFormat(ParseIntError),		InvalidNumberFormat(ParseIntError),
}		}

pub fn parse_string_attribute(		pub fn parse_string_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
Show All 27 Lines	match attribute_value {
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

		pub fn parse_int_attribute<T>(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<T, DBItemError>
		where
		T: FromStr<Err = ParseIntError>,
		{
		match &attribute_value {
		Some(AttributeValue::N(numeric_str)) => {
		parse_integer(attribute_name, &numeric_str)
		}
		Some(_) => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::IncorrectType,
		)),
		None => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::Missing,
		)),
		}
		}

pub fn parse_datetime_attribute(		pub fn parse_datetime_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<DateTime<Utc>, DBItemError> {		) -> Result<DateTime<Utc>, DBItemError> {
if let Some(AttributeValue::S(datetime)) = &attribute_value {		if let Some(AttributeValue::S(datetime)) = &attribute_value {
// parse() accepts a relaxed RFC3339 string		// parse() accepts a relaxed RFC3339 string
datetime.parse().map_err(\|e\| {		datetime.parse().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::InvalidTimestamp(e),		DBItemAttributeError::InvalidTimestamp(e),
)		)
})		})
} else {		} else {
Err(DBItemError::new(		Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
))		))
}		}
}		}

		/// Parses the UTC timestamp in milliseconds from a DynamoDB numeric attribute
		pub fn parse_timestamp_attribute(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<DateTime<Utc>, DBItemError> {
		let timestamp =
		parse_int_attribute::<i64>(attribute_name, attribute_value.clone())?;
		let naive_datetime = chrono::NaiveDateTime::from_timestamp_millis(timestamp)
		.ok_or_else(\|\| {
		DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::TimestampOutOfRange,
		)
		})?;
		Ok(DateTime::from_utc(naive_datetime, Utc))
		}

pub fn parse_map_attribute(		pub fn parse_map_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<HashMap<String, AttributeValue>, DBItemError> {		) -> Result<HashMap<String, AttributeValue>, DBItemError> {
match attribute_value {		match attribute_value {
Some(AttributeValue::M(map)) => Ok(map),		Some(AttributeValue::M(map)) => Ok(map),
Some(_) => Err(DBItemError::new(		Some(_) => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::IncorrectType,		DBItemAttributeError::IncorrectType,
)),		)),
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

pub fn parse_number(		pub fn parse_integer<T>(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: &str,		attribute_value: &str,
) -> Result<i32, DBItemError> {		) -> Result<T, DBItemError>
attribute_value.parse::<i32>().map_err(\|e\| {		where
		T: FromStr<Err = ParseIntError>,
		{
		attribute_value.parse::<T>().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::String(attribute_value.to_string()),		Value::String(attribute_value.to_string()),
DBItemAttributeError::InvalidNumberFormat(e),		DBItemAttributeError::InvalidNumberFormat(e),
)		)
})		})
}		}

		#[cfg(test)]

		mod tests {
		use super::*;

		#[test]
		fn test_parse_integer() {
		assert!(parse_integer::<i32>("some_attr", "123").is_ok());
		assert!(parse_integer::<i32>("negative", "-123").is_ok());

		assert!(parse_integer::<i32>("float", "3.14").is_err());
		assert!(parse_integer::<i32>("NaN", "foo").is_err());

		assert!(parse_integer::<u32>("negative_uint", "-123").is_err());
		assert!(parse_integer::<u8>("too_large", "65536").is_err());
		}

		#[test]
		fn test_parse_timestamp() {
		let timestamp = Utc::now().timestamp_millis();
		let attr = AttributeValue::N(timestamp.to_string());

		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));

		assert!(parsed_timestamp.is_ok());
		assert_eq!(parsed_timestamp.unwrap().timestamp_millis(), timestamp);
		}

		#[test]
		fn test_parse_invalid_timestamp() {
		let attr = AttributeValue::N("foo".to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		}

		#[test]
		fn test_parse_timestamp_out_of_range() {
		let attr = AttributeValue::N(i64::MAX.to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		assert!(matches!(
		parsed_timestamp.unwrap_err().attribute_error,
		DBItemAttributeError::TimestampOutOfRange
		));
		}
		}

View Options

services/terraform/localstack.tf

use aws_sdk_dynamodb::types::AttributeValue;		use aws_sdk_dynamodb::types::AttributeValue;
use aws_sdk_dynamodb::Error as DynamoDBError;		use aws_sdk_dynamodb::Error as DynamoDBError;
use chrono::{DateTime, Utc};		use chrono::{DateTime, Utc};
use std::collections::HashMap;		use std::collections::HashMap;
use std::fmt::{Display, Formatter};		use std::fmt::{Display, Formatter};
use std::num::ParseIntError;		use std::num::ParseIntError;
		use std::str::FromStr;

#[derive(		#[derive(
Debug, derive_more::Display, derive_more::From, derive_more::Error,		Debug, derive_more::Display, derive_more::From, derive_more::Error,
)]		)]
pub enum Error {		pub enum Error {
#[display(...)]		#[display(...)]
AwsSdk(DynamoDBError),		AwsSdk(DynamoDBError),
#[display(...)]		#[display(...)]
Show All 35 Lines

#[derive(Debug, derive_more::Display, derive_more::Error)]		#[derive(Debug, derive_more::Display, derive_more::Error)]
pub enum DBItemAttributeError {		pub enum DBItemAttributeError {
#[display(...)]		#[display(...)]
Missing,		Missing,
#[display(...)]		#[display(...)]
IncorrectType,		IncorrectType,
#[display(...)]		#[display(...)]
		TimestampOutOfRange,
		#[display(...)]
InvalidTimestamp(chrono::ParseError),		InvalidTimestamp(chrono::ParseError),
#[display(...)]		#[display(...)]
InvalidNumberFormat(ParseIntError),		InvalidNumberFormat(ParseIntError),
}		}

pub fn parse_string_attribute(		pub fn parse_string_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
Show All 27 Lines	match attribute_value {
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

		pub fn parse_int_attribute<T>(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<T, DBItemError>
		where
		T: FromStr<Err = ParseIntError>,
		{
		match &attribute_value {
		Some(AttributeValue::N(numeric_str)) => {
		parse_integer(attribute_name, &numeric_str)
		}
		Some(_) => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::IncorrectType,
		)),
		None => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::Missing,
		)),
		}
		}

pub fn parse_datetime_attribute(		pub fn parse_datetime_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<DateTime<Utc>, DBItemError> {		) -> Result<DateTime<Utc>, DBItemError> {
if let Some(AttributeValue::S(datetime)) = &attribute_value {		if let Some(AttributeValue::S(datetime)) = &attribute_value {
// parse() accepts a relaxed RFC3339 string		// parse() accepts a relaxed RFC3339 string
datetime.parse().map_err(\|e\| {		datetime.parse().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::InvalidTimestamp(e),		DBItemAttributeError::InvalidTimestamp(e),
)		)
})		})
} else {		} else {
Err(DBItemError::new(		Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
))		))
}		}
}		}

		/// Parses the UTC timestamp in milliseconds from a DynamoDB numeric attribute
		pub fn parse_timestamp_attribute(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<DateTime<Utc>, DBItemError> {
		let timestamp =
		parse_int_attribute::<i64>(attribute_name, attribute_value.clone())?;
		let naive_datetime = chrono::NaiveDateTime::from_timestamp_millis(timestamp)
		.ok_or_else(\|\| {
		DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::TimestampOutOfRange,
		)
		})?;
		Ok(DateTime::from_utc(naive_datetime, Utc))
		}

pub fn parse_map_attribute(		pub fn parse_map_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<HashMap<String, AttributeValue>, DBItemError> {		) -> Result<HashMap<String, AttributeValue>, DBItemError> {
match attribute_value {		match attribute_value {
Some(AttributeValue::M(map)) => Ok(map),		Some(AttributeValue::M(map)) => Ok(map),
Some(_) => Err(DBItemError::new(		Some(_) => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::IncorrectType,		DBItemAttributeError::IncorrectType,
)),		)),
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

pub fn parse_number(		pub fn parse_integer<T>(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: &str,		attribute_value: &str,
) -> Result<i32, DBItemError> {		) -> Result<T, DBItemError>
attribute_value.parse::<i32>().map_err(\|e\| {		where
		T: FromStr<Err = ParseIntError>,
		{
		attribute_value.parse::<T>().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::String(attribute_value.to_string()),		Value::String(attribute_value.to_string()),
DBItemAttributeError::InvalidNumberFormat(e),		DBItemAttributeError::InvalidNumberFormat(e),
)		)
})		})
}		}

		#[cfg(test)]

		mod tests {
		use super::*;

		#[test]
		fn test_parse_integer() {
		assert!(parse_integer::<i32>("some_attr", "123").is_ok());
		assert!(parse_integer::<i32>("negative", "-123").is_ok());

		assert!(parse_integer::<i32>("float", "3.14").is_err());
		assert!(parse_integer::<i32>("NaN", "foo").is_err());

		assert!(parse_integer::<u32>("negative_uint", "-123").is_err());
		assert!(parse_integer::<u8>("too_large", "65536").is_err());
		}

		#[test]
		fn test_parse_timestamp() {
		let timestamp = Utc::now().timestamp_millis();
		let attr = AttributeValue::N(timestamp.to_string());

		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));

		assert!(parsed_timestamp.is_ok());
		assert_eq!(parsed_timestamp.unwrap().timestamp_millis(), timestamp);
		}

		#[test]
		fn test_parse_invalid_timestamp() {
		let attr = AttributeValue::N("foo".to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		}

		#[test]
		fn test_parse_timestamp_out_of_range() {
		let attr = AttributeValue::N(i64::MAX.to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		assert!(matches!(
		parsed_timestamp.unwrap_err().attribute_error,
		DBItemAttributeError::TimestampOutOfRange
		));
		}
		}

View Options

services/terraform/providers.tf

use aws_sdk_dynamodb::types::AttributeValue;		use aws_sdk_dynamodb::types::AttributeValue;
use aws_sdk_dynamodb::Error as DynamoDBError;		use aws_sdk_dynamodb::Error as DynamoDBError;
use chrono::{DateTime, Utc};		use chrono::{DateTime, Utc};
use std::collections::HashMap;		use std::collections::HashMap;
use std::fmt::{Display, Formatter};		use std::fmt::{Display, Formatter};
use std::num::ParseIntError;		use std::num::ParseIntError;
		use std::str::FromStr;

#[derive(		#[derive(
Debug, derive_more::Display, derive_more::From, derive_more::Error,		Debug, derive_more::Display, derive_more::From, derive_more::Error,
)]		)]
pub enum Error {		pub enum Error {
#[display(...)]		#[display(...)]
AwsSdk(DynamoDBError),		AwsSdk(DynamoDBError),
#[display(...)]		#[display(...)]
Show All 35 Lines

#[derive(Debug, derive_more::Display, derive_more::Error)]		#[derive(Debug, derive_more::Display, derive_more::Error)]
pub enum DBItemAttributeError {		pub enum DBItemAttributeError {
#[display(...)]		#[display(...)]
Missing,		Missing,
#[display(...)]		#[display(...)]
IncorrectType,		IncorrectType,
#[display(...)]		#[display(...)]
		TimestampOutOfRange,
		#[display(...)]
InvalidTimestamp(chrono::ParseError),		InvalidTimestamp(chrono::ParseError),
#[display(...)]		#[display(...)]
InvalidNumberFormat(ParseIntError),		InvalidNumberFormat(ParseIntError),
}		}

pub fn parse_string_attribute(		pub fn parse_string_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
Show All 27 Lines	match attribute_value {
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

		pub fn parse_int_attribute<T>(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<T, DBItemError>
		where
		T: FromStr<Err = ParseIntError>,
		{
		match &attribute_value {
		Some(AttributeValue::N(numeric_str)) => {
		parse_integer(attribute_name, &numeric_str)
		}
		Some(_) => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::IncorrectType,
		)),
		None => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::Missing,
		)),
		}
		}

pub fn parse_datetime_attribute(		pub fn parse_datetime_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<DateTime<Utc>, DBItemError> {		) -> Result<DateTime<Utc>, DBItemError> {
if let Some(AttributeValue::S(datetime)) = &attribute_value {		if let Some(AttributeValue::S(datetime)) = &attribute_value {
// parse() accepts a relaxed RFC3339 string		// parse() accepts a relaxed RFC3339 string
datetime.parse().map_err(\|e\| {		datetime.parse().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::InvalidTimestamp(e),		DBItemAttributeError::InvalidTimestamp(e),
)		)
})		})
} else {		} else {
Err(DBItemError::new(		Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
))		))
}		}
}		}

		/// Parses the UTC timestamp in milliseconds from a DynamoDB numeric attribute
		pub fn parse_timestamp_attribute(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<DateTime<Utc>, DBItemError> {
		let timestamp =
		parse_int_attribute::<i64>(attribute_name, attribute_value.clone())?;
		let naive_datetime = chrono::NaiveDateTime::from_timestamp_millis(timestamp)
		.ok_or_else(\|\| {
		DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::TimestampOutOfRange,
		)
		})?;
		Ok(DateTime::from_utc(naive_datetime, Utc))
		}

pub fn parse_map_attribute(		pub fn parse_map_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<HashMap<String, AttributeValue>, DBItemError> {		) -> Result<HashMap<String, AttributeValue>, DBItemError> {
match attribute_value {		match attribute_value {
Some(AttributeValue::M(map)) => Ok(map),		Some(AttributeValue::M(map)) => Ok(map),
Some(_) => Err(DBItemError::new(		Some(_) => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::IncorrectType,		DBItemAttributeError::IncorrectType,
)),		)),
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

pub fn parse_number(		pub fn parse_integer<T>(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: &str,		attribute_value: &str,
) -> Result<i32, DBItemError> {		) -> Result<T, DBItemError>
attribute_value.parse::<i32>().map_err(\|e\| {		where
		T: FromStr<Err = ParseIntError>,
		{
		attribute_value.parse::<T>().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::String(attribute_value.to_string()),		Value::String(attribute_value.to_string()),
DBItemAttributeError::InvalidNumberFormat(e),		DBItemAttributeError::InvalidNumberFormat(e),
)		)
})		})
}		}

		#[cfg(test)]

		mod tests {
		use super::*;

		#[test]
		fn test_parse_integer() {
		assert!(parse_integer::<i32>("some_attr", "123").is_ok());
		assert!(parse_integer::<i32>("negative", "-123").is_ok());

		assert!(parse_integer::<i32>("float", "3.14").is_err());
		assert!(parse_integer::<i32>("NaN", "foo").is_err());

		assert!(parse_integer::<u32>("negative_uint", "-123").is_err());
		assert!(parse_integer::<u8>("too_large", "65536").is_err());
		}

		#[test]
		fn test_parse_timestamp() {
		let timestamp = Utc::now().timestamp_millis();
		let attr = AttributeValue::N(timestamp.to_string());

		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));

		assert!(parsed_timestamp.is_ok());
		assert_eq!(parsed_timestamp.unwrap().timestamp_millis(), timestamp);
		}

		#[test]
		fn test_parse_invalid_timestamp() {
		let attr = AttributeValue::N("foo".to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		}

		#[test]
		fn test_parse_timestamp_out_of_range() {
		let attr = AttributeValue::N(i64::MAX.to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		assert!(matches!(
		parsed_timestamp.unwrap_err().attribute_error,
		DBItemAttributeError::TimestampOutOfRange
		));
		}
		}

View Options

services/terraform/run.sh

use aws_sdk_dynamodb::types::AttributeValue;		use aws_sdk_dynamodb::types::AttributeValue;
use aws_sdk_dynamodb::Error as DynamoDBError;		use aws_sdk_dynamodb::Error as DynamoDBError;
use chrono::{DateTime, Utc};		use chrono::{DateTime, Utc};
use std::collections::HashMap;		use std::collections::HashMap;
use std::fmt::{Display, Formatter};		use std::fmt::{Display, Formatter};
use std::num::ParseIntError;		use std::num::ParseIntError;
		use std::str::FromStr;

#[derive(		#[derive(
Debug, derive_more::Display, derive_more::From, derive_more::Error,		Debug, derive_more::Display, derive_more::From, derive_more::Error,
)]		)]
pub enum Error {		pub enum Error {
#[display(...)]		#[display(...)]
AwsSdk(DynamoDBError),		AwsSdk(DynamoDBError),
#[display(...)]		#[display(...)]
Show All 35 Lines

#[derive(Debug, derive_more::Display, derive_more::Error)]		#[derive(Debug, derive_more::Display, derive_more::Error)]
pub enum DBItemAttributeError {		pub enum DBItemAttributeError {
#[display(...)]		#[display(...)]
Missing,		Missing,
#[display(...)]		#[display(...)]
IncorrectType,		IncorrectType,
#[display(...)]		#[display(...)]
		TimestampOutOfRange,
		#[display(...)]
InvalidTimestamp(chrono::ParseError),		InvalidTimestamp(chrono::ParseError),
#[display(...)]		#[display(...)]
InvalidNumberFormat(ParseIntError),		InvalidNumberFormat(ParseIntError),
}		}

pub fn parse_string_attribute(		pub fn parse_string_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
Show All 27 Lines	match attribute_value {
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

		pub fn parse_int_attribute<T>(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<T, DBItemError>
		where
		T: FromStr<Err = ParseIntError>,
		{
		match &attribute_value {
		Some(AttributeValue::N(numeric_str)) => {
		parse_integer(attribute_name, &numeric_str)
		}
		Some(_) => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::IncorrectType,
		)),
		None => Err(DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::Missing,
		)),
		}
		}

pub fn parse_datetime_attribute(		pub fn parse_datetime_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<DateTime<Utc>, DBItemError> {		) -> Result<DateTime<Utc>, DBItemError> {
if let Some(AttributeValue::S(datetime)) = &attribute_value {		if let Some(AttributeValue::S(datetime)) = &attribute_value {
// parse() accepts a relaxed RFC3339 string		// parse() accepts a relaxed RFC3339 string
datetime.parse().map_err(\|e\| {		datetime.parse().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::InvalidTimestamp(e),		DBItemAttributeError::InvalidTimestamp(e),
)		)
})		})
} else {		} else {
Err(DBItemError::new(		Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
))		))
}		}
}		}

		/// Parses the UTC timestamp in milliseconds from a DynamoDB numeric attribute
		pub fn parse_timestamp_attribute(
		attribute_name: &'static str,
		attribute_value: Option<AttributeValue>,
		) -> Result<DateTime<Utc>, DBItemError> {
		let timestamp =
		parse_int_attribute::<i64>(attribute_name, attribute_value.clone())?;
		let naive_datetime = chrono::NaiveDateTime::from_timestamp_millis(timestamp)
		.ok_or_else(\|\| {
		DBItemError::new(
		attribute_name,
		Value::AttributeValue(attribute_value),
		DBItemAttributeError::TimestampOutOfRange,
		)
		})?;
		Ok(DateTime::from_utc(naive_datetime, Utc))
		}

pub fn parse_map_attribute(		pub fn parse_map_attribute(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: Option<AttributeValue>,		attribute_value: Option<AttributeValue>,
) -> Result<HashMap<String, AttributeValue>, DBItemError> {		) -> Result<HashMap<String, AttributeValue>, DBItemError> {
match attribute_value {		match attribute_value {
Some(AttributeValue::M(map)) => Ok(map),		Some(AttributeValue::M(map)) => Ok(map),
Some(_) => Err(DBItemError::new(		Some(_) => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::IncorrectType,		DBItemAttributeError::IncorrectType,
)),		)),
None => Err(DBItemError::new(		None => Err(DBItemError::new(
attribute_name,		attribute_name,
Value::AttributeValue(attribute_value),		Value::AttributeValue(attribute_value),
DBItemAttributeError::Missing,		DBItemAttributeError::Missing,
)),		)),
}		}
}		}

pub fn parse_number(		pub fn parse_integer<T>(
attribute_name: &'static str,		attribute_name: &'static str,
attribute_value: &str,		attribute_value: &str,
) -> Result<i32, DBItemError> {		) -> Result<T, DBItemError>
attribute_value.parse::<i32>().map_err(\|e\| {		where
		T: FromStr<Err = ParseIntError>,
		{
		attribute_value.parse::<T>().map_err(\|e\| {
DBItemError::new(		DBItemError::new(
attribute_name,		attribute_name,
Value::String(attribute_value.to_string()),		Value::String(attribute_value.to_string()),
DBItemAttributeError::InvalidNumberFormat(e),		DBItemAttributeError::InvalidNumberFormat(e),
)		)
})		})
}		}

		#[cfg(test)]

		mod tests {
		use super::*;

		#[test]
		fn test_parse_integer() {
		assert!(parse_integer::<i32>("some_attr", "123").is_ok());
		assert!(parse_integer::<i32>("negative", "-123").is_ok());

		assert!(parse_integer::<i32>("float", "3.14").is_err());
		assert!(parse_integer::<i32>("NaN", "foo").is_err());

		assert!(parse_integer::<u32>("negative_uint", "-123").is_err());
		assert!(parse_integer::<u8>("too_large", "65536").is_err());
		}

		#[test]
		fn test_parse_timestamp() {
		let timestamp = Utc::now().timestamp_millis();
		let attr = AttributeValue::N(timestamp.to_string());

		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));

		assert!(parsed_timestamp.is_ok());
		assert_eq!(parsed_timestamp.unwrap().timestamp_millis(), timestamp);
		}

		#[test]
		fn test_parse_invalid_timestamp() {
		let attr = AttributeValue::N("foo".to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		}

		#[test]
		fn test_parse_timestamp_out_of_range() {
		let attr = AttributeValue::N(i64::MAX.to_string());
		let parsed_timestamp = parse_timestamp_attribute("some_attr", Some(attr));
		assert!(parsed_timestamp.is_err());
		assert!(matches!(
		parsed_timestamp.unwrap_err().attribute_error,
		DBItemAttributeError::TimestampOutOfRange
		));
		}
		}

View Options

[services] Dev mode - Add terraformClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 12324

services/terraform/.gitignore

services/terraform/.terraform.lock.hcl

services/terraform/dynamodb-test.tf

services/terraform/dynamodb.tf

services/terraform/localstack.tf

services/terraform/providers.tf

services/terraform/run.sh

services/terraform/s3.tf

[services] Dev mode - Add terraform
ClosedPublic
Actions

Revision Contents
Changeset List