tuwunel_service/integrity/
joined_members.rs1use std::{fmt, str::from_utf8, sync::Arc};
8
9use futures::{Stream, TryFutureExt};
10use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId, events::room::member::MembershipState};
11use tuwunel_core::{
12 Result,
13 result::NotFound,
14 utils::{TryReadyExt, stream::TryBroadbandExt},
15};
16use tuwunel_database::{KeyBuf, SEP};
17
18use super::{Check, Report, ScanExt, per_room, tally, undecodable};
19use crate::{
20 Services,
21 rooms::{state_compressor::CompressedState, timeline::Mapped},
22};
23
24type Member = (OwnedRoomId, OwnedUserId);
25
26type State = Option<Mapped<Arc<CompressedState>>>;
28
29pub(super) static CHECK: Check = Check {
30 name: "joined-members",
31 about: "Every member roomuserid_joined lists has a join in its room's current state",
32 quiescent: true,
33 walk: |services, limit| tally(scan(services), limit),
34};
35
36pub enum Finding {
41 Contradicted {
43 room_id: OwnedRoomId,
45
46 user_id: OwnedUserId,
48
49 membership: MembershipState,
51 },
52
53 Unbacked {
55 room_id: OwnedRoomId,
57
58 user_id: OwnedUserId,
60 },
61
62 MalformedMapping {
65 room_id: OwnedRoomId,
67
68 user_id: OwnedUserId,
70 },
71
72 Unreadable {
74 room_id: OwnedRoomId,
76
77 user_id: OwnedUserId,
79 },
80
81 Unparsable {
83 key: KeyBuf,
85 },
86}
87
88#[tracing::instrument(level = "trace", skip_all)]
95pub fn scan(services: &Services) -> impl Stream<Item = Result<Finding>> + Send + '_ {
96 let members = services.db["roomuserid_joined"]
97 .raw_scan()
98 .scanned(&services.server)
99 .ready_try_filter_map(|(key, _)| Ok(split(key)));
100
101 per_room(
102 members,
103 |(room_id, _): &Member| room_id,
104 move |room_id| state(services, room_id),
105 )
106 .broad_and_then(async |member| match member {
107 | Ok((member, state)) => verify(services, member, state).await,
108 | Err(key) => Ok(Some(Finding::Unparsable { key })),
109 })
110 .ready_try_filter_map(Ok)
111}
112
113impl Report for Finding {
114 fn kind(&self) -> &'static str {
115 match self {
116 | Self::Contradicted { .. } => "contradicted-join",
117 | Self::Unbacked { .. } => "unbacked-join",
118 | Self::MalformedMapping { .. } => "malformed-mapping",
119 | Self::Unreadable { .. } => "unreadable-member",
120 | Self::Unparsable { .. } => "unparsable-key",
121 }
122 }
123}
124
125impl fmt::Display for Finding {
126 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
127 match self {
128 | Self::Contradicted { room_id, user_id, membership } => {
129 write!(
130 f,
131 "{user_id} is listed joined to {room_id}, whose state says {membership}"
132 )
133 },
134 | Self::Unbacked { room_id, user_id } => {
135 write!(
136 f,
137 "{user_id} is listed joined to {room_id}, whose state has no member event"
138 )
139 },
140 | Self::MalformedMapping { room_id, user_id } => {
141 write!(f, "a row resolving the member event of {user_id} in {room_id} is damaged")
142 },
143 | Self::Unreadable { room_id, user_id } => {
144 write!(f, "member event of {user_id} in {room_id} does not decode")
145 },
146 | Self::Unparsable { key } => {
147 write!(f, "key does not read as a room and a user: {}", key.escape_ascii())
148 },
149 }
150 }
151}
152
153fn split(key: &[u8]) -> Option<Result<Member, KeyBuf>> {
158 let at = key.iter().position(|&byte| byte == SEP)?;
159 let (room_id, user_id) = key.split_at(at);
160
161 user_id
162 .strip_prefix(&[SEP])
163 .filter(|user_id| user_id.first() != Some(&SEP))
164 .map(|user_id| member(room_id, user_id).ok_or_else(|| KeyBuf::from_slice(key)))
165}
166
167fn member(room_id: &[u8], user_id: &[u8]) -> Option<Member> {
168 let room_id: &RoomId = from_utf8(room_id).ok()?.try_into().ok()?;
169 let user_id: &UserId = from_utf8(user_id).ok()?.try_into().ok()?;
170
171 Some((room_id.to_owned(), user_id.to_owned()))
172}
173
174#[tracing::instrument(level = "debug", skip(services))]
175async fn state(services: &Services, room_id: OwnedRoomId) -> Result<State> {
176 services
177 .state_accessor
178 .room_state_checked(&room_id)
179 .map_ok(|state| state.map(Arc::new))
180 .await
181 .present()
182}
183
184#[tracing::instrument(level = "debug", skip_all)]
185async fn verify(
186 services: &Services,
187 (room_id, user_id): Member,
188 state: State,
189) -> Result<Option<Finding>> {
190 let member = match state {
191 | None => return Ok(Some(Finding::Unbacked { room_id, user_id })),
192 | Some(Mapped::Damaged) => {
193 return Ok(Some(Finding::MalformedMapping { room_id, user_id }));
194 },
195 | Some(Mapped::Event(state)) =>
196 services
197 .state_accessor
198 .get_member_checked(&state, &user_id)
199 .await,
200 };
201
202 let finding: Option<Finding> = match member {
203 | Ok(Mapped::Event(member)) if member.membership == MembershipState::Join => None,
204 | Ok(Mapped::Damaged) => Some(Finding::MalformedMapping { room_id, user_id }),
205 | Ok(Mapped::Event(member)) => Finding::Contradicted {
206 room_id,
207 user_id,
208 membership: member.membership,
209 }
210 .into(),
211 | Err(error) if error.is_missing() => Some(Finding::Unbacked { room_id, user_id }),
212 | Err(error) if undecodable(&error) => Some(Finding::Unreadable { room_id, user_id }),
213 | Err(error) => return Err(error),
214 };
215
216 Ok(finding)
217}