studio/tuwunel
2
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Refactor sliding window selector. (fixes #170)

Browse Source 
Refactor list filtering.

Signed-off-by: Jason Volk <jason@zemos.net>
This commit is contained in:
Jason Volk
2025-10-07 21:35:42 +00:00
parent ab8536d5c3
commit 46c940b863
16 changed files with 818 additions and 684 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
src/service/sync/mod.rs
View File

@@ -1,18 +1,19 @@
mod watch;
use std::{
collections::{BTreeMap, BTreeSet},
sync::{Arc, Mutex, Mutex as StdMutex},
collections::BTreeMap,
sync::{Arc, Mutex as StdMutex},
};
use ruma::{
DeviceId, OwnedDeviceId, OwnedRoomId, OwnedUserId, UserId,
api::client::sync::sync_events::v5::{
Request, request,
ConnId as ConnectionId, ListId, Request, request,
request::{AccountData, E2EE, Receipts, ToDevice, Typing},
},
};
use tuwunel_core::{Result, err, implement, is_equal_to, smallstr::SmallString};
use tokio::sync::Mutex as TokioMutex;
use tuwunel_core::{Result, err, implement, is_equal_to};
use tuwunel_database::Map;
pub struct Service {
@@ -38,23 +39,27 @@ pub struct Data {
}
#[derive(Debug, Default)]
pub struct Cache {
lists: Lists,
known_rooms: KnownRooms,
subscriptions: Subscriptions,
extensions: request::Extensions,
pub struct Connection {
pub lists: Lists,
pub rooms: Rooms,
pub subscriptions: Subscriptions,
pub extensions: request::Extensions,
pub globalsince: u64,
pub next_batch: u64,
}
type Connections = Mutex<BTreeMap<ConnectionKey, Connection>>;
type Connection = Arc<Mutex<Cache>>;
pub type ConnectionKey = (OwnedUserId, OwnedDeviceId, Option<ConnectionId>);
pub type ConnectionId = SmallString<[u8; 16]>;
#[derive(Clone, Debug, Default)]
pub struct Room {
pub roomsince: u64,
}
pub type Subscriptions = BTreeMap<OwnedRoomId, request::RoomSubscription>;
type Connections = StdMutex<BTreeMap<ConnectionKey, ConnectionVal>>;
pub type ConnectionVal = Arc<TokioMutex<Connection>>;
pub type ConnectionKey = (OwnedUserId, OwnedDeviceId, Option<ConnectionId>);
pub type Subscriptions = BTreeMap<OwnedRoomId, request::ListConfig>;
pub type Lists = BTreeMap<ListId, request::List>;
pub type KnownRooms = BTreeMap<ListId, ListRooms>;
pub type ListRooms = BTreeMap<OwnedRoomId, u64>;
pub type ListId = SmallString<[u8; 16]>;
pub type Rooms = BTreeMap<OwnedRoomId, Room>;
impl crate::Service for Service {
fn build(args: &crate::Args<'_>) -> Result<Arc<Self>> {
@@ -75,31 +80,26 @@ impl crate::Service for Service {
userid_lastonetimekeyupdate: args.db["userid_lastonetimekeyupdate"].clone(),
},
services: args.services.clone(),
connections: StdMutex::new(BTreeMap::new()),
connections: Default::default(),
}))
}
fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
}
#[implement(Service)]
pub fn update_cache(&self, key: &ConnectionKey, request: &mut Request) -> KnownRooms {
let cache = self.get_connection(key);
let mut cached = cache.lock().expect("locked");
Self::update_cache_lists(request, &mut cached);
Self::update_cache_subscriptions(request, &mut cached);
Self::update_cache_extensions(request, &mut cached);
cached.known_rooms.clone()
#[implement(Connection)]
pub fn update_cache(&mut self, request: &Request) {
Self::update_cache_lists(request, self);
Self::update_cache_subscriptions(request, self);
Self::update_cache_extensions(request, self);
}
#[implement(Service)]
fn update_cache_lists(request: &mut Request, cached: &mut Cache) {
for (list_id, request_list) in &mut request.lists {
#[implement(Connection)]
fn update_cache_lists(request: &Request, cached: &mut Self) {
for (list_id, request_list) in &request.lists {
cached
.lists
.entry(list_id.as_str().into())
.entry(list_id.clone())
.and_modify(|cached_list| {
Self::update_cache_list(request_list, cached_list);
})
@@ -107,134 +107,88 @@ fn update_cache_lists(request: &mut Request, cached: &mut Cache) {
}
}
#[implement(Service)]
fn update_cache_list(request: &mut request::List, cached: &mut request::List) {
list_or_sticky(
&mut request.room_details.required_state,
&mut cached.room_details.required_state,
);
#[implement(Connection)]
fn update_cache_list(request: &request::List, cached: &mut request::List) {
list_or_sticky(&request.room_details.required_state, &mut cached.room_details.required_state);
match (&mut request.filters, &mut cached.filters) {
match (&request.filters, &mut cached.filters) {
| (None, None) => {},
| (None, Some(cached)) => request.filters = Some(cached.clone()),
| (None, Some(_cached)) => {},
| (Some(request), None) => cached.filters = Some(request.clone()),
| (Some(request), Some(cached)) => {
some_or_sticky(&mut request.is_dm, &mut cached.is_dm);
some_or_sticky(&mut request.is_encrypted, &mut cached.is_encrypted);
some_or_sticky(&mut request.is_invite, &mut cached.is_invite);
list_or_sticky(&mut request.room_types, &mut cached.room_types);
list_or_sticky(&mut request.not_room_types, &mut cached.not_room_types);
list_or_sticky(&mut request.tags, &mut cached.not_tags);
list_or_sticky(&mut request.spaces, &mut cached.spaces);
some_or_sticky(request.is_dm.as_ref(), &mut cached.is_dm);
some_or_sticky(request.is_encrypted.as_ref(), &mut cached.is_encrypted);
some_or_sticky(request.is_invite.as_ref(), &mut cached.is_invite);
list_or_sticky(&request.room_types, &mut cached.room_types);
list_or_sticky(&request.not_room_types, &mut cached.not_room_types);
list_or_sticky(&request.tags, &mut cached.not_tags);
list_or_sticky(&request.spaces, &mut cached.spaces);
},
}
}
#[implement(Service)]
fn update_cache_subscriptions(request: &mut Request, cached: &mut Cache) {
#[implement(Connection)]
fn update_cache_subscriptions(request: &Request, cached: &mut Self) {
cached
.subscriptions
.extend(request.room_subscriptions.clone());
request
.room_subscriptions
.extend(cached.subscriptions.clone());
}
#[implement(Service)]
fn update_cache_extensions(request: &mut Request, cached: &mut Cache) {
let request = &mut request.extensions;
#[implement(Connection)]
fn update_cache_extensions(request: &Request, cached: &mut Self) {
let request = &request.extensions;
let cached = &mut cached.extensions;
Self::update_cache_account_data(&mut request.account_data, &mut cached.account_data);
Self::update_cache_receipts(&mut request.receipts, &mut cached.receipts);
Self::update_cache_typing(&mut request.typing, &mut cached.typing);
Self::update_cache_to_device(&mut request.to_device, &mut cached.to_device);
Self::update_cache_e2ee(&mut request.e2ee, &mut cached.e2ee);
Self::update_cache_account_data(&request.account_data, &mut cached.account_data);
Self::update_cache_receipts(&request.receipts, &mut cached.receipts);
Self::update_cache_typing(&request.typing, &mut cached.typing);
Self::update_cache_to_device(&request.to_device, &mut cached.to_device);
Self::update_cache_e2ee(&request.e2ee, &mut cached.e2ee);
}
#[implement(Service)]
fn update_cache_account_data(request: &mut AccountData, cached: &mut AccountData) {
some_or_sticky(&mut request.enabled, &mut cached.enabled);
some_or_sticky(&mut request.lists, &mut cached.lists);
some_or_sticky(&mut request.rooms, &mut cached.rooms);
#[implement(Connection)]
fn update_cache_account_data(request: &AccountData, cached: &mut AccountData) {
some_or_sticky(request.enabled.as_ref(), &mut cached.enabled);
some_or_sticky(request.lists.as_ref(), &mut cached.lists);
some_or_sticky(request.rooms.as_ref(), &mut cached.rooms);
}
#[implement(Service)]
fn update_cache_receipts(request: &mut Receipts, cached: &mut Receipts) {
some_or_sticky(&mut request.enabled, &mut cached.enabled);
some_or_sticky(&mut request.rooms, &mut cached.rooms);
some_or_sticky(&mut request.lists, &mut cached.lists);
#[implement(Connection)]
fn update_cache_receipts(request: &Receipts, cached: &mut Receipts) {
some_or_sticky(request.enabled.as_ref(), &mut cached.enabled);
some_or_sticky(request.rooms.as_ref(), &mut cached.rooms);
some_or_sticky(request.lists.as_ref(), &mut cached.lists);
}
#[implement(Service)]
fn update_cache_typing(request: &mut Typing, cached: &mut Typing) {
some_or_sticky(&mut request.enabled, &mut cached.enabled);
some_or_sticky(&mut request.rooms, &mut cached.rooms);
some_or_sticky(&mut request.lists, &mut cached.lists);
#[implement(Connection)]
fn update_cache_typing(request: &Typing, cached: &mut Typing) {
some_or_sticky(request.enabled.as_ref(), &mut cached.enabled);
some_or_sticky(request.rooms.as_ref(), &mut cached.rooms);
some_or_sticky(request.lists.as_ref(), &mut cached.lists);
}
#[implement(Service)]
fn update_cache_to_device(request: &mut ToDevice, cached: &mut ToDevice) {
some_or_sticky(&mut request.enabled, &mut cached.enabled);
#[implement(Connection)]
fn update_cache_to_device(request: &ToDevice, cached: &mut ToDevice) {
some_or_sticky(request.enabled.as_ref(), &mut cached.enabled);
}
#[implement(Service)]
fn update_cache_e2ee(request: &mut E2EE, cached: &mut E2EE) {
some_or_sticky(&mut request.enabled, &mut cached.enabled);
#[implement(Connection)]
fn update_cache_e2ee(request: &E2EE, cached: &mut E2EE) {
some_or_sticky(request.enabled.as_ref(), &mut cached.enabled);
}
/// load params from cache if body doesn't contain it, as long as it's allowed
/// in some cases we may need to allow an empty list as an actual value
fn list_or_sticky<T: Clone>(target: &mut Vec<T>, cached: &mut Vec<T>) {
fn list_or_sticky<T: Clone>(target: &Vec<T>, cached: &mut Vec<T>) {
if !target.is_empty() {
cached.clone_from(target);
} else {
target.clone_from(cached);
}
}
fn some_or_sticky<T: Clone>(target: &mut Option<T>, cached: &mut Option<T>) {
fn some_or_sticky<T: Clone>(target: Option<&T>, cached: &mut Option<T>) {
if let Some(target) = target {
cached.replace(target.clone());
} else {
target.clone_from(cached);
}
}
#[implement(Service)]
pub fn update_known_rooms(
&self,
key: &ConnectionKey,
list_id: ListId,
new_rooms: BTreeSet<OwnedRoomId>,
globalsince: u64,
) {
assert!(key.2.is_some(), "Some(conn_id) required for this call");
let cache = self.get_connection(key);
let mut cached = cache.lock().expect("locked");
let list_rooms = cached.known_rooms.entry(list_id).or_default();
for (room_id, lastsince) in list_rooms.iter_mut() {
if !new_rooms.contains(room_id) {
*lastsince = 0;
}
}
for room_id in new_rooms {
list_rooms.insert(room_id, globalsince);
}
}
#[implement(Service)]
pub fn update_subscriptions(&self, key: &ConnectionKey, subscriptions: Subscriptions) {
self.get_connection(key)
.lock()
.expect("locked")
.subscriptions = subscriptions;
}
#[implement(Service)]
pub fn clear_connections(
&self,
@@ -270,17 +224,18 @@ pub fn list_connections(&self) -> Vec<ConnectionKey> {
}
#[implement(Service)]
pub fn get_connection(&self, key: &ConnectionKey) -> Arc<Mutex<Cache>> {
pub fn init_connection(&self, key: &ConnectionKey) -> ConnectionVal {
self.connections
.lock()
.expect("locked")
.entry(key.clone())
.or_insert_with(|| Arc::new(Mutex::new(Cache::default())))
.and_modify(|existing| *existing = ConnectionVal::default())
.or_default()
.clone()
}
#[implement(Service)]
pub fn find_connection(&self, key: &ConnectionKey) -> Result<Arc<Mutex<Cache>>> {
pub fn find_connection(&self, key: &ConnectionKey) -> Result<ConnectionVal> {
self.connections
.lock()
.expect("locked")
@@ -290,7 +245,7 @@ pub fn find_connection(&self, key: &ConnectionKey) -> Result<Arc<Mutex<Cache>>>
}
#[implement(Service)]
pub fn is_connection_cached(&self, key: &ConnectionKey) -> bool {
pub fn contains_connection(&self, key: &ConnectionKey) -> bool {
self.connections
.lock()
.expect("locked")