Skip to main content

tuwunel_service/presence/
data.rs

1use std::sync::Arc;
2
3use futures::Stream;
4use ruma::{UInt, UserId, events::presence::PresenceEvent, presence::PresenceState};
5use tuwunel_core::{
6	Result, debug_warn, implement, utils,
7	utils::{ReadyExt, result::NotFound, stream::TryIgnore, u64_from_u8},
8};
9use tuwunel_database::{Deserialized, Json, Map};
10
11use crate::presence::Presence;
12
13pub(crate) struct Data {
14	presenceid_presence: Arc<Map>,
15	userid_presenceid: Arc<Map>,
16	services: Arc<crate::services::OnceServices>,
17}
18
19impl Data {
20	pub(super) fn new(args: &crate::Args<'_>) -> Self {
21		let db = &args.db;
22		Self {
23			presenceid_presence: db["presenceid_presence"].clone(),
24			userid_presenceid: db["userid_presenceid"].clone(),
25			services: args.services.clone(),
26		}
27	}
28
29	pub(super) async fn get_presence_raw(&self, user_id: &UserId) -> Result<(u64, Presence)> {
30		let count = self
31			.userid_presenceid
32			.get(user_id)
33			.await
34			.deserialized::<u64>()?;
35
36		let key = presenceid_key(count, user_id);
37		let bytes = self.presenceid_presence.get(&key).await?;
38		let presence = Presence::from_json_bytes(&bytes)?;
39
40		Ok((count, presence))
41	}
42
43	pub(super) async fn set_presence(
44		&self,
45		user_id: &UserId,
46		presence_state: &PresenceState,
47		currently_active: Option<bool>,
48		last_active_ago: Option<UInt>,
49		status_msg: Option<String>,
50	) -> Result<Option<u64>> {
51		let last_presence = self.get_presence(user_id).await;
52		let state_changed = match last_presence {
53			| Err(_) => true,
54			| Ok(ref presence) => presence.1.content.presence != *presence_state,
55		};
56
57		let status_msg_changed = match last_presence {
58			| Err(_) => true,
59			| Ok(ref last_presence) => {
60				let old_msg = last_presence
61					.1
62					.content
63					.status_msg
64					.clone()
65					.unwrap_or_default();
66
67				let new_msg = status_msg.clone().unwrap_or_default();
68
69				new_msg != old_msg
70			},
71		};
72
73		let now = utils::millis_since_unix_epoch();
74		let last_last_active_ts = match last_presence {
75			| Err(_) => 0,
76			| Ok((_, ref presence)) => now.saturating_sub(
77				presence
78					.content
79					.last_active_ago
80					.unwrap_or_default()
81					.into(),
82			),
83		};
84
85		let last_active_ts = match last_active_ago {
86			| None => now,
87			| Some(last_active_ago) => now.saturating_sub(last_active_ago.into()),
88		};
89
90		// TODO: tighten for state flicker?
91		if !status_msg_changed && !state_changed && last_active_ts < last_last_active_ts {
92			debug_warn!(
93				"presence spam {user_id:?} last_active_ts:{last_active_ts:?} < \
94				 {last_last_active_ts:?}",
95			);
96			return Ok(None);
97		}
98
99		let status_msg = if status_msg.as_ref().is_some_and(String::is_empty) {
100			None
101		} else {
102			status_msg
103		};
104
105		let presence = Presence {
106			state: presence_state.to_owned(),
107			currently_active: currently_active.unwrap_or(false),
108			last_active_ts,
109			status_msg,
110		};
111
112		let count = self.services.globals.next_count();
113		let key = presenceid_key(*count, user_id);
114
115		self.userid_presenceid.raw_put(user_id, *count);
116		self.presenceid_presence
117			.raw_put(key, Json(presence));
118
119		if let Ok((last_count, _)) = last_presence {
120			let key = presenceid_key(last_count, user_id);
121			self.presenceid_presence.remove(&key);
122		}
123
124		Ok(Some(*count))
125	}
126
127	#[inline]
128	pub(super) async fn remove_presence(&self, user_id: &UserId) {
129		let Ok(count) = self
130			.userid_presenceid
131			.get(user_id)
132			.await
133			.deserialized::<u64>()
134		else {
135			return;
136		};
137
138		let key = presenceid_key(count, user_id);
139		self.presenceid_presence.remove(&key);
140		self.userid_presenceid.remove(user_id);
141	}
142
143	#[inline]
144	pub(super) fn presence_since(
145		&self,
146		since: u64,
147		to: Option<u64>,
148	) -> impl Stream<Item = (&UserId, u64, &[u8])> + Send + '_ {
149		let upper = to
150			.and_then(|to| to.checked_add(1))
151			.map(u64::to_be_bytes);
152
153		self.presenceid_presence
154			.raw_stream_range(&since.to_be_bytes(), upper.as_ref().map(AsRef::as_ref))
155			.ignore_err()
156			.ready_filter_map(|(key, presence)| {
157				let (count, user_id) = key.split_at_checked(size_of::<u64>())?;
158
159				Some((u64_from_u8(count), user_id, presence))
160			})
161			.ready_take_while(move |(count, ..)| to.is_none_or(|to| *count <= to))
162			.ready_filter(move |(count, ..)| *count > since)
163			.ready_filter_map(|(count, user_id, presence)| {
164				user_id_from_bytes(user_id)
165					.ok()
166					.map(|user_id| (user_id, count, presence))
167			})
168	}
169}
170
171#[implement(Data)]
172#[inline]
173pub(super) async fn get_presence(&self, user_id: &UserId) -> Result<(u64, PresenceEvent)> {
174	let count = self
175		.userid_presenceid
176		.get(user_id)
177		.await
178		.deserialized::<u64>()?;
179
180	let event = self.get_presence_event(count, user_id).await?;
181
182	Ok((count, event))
183}
184
185#[implement(Data)]
186#[inline]
187pub(super) async fn get_presence_optional(
188	&self,
189	user_id: &UserId,
190) -> Result<Option<(u64, PresenceEvent)>> {
191	let Some(count) = self
192		.userid_presenceid
193		.get(user_id)
194		.await
195		.optional()?
196	else {
197		return Ok(None);
198	};
199
200	let count = count.deserialized::<u64>()?;
201	let event = self.get_presence_event(count, user_id).await?;
202
203	Ok(Some((count, event)))
204}
205
206#[implement(Data)]
207#[tracing::instrument(level = "trace", skip(self))]
208async fn get_presence_event(&self, count: u64, user_id: &UserId) -> Result<PresenceEvent> {
209	let key = presenceid_key(count, user_id);
210	let bytes = self.presenceid_presence.get(&key).await?;
211
212	self.services
213		.presence
214		.from_json_bytes_to_event(&bytes, user_id)
215		.await
216}
217
218#[inline]
219fn presenceid_key(count: u64, user_id: &UserId) -> Vec<u8> {
220	let cap = size_of::<u64>().saturating_add(user_id.as_bytes().len());
221	let mut key = Vec::with_capacity(cap);
222	key.extend_from_slice(&count.to_be_bytes());
223	key.extend_from_slice(user_id.as_bytes());
224	key
225}
226
227/// Parses a `UserId` from bytes.
228fn user_id_from_bytes(bytes: &[u8]) -> Result<&UserId> {
229	let str: &str = utils::str_from_bytes(bytes)?;
230	let user_id: &UserId = str.try_into()?;
231
232	Ok(user_id)
233}