refactor: remove previous typing implementation and add sync wakeup for new one

Signed-off-by: strawberry <strawberry@puppygock.gay>

src/service/mod.rs

@@ -4,7 +4,7 @@ use std::{
 };
 
 use lru_cache::LruCache;
-use tokio::sync::{Mutex, RwLock};
+use tokio::sync::{broadcast, Mutex, RwLock};
 
 use crate::{Config, Result};
 
@@ -77,9 +77,9 @@ impl Services<'_> {
 						db,
 					},
 					typing: rooms::edus::typing::Service {
-						db,
 						typing: RwLock::new(BTreeMap::new()),
 						last_typing_update: RwLock::new(BTreeMap::new()),
+						typing_update_sender: broadcast::channel(100).0,
 					},
 				},
 				event_handler: rooms::event_handler::Service,

src/service/rooms/edus/mod.rs

@@ -2,7 +2,7 @@ pub mod presence;
 pub mod read_receipt;
 pub mod typing;
 
-pub trait Data: presence::Data + read_receipt::Data + typing::Data + 'static {}
+pub trait Data: presence::Data + read_receipt::Data + 'static {}
 
 pub struct Service {
 	pub presence: presence::Service,

src/service/rooms/edus/typing/data.rs

@@ -1,23 +0,0 @@
-use std::collections::HashSet;
-
-use ruma::{OwnedUserId, RoomId, UserId};
-
-use crate::Result;
-
-pub trait Data: Send + Sync {
-	/// Sets a user as typing until the timeout timestamp is reached or
-	/// roomtyping_remove is called.
-	fn typing_add(&self, user_id: &UserId, room_id: &RoomId, timeout: u64) -> Result<()>;
-
-	/// Removes a user from typing before the timeout is reached.
-	fn typing_remove(&self, user_id: &UserId, room_id: &RoomId) -> Result<()>;
-
-	/// Makes sure that typing events with old timestamps get removed.
-	fn typings_maintain(&self, room_id: &RoomId) -> Result<()>;
-
-	/// Returns the count of the last typing update in this room.
-	fn last_typing_update(&self, room_id: &RoomId) -> Result<u64>;
-
-	/// Returns all user ids currently typing.
-	fn typings_all(&self, room_id: &RoomId) -> Result<HashSet<OwnedUserId>>;
-}

src/service/rooms/edus/typing/mod.rs

@@ -1,18 +1,15 @@
-mod data;
-
 use std::collections::BTreeMap;
 
-pub use data::Data;
 use ruma::{events::SyncEphemeralRoomEvent, OwnedRoomId, OwnedUserId, RoomId, UserId};
-use tokio::sync::RwLock;
+use tokio::sync::{broadcast, RwLock};
 
 use crate::{services, utils, Result};
 
 pub struct Service {
-	pub db: &'static dyn Data,
 	pub typing: RwLock<BTreeMap<OwnedRoomId, BTreeMap<OwnedUserId, u64>>>, // u64 is unix timestamp of timeout
 	pub last_typing_update: RwLock<BTreeMap<OwnedRoomId, u64>>,            /* timestamp of the last change to typing
 	                                                                        * users */
+	pub typing_update_sender: broadcast::Sender<OwnedRoomId>,
 }
 
 impl Service {
@@ -21,6 +18,7 @@ impl Service {
 	pub async fn typing_add(&self, user_id: &UserId, room_id: &RoomId, timeout: u64) -> Result<()> {
 		self.typing.write().await.entry(room_id.to_owned()).or_default().insert(user_id.to_owned(), timeout);
 		self.last_typing_update.write().await.insert(room_id.to_owned(), services().globals.next_count()?);
+		let _ = self.typing_update_sender.send(room_id.to_owned());
 		Ok(())
 	}
 
@@ -28,6 +26,18 @@ impl Service {
 	pub async fn typing_remove(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
 		self.typing.write().await.entry(room_id.to_owned()).or_default().remove(user_id);
 		self.last_typing_update.write().await.insert(room_id.to_owned(), services().globals.next_count()?);
+		let _ = self.typing_update_sender.send(room_id.to_owned());
+		Ok(())
+	}
+
+	pub async fn wait_for_update(&self, room_id: &RoomId) -> Result<()> {
+		let mut receiver = self.typing_update_sender.subscribe();
+		while let Ok(next) = receiver.recv().await {
+			if next == room_id {
+				break;
+			}
+		}
+
 		Ok(())
 	}
 
@@ -55,6 +65,7 @@ impl Service {
 				room.remove(&user);
 			}
 			self.last_typing_update.write().await.insert(room_id.to_owned(), services().globals.next_count()?);
+			let _ = self.typing_update_sender.send(room_id.to_owned());
 		}
 
 		Ok(())