1#[cfg(test)]
9mod tests;
10mod update;
11mod via;
12
13use std::{
14 collections::HashMap,
15 convert::identity,
16 sync::{Arc, RwLock},
17};
18
19use futures::{
20 Stream, StreamExt, TryStreamExt,
21 future::{join5, ready},
22 pin_mut,
23 stream::{empty, select},
24};
25use ruma::{
26 OwnedEventId, OwnedRoomId, OwnedServerName, RoomId, ServerName, UserId,
27 events::{AnyStrippedStateEvent, AnySyncStateEvent, room::member::MembershipState},
28 serde::Raw,
29};
30use serde::de::DeserializeOwned;
31use tuwunel_core::{
32 Err, Result, at, debug_warn, err, implement, trace,
33 utils::{
34 self, BoolExt,
35 result::NotFound,
36 stream::{BroadbandExt, IterStream, ReadyExt, TryIgnore},
37 },
38 warn,
39};
40use tuwunel_database::{
41 Deserialized, Ignore, IgnoreAll, Interfix, Map, SEP, deserialize_from_slice,
42};
43use tuwunel_matrix::{Event, Pdu, event::Owned};
44use update::EMPTY_INVITE_STATE;
45pub use update::{MembershipUpdate, StrippedRoomState};
51
52use crate::appservice::RegistrationInfo;
53
54pub struct Service {
60 appservice_in_room_cache: AppServiceInRoomCache,
61 services: Arc<crate::services::OnceServices>,
62 db: Data,
63}
64
65struct Data {
66 roomid_knockedcount: Arc<Map>,
67 roomid_invitedcount: Arc<Map>,
68 roomid_inviteviaservers: Arc<Map>,
69 roomid_joinedcount: Arc<Map>,
70 roomserverids: Arc<Map>,
71 roomuserid_invitecount: Arc<Map>,
72 roomuserid_joinedcount: Arc<Map>,
73 roomuserid_leftcount: Arc<Map>,
74 roomuserid_knockedcount: Arc<Map>,
75 roomuseroncejoinedids: Arc<Map>,
76 serverroomids: Arc<Map>,
77 userroomid_invitestate: Arc<Map>,
78 userroomid_joinedcount: Arc<Map>,
79 userroomid_leftstate: Arc<Map>,
80 userroomid_knockedstate: Arc<Map>,
81}
82
83type AppServiceInRoomCache = RwLock<HashMap<OwnedRoomId, HashMap<String, bool>>>;
84type StrippedState = Vec<Raw<AnyStrippedStateEvent>>;
85type StrippedStateEventItem = (OwnedRoomId, StrippedState);
86type SyncStateEventItem = (OwnedRoomId, Vec<Raw<AnySyncStateEvent>>);
87
88const FORGOTTEN_STATE: &[u8] = b"\xCA\xF6";
90
91impl crate::Service for Service {
92 fn build(args: &crate::Args<'_>) -> Result<Arc<Self>> {
93 Ok(Arc::new(Self {
94 appservice_in_room_cache: RwLock::new(HashMap::new()),
95 services: args.services.clone(),
96 db: Data {
97 roomid_knockedcount: args.db["roomid_knockedcount"].clone(),
98 roomid_invitedcount: args.db["roomid_invitedcount"].clone(),
99 roomid_inviteviaservers: args.db["roomid_inviteviaservers"].clone(),
100 roomid_joinedcount: args.db["roomid_joinedcount"].clone(),
101 roomserverids: args.db["roomserverids"].clone(),
102 roomuserid_invitecount: args.db["roomuserid_invitecount"].clone(),
103 roomuserid_joinedcount: args.db["roomuserid_joined"].clone(),
104 roomuserid_leftcount: args.db["roomuserid_leftcount"].clone(),
105 roomuserid_knockedcount: args.db["roomuserid_knockedcount"].clone(),
106 roomuseroncejoinedids: args.db["roomuseroncejoinedids"].clone(),
107 serverroomids: args.db["serverroomids"].clone(),
108 userroomid_invitestate: args.db["userroomid_invitestate"].clone(),
109 userroomid_joinedcount: args.db["userroomid_joined"].clone(),
110 userroomid_leftstate: args.db["userroomid_leftstate"].clone(),
111 userroomid_knockedstate: args.db["userroomid_knockedstate"].clone(),
112 },
113 }))
114 }
115
116 fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
117}
118
119#[implement(Service)]
132#[tracing::instrument(level = "trace", skip_all)]
133pub async fn appservice_in_room(&self, room_id: &RoomId, appservice: &RegistrationInfo) -> bool {
134 let cached = self
135 .appservice_in_room_cache
136 .read()
137 .expect("locked")
138 .get(room_id)
139 .and_then(|map| map.get(&appservice.registration.id))
140 .copied();
141
142 if let Some(cached) = cached {
143 return cached;
144 }
145
146 let in_room = self
147 .appservice_in_room_uncached(room_id, appservice)
148 .await;
149
150 self.appservice_in_room_cache
151 .write()
152 .expect("locked")
153 .entry(room_id.into())
154 .or_default()
155 .insert(appservice.registration.id.clone(), in_room);
156
157 in_room
158}
159
160#[implement(Service)]
166#[tracing::instrument(level = "trace", skip_all)]
167pub async fn appservice_in_room_uncached(
168 &self,
169 room_id: &RoomId,
170 appservice: &RegistrationInfo,
171) -> bool {
172 self.is_joined(&appservice.sender, room_id).await
173 || self
174 .room_members(room_id)
175 .ready_any(|user_id| appservice.is_user_match(user_id))
176 .await
177}
178
179#[implement(Service)]
185pub fn get_appservice_in_room_cache_usage(&self) -> (usize, usize) {
186 let cache = self
187 .appservice_in_room_cache
188 .read()
189 .expect("locked");
190
191 (cache.len(), cache.capacity())
192}
193
194#[implement(Service)]
200#[tracing::instrument(level = "debug", skip_all)]
201pub fn clear_appservice_in_room_cache(&self) {
202 self.appservice_in_room_cache
203 .write()
204 .expect("locked")
205 .clear();
206}
207
208#[implement(Service)]
214#[tracing::instrument(level = "debug", skip(self))]
215pub fn clear_appservice_in_room_cache_for(&self, appservice_id: &str) {
216 self.appservice_in_room_cache
217 .write()
218 .expect("locked")
219 .retain(|_, appservices| {
220 appservices.remove(appservice_id);
221 !appservices.is_empty()
222 });
223}
224
225#[implement(Service)]
232#[tracing::instrument(skip(self), level = "trace")]
233pub fn remote_room_servers<'a>(
234 &'a self,
235 room_id: &'a RoomId,
236) -> impl Stream<Item = &ServerName> + Send + 'a {
237 self.room_servers(room_id)
238 .ready_filter(|server| !self.services.globals.server_is_ours(server))
239}
240
241#[implement(Service)]
246#[tracing::instrument(skip(self), level = "debug")]
247pub fn room_servers<'a>(
248 &'a self,
249 room_id: &'a RoomId,
250) -> impl Stream<Item = &ServerName> + Send + 'a {
251 let prefix = (room_id, Interfix);
252 self.db
253 .roomserverids
254 .keys_prefix(&prefix)
255 .ignore_err()
256 .map(|(_, server): (Ignore, &ServerName)| server)
257}
258
259#[implement(Service)]
264#[tracing::instrument(skip(self), level = "trace")]
265pub async fn server_in_room<'a>(&'a self, server: &'a ServerName, room_id: &'a RoomId) -> bool {
266 self.server_in_room_result(server, room_id)
267 .await
268 .unwrap_or(false)
269}
270
271#[implement(Service)]
276#[tracing::instrument(skip(self), level = "trace")]
277pub async fn server_in_room_result<'a>(
278 &'a self,
279 server: &'a ServerName,
280 room_id: &'a RoomId,
281) -> Result<bool> {
282 let key = (server, room_id);
283
284 match self.db.serverroomids.qry(&key).await {
285 | Ok(_) => Ok(true),
286 | Err(error) if error.is_not_found() => Ok(false),
287 | Err(error) => Err(error),
288 }
289}
290
291#[implement(Service)]
296#[tracing::instrument(skip(self), level = "debug")]
297pub fn server_rooms<'a>(
298 &'a self,
299 server: &'a ServerName,
300) -> impl Stream<Item = &RoomId> + Send + 'a {
301 let prefix = (server, Interfix);
302 self.db
303 .serverroomids
304 .keys_prefix(&prefix)
305 .ignore_err()
306 .map(|(_, room_id): (Ignore, &RoomId)| room_id)
307}
308
309#[implement(Service)]
315#[tracing::instrument(skip(self), level = "debug")]
316pub fn servers(&self) -> impl Stream<Item = &ServerName> + Send + '_ {
317 self.db
318 .serverroomids
319 .keys()
320 .ignore_err()
321 .ready_scan(
322 None,
323 |last: &mut Option<OwnedServerName>, (server, _): (&ServerName, Ignore)| {
324 let fresh = last.as_deref() != Some(server);
325
326 if fresh {
327 *last = Some(server.to_owned());
328 }
329
330 Some(fresh.then_some(server))
331 },
332 )
333 .ready_filter_map(identity)
334}
335
336#[implement(Service)]
341#[tracing::instrument(skip(self), level = "trace")]
342pub async fn server_shares_room(&self, server: &ServerName) -> bool {
343 self.server_rooms(server)
344 .ready_any(|_| true)
345 .await
346}
347
348#[implement(Service)]
353#[tracing::instrument(skip(self), level = "trace")]
354pub async fn server_sees_user(&self, server: &ServerName, user_id: &UserId) -> bool {
355 self.server_rooms(server)
356 .map(ToOwned::to_owned)
357 .broad_any(async |room_id| self.is_joined(user_id, &room_id).await)
358 .await
359}
360
361#[implement(Service)]
366#[tracing::instrument(skip(self), level = "trace")]
367pub async fn user_sees_user(&self, user_a: &UserId, user_b: &UserId) -> bool {
368 let get_shared_rooms = self.get_shared_rooms(user_a, user_b);
369
370 pin_mut!(get_shared_rooms);
371 get_shared_rooms.next().await.is_some()
372}
373
374#[implement(Service)]
381#[tracing::instrument(skip(self), level = "debug")]
382pub fn get_shared_rooms<'a>(
383 &'a self,
384 user_a: &'a UserId,
385 user_b: &'a UserId,
386) -> impl Stream<Item = &RoomId> + Send + 'a {
387 let a = self.rooms_joined(user_a);
388 let b = self.rooms_joined(user_b);
389
390 utils::set::intersection_sorted_stream2(a, b)
391}
392
393#[implement(Service)]
398#[tracing::instrument(skip(self), level = "debug")]
399pub fn room_members<'a>(
400 &'a self,
401 room_id: &'a RoomId,
402) -> impl Stream<Item = &UserId> + Send + 'a {
403 self.room_members_checked(room_id).ignore_err()
404}
405
406#[implement(Service)]
412#[tracing::instrument(skip(self), level = "debug")]
413pub fn room_members_checked<'a>(
414 &'a self,
415 room_id: &'a RoomId,
416) -> impl Stream<Item = Result<&'a UserId>> + Send + 'a {
417 let prefix = (room_id, Interfix);
418
419 self.db
420 .roomuserid_joinedcount
421 .keys_prefix(&prefix)
422 .map_ok(|(_, user_id): (Ignore, &UserId)| user_id)
423}
424
425#[implement(Service)]
431#[tracing::instrument(skip(self), level = "trace")]
432pub async fn room_joined_count(&self, room_id: &RoomId) -> Result<u64> {
433 self.db
434 .roomid_joinedcount
435 .get(room_id)
436 .await
437 .deserialized()
438}
439
440#[implement(Service)]
446#[tracing::instrument(skip(self), level = "trace")]
447pub async fn room_invited_count(&self, room_id: &RoomId) -> Result<u64> {
448 self.db
449 .roomid_invitedcount
450 .get(room_id)
451 .await
452 .deserialized()
453}
454
455#[implement(Service)]
461#[tracing::instrument(skip(self), level = "trace")]
462pub async fn room_knocked_count(&self, room_id: &RoomId) -> Result<u64> {
463 self.db
464 .roomid_knockedcount
465 .get(room_id)
466 .await
467 .deserialized()
468}
469
470#[implement(Service)]
476#[tracing::instrument(skip(self), level = "debug")]
477pub fn active_local_users_in_room<'a>(
478 &'a self,
479 room_id: &'a RoomId,
480) -> impl Stream<Item = &UserId> + Send + 'a {
481 self.local_users_in_room(room_id)
482 .filter(|user| self.services.users.is_active(user))
483}
484
485#[implement(Service)]
490#[tracing::instrument(skip(self), level = "debug")]
491pub fn local_users_in_room<'a>(
492 &'a self,
493 room_id: &'a RoomId,
494) -> impl Stream<Item = &UserId> + Send + 'a {
495 self.room_members(room_id)
496 .ready_filter(|user| self.services.globals.user_is_local(user))
497}
498
499#[implement(Service)]
504#[tracing::instrument(skip(self), level = "debug")]
505pub fn local_users_invited_to_room<'a>(
506 &'a self,
507 room_id: &'a RoomId,
508) -> impl Stream<Item = &UserId> + Send + 'a {
509 self.room_members_invited(room_id)
510 .ready_filter(|user| self.services.globals.user_is_local(user))
511}
512
513#[implement(Service)]
519#[tracing::instrument(skip(self), level = "debug")]
520pub async fn can_prune_room(&self, room_id: &RoomId, require_forgotten: bool) -> Result<bool> {
521 let prefix = (room_id, Interfix);
522 let occupied = [
523 &self.db.roomuserid_joinedcount,
524 &self.db.roomuserid_invitecount,
525 &self.db.roomuserid_knockedcount,
526 ]
527 .into_iter()
528 .stream()
529 .flat_map(|map| map.keys_prefix(&prefix))
530 .try_any(|(_, user): (Ignore, &UserId)| ready(self.services.globals.user_is_local(user)))
531 .await?;
532
533 if occupied || !require_forgotten {
534 return Ok(!occupied);
535 }
536
537 self.db
538 .roomuserid_leftcount
539 .keys_prefix(&prefix)
540 .try_filter(|(_, user): &(Ignore, &UserId)| {
541 ready(self.services.globals.user_is_local(user))
542 })
543 .and_then(async |(_, user)| self.is_forgotten(user, room_id).await)
544 .try_all(ready)
545 .await
546}
547
548#[implement(Service)]
556#[tracing::instrument(skip(self), level = "debug")]
557pub fn room_useroncejoined<'a>(
558 &'a self,
559 room_id: &'a RoomId,
560) -> impl Stream<Item = &UserId> + Send + 'a {
561 let prefix = (room_id, Interfix);
562 self.db
563 .roomuseroncejoinedids
564 .keys_prefix(&prefix)
565 .ignore_err()
566 .map(|(_, user_id): (Ignore, &UserId)| user_id)
567}
568
569#[implement(Service)]
574#[tracing::instrument(skip(self), level = "debug")]
575pub fn room_members_invited<'a>(
576 &'a self,
577 room_id: &'a RoomId,
578) -> impl Stream<Item = &UserId> + Send + 'a {
579 let prefix = (room_id, Interfix);
580 self.db
581 .roomuserid_invitecount
582 .keys_prefix(&prefix)
583 .ignore_err()
584 .map(|(_, user_id): (Ignore, &UserId)| user_id)
585}
586
587#[implement(Service)]
592#[tracing::instrument(skip(self), level = "debug")]
593pub fn room_members_knocked<'a>(
594 &'a self,
595 room_id: &'a RoomId,
596) -> impl Stream<Item = &UserId> + Send + 'a {
597 let prefix = (room_id, Interfix);
598 self.db
599 .roomuserid_knockedcount
600 .keys_prefix(&prefix)
601 .ignore_err()
602 .map(|(_, user_id): (Ignore, &UserId)| user_id)
603}
604
605#[implement(Service)]
610#[tracing::instrument(skip(self), level = "trace")]
611pub async fn get_invite_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<u64> {
612 let key = (room_id, user_id);
613 self.db
614 .roomuserid_invitecount
615 .qry(&key)
616 .await
617 .deserialized()
618 .map(|(count, _): (u64, IgnoreAll)| count)
619}
620
621#[implement(Service)]
625#[tracing::instrument(skip(self), level = "trace")]
626pub async fn get_invite_event(
627 &self,
628 room_id: &RoomId,
629 user_id: &UserId,
630) -> Result<Option<OwnedEventId>> {
631 let key = (room_id, user_id);
632 let value = self.db.roomuserid_invitecount.qry(&key).await?;
633 let tail = value
634 .get(size_of::<u64>()..)
635 .ok_or_else(|| err!(Database("Invalid invite count prefix")))?;
636
637 if let Some((&separator, event_id)) = tail.split_first()
639 && (separator != SEP || event_id.contains(&SEP))
640 {
641 return Err!(Database("Invalid invite event tail framing"));
642 }
643
644 value
645 .deserialized()
646 .map(|(_, event_id): (u64, Option<OwnedEventId>)| event_id)
647}
648
649#[implement(Service)]
655#[tracing::instrument(skip(self), level = "trace")]
656pub async fn get_knock_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<u64> {
657 let key = (room_id, user_id);
658 self.db
659 .roomuserid_knockedcount
660 .qry(&key)
661 .await
662 .deserialized()
663}
664
665#[implement(Service)]
671#[tracing::instrument(skip(self), level = "trace")]
672pub async fn get_left_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<u64> {
673 let count = self.get_departure_count(room_id, user_id).await?;
674
675 if self.is_forgotten(user_id, room_id).await? {
676 return Err!(Request(NotFound("Room has been forgotten")));
677 }
678
679 Ok(count)
680}
681
682#[implement(Service)]
688#[tracing::instrument(skip(self), level = "trace")]
689pub async fn get_departure_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<u64> {
690 let key = (room_id, user_id);
691
692 self.db
693 .roomuserid_leftcount
694 .qry(&key)
695 .await
696 .deserialized()
697}
698
699#[implement(Service)]
704#[tracing::instrument(skip(self), level = "trace")]
705pub async fn is_forgotten(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
706 let key = (user_id, room_id);
707
708 self.db
709 .userroomid_leftstate
710 .qry(&key)
711 .await
712 .optional()
713 .map(|state| state.is_some_and(|state| state.as_ref().eq(FORGOTTEN_STATE)))
714}
715
716#[implement(Service)]
726#[tracing::instrument(skip(self), level = "trace")]
727pub async fn get_joined_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<u64> {
728 let key = (room_id, user_id);
729
730 self.db
731 .roomuserid_joinedcount
732 .qry(&key)
733 .await
734 .and_then(|value| {
735 value
736 .is_empty()
737 .map_or_else(|| value.deserialized(), || Ok(0))
738 })
739}
740
741#[implement(Service)]
748#[inline]
749pub fn all_user_memberships<'a>(
750 &'a self,
751 user_id: &'a UserId,
752) -> impl Stream<Item = (MembershipState, &RoomId)> + Send + 'a {
753 self.user_memberships(user_id, None)
754}
755
756#[implement(Service)]
764#[tracing::instrument(skip(self), level = "debug")]
765pub fn user_memberships<'a>(
766 &'a self,
767 user_id: &'a UserId,
768 mask: Option<&[MembershipState]>,
769) -> impl Stream<Item = (MembershipState, &RoomId)> + Send + 'a {
770 let joined = mask
771 .is_none_or(|mask| mask.contains(&MembershipState::Join))
772 .then(|| {
773 self.rooms_joined(user_id)
774 .map(|room_id| (MembershipState::Join, room_id))
775 .left_stream()
776 })
777 .unwrap_or_else(|| empty().right_stream());
778
779 let invited = mask
780 .is_none_or(|mask| mask.contains(&MembershipState::Invite))
781 .then(|| {
782 self.rooms_invited(user_id)
783 .map(|room_id| (MembershipState::Invite, room_id))
784 .left_stream()
785 })
786 .unwrap_or_else(|| empty().right_stream());
787
788 let knocked = mask
789 .is_none_or(|mask| mask.contains(&MembershipState::Knock))
790 .then(|| {
791 self.rooms_knocked(user_id)
792 .map(|room_id| (MembershipState::Knock, room_id))
793 .left_stream()
794 })
795 .unwrap_or_else(|| empty().right_stream());
796
797 let left = mask
798 .is_none_or(|mask| mask.contains(&MembershipState::Leave))
799 .then(|| {
800 self.rooms_left(user_id)
801 .map(|room_id| (MembershipState::Leave, room_id))
802 .left_stream()
803 })
804 .unwrap_or_else(|| empty().right_stream());
805
806 select(select(joined, left), select(invited, knocked))
807}
808
809#[implement(Service)]
815#[tracing::instrument(skip(self), level = "debug")]
816pub fn rooms_joined<'a>(
817 &'a self,
818 user_id: &'a UserId,
819) -> impl Stream<Item = &RoomId> + Send + 'a {
820 let prefix = (user_id, Interfix);
821 self.db
822 .userroomid_joinedcount
823 .keys_prefix(&prefix)
824 .ignore_err()
825 .map(|(_, room_id): (Ignore, &RoomId)| room_id)
826}
827
828#[implement(Service)]
834#[tracing::instrument(skip(self), level = "trace")]
835pub fn rooms_joined_checked<'a>(
836 &'a self,
837 user_id: &'a UserId,
838) -> impl Stream<Item = Result<&'a RoomId>> + Send + 'a {
839 let prefix = (user_id, Interfix);
840
841 self.db
842 .userroomid_joinedcount
843 .keys_prefix(&prefix)
844 .map_ok(|(_, room_id): (Ignore, &RoomId)| room_id)
845}
846
847#[implement(Service)]
853#[tracing::instrument(skip(self), level = "debug")]
854pub fn rooms_invited<'a>(
855 &'a self,
856 user_id: &'a UserId,
857) -> impl Stream<Item = &RoomId> + Send + 'a {
858 let prefix = (user_id, Interfix);
859 self.db
860 .userroomid_invitestate
861 .keys_prefix(&prefix)
862 .ignore_err()
863 .map(|(_, room_id): (Ignore, &RoomId)| room_id)
864}
865
866#[implement(Service)]
872#[tracing::instrument(skip(self), level = "debug")]
873pub fn rooms_knocked<'a>(
874 &'a self,
875 user_id: &'a UserId,
876) -> impl Stream<Item = &RoomId> + Send + 'a {
877 let prefix = (user_id, Interfix);
878 self.db
879 .userroomid_knockedstate
880 .keys_prefix(&prefix)
881 .ignore_err()
882 .map(|(_, room_id): (Ignore, &RoomId)| room_id)
883}
884
885#[implement(Service)]
891#[tracing::instrument(skip(self), level = "debug")]
892pub fn rooms_left<'a>(&'a self, user_id: &'a UserId) -> impl Stream<Item = &RoomId> + Send + 'a {
893 self.retained_left_rows(user_id).map(at!(0))
894}
895
896#[implement(Service)]
897fn retained_left_rows<'a>(
898 &'a self,
899 user_id: &'a UserId,
900) -> impl Stream<Item = (&RoomId, &[u8])> + Send + 'a {
901 let prefix = (user_id, Interfix);
902
903 self.db
904 .userroomid_leftstate
905 .stream_prefix_raw(&prefix)
906 .ignore_err()
907 .ready_filter(|(_, state)| *state != FORGOTTEN_STATE)
908 .map(|(key, state)| {
909 deserialize_from_slice(key).map(|(_, room_id): (Ignore, &RoomId)| (room_id, state))
910 })
911 .ignore_err()
912}
913
914#[implement(Service)]
920#[tracing::instrument(skip(self), level = "debug")]
921pub fn rooms_departed<'a>(
922 &'a self,
923 user_id: &'a UserId,
924) -> impl Stream<Item = &RoomId> + Send + 'a {
925 let prefix = (user_id, Interfix);
926 self.db
927 .userroomid_leftstate
928 .keys_prefix(&prefix)
929 .ignore_err()
930 .map(|(_, room_id): (Ignore, &RoomId)| room_id)
931}
932
933#[implement(Service)]
938#[tracing::instrument(skip(self), level = "debug")]
939pub fn rooms_invited_state<'a>(
940 &'a self,
941 user_id: &'a UserId,
942) -> impl Stream<Item = StrippedStateEventItem> + Send + 'a {
943 type KeyVal<'a> = (Key<'a>, Raw<Vec<AnyStrippedStateEvent>>);
944 type Key<'a> = (&'a UserId, &'a RoomId);
945
946 let prefix = (user_id, Interfix);
947 self.db
948 .userroomid_invitestate
949 .stream_prefix(&prefix)
950 .ignore_err()
951 .map(|((_, room_id), state): KeyVal<'_>| (room_id.to_owned(), state))
952 .map(|(room_id, state)| Ok((room_id, state.deserialize_as_unchecked()?)))
953 .ignore_err()
954}
955
956#[implement(Service)]
962#[tracing::instrument(skip(self), level = "trace")]
963pub fn rooms_knocked_state<'a>(
964 &'a self,
965 user_id: &'a UserId,
966) -> impl Stream<Item = StrippedStateEventItem> + Send + 'a {
967 type KeyVal<'a> = (Key<'a>, Raw<Vec<AnyStrippedStateEvent>>);
968 type Key<'a> = (&'a UserId, &'a RoomId);
969
970 let prefix = (user_id, Interfix);
971 self.db
972 .userroomid_knockedstate
973 .stream_prefix(&prefix)
974 .ignore_err()
975 .map(|((_, room_id), state): KeyVal<'_>| (room_id.to_owned(), state))
976 .map(|(room_id, state)| Ok((room_id, state.deserialize_as_unchecked()?)))
977 .ignore_err()
978 .map(move |(room_id, state)| (room_id, without_superseded_membership(state, user_id)))
979}
980
981#[implement(Service)]
987#[tracing::instrument(skip(self), level = "debug")]
988pub fn rooms_left_state<'a>(
989 &'a self,
990 user_id: &'a UserId,
991) -> impl Stream<Item = SyncStateEventItem> + Send + 'a {
992 self.retained_left_rows(user_id)
993 .map(|(room_id, state)| {
994 deserialize_from_slice(state)
995 .map(|state: Raw<Vec<AnySyncStateEvent>>| (room_id.to_owned(), state))
996 })
997 .ignore_err()
998 .map(|(room_id, state)| {
999 let state = state_events(&room_id, &state);
1000
1001 (room_id, state)
1002 })
1003}
1004
1005#[implement(Service)]
1010#[tracing::instrument(skip(self), level = "trace")]
1011pub async fn invite_state(
1012 &self,
1013 user_id: &UserId,
1014 room_id: &RoomId,
1015) -> Result<Vec<Raw<AnyStrippedStateEvent>>> {
1016 let key = (user_id, room_id);
1017 self.db
1018 .userroomid_invitestate
1019 .qry(&key)
1020 .await
1021 .deserialized()
1022 .and_then(|val: Raw<Vec<AnyStrippedStateEvent>>| {
1023 val.deserialize_as_unchecked().map_err(Into::into)
1024 })
1025}
1026
1027#[implement(Service)]
1033#[tracing::instrument(skip(self), level = "trace")]
1034pub async fn has_invite_state(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
1035 let key = (user_id, room_id);
1036
1037 self.db
1038 .userroomid_invitestate
1039 .qry(&key)
1040 .await
1041 .optional()
1042 .map(|state| state.is_some_and(|state| state.len() > EMPTY_INVITE_STATE.len()))
1043}
1044
1045#[implement(Service)]
1051#[tracing::instrument(skip(self), level = "trace")]
1052pub async fn knock_state(
1053 &self,
1054 user_id: &UserId,
1055 room_id: &RoomId,
1056) -> Result<Vec<Raw<AnyStrippedStateEvent>>> {
1057 let key = (user_id, room_id);
1058
1059 self.db
1060 .userroomid_knockedstate
1061 .qry(&key)
1062 .await
1063 .deserialized()
1064 .and_then(|val: Raw<Vec<AnyStrippedStateEvent>>| {
1065 val.deserialize_as_unchecked().map_err(Into::into)
1066 })
1067 .map(|state| without_superseded_membership(state, user_id))
1068}
1069
1070fn without_superseded_membership(state: StrippedState, user_id: &UserId) -> StrippedState {
1075 let own_member = |event: &Raw<AnyStrippedStateEvent>| {
1076 let field = |key| event.get_field::<&str>(key).ok().flatten();
1077
1078 field("type") == Some("m.room.member") && field("state_key") == Some(user_id.as_str())
1079 };
1080
1081 let last = state.iter().rposition(own_member);
1082
1083 state
1084 .into_iter()
1085 .enumerate()
1086 .filter(|(i, event)| Some(*i) == last || !own_member(event))
1087 .map(at!(1))
1088 .collect()
1089}
1090
1091#[implement(Service)]
1097#[tracing::instrument(skip(self), level = "trace")]
1098pub async fn left_state(
1099 &self,
1100 user_id: &UserId,
1101 room_id: &RoomId,
1102) -> Result<Vec<Raw<AnyStrippedStateEvent>>> {
1103 let key = (user_id, room_id);
1104 self.db
1105 .userroomid_leftstate
1106 .qry(&key)
1107 .await
1108 .and_then(|state| {
1109 if state.as_ref().eq(FORGOTTEN_STATE) {
1110 return Err!(Request(NotFound("Room has been forgotten")));
1111 }
1112
1113 Ok(state)
1114 })
1115 .deserialized()
1116 .map(|state: Raw<Vec<AnyStrippedStateEvent>>| state_events(room_id, &state))
1117}
1118
1119#[implement(Service)]
1126#[tracing::instrument(skip(self), level = "trace")]
1127pub async fn user_membership(
1128 &self,
1129 user_id: &UserId,
1130 room_id: &RoomId,
1131) -> Option<MembershipState> {
1132 let states = join5(
1133 self.is_joined(user_id, room_id),
1134 self.is_left(user_id, room_id),
1135 self.is_knocked(user_id, room_id),
1136 self.is_invited(user_id, room_id),
1137 self.once_joined(user_id, room_id),
1138 )
1139 .await;
1140
1141 match states {
1142 | (true, ..) => Some(MembershipState::Join),
1143 | (_, true, ..) => Some(MembershipState::Leave),
1144 | (_, _, true, ..) => Some(MembershipState::Knock),
1145 | (_, _, _, true, ..) => Some(MembershipState::Invite),
1146 | (false, false, false, false, true) => Some(MembershipState::Ban),
1147 | _ => None,
1148 }
1149}
1150
1151#[implement(Service)]
1156#[tracing::instrument(skip(self), level = "debug")]
1157pub async fn once_joined(&self, user_id: &UserId, room_id: &RoomId) -> bool {
1158 let key = (user_id, room_id);
1159 self.db.roomuseroncejoinedids.contains(&key).await
1160}
1161
1162#[implement(Service)]
1168#[tracing::instrument(skip(self, room_ids), level = "trace")]
1169pub async fn is_joined_any<'a, Rooms>(&self, user_id: &UserId, room_ids: Rooms) -> bool
1170where
1171 Rooms: IntoIterator<Item = &'a RoomId> + Send,
1172 Rooms::IntoIter: Send,
1173{
1174 room_ids
1175 .into_iter()
1176 .stream()
1177 .broad_any(|room_id| self.is_joined(user_id, room_id))
1178 .await
1179}
1180
1181#[implement(Service)]
1186#[tracing::instrument(skip(self), level = "trace")]
1187pub async fn is_joined<'a>(&'a self, user_id: &'a UserId, room_id: &'a RoomId) -> bool {
1188 let key = (user_id, room_id);
1189
1190 self.db
1191 .userroomid_joinedcount
1192 .contains(&key)
1193 .await
1194}
1195
1196#[implement(Service)]
1201#[tracing::instrument(skip(self), level = "trace")]
1202pub async fn try_is_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
1203 let key = (user_id, room_id);
1204
1205 self.db
1206 .userroomid_joinedcount
1207 .try_contains(&key)
1208 .await
1209}
1210
1211#[implement(Service)]
1216#[tracing::instrument(skip(self), level = "trace")]
1217pub async fn is_knocked<'a>(&'a self, user_id: &'a UserId, room_id: &'a RoomId) -> bool {
1218 let key = (user_id, room_id);
1219 self.db
1220 .userroomid_knockedstate
1221 .contains(&key)
1222 .await
1223}
1224
1225#[implement(Service)]
1230#[tracing::instrument(skip(self), level = "trace")]
1231pub async fn is_invited(&self, user_id: &UserId, room_id: &RoomId) -> bool {
1232 let key = (user_id, room_id);
1233
1234 self.db
1235 .userroomid_invitestate
1236 .contains(&key)
1237 .await
1238}
1239
1240#[implement(Service)]
1245#[tracing::instrument(skip(self), level = "trace")]
1246pub async fn try_is_invited(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
1247 let key = (user_id, room_id);
1248
1249 self.db
1250 .userroomid_invitestate
1251 .try_contains(&key)
1252 .await
1253}
1254
1255#[implement(Service)]
1260#[tracing::instrument(skip(self), level = "trace")]
1261pub async fn is_left(&self, user_id: &UserId, room_id: &RoomId) -> bool {
1262 let key = (user_id, room_id);
1263
1264 self.db
1265 .userroomid_leftstate
1266 .qry(&key)
1267 .await
1268 .is_ok_and(|state| state.as_ref().ne(FORGOTTEN_STATE))
1269}
1270
1271#[implement(Service)]
1280#[tracing::instrument(skip(self), level = "trace")]
1281pub async fn delete_room_join_counts(&self, room_id: &RoomId, force: bool) -> Result {
1282 let prefix = (room_id, Interfix);
1283 let mut txn = self.services.db.txn();
1284
1285 txn.del_raw(&self.db.roomid_knockedcount, room_id);
1286
1287 txn.del_raw(&self.db.roomid_invitedcount, room_id);
1288
1289 txn.del_raw(&self.db.roomid_inviteviaservers, room_id);
1290
1291 txn.del_raw(&self.db.roomid_joinedcount, room_id);
1292
1293 self.db
1294 .roomserverids
1295 .keys_prefix(&prefix)
1296 .ignore_err()
1297 .ready_for_each(|key: (&RoomId, &ServerName)| {
1298 trace!("Removing key: {key:?}");
1299 txn.del(&self.db.roomserverids, key);
1300
1301 let reverse_key = (key.1, key.0);
1302
1303 trace!("Removing reverse key: {reverse_key:?}");
1304 txn.del(&self.db.serverroomids, reverse_key);
1305 })
1306 .await;
1307
1308 self.db
1309 .roomuserid_invitecount
1310 .keys_prefix(&prefix)
1311 .ignore_err()
1312 .ready_for_each(|key: (&RoomId, &UserId)| {
1313 trace!("Removing key: {key:?}");
1314 txn.del(&self.db.roomuserid_invitecount, key);
1315
1316 let reverse_key = (key.1, key.0);
1317
1318 trace!("Removing reverse key: {reverse_key:?}");
1319 txn.del(&self.db.userroomid_invitestate, reverse_key);
1320 })
1321 .await;
1322
1323 self.db
1324 .roomuserid_joinedcount
1325 .keys_prefix(&prefix)
1326 .ignore_err()
1327 .ready_for_each(|key: (&RoomId, &UserId)| {
1328 trace!("Removing key: {key:?}");
1329 txn.del(&self.db.roomuserid_joinedcount, key);
1330
1331 let reverse_key = (key.1, key.0);
1332
1333 trace!("Removing reverse key: {reverse_key:?}");
1334 txn.del(&self.db.userroomid_joinedcount, reverse_key);
1335 })
1336 .await;
1337
1338 self.db
1339 .roomuserid_knockedcount
1340 .keys_prefix(&prefix)
1341 .ignore_err()
1342 .ready_for_each(|key: (&RoomId, &UserId)| {
1343 trace!("Removing key: {key:?}");
1344 txn.del(&self.db.roomuserid_knockedcount, key);
1345
1346 let reverse_key = (key.1, key.0);
1347
1348 trace!("Removing reverse key: {reverse_key:?}");
1349 txn.del(&self.db.userroomid_knockedstate, reverse_key);
1350 })
1351 .await;
1352
1353 self.db
1354 .roomuserid_leftcount
1355 .keys_prefix(&prefix)
1356 .ignore_err()
1357 .ready_filter(|(_, user_id): &(&RoomId, &UserId)| {
1358 force || !self.services.globals.user_is_local(user_id)
1359 })
1360 .ready_for_each(|key: (&RoomId, &UserId)| {
1361 trace!("Removing key: {key:?}");
1362 txn.del(&self.db.roomuserid_leftcount, key);
1363
1364 let reverse_key = (key.1, key.0);
1365
1366 trace!("Removing reverse key: {reverse_key:?}");
1367 txn.del(&self.db.userroomid_leftstate, reverse_key);
1368 })
1369 .await;
1370
1371 txn.execute();
1372
1373 Ok(())
1374}
1375
1376fn state_events<T, U>(room_id: &RoomId, state: &Raw<T>) -> Vec<U>
1382where
1383 U: DeserializeOwned + From<Owned<Pdu>>,
1384{
1385 match state.json().get().trim_start().as_bytes().first() {
1386 | Some(b'[') => state
1387 .deserialize_as_unchecked()
1388 .inspect_err(
1389 |e| debug_warn!(%room_id, error = %e, "Unusable cached membership state"),
1390 )
1391 .unwrap_or_default(),
1392
1393 | Some(b'{') => state
1395 .deserialize_as_unchecked()
1396 .map(|event: Pdu| [event.into_format()].into())
1397 .inspect_err(|e| debug_warn!(%room_id, error = %e, "Unusable cached leave event"))
1398 .unwrap_or_default(),
1399
1400 | _ => Vec::new(),
1401 }
1402}