Page MenuHomePhabricator
Differential D10824

[web] introduce build info to users settings list
ClosedPublic
Actions

Authored by ginsu on Jan 25 2024, 1:33 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 18, 10:41 PM
Unknown Object (File)
Mon, Mar 17, 12:49 PM
Unknown Object (File)
Fri, Mar 14, 9:53 AM
Unknown Object (File)
Thu, Mar 13, 10:48 AM
Unknown Object (File)
Feb 16 2025, 6:05 PM
Unknown Object (File)
Feb 16 2025, 6:05 PM
Unknown Object (File)
Feb 16 2025, 6:05 PM
Unknown Object (File)
Feb 16 2025, 6:05 PM
View All 72 Files
Subscribers
ashoat
tomek

Details

Reviewers
atul
inka
Commits
rCOMM51034220c407: [web] introduce build info to users settings list
Summary

This diff introduces the build info setting to the user settings list + all the relevant logic needed to make this happen

Linear task: https://linear.app/comm/issue/ENG-834/build-info-page

Test Plan

Please see the screenshot below

Screenshot 2024-01-25 at 4.36.29 PM.png (1×3 px, 558 KB)

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

ginsu created this revision.Jan 25 2024, 1:33 PM
Herald added subscribers: tomek, ashoat. · View Herald TranscriptJan 25 2024, 1:33 PM
ginsu edited the summary of this revision. (Show Details)Jan 25 2024, 1:38 PM
ginsu edited the test plan for this revision. (Show Details)
ginsu attached a referenced file: F1088894: Screenshot 2024-01-25 at 4.36.29 PM.png. (Show Details)
ginsu added reviewers: atul, inka.
ginsu added a child revision: D10825: [native] consolidate staff context provider into one file.Jan 25 2024, 2:05 PM
Harbormaster completed remote builds in B26167: Diff 36144.Jan 25 2024, 2:14 PM
ginsu requested review of this revision.Jan 25 2024, 2:14 PM
atul accepted this revision.Jan 29 2024, 9:56 PM
This revision is now accepted and ready to land.Jan 29 2024, 9:56 PM
ginsu mentioned this in D10891: [web][lib] Move `WebNavInfo` type dependencies to `lib`.Jan 31 2024, 11:00 AM
ginsu updated this revision to Diff 36464.Jan 31 2024, 12:43 PM

fix merge conflicts + rebase

Harbormaster completed remote builds in B26374: Diff 36464.Jan 31 2024, 1:02 PM
Closed by commit rCOMM51034220c407: [web] introduce build info to users settings list (authored by ginsu). · Explain WhyJan 31 2024, 1:08 PM
This revision was automatically updated to reflect the committed changes.
ginsu added a commit: rCOMM51034220c407: [web] introduce build info to users settings list.

Revision Contents
Changeset List

PathSize
lib/
types/
2 lines
utils/
6 lines
web/
2 lines
settings/
13 lines

Diff 36469

View Options

lib/types/nav-types.js

