Paths

Table of Contentst

-
keyserver/
-
package.json
-
src/
-
keyserver.js
-
socket/
-
tunnelbroker.js
-
lib/types/
-
types/
-
tunnelbroker-messages.js
-
services/
-
commtest/tests/
-
tests/
-
tunnelbroker_integration_test.rs
-
tunnelbroker/src/websockets/
-
src/
-
websockets/
-
session.rs
-
shared/tunnelbroker_messages/src/messages/
-
tunnelbroker_messages/
-
src/
-
messages/
-
mod.rs
-
session.rs
-
yarn.lock

[Keyserver] Open websocket connection with tunnelbroker
ClosedPublic
Actions

Authored by kamil on Apr 30 2023, 10:58 PM.

Details

Reviewers

ashoat
• jon
bartek
michal

Commits

rCOMM8f42e5423993: [Keyserver] Open websocket connection with tunnelbroker

Summary

Attempt to connect to tunnelbroker if available.
This is meant to be a "hello world" for establishing
a tunnelbroker connection.

https://linear.app/comm/issue/ENG-3766

Depends on D8476

Test Plan

(cd services/tunnelbroker && cargo run &)
# should see message about db migration, then tunnelbroker message
(cd keyserver && yarn dev)

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

There are a very large number of changes, so older changes are hidden. Show Older Changes

• jon added a parent revision: D8476: [Keyserver] Publish prekeys to identity service for cron job.Jul 24 2023, 6:39 AM

• jon removed a child revision: D7702: [Keyserver] Introduce tunnelbroker types.

Harbormaster failed remote builds in B21147: Diff 28969!Jul 24 2023, 6:43 AM

• jon added a child revision: D8605: [Protos] Move GetKeyserverInfo to authtenticated service.Jul 24 2023, 6:50 AM

Correct rebase

• jon planned changes to this revision.Jul 24 2023, 5:10 PM

Harbormaster completed remote builds in B21159: Diff 28981.Jul 24 2023, 5:27 PM

Address feedback

