Files
continuwuity/src/service/key_backups/mod.rs
T

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

317 lines
7.0 KiB
Rust
Raw Normal View History

2024-05-09 15:59:08 -07:00
use std::{collections::BTreeMap, sync::Arc};
2021-06-08 18:10:00 +02:00
2024-08-08 17:18:30 +00:00
use futures::StreamExt;
2020-06-16 12:11:38 +02:00
use ruma::{
OwnedRoomId, RoomId, UserId,
2022-10-08 13:03:07 +02:00
api::client::backup::{BackupAlgorithm, KeyBackupData, RoomKeyBackup},
2021-12-22 19:41:33 +01:00
serde::Raw,
2024-03-05 19:48:54 -05:00
};
2025-04-22 01:41:02 +00:00
use tuwunel_core::{
Err, Result, err, implement,
utils::stream::{ReadyExt, TryIgnore},
};
use tuwunel_database::{Deserialized, Ignore, Interfix, Json, Map};
2024-03-05 19:48:54 -05:00
2024-05-09 15:59:08 -07:00
pub struct Service {
2024-06-28 22:51:39 +00:00
db: Data,
2025-08-22 20:15:54 +05:00
services: Arc<crate::services::OnceServices>,
2024-08-08 17:18:30 +00:00
}
struct Data {
backupid_algorithm: Arc<Map>,
backupid_etag: Arc<Map>,
backupkeyid_backup: Arc<Map>,
}
2024-07-04 03:26:19 +00:00
impl crate::Service for Service {
2025-09-17 14:21:55 +05:00
fn build(args: &crate::Args<'_>) -> Result<Arc<Self>> {
2024-07-04 03:26:19 +00:00
Ok(Arc::new(Self {
2024-08-08 17:18:30 +00:00
db: Data {
backupid_algorithm: args.db["backupid_algorithm"].clone(),
backupid_etag: args.db["backupid_etag"].clone(),
backupkeyid_backup: args.db["backupkeyid_backup"].clone(),
},
2025-08-22 20:15:54 +05:00
services: args.services.clone(),
2024-07-04 03:26:19 +00:00
}))
2024-05-27 03:17:20 +00:00
}
2024-07-04 03:26:19 +00:00
fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
}
2024-08-08 17:18:30 +00:00
#[implement(Service)]
pub fn create_backup(
&self,
user_id: &UserId,
backup_metadata: &Raw<BackupAlgorithm>,
) -> Result<String> {
let version = self.services.globals.next_count();
let count = self.services.globals.next_count();
2020-06-16 12:11:38 +02:00
let version_string = version.to_string();
let key = (user_id, &version_string);
2025-04-22 04:42:26 +00:00
self.db
.backupid_algorithm
.put(key, Json(backup_metadata));
self.db.backupid_etag.put(key, *count);
2021-08-31 19:14:37 +02:00
Ok(version_string)
2024-08-08 17:18:30 +00:00
}
#[implement(Service)]
pub async fn delete_backup(&self, user_id: &UserId, version: &str) {
2024-10-07 17:54:27 +00:00
let key = (user_id, version);
self.db.backupid_algorithm.del(key);
self.db.backupid_etag.del(key);
2024-08-08 17:18:30 +00:00
let key = (user_id, version, Interfix);
self.db
.backupkeyid_backup
.keys_prefix_raw(&key)
2024-08-08 17:18:30 +00:00
.ignore_err()
.ready_for_each(|outdated_key| {
self.db.backupkeyid_backup.remove(outdated_key);
})
2024-08-08 17:18:30 +00:00
.await;
}
#[implement(Service)]
2024-10-07 17:54:27 +00:00
pub async fn update_backup<'a>(
&self,
user_id: &UserId,
version: &'a str,
backup_metadata: &Raw<BackupAlgorithm>,
2024-10-07 17:54:27 +00:00
) -> Result<&'a str> {
2024-08-08 17:18:30 +00:00
let key = (user_id, version);
2025-04-22 04:42:26 +00:00
if self
.db
.backupid_algorithm
.qry(&key)
.await
.is_err()
{
2024-08-08 17:18:30 +00:00
return Err!(Request(NotFound("Tried to update nonexistent backup.")));
2020-06-16 12:11:38 +02:00
}
2024-08-08 17:18:30 +00:00
let count = self.services.globals.next_count();
self.db.backupid_etag.put(key, *count);
2024-08-08 17:18:30 +00:00
self.db
.backupid_algorithm
2024-10-07 17:54:27 +00:00
.put_raw(key, backup_metadata.json().get());
2024-08-08 17:18:30 +00:00
2024-10-07 17:54:27 +00:00
Ok(version)
2024-08-08 17:18:30 +00:00
}
#[implement(Service)]
pub async fn get_latest_backup_version(&self, user_id: &UserId) -> Result<String> {
type Key<'a> = (&'a UserId, &'a str);
2020-06-16 12:11:38 +02:00
2025-08-28 12:53:41 +00:00
let key = (user_id, Interfix);
let mut versions: Vec<_> = self
.db
2024-08-08 17:18:30 +00:00
.backupid_algorithm
2025-08-28 12:53:41 +00:00
.keys_from(&key)
2024-08-08 17:18:30 +00:00
.ignore_err()
.ready_take_while(|(user_id_, _): &Key<'_>| *user_id_ == user_id)
2025-08-28 12:53:41 +00:00
.ready_filter_map(|(_, version): Key<'_>| version.parse::<u64>().ok())
.collect()
.await;
versions.sort_unstable();
let Some(latest) = versions.last() else {
return Err!(Request(NotFound("No backup versions found")));
};
Ok(latest.to_string())
2024-08-08 17:18:30 +00:00
}
#[implement(Service)]
pub async fn get_latest_backup(
&self,
user_id: &UserId,
) -> Result<(String, Raw<BackupAlgorithm>)> {
2025-08-28 12:53:41 +00:00
let version = self.get_latest_backup_version(user_id).await?;
2024-08-08 17:18:30 +00:00
2025-08-28 12:53:41 +00:00
let key = (user_id, version.as_str());
2024-08-08 17:18:30 +00:00
self.db
.backupid_algorithm
2025-08-28 12:53:41 +00:00
.qry(&key)
2024-08-08 17:18:30 +00:00
.await
2025-08-28 12:53:41 +00:00
.deserialized()
.map(|algorithm| (version, algorithm))
.map_err(|e| err!(Request(NotFound("No backup found: {e}"))))
2024-08-08 17:18:30 +00:00
}
#[implement(Service)]
pub async fn get_backup(&self, user_id: &UserId, version: &str) -> Result<Raw<BackupAlgorithm>> {
let key = (user_id, version);
2025-04-22 04:42:26 +00:00
self.db
.backupid_algorithm
.qry(&key)
.await
.deserialized()
2024-08-08 17:18:30 +00:00
}
#[implement(Service)]
pub async fn add_key(
&self,
user_id: &UserId,
version: &str,
room_id: &RoomId,
session_id: &str,
key_data: &Raw<KeyBackupData>,
2025-07-08 12:08:13 +00:00
) -> Result {
2024-08-08 17:18:30 +00:00
let key = (user_id, version);
2025-04-22 04:42:26 +00:00
if self
.db
.backupid_algorithm
.qry(&key)
.await
.is_err()
{
2024-08-08 17:18:30 +00:00
return Err!(Request(NotFound("Tried to update nonexistent backup.")));
2020-06-16 12:11:38 +02:00
}
2024-08-08 17:18:30 +00:00
let count = self.services.globals.next_count();
self.db.backupid_etag.put(key, *count);
2024-08-08 17:18:30 +00:00
2024-10-07 17:54:27 +00:00
let key = (user_id, version, room_id, session_id);
2024-08-08 17:18:30 +00:00
self.db
.backupkeyid_backup
2024-10-07 17:54:27 +00:00
.put_raw(key, key_data.json().get());
2024-08-08 17:18:30 +00:00
Ok(())
}
#[implement(Service)]
pub async fn count_keys(&self, user_id: &UserId, version: &str) -> usize {
let prefix = (user_id, version);
self.db
.backupkeyid_backup
.keys_prefix_raw(&prefix)
2024-08-08 17:18:30 +00:00
.count()
.await
}
#[implement(Service)]
pub async fn get_etag(&self, user_id: &UserId, version: &str) -> String {
let key = (user_id, version);
self.db
.backupid_etag
.qry(&key)
.await
.deserialized::<u64>()
.as_ref()
.map(ToString::to_string)
.expect("Backup has no etag.")
}
#[implement(Service)]
pub async fn get_all(
&self,
user_id: &UserId,
version: &str,
) -> BTreeMap<OwnedRoomId, RoomKeyBackup> {
type Key<'a> = (Ignore, Ignore, &'a RoomId, &'a str);
type KeyVal<'a> = (Key<'a>, Raw<KeyBackupData>);
2024-08-08 17:18:30 +00:00
let mut rooms = BTreeMap::<OwnedRoomId, RoomKeyBackup>::new();
let default = || RoomKeyBackup { sessions: BTreeMap::new() };
2024-08-08 17:18:30 +00:00
let prefix = (user_id, version, Interfix);
self.db
.backupkeyid_backup
.stream_prefix(&prefix)
.ignore_err()
.ready_for_each(|((_, _, room_id, session_id), key_backup_data): KeyVal<'_>| {
2024-08-08 17:18:30 +00:00
rooms
.entry(room_id.into())
.or_insert_with(default)
.sessions
.insert(session_id.into(), key_backup_data);
2024-08-08 17:18:30 +00:00
})
.await;
2020-06-16 12:11:38 +02:00
2024-08-08 17:18:30 +00:00
rooms
}
2020-06-16 12:11:38 +02:00
2024-08-08 17:18:30 +00:00
#[implement(Service)]
pub async fn get_room(
&self,
user_id: &UserId,
version: &str,
room_id: &RoomId,
2024-08-08 17:18:30 +00:00
) -> BTreeMap<String, Raw<KeyBackupData>> {
type KeyVal<'a> = ((Ignore, Ignore, Ignore, &'a str), Raw<KeyBackupData>);
2020-06-16 12:11:38 +02:00
2024-08-08 17:18:30 +00:00
let prefix = (user_id, version, room_id, Interfix);
self.db
.backupkeyid_backup
.stream_prefix(&prefix)
.ignore_err()
.map(|((.., session_id), key_backup_data): KeyVal<'_>| {
(session_id.to_owned(), key_backup_data)
})
2024-08-08 17:18:30 +00:00
.collect()
.await
}
2024-08-08 17:18:30 +00:00
#[implement(Service)]
pub async fn get_session(
&self,
user_id: &UserId,
version: &str,
room_id: &RoomId,
session_id: &str,
2024-08-08 17:18:30 +00:00
) -> Result<Raw<KeyBackupData>> {
let key = (user_id, version, room_id, session_id);
2025-04-22 04:42:26 +00:00
self.db
.backupkeyid_backup
.qry(&key)
.await
.deserialized()
2024-08-08 17:18:30 +00:00
}
2024-08-08 17:18:30 +00:00
#[implement(Service)]
pub async fn delete_all_keys(&self, user_id: &UserId, version: &str) {
let key = (user_id, version, Interfix);
self.db
.backupkeyid_backup
.keys_prefix_raw(&key)
2024-08-08 17:18:30 +00:00
.ignore_err()
.ready_for_each(|outdated_key| self.db.backupkeyid_backup.remove(outdated_key))
.await;
}
2024-08-08 17:18:30 +00:00
#[implement(Service)]
pub async fn delete_room_keys(&self, user_id: &UserId, version: &str, room_id: &RoomId) {
let key = (user_id, version, room_id, Interfix);
self.db
.backupkeyid_backup
.keys_prefix_raw(&key)
2024-08-08 17:18:30 +00:00
.ignore_err()
.ready_for_each(|outdated_key| {
self.db.backupkeyid_backup.remove(outdated_key);
})
2024-08-08 17:18:30 +00:00
.await;
}
2024-08-08 17:18:30 +00:00
#[implement(Service)]
pub async fn delete_room_key(
&self,
user_id: &UserId,
version: &str,
room_id: &RoomId,
session_id: &str,
) {
2024-08-08 17:18:30 +00:00
let key = (user_id, version, room_id, session_id);
self.db
.backupkeyid_backup
.keys_prefix_raw(&key)
2024-08-08 17:18:30 +00:00
.ignore_err()
.ready_for_each(|outdated_key| {
self.db.backupkeyid_backup.remove(outdated_key);
})
2024-08-08 17:18:30 +00:00
.await;
2020-06-16 12:11:38 +02:00
}