use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::comm_service::{backup, blob, tunnelbroker}; use crate::comm_service::{backup, blob, tunnelbroker};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::staff::AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
use crate::database::{DeviceListUpdate, PlatformDetails}; use crate::database::{DeviceListUpdate, PlatformDetails};
use crate::device_list::validation::DeviceListValidator; use crate::device_list::validation::DeviceListValidator;
use crate::device_list::SignedDeviceList; use crate::device_list::SignedDeviceList;
use crate::error::consume_error; use crate::error::consume_error;
use crate::log::redact_sensitive_data; use crate::log::redact_sensitive_data;
use crate::{ use crate::{
client_service::{handle_db_error, WorkflowInProgress}, client_service::{handle_db_error, WorkflowInProgress},
constants::{error_types, request_metadata, staff, tonic_status_messages}, constants::{error_types, request_metadata, staff, tonic_status_messages},
Show All 19 Linesuse super::protos::auth::{
PrivilegedResetUserPasswordFinishRequest, PrivilegedResetUserPasswordFinishRequest,
PrivilegedResetUserPasswordStartRequest, PrivilegedResetUserPasswordStartRequest,
PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest, PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest,
UpdateDeviceListRequest, UpdateUserPasswordFinishRequest, UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse, UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest, UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest,
UserIdentitiesResponse, UserIdentitiesResponse,
}; };
use super::protos::unauth::Empty; use super::protos::unauth::{DeviceType, Empty};
#[derive(derive_more::Constructor)] #[derive(derive_more::Constructor)]
pub struct AuthenticatedService { pub struct AuthenticatedService {
db_client: DatabaseClient, db_client: DatabaseClient,
blob_client: BlobServiceClient, blob_client: BlobServiceClient,
comm_auth_service: AuthService, comm_auth_service: AuthService,
} }
▲ Show 20 Lines • Show All 424 Lines • ▼ Show 20 Lines ) -> Result<tonic::Response<Empty>, tonic::Status> {
self self
.verify_device_on_device_list( .verify_device_on_device_list(
&user_id, &user_id,
&device_id, &device_id,
DeviceListItemKind::Primary, DeviceListItemKind::Primary,
) )
.await?; .await?;
if user_id == AUTHORITATIVE_KEYSERVER_OWNER_USER_ID {
self.log_out_authoritative_keyserver_owner().await?;
return Ok(Response::new(Empty {}));
}
// Get and verify singleton device list // Get and verify singleton device list
let parsed_device_list: SignedDeviceList = let parsed_device_list: SignedDeviceList =
message.signed_device_list.parse()?; message.signed_device_list.parse()?;
let update_payload = DeviceListUpdate::try_from(parsed_device_list)?; let update_payload = DeviceListUpdate::try_from(parsed_device_list)?;
crate::device_list::verify_singleton_device_list( crate::device_list::verify_singleton_device_list(
&update_payload, &update_payload,
&device_id, &device_id,
▲ Show 20 Lines • Show All 704 Lines • ▼ Show 20 Lines let s2s_token =
errorType = error_types::HTTP_LOG, errorType = error_types::HTTP_LOG,
"Failed to retrieve service-to-service token: {err:?}", "Failed to retrieve service-to-service token: {err:?}",
); );
tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR) tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR)
})?; })?;
let blob_client = self.blob_client.with_authentication(s2s_token.into()); let blob_client = self.blob_client.with_authentication(s2s_token.into());
Ok(blob_client) Ok(blob_client)
} }
/// for authoritatative keyserver owner, instead of primary device logout,
/// we should remove all devices but keyserver, remove backup
/// and create an unsigned device list update, effectively downgrading
/// the user back to v1 flows
async fn log_out_authoritative_keyserver_owner(
&self,
) -> Result<(), tonic::Status> {
let user_id = AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
let devices = self.db_client.get_current_devices(user_id).await?;
let keyserver_device_id = devices
.iter()
.find(|it| matches!(it.device_type(), DeviceType::Keyserver))
.map(|keyserver| &keyserver.device_id);
let new_device_list = if let Some(keyserver_id) = keyserver_device_id {
vec![keyserver_id.to_string()]
} else {
Vec::new()
};
let device_list_update = DeviceListUpdate::new_unsigned(new_device_list)?;
let validator = None::<DeviceListValidator>;
self
.db_client
.apply_devicelist_update(user_id, device_list_update, validator, true)
.await?;
backup::delete_backup_user_data(user_id, &self.comm_auth_service).await?;
Ok(())
}
} }
#[derive( #[derive(
Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor, Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor,
)] )]
pub struct DeletePasswordUserInfo { pub struct DeletePasswordUserInfo {
pub opaque_server_login: comm_opaque2::server::Login, pub opaque_server_login: comm_opaque2::server::Login,
} }
Show All 14 Lines
View Options

lib/utils/url-utils.js

use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::comm_service::{backup, blob, tunnelbroker}; use crate::comm_service::{backup, blob, tunnelbroker};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::staff::AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
use crate::database::{DeviceListUpdate, PlatformDetails}; use crate::database::{DeviceListUpdate, PlatformDetails};
use crate::device_list::validation::DeviceListValidator; use crate::device_list::validation::DeviceListValidator;
use crate::device_list::SignedDeviceList; use crate::device_list::SignedDeviceList;
use crate::error::consume_error; use crate::error::consume_error;
use crate::log::redact_sensitive_data; use crate::log::redact_sensitive_data;
use crate::{ use crate::{
client_service::{handle_db_error, WorkflowInProgress}, client_service::{handle_db_error, WorkflowInProgress},
constants::{error_types, request_metadata, staff, tonic_status_messages}, constants::{error_types, request_metadata, staff, tonic_status_messages},
Show All 19 Linesuse super::protos::auth::{
PrivilegedResetUserPasswordFinishRequest, PrivilegedResetUserPasswordFinishRequest,
PrivilegedResetUserPasswordStartRequest, PrivilegedResetUserPasswordStartRequest,
PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest, PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest,
UpdateDeviceListRequest, UpdateUserPasswordFinishRequest, UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse, UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest, UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest,
UserIdentitiesResponse, UserIdentitiesResponse,
}; };
use super::protos::unauth::Empty; use super::protos::unauth::{DeviceType, Empty};
#[derive(derive_more::Constructor)] #[derive(derive_more::Constructor)]
pub struct AuthenticatedService { pub struct AuthenticatedService {
db_client: DatabaseClient, db_client: DatabaseClient,
blob_client: BlobServiceClient, blob_client: BlobServiceClient,
comm_auth_service: AuthService, comm_auth_service: AuthService,
} }
▲ Show 20 Lines • Show All 424 Lines • ▼ Show 20 Lines ) -> Result<tonic::Response<Empty>, tonic::Status> {
self self
.verify_device_on_device_list( .verify_device_on_device_list(
&user_id, &user_id,
&device_id, &device_id,
DeviceListItemKind::Primary, DeviceListItemKind::Primary,
) )
.await?; .await?;
if user_id == AUTHORITATIVE_KEYSERVER_OWNER_USER_ID {
self.log_out_authoritative_keyserver_owner().await?;
return Ok(Response::new(Empty {}));
}
// Get and verify singleton device list // Get and verify singleton device list
let parsed_device_list: SignedDeviceList = let parsed_device_list: SignedDeviceList =
message.signed_device_list.parse()?; message.signed_device_list.parse()?;
let update_payload = DeviceListUpdate::try_from(parsed_device_list)?; let update_payload = DeviceListUpdate::try_from(parsed_device_list)?;
crate::device_list::verify_singleton_device_list( crate::device_list::verify_singleton_device_list(
&update_payload, &update_payload,
&device_id, &device_id,
▲ Show 20 Lines • Show All 704 Lines • ▼ Show 20 Lines let s2s_token =
errorType = error_types::HTTP_LOG, errorType = error_types::HTTP_LOG,
"Failed to retrieve service-to-service token: {err:?}", "Failed to retrieve service-to-service token: {err:?}",
); );
tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR) tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR)
})?; })?;
let blob_client = self.blob_client.with_authentication(s2s_token.into()); let blob_client = self.blob_client.with_authentication(s2s_token.into());
Ok(blob_client) Ok(blob_client)
} }
/// for authoritatative keyserver owner, instead of primary device logout,
/// we should remove all devices but keyserver, remove backup
/// and create an unsigned device list update, effectively downgrading
/// the user back to v1 flows
async fn log_out_authoritative_keyserver_owner(
&self,
) -> Result<(), tonic::Status> {
let user_id = AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
let devices = self.db_client.get_current_devices(user_id).await?;
let keyserver_device_id = devices
.iter()
.find(|it| matches!(it.device_type(), DeviceType::Keyserver))
.map(|keyserver| &keyserver.device_id);
let new_device_list = if let Some(keyserver_id) = keyserver_device_id {
vec![keyserver_id.to_string()]
} else {
Vec::new()
};
let device_list_update = DeviceListUpdate::new_unsigned(new_device_list)?;
let validator = None::<DeviceListValidator>;
self
.db_client
.apply_devicelist_update(user_id, device_list_update, validator, true)
.await?;
backup::delete_backup_user_data(user_id, &self.comm_auth_service).await?;
Ok(())
}
} }
#[derive( #[derive(
Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor, Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor,
)] )]
pub struct DeletePasswordUserInfo { pub struct DeletePasswordUserInfo {
pub opaque_server_login: comm_opaque2::server::Login, pub opaque_server_login: comm_opaque2::server::Login,
} }
Show All 14 Lines
View Options

web/app.react.js

use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::comm_service::{backup, blob, tunnelbroker}; use crate::comm_service::{backup, blob, tunnelbroker};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::staff::AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
use crate::database::{DeviceListUpdate, PlatformDetails}; use crate::database::{DeviceListUpdate, PlatformDetails};
use crate::device_list::validation::DeviceListValidator; use crate::device_list::validation::DeviceListValidator;
use crate::device_list::SignedDeviceList; use crate::device_list::SignedDeviceList;
use crate::error::consume_error; use crate::error::consume_error;
use crate::log::redact_sensitive_data; use crate::log::redact_sensitive_data;
use crate::{ use crate::{
client_service::{handle_db_error, WorkflowInProgress}, client_service::{handle_db_error, WorkflowInProgress},
constants::{error_types, request_metadata, staff, tonic_status_messages}, constants::{error_types, request_metadata, staff, tonic_status_messages},
Show All 19 Linesuse super::protos::auth::{
PrivilegedResetUserPasswordFinishRequest, PrivilegedResetUserPasswordFinishRequest,
PrivilegedResetUserPasswordStartRequest, PrivilegedResetUserPasswordStartRequest,
PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest, PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest,
UpdateDeviceListRequest, UpdateUserPasswordFinishRequest, UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse, UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest, UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest,
UserIdentitiesResponse, UserIdentitiesResponse,
}; };
use super::protos::unauth::Empty; use super::protos::unauth::{DeviceType, Empty};
#[derive(derive_more::Constructor)] #[derive(derive_more::Constructor)]
pub struct AuthenticatedService { pub struct AuthenticatedService {
db_client: DatabaseClient, db_client: DatabaseClient,
blob_client: BlobServiceClient, blob_client: BlobServiceClient,
comm_auth_service: AuthService, comm_auth_service: AuthService,
} }
▲ Show 20 Lines • Show All 424 Lines • ▼ Show 20 Lines ) -> Result<tonic::Response<Empty>, tonic::Status> {
self self
.verify_device_on_device_list( .verify_device_on_device_list(
&user_id, &user_id,
&device_id, &device_id,
DeviceListItemKind::Primary, DeviceListItemKind::Primary,
) )
.await?; .await?;
if user_id == AUTHORITATIVE_KEYSERVER_OWNER_USER_ID {
self.log_out_authoritative_keyserver_owner().await?;
return Ok(Response::new(Empty {}));
}
// Get and verify singleton device list // Get and verify singleton device list
let parsed_device_list: SignedDeviceList = let parsed_device_list: SignedDeviceList =
message.signed_device_list.parse()?; message.signed_device_list.parse()?;
let update_payload = DeviceListUpdate::try_from(parsed_device_list)?; let update_payload = DeviceListUpdate::try_from(parsed_device_list)?;
crate::device_list::verify_singleton_device_list( crate::device_list::verify_singleton_device_list(
&update_payload, &update_payload,
&device_id, &device_id,
▲ Show 20 Lines • Show All 704 Lines • ▼ Show 20 Lines let s2s_token =
errorType = error_types::HTTP_LOG, errorType = error_types::HTTP_LOG,
"Failed to retrieve service-to-service token: {err:?}", "Failed to retrieve service-to-service token: {err:?}",
); );
tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR) tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR)
})?; })?;
let blob_client = self.blob_client.with_authentication(s2s_token.into()); let blob_client = self.blob_client.with_authentication(s2s_token.into());
Ok(blob_client) Ok(blob_client)
} }
/// for authoritatative keyserver owner, instead of primary device logout,
/// we should remove all devices but keyserver, remove backup
/// and create an unsigned device list update, effectively downgrading
/// the user back to v1 flows
async fn log_out_authoritative_keyserver_owner(
&self,
) -> Result<(), tonic::Status> {
let user_id = AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
let devices = self.db_client.get_current_devices(user_id).await?;
let keyserver_device_id = devices
.iter()
.find(|it| matches!(it.device_type(), DeviceType::Keyserver))
.map(|keyserver| &keyserver.device_id);
let new_device_list = if let Some(keyserver_id) = keyserver_device_id {
vec![keyserver_id.to_string()]
} else {
Vec::new()
};
let device_list_update = DeviceListUpdate::new_unsigned(new_device_list)?;
let validator = None::<DeviceListValidator>;
self
.db_client
.apply_devicelist_update(user_id, device_list_update, validator, true)
.await?;
backup::delete_backup_user_data(user_id, &self.comm_auth_service).await?;
Ok(())
}
} }
#[derive( #[derive(
Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor, Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor,
)] )]
pub struct DeletePasswordUserInfo { pub struct DeletePasswordUserInfo {
pub opaque_server_login: comm_opaque2::server::Login, pub opaque_server_login: comm_opaque2::server::Login,
} }
Show All 14 Lines
View Options

web/settings/user-settings-list.react.js

use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::comm_service::{backup, blob, tunnelbroker}; use crate::comm_service::{backup, blob, tunnelbroker};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::staff::AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
use crate::database::{DeviceListUpdate, PlatformDetails}; use crate::database::{DeviceListUpdate, PlatformDetails};
use crate::device_list::validation::DeviceListValidator; use crate::device_list::validation::DeviceListValidator;
use crate::device_list::SignedDeviceList; use crate::device_list::SignedDeviceList;
use crate::error::consume_error; use crate::error::consume_error;
use crate::log::redact_sensitive_data; use crate::log::redact_sensitive_data;
use crate::{ use crate::{
client_service::{handle_db_error, WorkflowInProgress}, client_service::{handle_db_error, WorkflowInProgress},
constants::{error_types, request_metadata, staff, tonic_status_messages}, constants::{error_types, request_metadata, staff, tonic_status_messages},
Show All 19 Linesuse super::protos::auth::{
PrivilegedResetUserPasswordFinishRequest, PrivilegedResetUserPasswordFinishRequest,
PrivilegedResetUserPasswordStartRequest, PrivilegedResetUserPasswordStartRequest,
PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest, PrivilegedResetUserPasswordStartResponse, RefreshUserPrekeysRequest,
UpdateDeviceListRequest, UpdateUserPasswordFinishRequest, UpdateDeviceListRequest, UpdateUserPasswordFinishRequest,
UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse, UpdateUserPasswordStartRequest, UpdateUserPasswordStartResponse,
UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest, UploadOneTimeKeysRequest, UserDevicesPlatformDetails, UserIdentitiesRequest,
UserIdentitiesResponse, UserIdentitiesResponse,
}; };
use super::protos::unauth::Empty; use super::protos::unauth::{DeviceType, Empty};
#[derive(derive_more::Constructor)] #[derive(derive_more::Constructor)]
pub struct AuthenticatedService { pub struct AuthenticatedService {
db_client: DatabaseClient, db_client: DatabaseClient,
blob_client: BlobServiceClient, blob_client: BlobServiceClient,
comm_auth_service: AuthService, comm_auth_service: AuthService,
} }
▲ Show 20 Lines • Show All 424 Lines • ▼ Show 20 Lines ) -> Result<tonic::Response<Empty>, tonic::Status> {
self self
.verify_device_on_device_list( .verify_device_on_device_list(
&user_id, &user_id,
&device_id, &device_id,
DeviceListItemKind::Primary, DeviceListItemKind::Primary,
) )
.await?; .await?;
if user_id == AUTHORITATIVE_KEYSERVER_OWNER_USER_ID {
self.log_out_authoritative_keyserver_owner().await?;
return Ok(Response::new(Empty {}));
}
// Get and verify singleton device list // Get and verify singleton device list
let parsed_device_list: SignedDeviceList = let parsed_device_list: SignedDeviceList =
message.signed_device_list.parse()?; message.signed_device_list.parse()?;
let update_payload = DeviceListUpdate::try_from(parsed_device_list)?; let update_payload = DeviceListUpdate::try_from(parsed_device_list)?;
crate::device_list::verify_singleton_device_list( crate::device_list::verify_singleton_device_list(
&update_payload, &update_payload,
&device_id, &device_id,
▲ Show 20 Lines • Show All 704 Lines • ▼ Show 20 Lines let s2s_token =
errorType = error_types::HTTP_LOG, errorType = error_types::HTTP_LOG,
"Failed to retrieve service-to-service token: {err:?}", "Failed to retrieve service-to-service token: {err:?}",
); );
tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR) tonic::Status::aborted(tonic_status_messages::UNEXPECTED_ERROR)
})?; })?;
let blob_client = self.blob_client.with_authentication(s2s_token.into()); let blob_client = self.blob_client.with_authentication(s2s_token.into());
Ok(blob_client) Ok(blob_client)
} }
/// for authoritatative keyserver owner, instead of primary device logout,
/// we should remove all devices but keyserver, remove backup
/// and create an unsigned device list update, effectively downgrading
/// the user back to v1 flows
async fn log_out_authoritative_keyserver_owner(
&self,
) -> Result<(), tonic::Status> {
let user_id = AUTHORITATIVE_KEYSERVER_OWNER_USER_ID;
let devices = self.db_client.get_current_devices(user_id).await?;
let keyserver_device_id = devices
.iter()
.find(|it| matches!(it.device_type(), DeviceType::Keyserver))
.map(|keyserver| &keyserver.device_id);
let new_device_list = if let Some(keyserver_id) = keyserver_device_id {
vec![keyserver_id.to_string()]
} else {
Vec::new()
};
let device_list_update = DeviceListUpdate::new_unsigned(new_device_list)?;
let validator = None::<DeviceListValidator>;
self
.db_client
.apply_devicelist_update(user_id, device_list_update, validator, true)
.await?;
backup::delete_backup_user_data(user_id, &self.comm_auth_service).await?;
Ok(())
}
} }
#[derive( #[derive(
Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor, Clone, serde::Serialize, serde::Deserialize, derive_more::Constructor,
)] )]
pub struct DeletePasswordUserInfo { pub struct DeletePasswordUserInfo {
pub opaque_server_login: comm_opaque2::server::Login, pub opaque_server_login: comm_opaque2::server::Login,
} }
Show All 14 Lines