keyserver/src/socket/tunnelbroker.js
41–43 ↗	(On Diff #28758)	It was useful, but I'll remove it now.
49 ↗	(On Diff #28758)	Yea, testing this code path locally will cause it to dump just a massive amount of output in a short amount of time. The sleep is just there to make it manage-able. We should probably have some type of exponential back-off. But 1s seems fine for now.

Harbormaster completed remote builds in B21160: Diff 28982.Jul 24 2023, 6:09 PM

ashoat requested changes to this revision.Jul 27 2023, 11:28 AM

ashoat added inline comments.

keyserver/src/keyserver.js
67–68 ↗	(On Diff #28982)	It's a little weird to see this pattern, where we `await` one `Promise` and but then don't `await` the subsequent one. It would be good to add a code comment explaining why we're doing this: `verifyUserLoggedIn` needs to be `await`ed because: Currently, the code for getting one-time keys to initiate the notif ratchet could have a race with the `verifyUserLoggedIn` code, leading to one-time keys getting erroneously marked as published. This will no longer be true after we update that code to source one-time keys from identity service, but... In the future, we expect that having a `commServicesAccessToken` will be required for normal keyserver functioning On the other hand, `createAndMaintainTunnelbrokerWebsocket` doesn't need to be `await`ed because: The connection to Tunnelbroker isn't strictly necessary for normal keyserver functioning at this time The call to `createAndMaintainTunnelbrokerWebsocket` doesn't return anything that we need ahead of forking the Express server threads
keyserver/src/socket/tunnelbroker.js
15 ↗	(On Diff #28982)	Please apply this feedback to every place in the diff that it applies to
17 ↗	(On Diff #28982)	You should not be `await`ing something that doesn't return a promise
42 ↗	(On Diff #28982)
46 ↗	(On Diff #28982)
48 ↗	(On Diff #28982)	Please apply this feedback everywhere
53 ↗	(On Diff #28982)
55 ↗	(On Diff #28982)	If we're not doing anything with `err`, we can omit it

This revision now requires changes to proceed.Jul 27 2023, 11:28 AM

• jon removed a child revision: D8605: [Protos] Move GetKeyserverInfo to authtenticated service.Aug 8 2023, 8:53 AM

• jon added a child revision: D8750: [Keyserver/rust] Implement upload_one_time_keys to identity service.

Address feedback

Add comments in keyserver.js

Capitalize Keyserver and Tunnelbroker in comments

Harbormaster completed remote builds in B21840: Diff 30012.Aug 17 2023, 8:24 AM

Harbormaster completed remote builds in B21839: Diff 30011.

Harbormaster completed remote builds in B21841: Diff 30013.Aug 17 2023, 8:27 AM

I got 15 lines into the file, and then gave up on the review due to frustration. You completely ignored a comment from my previous review.

Please fix the issue, and then review all previous diff feedback carefully and thoroughly to make sure it has been addressed before putting this back on my diff queue.

keyserver/src/keyserver.js
67–73 ↗	(On Diff #30013)	Minor changes
keyserver/src/socket/tunnelbroker.js
15 ↗	(On Diff #30013)	My feedback from the last review appears to have been ignored: {F695889} Remember – a reviewer should never have to repeat feedback. This is a common issue for you... please review feedback carefully before updating a diff. Go line by line for each comment you received, and make sure you addressed it 100%. It shouldn't ever be necessary for me to repeat feedback to you.

This revision now requires changes to proceed.Aug 18 2023, 3:19 PM

• jon marked 2 inline comments as done.Aug 21 2023, 12:15 AM

• jon added inline comments.

keyserver/src/socket/tunnelbroker.js
15 ↗	(On Diff #30013)	missed this one.

You seem to have accidentally addressed my 2 comments from the previous review in D8752. Can you make sure you update this diff as well?

• jon mentioned this in D8816: [Native] Encode platform type in native_rust_library.Aug 23 2023, 10:24 AM

kamil commandeered this revision.Sep 8 2023, 5:47 AM

kamil added a reviewer: • jon.

kamil removed a reviewer: • jon.

Herald added a reviewer: • jon. · View Herald TranscriptSep 8 2023, 5:48 AM

kamil removed a reviewer: • jon.Sep 8 2023, 5:49 AM

Herald added a reviewer: • jon. · View Herald TranscriptSep 8 2023, 5:49 AM

update comment
deviceId -> deviceID

kamil added inline comments.Sep 8 2023, 7:13 AM

keyserver/src/socket/tunnelbroker.js
47–49 ↗	(On Diff #30865)	I think we should remove this code until the staging is ready, otherwise, keyserver console will be spammed if someone will not run the local tunnelbroker. Thoughts?
lib/types/tunnelbroker-messages.js
8 ↗	(On Diff #30865)	To update this to `userID` we need to make some changes in Rust struct definition, Created a task ENG-4880

kamil added inline comments.Sep 8 2023, 7:15 AM

keyserver/src/keyserver.js
71–72 ↗	(On Diff #30865)	missed one line, will update shortly

Harbormaster completed remote builds in B22448: Diff 30865.Sep 8 2023, 7:24 AM

kamil mentioned this in D8752: [Keyserver] Upload new onetime keys to identity service when requested.Sep 8 2023, 9:17 AM

Some more bugs I found while testing D8918, I will address them later

keyserver/src/socket/tunnelbroker.js
15 ↗	(On Diff #30865)
38 ↗	(On Diff #30865)

curve25519 -> ed25519
deviceID -> userID
remove auto-establishing session

kamil added inline comments.Sep 12 2023, 3:16 AM

keyserver/src/socket/tunnelbroker.js
44–46	Some context in ENG-4924
lib/types/tunnelbroker-messages.js
3–9	D9128

Harbormaster failed remote builds in B22517: Diff 30954!Sep 12 2023, 3:21 AM

Harbormaster completed remote builds in B22522: Diff 30959.Sep 12 2023, 4:23 AM

JS looks good, but I don't know Rust so couldn't review that part

This revision is now accepted and ready to land.Sep 12 2023, 5:57 AM

@bartek, @michal could you take a brief look at Rust?

LGTM, mostly just a rename

services/tunnelbroker/src/websockets/session.rs
112–127 ↗	(On Diff #30959)	Why was this removed?

kamil removed a parent revision: D8476: [Keyserver] Publish prekeys to identity service for cron job.Sep 12 2023, 7:50 AM

rebase before landing

kamil removed a parent revision: D8476: [Keyserver] Publish prekeys to identity service for cron job.Sep 13 2023, 5:57 AM

kamil added inline comments.

services/tunnelbroker/src/websockets/session.rs
112–127 ↗	(On Diff #30959)	discussed in the office: this code is moved higher, to `accept_connection()`

michal accepted this revision.Sep 13 2023, 6:03 AM

Harbormaster completed remote builds in B22579: Diff 31032.Sep 13 2023, 6:14 AM

Closed by commit rCOMM8f42e5423993: [Keyserver] Open websocket connection with tunnelbroker (authored by • jon, committed by kamil). · Explain WhySep 13 2023, 6:43 AM

This revision was automatically updated to reflect the committed changes.

kamil added a commit: rCOMM8f42e5423993: [Keyserver] Open websocket connection with tunnelbroker.

Revision Contents
Changeset List

Path

Size

keyserver/

package.json

3 lines

src/

keyserver.js

11 lines

socket/

tunnelbroker.js

56 lines

lib/

types/

tunnelbroker-messages.js

30 lines

services/

commtest/

tests/

tunnelbroker_integration_test.rs

1 line

tunnelbroker/

src/

websockets/

session.rs

20 lines

shared/

tunnelbroker_messages/

src/

messages/

mod.rs

2 lines

session.rs

8 lines

yarn.lock

5 lines

Diff 30954

View Options

keyserver/package.json

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

keyserver/src/keyserver.js

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

keyserver/src/socket/tunnelbroker.js

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

lib/types/tunnelbroker-messages.js

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
		));
		}
		}