Page MenuHomePhabricator
Differential D3420

[services] Add comments about indexes
ClosedPublic
Actions

Authored by • karol on Mar 14 2022, 8:50 AM.
Tags
None
Referenced Files
F5243172: D3420.diff
Sat, Apr 5, 9:10 PM
Unknown Object (File)
Mon, Mar 31, 11:29 PM
Unknown Object (File)
Sun, Mar 30, 10:15 PM
Unknown Object (File)
Sun, Mar 30, 9:43 PM
Unknown Object (File)
Sun, Mar 30, 1:53 PM
Unknown Object (File)
Sun, Mar 30, 9:55 AM
Unknown Object (File)
Sat, Mar 29, 9:31 PM
Unknown Object (File)
Fri, Mar 28, 1:15 PM
View All Files
Subscribers
• adrian
ashoat
atul
• benschac
tomek

Details

Reviewers
tomek
varun
atul
• max
• jim
ashoat
Commits
rCOMM82073b570fb5: [services] Add comments about indexes
Summary

Raised here https://phabricator.ashoat.com/D3087#86770

Adding comments in places where database indexes are needed.

Test Plan

None, these are just comments

Diff Detail

Repository
rCOMM Comm
Branch
backup-follow-up
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

• karol created this revision.Mar 14 2022, 8:50 AM
Herald added subscribers: • benschac, atul, • adrian and 2 others. · View Herald TranscriptMar 14 2022, 8:50 AM
• karol edited the summary of this revision. (Show Details)Mar 14 2022, 8:51 AM
• karol edited the test plan for this revision. (Show Details)
• karol added reviewers: tomek, varun, atul, • max, • jim.
• karol mentioned this in D3087: [services] Backup - Database - add Backup Item.
Harbormaster completed remote builds in B7334: Diff 10335.Mar 14 2022, 8:55 AM
• karol requested review of this revision.Mar 14 2022, 8:55 AM
ashoat requested changes to this revision.Mar 14 2022, 11:12 AM
ashoat added inline comments.
services/backup/docker-server/contents/server/src/DatabaseEntities/BackupItem.h
13–17

My initial request was:

[comment] clarifying that this class is used for representing two things: the rows in the main table, and also the rows in the secondary index

This comment doesn't seem to provide that clarification. Is my understanding correcrt, that BackupItem is used for representing both rows in the main table, as well as rows in the secondary index? If so, can you add a comment making that clear?

This revision now requires changes to proceed.Mar 14 2022, 11:12 AM
• karol updated this revision to Diff 10555.Mar 21 2022, 3:44 AM

fix comment

Harbormaster completed remote builds in B7499: Diff 10555.Mar 21 2022, 3:50 AM
ashoat accepted this revision.Mar 21 2022, 7:23 AM
This revision is now accepted and ready to land.Mar 21 2022, 7:23 AM
Closed by commit rCOMM82073b570fb5: [services] Add comments about indexes (authored by • karol). · Explain WhyMar 22 2022, 1:40 AM
This revision was automatically updated to reflect the committed changes.
• karol added a commit: rCOMM82073b570fb5: [services] Add comments about indexes.

Revision Contents
Changeset List

PathSize
services/
backup/
docker-server/
contents/
server/
src/
DatabaseEntities/
7 lines
blob/
docker-server/
contents/
server/
src/
DatabaseEntities/
5 lines

Diff 10335

View Options

services/backup/docker-server/contents/server/src/DatabaseEntities/BackupItem.h

