Page MenuHomePhabricator
Differential D12660

[keyserver] Update ServerThreadInfo to only cover ThinThreadType
ClosedPublic
Actions

Authored by ashoat on Jul 3 2024, 8:43 PM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 17, 7:02 AM
Unknown Object (File)
Wed, Apr 16, 10:26 PM
Unknown Object (File)
Wed, Apr 16, 9:12 PM
Unknown Object (File)
Wed, Apr 16, 11:10 AM
Unknown Object (File)
Sat, Apr 12, 7:39 PM
Unknown Object (File)
Feb 21 2025, 12:11 AM
Unknown Object (File)
Feb 21 2025, 12:11 AM
Unknown Object (File)
Feb 21 2025, 12:11 AM
View All 69 Files
Subscribers
None

Details

Reviewers
tomek
marcin
inka
Commits
rCOMMa761d91e9ae2: [keyserver] Update ServerThreadInfo to only cover ThinThreadType
Summary

ServerThreadInfos are only used on the keyserver, and as such they don't include thick threads.

This diff is necessary to make sure that the changes in the next don't cause Flow errors.

Depends on D12656

Test Plan

Make sure the next diff doesn't have any Flow errors

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
keyserver/
src/
fetchers/
11 lines
lib/
shared/
5 lines
types/
2 lines

Diff 42062

View Options

keyserver/src/fetchers/thread-fetchers.js

use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::{ use chrono::{DateTime, Utc};
use comm_lib::{
aws::ddb::{
operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder}, operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder},
types::{ types::{
error::TransactionCanceledException, AttributeValue, DeleteRequest, Put, error::TransactionCanceledException, AttributeValue, DeleteRequest, Put,
TransactWriteItem, Update, WriteRequest, TransactWriteItem, Update, WriteRequest,
}, },
},
database::{AttributeMap, DynamoDBError},
}; };
use chrono::{DateTime, Utc};
use tracing::{error, warn}; use tracing::{error, warn};
use crate::{ use crate::{
client_service::FlattenedDeviceKeyUpload, client_service::FlattenedDeviceKeyUpload,
constants::{ constants::{
devices_table::{self, *}, devices_table::{self, *},
USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_PARTITION_KEY,
}, },
database::parse_string_attribute, database::parse_string_attribute,
ddb_utils::AttributesOptionExt, ddb_utils::AttributesOptionExt,
error::{ error::{
DBItemAttributeError, DBItemError, DeviceListError, Error, DBItemAttributeError, DBItemError, DeviceListError, Error,
FromAttributeValue, FromAttributeValue,
}, },
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
use super::{parse_date_time_attribute, DatabaseClient}; use super::{parse_date_time_attribute, DatabaseClient};
type RawAttributes = HashMap<String, AttributeValue>;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct DeviceRow { pub struct DeviceRow {
pub user_id: String, pub user_id: String,
pub device_id: String, pub device_id: String,
pub device_type: DeviceType, pub device_type: DeviceType,
pub device_key_info: IdentityKeyInfo, pub device_key_info: IdentityKeyInfo,
pub content_prekey: PreKey, pub content_prekey: PreKey,
pub notif_prekey: PreKey, pub notif_prekey: PreKey,
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines let timestamp: DateTime<Utc> = item_id
) )
}) })
})?; })?;
Ok(Self(timestamp)) Ok(Self(timestamp))
} }
} }
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<AttributeMap> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
let raw_device_type = let raw_device_type =
parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?; parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?;
let device_type = let device_type =
DeviceType::from_str_name(&raw_device_type).ok_or_else(|| { DeviceType::from_str_name(&raw_device_type).ok_or_else(|| {
Show All 31 Lines Ok(Self {
device_type, device_type,
device_key_info, device_key_info,
content_prekey, content_prekey,
notif_prekey, notif_prekey,
}) })
} }
} }
impl From<DeviceRow> for RawAttributes { impl From<DeviceRow> for AttributeMap {
fn from(value: DeviceRow) -> Self { fn from(value: DeviceRow) -> Self {
HashMap::from([ HashMap::from([
(ATTR_USER_ID.to_string(), AttributeValue::S(value.user_id)), (ATTR_USER_ID.to_string(), AttributeValue::S(value.user_id)),
( (
ATTR_ITEM_ID.to_string(), ATTR_ITEM_ID.to_string(),
DeviceIDAttribute(value.device_id).into(), DeviceIDAttribute(value.device_id).into(),
), ),
( (
Show All 27 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<RawAttributes> for IdentityKeyInfo { impl TryFrom<AttributeMap> for IdentityKeyInfo {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let key_payload = let key_payload =
parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?; parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?;
let key_payload_signature = parse_string_attribute( let key_payload_signature = parse_string_attribute(
ATTR_KEY_PAYLOAD_SIGNATURE, ATTR_KEY_PAYLOAD_SIGNATURE,
attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE), attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE),
)?; )?;
// social proof is optional // social proof is optional
let social_proof = attrs let social_proof = attrs
Show All 17 Lines let attrs = HashMap::from([
ATTR_PREKEY_SIGNATURE.to_string(), ATTR_PREKEY_SIGNATURE.to_string(),
AttributeValue::S(value.pre_key_signature), AttributeValue::S(value.pre_key_signature),
), ),
]); ]);
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<RawAttributes> for PreKey { impl TryFrom<AttributeMap> for PreKey {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let pre_key = let pre_key =
parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?; parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?;
let pre_key_signature = parse_string_attribute( let pre_key_signature = parse_string_attribute(
ATTR_PREKEY_SIGNATURE, ATTR_PREKEY_SIGNATURE,
attrs.remove(ATTR_PREKEY_SIGNATURE), attrs.remove(ATTR_PREKEY_SIGNATURE),
)?; )?;
Ok(Self { Ok(Self {
pre_key, pre_key,
pre_key_signature, pre_key_signature,
}) })
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow { impl TryFrom<AttributeMap> for DeviceListRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) = let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?; attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync // validate timestamps are in sync
let timestamps_match = attrs let timestamps_match = attrs
.remove(ATTR_TIMESTAMP) .remove(ATTR_TIMESTAMP)
Show All 27 Lines fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
user_id, user_id,
timestamp, timestamp,
device_ids, device_ids,
}) })
} }
} }
impl From<DeviceListRow> for RawAttributes { impl From<DeviceListRow> for AttributeMap {
fn from(device_list: DeviceListRow) -> Self { fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new(); let mut attrs = HashMap::new();
attrs.insert( attrs.insert(
ATTR_USER_ID.to_string(), ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()), AttributeValue::S(device_list.user_id.clone()),
); );
attrs.insert( attrs.insert(
ATTR_ITEM_ID.to_string(), ATTR_ITEM_ID.to_string(),
▲ Show 20 Lines • Show All 243 Lines • ▼ Show 20 Lines ) -> Result<(), Error> {
self self
.client .client
.transact_write_items() .transact_write_items()
.transact_items(operation) .transact_items(operation)
.transact_items(put_device_list_operation) .transact_items(put_device_list_operation)
.transact_items(timestamp_update_operation) .transact_items(timestamp_update_operation)
.send() .send()
.await .await
.map_err(|e| match aws_sdk_dynamodb::Error::from(e) { .map_err(|e| match DynamoDBError::from(e) {
aws_sdk_dynamodb::Error::TransactionCanceledException( DynamoDBError::TransactionCanceledException(
TransactionCanceledException { TransactionCanceledException {
cancellation_reasons: Some(reasons), cancellation_reasons: Some(reasons),
.. ..
}, },
) if reasons ) if reasons
.iter() .iter()
.any(|reason| reason.code() == Some("ConditionalCheckFailed")) => .any(|reason| reason.code() == Some("ConditionalCheckFailed")) =>
{ {
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines
View Options

lib/shared/thread-utils.js

use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::{ use chrono::{DateTime, Utc};
use comm_lib::{
aws::ddb::{
operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder}, operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder},
types::{ types::{
error::TransactionCanceledException, AttributeValue, DeleteRequest, Put, error::TransactionCanceledException, AttributeValue, DeleteRequest, Put,
TransactWriteItem, Update, WriteRequest, TransactWriteItem, Update, WriteRequest,
}, },
},
database::{AttributeMap, DynamoDBError},
}; };
use chrono::{DateTime, Utc};
use tracing::{error, warn}; use tracing::{error, warn};
use crate::{ use crate::{
client_service::FlattenedDeviceKeyUpload, client_service::FlattenedDeviceKeyUpload,
constants::{ constants::{
devices_table::{self, *}, devices_table::{self, *},
USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_PARTITION_KEY,
}, },
database::parse_string_attribute, database::parse_string_attribute,
ddb_utils::AttributesOptionExt, ddb_utils::AttributesOptionExt,
error::{ error::{
DBItemAttributeError, DBItemError, DeviceListError, Error, DBItemAttributeError, DBItemError, DeviceListError, Error,
FromAttributeValue, FromAttributeValue,
}, },
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
use super::{parse_date_time_attribute, DatabaseClient}; use super::{parse_date_time_attribute, DatabaseClient};
type RawAttributes = HashMap<String, AttributeValue>;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct DeviceRow { pub struct DeviceRow {
pub user_id: String, pub user_id: String,
pub device_id: String, pub device_id: String,
pub device_type: DeviceType, pub device_type: DeviceType,
pub device_key_info: IdentityKeyInfo, pub device_key_info: IdentityKeyInfo,
pub content_prekey: PreKey, pub content_prekey: PreKey,
pub notif_prekey: PreKey, pub notif_prekey: PreKey,
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines let timestamp: DateTime<Utc> = item_id
) )
}) })
})?; })?;
Ok(Self(timestamp)) Ok(Self(timestamp))
} }
} }
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<AttributeMap> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
let raw_device_type = let raw_device_type =
parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?; parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?;
let device_type = let device_type =
DeviceType::from_str_name(&raw_device_type).ok_or_else(|| { DeviceType::from_str_name(&raw_device_type).ok_or_else(|| {
Show All 31 Lines Ok(Self {
device_type, device_type,
device_key_info, device_key_info,
content_prekey, content_prekey,
notif_prekey, notif_prekey,
}) })
} }
} }
impl From<DeviceRow> for RawAttributes { impl From<DeviceRow> for AttributeMap {
fn from(value: DeviceRow) -> Self { fn from(value: DeviceRow) -> Self {
HashMap::from([ HashMap::from([
(ATTR_USER_ID.to_string(), AttributeValue::S(value.user_id)), (ATTR_USER_ID.to_string(), AttributeValue::S(value.user_id)),
( (
ATTR_ITEM_ID.to_string(), ATTR_ITEM_ID.to_string(),
DeviceIDAttribute(value.device_id).into(), DeviceIDAttribute(value.device_id).into(),
), ),
( (
Show All 27 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<RawAttributes> for IdentityKeyInfo { impl TryFrom<AttributeMap> for IdentityKeyInfo {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let key_payload = let key_payload =
parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?; parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?;
let key_payload_signature = parse_string_attribute( let key_payload_signature = parse_string_attribute(
ATTR_KEY_PAYLOAD_SIGNATURE, ATTR_KEY_PAYLOAD_SIGNATURE,
attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE), attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE),
)?; )?;
// social proof is optional // social proof is optional
let social_proof = attrs let social_proof = attrs
Show All 17 Lines let attrs = HashMap::from([
ATTR_PREKEY_SIGNATURE.to_string(), ATTR_PREKEY_SIGNATURE.to_string(),
AttributeValue::S(value.pre_key_signature), AttributeValue::S(value.pre_key_signature),
), ),
]); ]);
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<RawAttributes> for PreKey { impl TryFrom<AttributeMap> for PreKey {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let pre_key = let pre_key =
parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?; parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?;
let pre_key_signature = parse_string_attribute( let pre_key_signature = parse_string_attribute(
ATTR_PREKEY_SIGNATURE, ATTR_PREKEY_SIGNATURE,
attrs.remove(ATTR_PREKEY_SIGNATURE), attrs.remove(ATTR_PREKEY_SIGNATURE),
)?; )?;
Ok(Self { Ok(Self {
pre_key, pre_key,
pre_key_signature, pre_key_signature,
}) })
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow { impl TryFrom<AttributeMap> for DeviceListRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) = let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?; attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync // validate timestamps are in sync
let timestamps_match = attrs let timestamps_match = attrs
.remove(ATTR_TIMESTAMP) .remove(ATTR_TIMESTAMP)
Show All 27 Lines fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
user_id, user_id,
timestamp, timestamp,
device_ids, device_ids,
}) })
} }
} }
impl From<DeviceListRow> for RawAttributes { impl From<DeviceListRow> for AttributeMap {
fn from(device_list: DeviceListRow) -> Self { fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new(); let mut attrs = HashMap::new();
attrs.insert( attrs.insert(
ATTR_USER_ID.to_string(), ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()), AttributeValue::S(device_list.user_id.clone()),
); );
attrs.insert( attrs.insert(
ATTR_ITEM_ID.to_string(), ATTR_ITEM_ID.to_string(),
▲ Show 20 Lines • Show All 243 Lines • ▼ Show 20 Lines ) -> Result<(), Error> {
self self
.client .client
.transact_write_items() .transact_write_items()
.transact_items(operation) .transact_items(operation)
.transact_items(put_device_list_operation) .transact_items(put_device_list_operation)
.transact_items(timestamp_update_operation) .transact_items(timestamp_update_operation)
.send() .send()
.await .await
.map_err(|e| match aws_sdk_dynamodb::Error::from(e) { .map_err(|e| match DynamoDBError::from(e) {
aws_sdk_dynamodb::Error::TransactionCanceledException( DynamoDBError::TransactionCanceledException(
TransactionCanceledException { TransactionCanceledException {
cancellation_reasons: Some(reasons), cancellation_reasons: Some(reasons),
.. ..
}, },
) if reasons ) if reasons
.iter() .iter()
.any(|reason| reason.code() == Some("ConditionalCheckFailed")) => .any(|reason| reason.code() == Some("ConditionalCheckFailed")) =>
{ {
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines
View Options

lib/types/thread-types.js

use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::{ use chrono::{DateTime, Utc};
use comm_lib::{
aws::ddb::{
operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder}, operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder},
types::{ types::{
error::TransactionCanceledException, AttributeValue, DeleteRequest, Put, error::TransactionCanceledException, AttributeValue, DeleteRequest, Put,
TransactWriteItem, Update, WriteRequest, TransactWriteItem, Update, WriteRequest,
}, },
},
database::{AttributeMap, DynamoDBError},
}; };
use chrono::{DateTime, Utc};
use tracing::{error, warn}; use tracing::{error, warn};
use crate::{ use crate::{
client_service::FlattenedDeviceKeyUpload, client_service::FlattenedDeviceKeyUpload,
constants::{ constants::{
devices_table::{self, *}, devices_table::{self, *},
USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_PARTITION_KEY,
}, },
database::parse_string_attribute, database::parse_string_attribute,
ddb_utils::AttributesOptionExt, ddb_utils::AttributesOptionExt,
error::{ error::{
DBItemAttributeError, DBItemError, DeviceListError, Error, DBItemAttributeError, DBItemError, DeviceListError, Error,
FromAttributeValue, FromAttributeValue,
}, },
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
use super::{parse_date_time_attribute, DatabaseClient}; use super::{parse_date_time_attribute, DatabaseClient};
type RawAttributes = HashMap<String, AttributeValue>;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct DeviceRow { pub struct DeviceRow {
pub user_id: String, pub user_id: String,
pub device_id: String, pub device_id: String,
pub device_type: DeviceType, pub device_type: DeviceType,
pub device_key_info: IdentityKeyInfo, pub device_key_info: IdentityKeyInfo,
pub content_prekey: PreKey, pub content_prekey: PreKey,
pub notif_prekey: PreKey, pub notif_prekey: PreKey,
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines let timestamp: DateTime<Utc> = item_id
) )
}) })
})?; })?;
Ok(Self(timestamp)) Ok(Self(timestamp))
} }
} }
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<AttributeMap> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
let raw_device_type = let raw_device_type =
parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?; parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?;
let device_type = let device_type =
DeviceType::from_str_name(&raw_device_type).ok_or_else(|| { DeviceType::from_str_name(&raw_device_type).ok_or_else(|| {
Show All 31 Lines Ok(Self {
device_type, device_type,
device_key_info, device_key_info,
content_prekey, content_prekey,
notif_prekey, notif_prekey,
}) })
} }
} }
impl From<DeviceRow> for RawAttributes { impl From<DeviceRow> for AttributeMap {
fn from(value: DeviceRow) -> Self { fn from(value: DeviceRow) -> Self {
HashMap::from([ HashMap::from([
(ATTR_USER_ID.to_string(), AttributeValue::S(value.user_id)), (ATTR_USER_ID.to_string(), AttributeValue::S(value.user_id)),
( (
ATTR_ITEM_ID.to_string(), ATTR_ITEM_ID.to_string(),
DeviceIDAttribute(value.device_id).into(), DeviceIDAttribute(value.device_id).into(),
), ),
( (
Show All 27 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<RawAttributes> for IdentityKeyInfo { impl TryFrom<AttributeMap> for IdentityKeyInfo {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let key_payload = let key_payload =
parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?; parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?;
let key_payload_signature = parse_string_attribute( let key_payload_signature = parse_string_attribute(
ATTR_KEY_PAYLOAD_SIGNATURE, ATTR_KEY_PAYLOAD_SIGNATURE,
attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE), attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE),
)?; )?;
// social proof is optional // social proof is optional
let social_proof = attrs let social_proof = attrs
Show All 17 Lines let attrs = HashMap::from([
ATTR_PREKEY_SIGNATURE.to_string(), ATTR_PREKEY_SIGNATURE.to_string(),
AttributeValue::S(value.pre_key_signature), AttributeValue::S(value.pre_key_signature),
), ),
]); ]);
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<RawAttributes> for PreKey { impl TryFrom<AttributeMap> for PreKey {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let pre_key = let pre_key =
parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?; parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?;
let pre_key_signature = parse_string_attribute( let pre_key_signature = parse_string_attribute(
ATTR_PREKEY_SIGNATURE, ATTR_PREKEY_SIGNATURE,
attrs.remove(ATTR_PREKEY_SIGNATURE), attrs.remove(ATTR_PREKEY_SIGNATURE),
)?; )?;
Ok(Self { Ok(Self {
pre_key, pre_key,
pre_key_signature, pre_key_signature,
}) })
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow { impl TryFrom<AttributeMap> for DeviceListRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) = let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?; attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync // validate timestamps are in sync
let timestamps_match = attrs let timestamps_match = attrs
.remove(ATTR_TIMESTAMP) .remove(ATTR_TIMESTAMP)
Show All 27 Lines fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
user_id, user_id,
timestamp, timestamp,
device_ids, device_ids,
}) })
} }
} }
impl From<DeviceListRow> for RawAttributes { impl From<DeviceListRow> for AttributeMap {
fn from(device_list: DeviceListRow) -> Self { fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new(); let mut attrs = HashMap::new();
attrs.insert( attrs.insert(
ATTR_USER_ID.to_string(), ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()), AttributeValue::S(device_list.user_id.clone()),
); );
attrs.insert( attrs.insert(
ATTR_ITEM_ID.to_string(), ATTR_ITEM_ID.to_string(),
▲ Show 20 Lines • Show All 243 Lines • ▼ Show 20 Lines ) -> Result<(), Error> {
self self
.client .client
.transact_write_items() .transact_write_items()
.transact_items(operation) .transact_items(operation)
.transact_items(put_device_list_operation) .transact_items(put_device_list_operation)
.transact_items(timestamp_update_operation) .transact_items(timestamp_update_operation)
.send() .send()
.await .await
.map_err(|e| match aws_sdk_dynamodb::Error::from(e) { .map_err(|e| match DynamoDBError::from(e) {
aws_sdk_dynamodb::Error::TransactionCanceledException( DynamoDBError::TransactionCanceledException(
TransactionCanceledException { TransactionCanceledException {
cancellation_reasons: Some(reasons), cancellation_reasons: Some(reasons),
.. ..
}, },
) if reasons ) if reasons
.iter() .iter()
.any(|reason| reason.code() == Some("ConditionalCheckFailed")) => .any(|reason| reason.code() == Some("ConditionalCheckFailed")) =>
{ {
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines