Page MenuHomePhabricator
Differential D13668

[landing] Mark encryption as shipped
ClosedPublic
Actions

Authored by ashoat on Oct 9 2024, 12:59 PM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Apr 11, 1:42 AM
Unknown Object (File)
Sun, Apr 6, 6:53 PM
Unknown Object (File)
Thu, Mar 27, 8:37 PM
Unknown Object (File)
Sun, Mar 23, 12:47 AM
Unknown Object (File)
Thu, Mar 20, 10:15 PM
Unknown Object (File)
Mon, Mar 17, 9:19 PM
Unknown Object (File)
Sat, Mar 15, 3:17 AM
Unknown Object (File)
Mar 9 2025, 6:30 PM
View All 56 Files
Subscribers
tomek

Details

Reviewers
varun
Commits
rCOMMf8a0a3d9fe10: [landing] Mark encryption as shipped
Summary

Now that E2EE is shipped, we should say so on our landing page.

Test Plan

Change seems safe

Diff Detail

Repository
rCOMM Comm
Branch
ashoat/landing
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
landing/
2 lines

Diff 45023

View Options

landing/competitor-data.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
));
}
}