Show All 10 Linesuse comm_lib::database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError, AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
TryFromAttribute, TryFromAttribute,
}; };
use constant_time_eq::constant_time_eq; use constant_time_eq::constant_time_eq;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::str::FromStr; use std::str::FromStr;
use std::sync::Arc; use std::sync::Arc;
use crate::ddb_utils::{ use crate::{
constants::USERS_TABLE_DEVICES_ATTRIBUTE,
ddb_utils::{
create_one_time_key_partition_key, into_one_time_put_requests, Identifier, create_one_time_key_partition_key, into_one_time_put_requests, Identifier,
OlmAccountType, OlmAccountType,
},
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
},
reserved_users::UserDetail,
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
},
error::{consume_error, Error},
}; };
use crate::error::{consume_error, Error};
use crate::reserved_users::UserDetail;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use tracing::{debug, error, info, warn}; use tracing::{debug, error, info, warn};
use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo}; use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::{ use crate::constants::{
ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE, ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE,
ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE, ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE,
ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE, ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE,
ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE, ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE,
NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE, NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE,
NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY, NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY,
NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE, NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE,
RESERVED_USERNAMES_TABLE_PARTITION_KEY, RESERVED_USERNAMES_TABLE_PARTITION_KEY,
RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE, RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE,
USERS_TABLE_DEVICES_ATTRIBUTE,
USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME, USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE, USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE,
USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX, USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX,
USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX, USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX,
}; };
use crate::error::{AttributeValueFromHashMap, FromAttributeValue}; use crate::error::AttributeValueFromHashMap;
use crate::id::generate_uuid; use crate::id::generate_uuid;
use crate::nonce::NonceData; use crate::nonce::NonceData;
use crate::token::{AccessTokenData, AuthType}; use crate::token::{AccessTokenData, AuthType};
pub use grpc_clients::identity::DeviceType; pub use grpc_clients::identity::DeviceType;
mod device_list; mod device_list;
pub use device_list::DeviceListRow; pub use device_list::DeviceListRow;
▲ Show 20 Lines • Show All 306 Lines • ▼ Show 20 Lines pub async fn get_keyserver_keys_for_user(
&self, &self,
user_id: &str, user_id: &str,
) -> Result<Option<OutboundKeys>, Error> { ) -> Result<Option<OutboundKeys>, Error> {
use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType; use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType;
// DynamoDB doesn't have a way to "pop" a value from a list, so we must // DynamoDB doesn't have a way to "pop" a value from a list, so we must
// first read in user info, then update one_time_keys with value we // first read in user info, then update one_time_keys with value we
// gave to requester // gave to requester
let user_info = self let mut user_info = self
.get_item_from_users_table(user_id) .get_item_from_users_table(user_id)
.await? .await?
.item .item
.ok_or(Error::MissingItem)?; .ok_or(Error::MissingItem)?;
let user_id = user_info let user_id: String = user_info.take_attr(USERS_TABLE_PARTITION_KEY)?;
.get(USERS_TABLE_PARTITION_KEY)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_PARTITION_KEY)?;
let devices = user_info
.get(USERS_TABLE_DEVICES_ATTRIBUTE)
.ok_or(Error::MissingItem)?
.to_hashmap(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let user_devices = self.get_current_devices(user_id).await?; let user_devices = self.get_current_devices(user_id).await?;
let maybe_keyserver_device = user_devices let maybe_keyserver_device = user_devices
.into_iter() .into_iter()
.find(|device| device.device_type == GrpcDeviceType::Keyserver); .find(|device| device.device_type == GrpcDeviceType::Keyserver);
if let Some(keyserver) = maybe_keyserver_device { let Some(keyserver) = maybe_keyserver_device else {
return Ok(None);
};
debug!( debug!(
"Found keyserver in devices table (ID={})", "Found keyserver in devices table (ID={})",
&keyserver.device_id &keyserver.device_id
); );
let notif_one_time_key: Option<String> = self let notif_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Notification) .get_one_time_key(&keyserver.device_id, OlmAccountType::Notification)
.await?; .await?;
let content_one_time_key: Option<String> = self let content_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Content) .get_one_time_key(&keyserver.device_id, OlmAccountType::Content)
.await?; .await?;
debug!( debug!(
"Able to get notif one-time key for keyserver {}: {}", "Able to get notif one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
notif_one_time_key.is_some() notif_one_time_key.is_some()
); );
debug!( debug!(
"Able to get content one-time key for keyserver {}: {}", "Able to get content one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
content_one_time_key.is_some() content_one_time_key.is_some()
); );
let outbound_payload = OutboundKeys { let outbound_payload = OutboundKeys {
key_payload: keyserver.device_key_info.key_payload, key_payload: keyserver.device_key_info.key_payload,
key_payload_signature: keyserver.device_key_info.key_payload_signature, key_payload_signature: keyserver.device_key_info.key_payload_signature,
social_proof: keyserver.device_key_info.social_proof, social_proof: keyserver.device_key_info.social_proof,
content_prekey: PreKey { content_prekey: PreKey {
prekey: keyserver.content_prekey.pre_key, prekey: keyserver.content_prekey.pre_key,
prekey_signature: keyserver.content_prekey.pre_key_signature, prekey_signature: keyserver.content_prekey.pre_key_signature,
}, },
notif_prekey: PreKey { notif_prekey: PreKey {
prekey: keyserver.notif_prekey.pre_key, prekey: keyserver.notif_prekey.pre_key,
prekey_signature: keyserver.notif_prekey.pre_key_signature, prekey_signature: keyserver.notif_prekey.pre_key_signature,
}, },
content_one_time_key, content_one_time_key,
notif_one_time_key, notif_one_time_key,
}; };
return Ok(Some(outbound_payload));
}
let mut maybe_keyserver_id = None;
for (device_id, device_info) in devices {
let device_type = device_info
.to_hashmap("device_id")?
.get(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)?;
if device_type == "keyserver" {
maybe_keyserver_id = Some(device_id);
break;
}
}
// Assert that the user has a keyserver, if they don't return None
let keyserver_id = match maybe_keyserver_id {
None => return Ok(None),
Some(id) => id,
};
let keyserver = devices.get_map(keyserver_id)?;
let notif_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Notification)
.await?;
let content_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Content)
.await?;
debug!(
"Able to get notif one-time key for keyserver {}: {}",
keyserver_id,
notif_one_time_key.is_some()
);
debug!(
"Able to get content one-time key for keyserver {}: {}",
keyserver_id,
content_one_time_key.is_some()
);
let content_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME)?;
let content_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let notif_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME)?;
let notif_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let key_payload = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME)?
.to_string();
let key_payload_signature = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME)?
.to_string();
let social_proof = keyserver
.get(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.and_then(|s| {
s.to_string(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.ok()
})
.map(|s| s.to_owned());
let full_content_prekey = PreKey {
prekey: content_prekey.to_string(),
prekey_signature: content_prekey_signature.to_string(),
};
let full_notif_prekey = PreKey {
prekey: notif_prekey.to_string(),
prekey_signature: notif_prekey_signature.to_string(),
};
let outbound_payload = OutboundKeys {
key_payload,
key_payload_signature,
social_proof,
content_prekey: full_content_prekey,
notif_prekey: full_notif_prekey,
content_one_time_key,
notif_one_time_key,
};
Ok(Some(outbound_payload)) Ok(Some(outbound_payload))
} }
/// Will "mint" a single one-time key by attempting to successfully delete a /// Will "mint" a single one-time key by attempting to successfully delete a
/// key /// key
pub async fn get_one_time_key( pub async fn get_one_time_key(
&self, &self,
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines self
let capacity_units = response let capacity_units = response
.consumed_capacity() .consumed_capacity()
.and_then(|it| it.capacity_units()); .and_then(|it| it.capacity_units());
debug!("OTK read consumed capacity: {:?}", capacity_units); debug!("OTK read consumed capacity: {:?}", capacity_units);
response response
}) })
} }
pub async fn set_prekey( pub async fn set_prekey(
&self, &self,
user_id: String, user_id: String,
device_id: String, device_id: String,
content_prekey: String, content_prekey: String,
content_prekey_signature: String, content_prekey_signature: String,
notif_prekey: String, notif_prekey: String,
notif_prekey_signature: String, notif_prekey_signature: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// update new device list too
self self
.update_device_prekeys( .update_device_prekeys(
user_id.clone(), user_id,
device_id.clone(), device_id,
content_prekey.clone(), content_prekey,
content_prekey_signature.clone(), content_prekey_signature,
notif_prekey.clone(), notif_prekey,
notif_prekey_signature.clone(), notif_prekey_signature,
) )
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
.await?;
let notif_prekey_av = AttributeValue::S(notif_prekey);
let notif_prekey_signature_av = AttributeValue::S(notif_prekey_signature);
let content_prekey_av = AttributeValue::S(content_prekey);
let content_prekey_signature_av =
AttributeValue::S(content_prekey_signature);
let update_expression =
format!("SET {0}.#{1}.{2} = :n, {0}.#{1}.{3} = :p, {0}.#{1}.{4} = :c, {0}.#{1}.{5} = :d",
USERS_TABLE_DEVICES_ATTRIBUTE,
"deviceID",
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
);
let expression_attribute_names = HashMap::from([
(format!("#{}", "deviceID"), device_id),
(
"#user_id".to_string(),
USERS_TABLE_PARTITION_KEY.to_string(),
),
]);
let expression_attribute_values = HashMap::from([
(":n".to_string(), notif_prekey_av),
(":p".to_string(), notif_prekey_signature_av),
(":c".to_string(), content_prekey_av),
(":d".to_string(), content_prekey_signature_av),
]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.condition_expression("attribute_exists(#user_id)")
.set_expression_attribute_names(Some(expression_attribute_names))
.set_expression_attribute_values(Some(expression_attribute_values))
.send()
.await .await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn append_one_time_prekeys( pub async fn append_one_time_prekeys(
&self, &self,
device_id: String, device_id: String,
content_one_time_keys: Vec<String>, content_one_time_keys: Vec<String>,
notif_one_time_keys: Vec<String>, notif_one_time_keys: Vec<String>,
) -> Result<(), Error> { ) -> Result<(), Error> {
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines self
content_one_time_keys, content_one_time_keys,
notif_one_time_keys, notif_one_time_keys,
) )
.await?; .await?;
Ok(()) Ok(())
} }
pub async fn remove_device_from_users_table( pub async fn remove_device_from_users_table(
&self, &self,
user_id: String, user_id: String,
device_id_key: String, device_id_key: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// delete from new device list too self.remove_device(&user_id, &device_id_key).await
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
self.remove_device(&user_id, &device_id_key).await?;
let update_expression =
format!("REMOVE {}.{}", USERS_TABLE_DEVICES_ATTRIBUTE, "#deviceID");
let expression_attribute_names =
HashMap::from([("#deviceID".to_string(), device_id_key)]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.set_expression_attribute_names(Some(expression_attribute_names))
.send()
.await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn update_user_password( pub async fn update_user_password(
&self, &self,
user_id: String, user_id: String,
password_file: Vec<u8>, password_file: Vec<u8>,
) -> Result<(), Error> { ) -> Result<(), Error> {
let update_expression = let update_expression =
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Linesimpl DatabaseClient {
} }
async fn get_keys_for_user( async fn get_keys_for_user(
&self, &self,
mut user: AttributeMap, mut user: AttributeMap,
get_one_time_keys: bool, get_one_time_keys: bool,
) -> Result<Option<Devices>, Error> { ) -> Result<Option<Devices>, Error> {
let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?; let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?;
let devices: AttributeMap =
user.take_attr(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let mut devices_response = self.get_keys_for_user_devices(user_id).await?; let mut devices_response = self.get_keys_for_user_devices(user_id).await?;
for (device_id_key, device_info) in devices {
let device_info_map =
AttributeMap::try_from_attr(&device_id_key, Some(device_info))?;
let mut device_info_string_map = HashMap::new();
for (attribute_name, attribute_value) in device_info_map {
// Excluding one-time keys since we're moving them to a separate table
if attribute_name
== USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME
|| attribute_name
== USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME
{
continue;
}
// Excluding info already taken from device list response
if devices_response
.get(&device_id_key)
.map(|device| device.contains_key(&attribute_name))
.unwrap_or(false)
{
continue;
}
let attribute_value_str =
String::try_from_attr(&attribute_name, Some(attribute_value))?;
device_info_string_map.insert(attribute_name, attribute_value_str);
}
bartekAuthorUnsubmitted
Done
Inline Actions

Previously, we were merging legacy and new device list attribute by attribute, now we no longer need that.

bartek: Previously, we were merging legacy and new device list attribute by attribute, now we no longer…
if get_one_time_keys { if get_one_time_keys {
for (device_id_key, device_info_map) in devices_response.iter_mut() {
if let Some(notif_one_time_key) = self if let Some(notif_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Notification) .get_one_time_key(device_id_key, OlmAccountType::Notification)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key); .insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key);
} }
if let Some(content_one_time_key) = self if let Some(content_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Content) .get_one_time_key(device_id_key, OlmAccountType::Content)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key); .insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key);
} }
} }
devices_response.insert(device_id_key, device_info_string_map);
} }
Ok(Some(devices_response)) Ok(Some(devices_response))
} }
pub async fn get_user_id_from_user_info( pub async fn get_user_id_from_user_info(
&self, &self,
user_info: String, user_info: String,
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines
View Options

services/blob/docker-server/contents/server/src/DatabaseEntities/ReverseIndexItem.h

Show All 10 Linesuse comm_lib::database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError, AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
TryFromAttribute, TryFromAttribute,
}; };
use constant_time_eq::constant_time_eq; use constant_time_eq::constant_time_eq;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::str::FromStr; use std::str::FromStr;
use std::sync::Arc; use std::sync::Arc;
use crate::ddb_utils::{ use crate::{
constants::USERS_TABLE_DEVICES_ATTRIBUTE,
ddb_utils::{
create_one_time_key_partition_key, into_one_time_put_requests, Identifier, create_one_time_key_partition_key, into_one_time_put_requests, Identifier,
OlmAccountType, OlmAccountType,
},
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
},
reserved_users::UserDetail,
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
},
error::{consume_error, Error},
}; };
use crate::error::{consume_error, Error};
use crate::reserved_users::UserDetail;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use tracing::{debug, error, info, warn}; use tracing::{debug, error, info, warn};
use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo}; use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::{ use crate::constants::{
ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE, ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE,
ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE, ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE,
ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE, ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE,
ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE, ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE,
NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE, NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE,
NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY, NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY,
NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE, NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE,
RESERVED_USERNAMES_TABLE_PARTITION_KEY, RESERVED_USERNAMES_TABLE_PARTITION_KEY,
RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE, RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE,
USERS_TABLE_DEVICES_ATTRIBUTE,
USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME, USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE, USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE,
USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX, USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX,
USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX, USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX,
}; };
use crate::error::{AttributeValueFromHashMap, FromAttributeValue}; use crate::error::AttributeValueFromHashMap;
use crate::id::generate_uuid; use crate::id::generate_uuid;
use crate::nonce::NonceData; use crate::nonce::NonceData;
use crate::token::{AccessTokenData, AuthType}; use crate::token::{AccessTokenData, AuthType};
pub use grpc_clients::identity::DeviceType; pub use grpc_clients::identity::DeviceType;
mod device_list; mod device_list;
pub use device_list::DeviceListRow; pub use device_list::DeviceListRow;
▲ Show 20 Lines • Show All 306 Lines • ▼ Show 20 Lines pub async fn get_keyserver_keys_for_user(
&self, &self,
user_id: &str, user_id: &str,
) -> Result<Option<OutboundKeys>, Error> { ) -> Result<Option<OutboundKeys>, Error> {
use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType; use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType;
// DynamoDB doesn't have a way to "pop" a value from a list, so we must // DynamoDB doesn't have a way to "pop" a value from a list, so we must
// first read in user info, then update one_time_keys with value we // first read in user info, then update one_time_keys with value we
// gave to requester // gave to requester
let user_info = self let mut user_info = self
.get_item_from_users_table(user_id) .get_item_from_users_table(user_id)
.await? .await?
.item .item
.ok_or(Error::MissingItem)?; .ok_or(Error::MissingItem)?;
let user_id = user_info let user_id: String = user_info.take_attr(USERS_TABLE_PARTITION_KEY)?;
.get(USERS_TABLE_PARTITION_KEY)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_PARTITION_KEY)?;
let devices = user_info
.get(USERS_TABLE_DEVICES_ATTRIBUTE)
.ok_or(Error::MissingItem)?
.to_hashmap(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let user_devices = self.get_current_devices(user_id).await?; let user_devices = self.get_current_devices(user_id).await?;
let maybe_keyserver_device = user_devices let maybe_keyserver_device = user_devices
.into_iter() .into_iter()
.find(|device| device.device_type == GrpcDeviceType::Keyserver); .find(|device| device.device_type == GrpcDeviceType::Keyserver);
if let Some(keyserver) = maybe_keyserver_device { let Some(keyserver) = maybe_keyserver_device else {
return Ok(None);
};
debug!( debug!(
"Found keyserver in devices table (ID={})", "Found keyserver in devices table (ID={})",
&keyserver.device_id &keyserver.device_id
); );
let notif_one_time_key: Option<String> = self let notif_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Notification) .get_one_time_key(&keyserver.device_id, OlmAccountType::Notification)
.await?; .await?;
let content_one_time_key: Option<String> = self let content_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Content) .get_one_time_key(&keyserver.device_id, OlmAccountType::Content)
.await?; .await?;
debug!( debug!(
"Able to get notif one-time key for keyserver {}: {}", "Able to get notif one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
notif_one_time_key.is_some() notif_one_time_key.is_some()
); );
debug!( debug!(
"Able to get content one-time key for keyserver {}: {}", "Able to get content one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
content_one_time_key.is_some() content_one_time_key.is_some()
); );
let outbound_payload = OutboundKeys { let outbound_payload = OutboundKeys {
key_payload: keyserver.device_key_info.key_payload, key_payload: keyserver.device_key_info.key_payload,
key_payload_signature: keyserver.device_key_info.key_payload_signature, key_payload_signature: keyserver.device_key_info.key_payload_signature,
social_proof: keyserver.device_key_info.social_proof, social_proof: keyserver.device_key_info.social_proof,
content_prekey: PreKey { content_prekey: PreKey {
prekey: keyserver.content_prekey.pre_key, prekey: keyserver.content_prekey.pre_key,
prekey_signature: keyserver.content_prekey.pre_key_signature, prekey_signature: keyserver.content_prekey.pre_key_signature,
}, },
notif_prekey: PreKey { notif_prekey: PreKey {
prekey: keyserver.notif_prekey.pre_key, prekey: keyserver.notif_prekey.pre_key,
prekey_signature: keyserver.notif_prekey.pre_key_signature, prekey_signature: keyserver.notif_prekey.pre_key_signature,
}, },
content_one_time_key, content_one_time_key,
notif_one_time_key, notif_one_time_key,
}; };
return Ok(Some(outbound_payload));
}
let mut maybe_keyserver_id = None;
for (device_id, device_info) in devices {
let device_type = device_info
.to_hashmap("device_id")?
.get(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)?;
if device_type == "keyserver" {
maybe_keyserver_id = Some(device_id);
break;
}
}
// Assert that the user has a keyserver, if they don't return None
let keyserver_id = match maybe_keyserver_id {
None => return Ok(None),
Some(id) => id,
};
let keyserver = devices.get_map(keyserver_id)?;
let notif_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Notification)
.await?;
let content_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Content)
.await?;
debug!(
"Able to get notif one-time key for keyserver {}: {}",
keyserver_id,
notif_one_time_key.is_some()
);
debug!(
"Able to get content one-time key for keyserver {}: {}",
keyserver_id,
content_one_time_key.is_some()
);
let content_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME)?;
let content_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let notif_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME)?;
let notif_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let key_payload = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME)?
.to_string();
let key_payload_signature = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME)?
.to_string();
let social_proof = keyserver
.get(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.and_then(|s| {
s.to_string(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.ok()
})
.map(|s| s.to_owned());
let full_content_prekey = PreKey {
prekey: content_prekey.to_string(),
prekey_signature: content_prekey_signature.to_string(),
};
let full_notif_prekey = PreKey {
prekey: notif_prekey.to_string(),
prekey_signature: notif_prekey_signature.to_string(),
};
let outbound_payload = OutboundKeys {
key_payload,
key_payload_signature,
social_proof,
content_prekey: full_content_prekey,
notif_prekey: full_notif_prekey,
content_one_time_key,
notif_one_time_key,
};
Ok(Some(outbound_payload)) Ok(Some(outbound_payload))
} }
/// Will "mint" a single one-time key by attempting to successfully delete a /// Will "mint" a single one-time key by attempting to successfully delete a
/// key /// key
pub async fn get_one_time_key( pub async fn get_one_time_key(
&self, &self,
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines self
let capacity_units = response let capacity_units = response
.consumed_capacity() .consumed_capacity()
.and_then(|it| it.capacity_units()); .and_then(|it| it.capacity_units());
debug!("OTK read consumed capacity: {:?}", capacity_units); debug!("OTK read consumed capacity: {:?}", capacity_units);
response response
}) })
} }
pub async fn set_prekey( pub async fn set_prekey(
&self, &self,
user_id: String, user_id: String,
device_id: String, device_id: String,
content_prekey: String, content_prekey: String,
content_prekey_signature: String, content_prekey_signature: String,
notif_prekey: String, notif_prekey: String,
notif_prekey_signature: String, notif_prekey_signature: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// update new device list too
self self
.update_device_prekeys( .update_device_prekeys(
user_id.clone(), user_id,
device_id.clone(), device_id,
content_prekey.clone(), content_prekey,
content_prekey_signature.clone(), content_prekey_signature,
notif_prekey.clone(), notif_prekey,
notif_prekey_signature.clone(), notif_prekey_signature,
) )
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
.await?;
let notif_prekey_av = AttributeValue::S(notif_prekey);
let notif_prekey_signature_av = AttributeValue::S(notif_prekey_signature);
let content_prekey_av = AttributeValue::S(content_prekey);
let content_prekey_signature_av =
AttributeValue::S(content_prekey_signature);
let update_expression =
format!("SET {0}.#{1}.{2} = :n, {0}.#{1}.{3} = :p, {0}.#{1}.{4} = :c, {0}.#{1}.{5} = :d",
USERS_TABLE_DEVICES_ATTRIBUTE,
"deviceID",
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
);
let expression_attribute_names = HashMap::from([
(format!("#{}", "deviceID"), device_id),
(
"#user_id".to_string(),
USERS_TABLE_PARTITION_KEY.to_string(),
),
]);
let expression_attribute_values = HashMap::from([
(":n".to_string(), notif_prekey_av),
(":p".to_string(), notif_prekey_signature_av),
(":c".to_string(), content_prekey_av),
(":d".to_string(), content_prekey_signature_av),
]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.condition_expression("attribute_exists(#user_id)")
.set_expression_attribute_names(Some(expression_attribute_names))
.set_expression_attribute_values(Some(expression_attribute_values))
.send()
.await .await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn append_one_time_prekeys( pub async fn append_one_time_prekeys(
&self, &self,
device_id: String, device_id: String,
content_one_time_keys: Vec<String>, content_one_time_keys: Vec<String>,
notif_one_time_keys: Vec<String>, notif_one_time_keys: Vec<String>,
) -> Result<(), Error> { ) -> Result<(), Error> {
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines self
content_one_time_keys, content_one_time_keys,
notif_one_time_keys, notif_one_time_keys,
) )
.await?; .await?;
Ok(()) Ok(())
} }
pub async fn remove_device_from_users_table( pub async fn remove_device_from_users_table(
&self, &self,
user_id: String, user_id: String,
device_id_key: String, device_id_key: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// delete from new device list too self.remove_device(&user_id, &device_id_key).await
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
self.remove_device(&user_id, &device_id_key).await?;
let update_expression =
format!("REMOVE {}.{}", USERS_TABLE_DEVICES_ATTRIBUTE, "#deviceID");
let expression_attribute_names =
HashMap::from([("#deviceID".to_string(), device_id_key)]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.set_expression_attribute_names(Some(expression_attribute_names))
.send()
.await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn update_user_password( pub async fn update_user_password(
&self, &self,
user_id: String, user_id: String,
password_file: Vec<u8>, password_file: Vec<u8>,
) -> Result<(), Error> { ) -> Result<(), Error> {
let update_expression = let update_expression =
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Linesimpl DatabaseClient {
} }
async fn get_keys_for_user( async fn get_keys_for_user(
&self, &self,
mut user: AttributeMap, mut user: AttributeMap,
get_one_time_keys: bool, get_one_time_keys: bool,
) -> Result<Option<Devices>, Error> { ) -> Result<Option<Devices>, Error> {
let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?; let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?;
let devices: AttributeMap =
user.take_attr(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let mut devices_response = self.get_keys_for_user_devices(user_id).await?; let mut devices_response = self.get_keys_for_user_devices(user_id).await?;
for (device_id_key, device_info) in devices {
let device_info_map =
AttributeMap::try_from_attr(&device_id_key, Some(device_info))?;
let mut device_info_string_map = HashMap::new();
for (attribute_name, attribute_value) in device_info_map {
// Excluding one-time keys since we're moving them to a separate table
if attribute_name
== USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME
|| attribute_name
== USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME
{
continue;
}
// Excluding info already taken from device list response
if devices_response
.get(&device_id_key)
.map(|device| device.contains_key(&attribute_name))
.unwrap_or(false)
{
continue;
}
let attribute_value_str =
String::try_from_attr(&attribute_name, Some(attribute_value))?;
device_info_string_map.insert(attribute_name, attribute_value_str);
}
bartekAuthorUnsubmitted
Done
Inline Actions

Previously, we were merging legacy and new device list attribute by attribute, now we no longer need that.

bartek: Previously, we were merging legacy and new device list attribute by attribute, now we no longer…
if get_one_time_keys { if get_one_time_keys {
for (device_id_key, device_info_map) in devices_response.iter_mut() {
if let Some(notif_one_time_key) = self if let Some(notif_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Notification) .get_one_time_key(device_id_key, OlmAccountType::Notification)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key); .insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key);
} }
if let Some(content_one_time_key) = self if let Some(content_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Content) .get_one_time_key(device_id_key, OlmAccountType::Content)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key); .insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key);
} }
} }
devices_response.insert(device_id_key, device_info_string_map);
} }
Ok(Some(devices_response)) Ok(Some(devices_response))
} }
pub async fn get_user_id_from_user_info( pub async fn get_user_id_from_user_info(
&self, &self,
user_info: String, user_info: String,
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines