backups/grapevine
1
0
Fork 0
mirror of https://gitlab.computer.surgery/matrix/grapevine.git synced 2025-12-17 15:51:23 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use TokenSet for roomid_mutex_state

Browse source
This commit is contained in:
Lambda 2024-06-23 18:39:56 +00:00
parent 07b5233980
commit 34ccb2cd06
15 changed files with 243 additions and 429 deletions
Download patch file Download diff file Expand all files Collapse all files

160
src/api/client_server/membership.rs
View file

@ -226,16 +226,11 @@ pub(crate) async fn kick_user_route(
event.membership = MembershipState::Leave;
event.reason.clone_from(&body.reason);
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(body.room_id.clone())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(body.room_id.clone())
.await;
services()
.rooms
@ -250,12 +245,11 @@ pub(crate) async fn kick_user_route(
redacts: None,
},
sender_user,
&body.room_id,
&state_lock,
&room_token,
)
.await?;
drop(state_lock);
drop(room_token);
Ok(Ra(kick_user::v3::Response::new()))
}
@ -302,16 +296,11 @@ pub(crate) async fn ban_user_route(
},
)?;
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(body.room_id.clone())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(body.room_id.clone())
.await;
services()
.rooms
@ -326,12 +315,11 @@ pub(crate) async fn ban_user_route(
redacts: None,
},
sender_user,
&body.room_id,
&state_lock,
&room_token,
)
.await?;
drop(state_lock);
drop(room_token);
Ok(Ra(ban_user::v3::Response::new()))
}
@ -365,16 +353,11 @@ pub(crate) async fn unban_user_route(
event.membership = MembershipState::Leave;
event.reason.clone_from(&body.reason);
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(body.room_id.clone())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(body.room_id.clone())
.await;
services()
.rooms
@ -389,12 +372,11 @@ pub(crate) async fn unban_user_route(
redacts: None,
},
sender_user,
&body.room_id,
&state_lock,
&room_token,
)
.await?;
drop(state_lock);
drop(room_token);
Ok(Ra(unban_user::v3::Response::new()))
}
@ -528,16 +510,11 @@ async fn join_room_by_id_helper(
) -> Result<join_room_by_id::v3::Response> {
let sender_user = sender_user.expect("user is authenticated");
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(room_id.to_owned())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(room_id.to_owned())
.await;
// Ask a remote server if we are not participating in this room
if services()
@ -601,10 +578,9 @@ async fn join_room_by_id_helper(
{
if user.server_name() == services().globals.server_name()
&& services().rooms.state_accessor.user_can_invite(
room_id,
&room_token,
&user,
sender_user,
&state_lock,
)
{
auth_user = Some(user);
@ -641,8 +617,7 @@ async fn join_room_by_id_helper(
redacts: None,
},
sender_user,
room_id,
&state_lock,
&room_token,
)
.await
{
@ -797,7 +772,7 @@ async fn join_room_by_id_helper(
));
}
drop(state_lock);
drop(room_token);
let pub_key_map = RwLock::new(BTreeMap::new());
services()
.rooms
@ -1113,13 +1088,7 @@ async fn join_room_by_id_helper(
services()
.rooms
.state
.force_state(
room_id,
statehash_before_join,
new,
removed,
&state_lock,
)
.force_state(&room_token, statehash_before_join, new, removed)
.await?;
info!("Updating joined counts for new room");
@ -1139,7 +1108,7 @@ async fn join_room_by_id_helper(
&parsed_join_pdu,
join_event,
vec![(*parsed_join_pdu.event_id).to_owned()],
&state_lock,
&room_token,
)
.await?;
@ -1147,11 +1116,10 @@ async fn join_room_by_id_helper(
// We set the room state after inserting the pdu, so that we never have
// a moment in time where events in the current room state do
// not exist
services().rooms.state.set_room_state(
room_id,
statehash_after_join,
&state_lock,
)?;
services()
.rooms
.state
.set_room_state(&room_token, statehash_after_join)?;
}
Ok(join_room_by_id::v3::Response::new(room_id.to_owned()))
@ -1306,16 +1274,11 @@ pub(crate) async fn invite_helper(
) -> Result<()> {
if user_id.server_name() != services().globals.server_name() {
let (pdu, pdu_json, invite_room_state) = {
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(room_id.to_owned())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(room_id.to_owned())
.await;
let content = to_raw_value(&RoomMemberEventContent {
avatar_url: None,
@ -1339,14 +1302,13 @@ pub(crate) async fn invite_helper(
redacts: None,
},
sender_user,
room_id,
&state_lock,
&room_token,
)?;
let invite_room_state =
services().rooms.state.calculate_invite_state(&pdu)?;
drop(state_lock);
drop(room_token);
(pdu, pdu_json, invite_room_state)
};
@ -1447,16 +1409,11 @@ pub(crate) async fn invite_helper(
));
}
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(room_id.to_owned())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(room_id.to_owned())
.await;
services()
.rooms
@ -1480,12 +1437,11 @@ pub(crate) async fn invite_helper(
redacts: None,
},
sender_user,
room_id,
&state_lock,
&room_token,
)
.await?;
drop(state_lock);
drop(room_token);
Ok(())
}
@ -1530,16 +1486,11 @@ pub(crate) async fn leave_room(
.state_cache
.server_in_room(services().globals.server_name(), room_id)?
{
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(room_id.to_owned())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(room_id.to_owned())
.await;
let member_event = services().rooms.state_accessor.room_state_get(
room_id,
@ -1587,8 +1538,7 @@ pub(crate) async fn leave_room(
redacts: None,
},
user_id,
room_id,
&state_lock,
&room_token,
)
.await?;
} else {

25
src/api/client_server/message.rs
View file

@ -1,7 +1,4 @@
use std::{
collections::{BTreeMap, HashSet},
sync::Arc,
};
use std::collections::{BTreeMap, HashSet};
use ruma::{
api::client::{
@ -32,16 +29,11 @@ pub(crate) async fn send_message_event_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device = body.sender_device.as_deref();
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(body.room_id.clone())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(body.room_id.clone())
.await;
// Forbid m.room.encrypted if encryption is disabled
if TimelineEventType::RoomEncrypted == body.event_type.to_string().into()
@ -104,8 +96,7 @@ pub(crate) async fn send_message_event_route(
redacts: None,
},
sender_user,
&body.room_id,
&state_lock,
&room_token,
)
.await?;
@ -116,7 +107,7 @@ pub(crate) async fn send_message_event_route(
event_id.as_bytes(),
)?;
drop(state_lock);
drop(room_token);
Ok(Ra(send_message_event::v3::Response::new((*event_id).to_owned())))
}

46
src/api/client_server/profile.rs
View file

@ -1,5 +1,3 @@
use std::sync::Arc;
use ruma::{
api::{
client::{
@ -81,26 +79,16 @@ pub(crate) async fn set_displayname_route(
.collect();
for (pdu_builder, room_id) in all_rooms_joined {
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(room_id.clone())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(room_id.clone())
.await;
if let Err(error) = services()
.rooms
.timeline
.build_and_append_pdu(
pdu_builder,
sender_user,
&room_id,
&state_lock,
)
.build_and_append_pdu(pdu_builder, sender_user, &room_token)
.await
{
warn!(%error, "failed to add PDU");
@ -203,26 +191,16 @@ pub(crate) async fn set_avatar_url_route(
.collect();
for (pdu_builder, room_id) in all_joined_rooms {
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(room_id.clone())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(room_id.clone())
.await;
if let Err(error) = services()
.rooms
.timeline
.build_and_append_pdu(
pdu_builder,
sender_user,
&room_id,
&state_lock,
)
.build_and_append_pdu(pdu_builder, sender_user, &room_token)
.await
{
warn!(%error, "failed to add PDU");

22
src/api/client_server/redact.rs
View file

@ -1,5 +1,3 @@
use std::sync::Arc;
use ruma::{
api::client::redact::redact_event,
events::{room::redaction::RoomRedactionEventContent, TimelineEventType},
@ -19,16 +17,11 @@ pub(crate) async fn redact_event_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let body = body.body;
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(body.room_id.clone())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(body.room_id.clone())
.await;
let event_id = services()
.rooms
@ -46,12 +39,11 @@ pub(crate) async fn redact_event_route(
redacts: Some(body.event_id.into()),
},
sender_user,
&body.room_id,
&state_lock,
&room_token,
)
.await?;
drop(state_lock);
drop(room_token);
let event_id = (*event_id).to_owned();
Ok(Ra(redact_event::v3::Response {

97
src/api/client_server/room.rs
View file

@ -1,4 +1,4 @@
use std::{cmp::max, collections::BTreeMap, sync::Arc};
use std::{cmp::max, collections::BTreeMap};
use ruma::{
api::client::{
@ -63,16 +63,8 @@ pub(crate) async fn create_room_route(
services().rooms.short.get_or_create_shortroomid(&room_id)?;
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(room_id.clone())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token =
services().globals.roomid_mutex_state.lock_key(room_id.clone()).await;
if !services().globals.allow_room_creation()
&& body.appservice_info.is_none()
@ -250,8 +242,7 @@ pub(crate) async fn create_room_route(
redacts: None,
},
sender_user,
&room_id,
&state_lock,
&room_token,
)
.await?;
@ -278,8 +269,7 @@ pub(crate) async fn create_room_route(
redacts: None,
},
sender_user,
&room_id,
&state_lock,
&room_token,
)
.await?;
@ -338,8 +328,7 @@ pub(crate) async fn create_room_route(
redacts: None,
},
sender_user,
&room_id,
&state_lock,
&room_token,
)
.await?;
@ -361,8 +350,7 @@ pub(crate) async fn create_room_route(
redacts: None,
},
sender_user,
&room_id,
&state_lock,
&room_token,
)
.await?;
}
@ -389,8 +377,7 @@ pub(crate) async fn create_room_route(
redacts: None,
},
sender_user,
&room_id,
&state_lock,
&room_token,
)
.await?;
@ -410,8 +397,7 @@ pub(crate) async fn create_room_route(
redacts: None,
},
sender_user,
&room_id,
&state_lock,
&room_token,
)
.await?;
@ -434,8 +420,7 @@ pub(crate) async fn create_room_route(
redacts: None,
},
sender_user,
&room_id,
&state_lock,
&room_token,
)
.await?;
@ -463,12 +448,7 @@ pub(crate) async fn create_room_route(
services()
.rooms
.timeline
.build_and_append_pdu(
pdu_builder,
sender_user,
&room_id,
&state_lock,
)
.build_and_append_pdu(pdu_builder, sender_user, &room_token)
.await?;
}
@ -489,8 +469,7 @@ pub(crate) async fn create_room_route(
redacts: None,
},
sender_user,
&room_id,
&state_lock,
&room_token,
)
.await?;
}
@ -511,14 +490,13 @@ pub(crate) async fn create_room_route(
redacts: None,
},
sender_user,
&room_id,
&state_lock,
&room_token,
)
.await?;
}
// 8. Events implied by invite (and TODO: invite_3pid)
drop(state_lock);
drop(room_token);
for user_id in &body.invite {
if let Err(error) =
invite_helper(sender_user, user_id, &room_id, None, body.is_direct)
@ -635,16 +613,11 @@ pub(crate) async fn upgrade_room_route(
let replacement_room = RoomId::new(services().globals.server_name());
services().rooms.short.get_or_create_shortroomid(&replacement_room)?;
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(body.room_id.clone())
.or_default(),
);
let original_state_lock = mutex_state.lock().await;
let original_room_token = services()
.globals
.roomid_mutex_state
.lock_key(body.room_id.clone())
.await;
// Send a m.room.tombstone event to the old room to indicate that it is not
// intended to be used any further Fail if the sender does not have the
@ -665,22 +638,16 @@ pub(crate) async fn upgrade_room_route(
redacts: None,
},
sender_user,
&body.room_id,
&original_state_lock,
&original_room_token,
)
.await?;
// Change lock to replacement room
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(replacement_room.clone())
.or_default(),
);
let replacement_state_lock = mutex_state.lock().await;
let replacement_room_token = services()
.globals
.roomid_mutex_state
.lock_key(replacement_room.clone())
.await;
// Get the old room creation event
let mut create_event_content = serde_json::from_str::<CanonicalJsonObject>(
@ -777,8 +744,7 @@ pub(crate) async fn upgrade_room_route(
redacts: None,
},
sender_user,
&replacement_room,
&replacement_state_lock,
&replacement_room_token,
)
.await?;
@ -805,8 +771,7 @@ pub(crate) async fn upgrade_room_route(
redacts: None,
},
sender_user,
&replacement_room,
&replacement_state_lock,
&replacement_room_token,
)
.await?;
@ -847,8 +812,7 @@ pub(crate) async fn upgrade_room_route(
redacts: None,
},
sender_user,
&replacement_room,
&replacement_state_lock,
&replacement_room_token,
)
.await?;
}
@ -910,13 +874,10 @@ pub(crate) async fn upgrade_room_route(
redacts: None,
},
sender_user,
&body.room_id,
&original_state_lock,
&original_room_token,
)
.await?;
drop(replacement_state_lock);
// Return the replacement room id
Ok(Ra(upgrade_room::v3::Response {
replacement_room,

18
src/api/client_server/state.rs
View file

@ -240,16 +240,11 @@ async fn send_state_event_for_key_helper(
}
}
let mutex_state = Arc::clone(
services()
.globals
.roomid_mutex_state
.write()
.await
.entry(room_id.to_owned())
.or_default(),
);
let state_lock = mutex_state.lock().await;
let room_token = services()
.globals
.roomid_mutex_state
.lock_key(room_id.to_owned())
.await;
let event_id = services()
.rooms
@ -264,8 +259,7 @@ async fn send_state_event_for_key_helper(
redacts: None,
},
sender_user,
room_id,
&state_lock,
&room_token,
)
.await?;