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

enable single_match_else lint

Browse source 
Also collapses some if statements in the federation name resolution code
This commit is contained in:
Charles Hall 2024-05-14 19:09:29 -07:00
parent a62fa7b6ee
commit 75358340bb
No known key found for this signature in database
GPG key ID: 7B8E0645816E07CF
6 changed files with 211 additions and 236 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Cargo.toml
View file

@ -69,6 +69,7 @@ same_name_method = "warn"
semicolon_if_nothing_returned = "warn" semicolon_if_nothing_returned = "warn"
semicolon_inside_block = "warn" semicolon_inside_block = "warn"
similar_names = "warn" similar_names = "warn"
single_match_else = "warn"
str_to_string = "warn" str_to_string = "warn"
string_add = "warn" string_add = "warn"
string_lit_chars_any = "warn" string_lit_chars_any = "warn"

55
src/api/client_server/keys.rs
View file

@ -402,39 +402,36 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
.collect(); .collect();
while let Some((server, response)) = futures.next().await { while let Some((server, response)) = futures.next().await {
match response { if let Ok(Ok(response)) = response {
Ok(Ok(response)) => { for (user, masterkey) in response.master_keys {
for (user, masterkey) in response.master_keys { let (master_key_id, mut master_key) =
let (master_key_id, mut master_key) = services().users.parse_master_key(&user, &masterkey)?;
services().users.parse_master_key(&user, &masterkey)?;
if let Some(our_master_key) = services().users.get_key( if let Some(our_master_key) = services().users.get_key(
&master_key_id, &master_key_id,
sender_user, sender_user,
&user, &user,
&allowed_signatures, &allowed_signatures,
)? { )? {
let (_, our_master_key) = let (_, our_master_key) =
services().users.parse_master_key(&user, &our_master_key)?; services().users.parse_master_key(&user, &our_master_key)?;
master_key.signatures.extend(our_master_key.signatures); master_key.signatures.extend(our_master_key.signatures);
}
let json = serde_json::to_value(master_key).expect("to_value always works");
let raw = serde_json::from_value(json).expect("Raw::from_value always works");
services().users.add_cross_signing_keys(
&user, &raw, &None, &None,
false, // Dont notify. A notification would trigger another key request resulting in an endless loop
)?;
master_keys.insert(user, raw);
} }
let json = serde_json::to_value(master_key).expect("to_value always works");
self_signing_keys.extend(response.self_signing_keys); let raw = serde_json::from_value(json).expect("Raw::from_value always works");
device_keys.extend(response.device_keys); services().users.add_cross_signing_keys(
&user, &raw, &None, &None,
false, // Dont notify. A notification would trigger another key request resulting in an endless loop
)?;
master_keys.insert(user, raw);
} }
_ => {
back_off(server.to_owned()).await;
failures.insert(server.to_string(), json!({})); self_signing_keys.extend(response.self_signing_keys);
} device_keys.extend(response.device_keys);
} else {
back_off(server.to_owned()).await;
failures.insert(server.to_string(), json!({}));
} }
} }

177
src/api/server_server.rs
View file

@ -359,100 +359,84 @@ async fn find_actual_destination(destination: &'_ ServerName) -> (FedDest, FedDe
FedDest::Named(host.to_owned(), port.to_owned()) FedDest::Named(host.to_owned(), port.to_owned())
} else { } else {
debug!("Requesting well known for {destination}"); debug!("Requesting well known for {destination}");
match request_well_known(destination.as_str()).await { if let Some(delegated_hostname) = request_well_known(destination.as_str()).await {
Some(delegated_hostname) => { debug!("3: A .well-known file is available");
debug!("3: A .well-known file is available"); hostname = add_port_to_hostname(&delegated_hostname).into_uri_string();
hostname = add_port_to_hostname(&delegated_hostname).into_uri_string(); if let Some(host_and_port) = get_ip_with_port(&delegated_hostname) {
match get_ip_with_port(&delegated_hostname) { host_and_port
Some(host_and_port) => host_and_port, // 3.1: IP literal in .well-known file } else if let Some(pos) = delegated_hostname.find(':') {
None => { debug!("3.2: Hostname with port in .well-known file");
if let Some(pos) = delegated_hostname.find(':') { let (host, port) = delegated_hostname.split_at(pos);
debug!("3.2: Hostname with port in .well-known file"); FedDest::Named(host.to_owned(), port.to_owned())
let (host, port) = delegated_hostname.split_at(pos); } else {
FedDest::Named(host.to_owned(), port.to_owned()) debug!("Delegated hostname has no port in this branch");
} else { if let Some(hostname_override) = query_srv_record(&delegated_hostname).await
debug!("Delegated hostname has no port in this branch"); {
if let Some(hostname_override) = debug!("3.3: SRV lookup successful");
query_srv_record(&delegated_hostname).await let force_port = hostname_override.port();
{
debug!("3.3: SRV lookup successful");
let force_port = hostname_override.port();
if let Ok(override_ip) = services() if let Ok(override_ip) = services()
.globals .globals
.dns_resolver() .dns_resolver()
.lookup_ip(hostname_override.hostname()) .lookup_ip(hostname_override.hostname())
.await .await
{ {
services() services()
.globals .globals
.tls_name_override .tls_name_override
.write() .write()
.unwrap() .unwrap()
.insert( .insert(
delegated_hostname.clone(), delegated_hostname.clone(),
( (override_ip.iter().collect(), force_port.unwrap_or(8448)),
override_ip.iter().collect(), );
force_port.unwrap_or(8448), } else {
), warn!("Using SRV record, but could not resolve to IP");
);
} else {
warn!("Using SRV record, but could not resolve to IP");
}
if let Some(port) = force_port {
FedDest::Named(delegated_hostname, format!(":{port}"))
} else {
add_port_to_hostname(&delegated_hostname)
}
} else {
debug!("3.4: No SRV records, just use the hostname from .well-known");
add_port_to_hostname(&delegated_hostname)
}
}
} }
if let Some(port) = force_port {
FedDest::Named(delegated_hostname, format!(":{port}"))
} else {
add_port_to_hostname(&delegated_hostname)
}
} else {
debug!("3.4: No SRV records, just use the hostname from .well-known");
add_port_to_hostname(&delegated_hostname)
} }
} }
None => { } else {
debug!("4: No .well-known or an error occured"); debug!("4: No .well-known or an error occured");
match query_srv_record(&destination_str).await { if let Some(hostname_override) = query_srv_record(&destination_str).await {
Some(hostname_override) => { debug!("4: SRV record found");
debug!("4: SRV record found"); let force_port = hostname_override.port();
let force_port = hostname_override.port();
if let Ok(override_ip) = services() if let Ok(override_ip) = services()
.globals .globals
.dns_resolver() .dns_resolver()
.lookup_ip(hostname_override.hostname()) .lookup_ip(hostname_override.hostname())
.await .await
{ {
services() services()
.globals .globals
.tls_name_override .tls_name_override
.write() .write()
.unwrap() .unwrap()
.insert( .insert(
hostname.clone(), hostname.clone(),
( (override_ip.iter().collect(), force_port.unwrap_or(8448)),
override_ip.iter().collect(), );
force_port.unwrap_or(8448), } else {
), warn!("Using SRV record, but could not resolve to IP");
);
} else {
warn!("Using SRV record, but could not resolve to IP");
}
if let Some(port) = force_port {
FedDest::Named(hostname.clone(), format!(":{port}"))
} else {
add_port_to_hostname(&hostname)
}
}
None => {
debug!("5: No SRV record found");
add_port_to_hostname(&destination_str)
}
} }
if let Some(port) = force_port {
FedDest::Named(hostname.clone(), format!(":{port}"))
} else {
add_port_to_hostname(&hostname)
}
} else {
debug!("5: No SRV record found");
add_port_to_hostname(&destination_str)
} }
} }
} }
@ -1270,15 +1254,14 @@ pub(crate) async fn get_room_state_route(
Ok(get_room_state::v1::Response { Ok(get_room_state::v1::Response {
auth_chain: auth_chain_ids auth_chain: auth_chain_ids
.filter_map( .filter_map(|id| {
|id| match services().rooms.timeline.get_pdu_json(&id).ok()? { if let Some(json) = services().rooms.timeline.get_pdu_json(&id).ok()? {
Some(json) => Some(PduEvent::convert_to_outgoing_federation_event(json)), Some(PduEvent::convert_to_outgoing_federation_event(json))
None => { } else {
error!("Could not find event json for {id} in db."); error!("Could not find event json for {id} in db.");
None None
} }
}, })
)
.collect(), .collect(),
pdus, pdus,
}) })

65
src/database/key_value/rooms/short.rs
View file

@ -10,18 +10,18 @@ impl service::rooms::short::Data for KeyValueDatabase {
return Ok(*short); return Ok(*short);
} }
let short = match self.eventid_shorteventid.get(event_id.as_bytes())? { let short =
Some(shorteventid) => utils::u64_from_bytes(&shorteventid) if let Some(shorteventid) = self.eventid_shorteventid.get(event_id.as_bytes())? {
.map_err(|_| Error::bad_database("Invalid shorteventid in db."))?, utils::u64_from_bytes(&shorteventid)
None => { .map_err(|_| Error::bad_database("Invalid shorteventid in db."))?
} else {
let shorteventid = services().globals.next_count()?; let shorteventid = services().globals.next_count()?;
self.eventid_shorteventid self.eventid_shorteventid
.insert(event_id.as_bytes(), &shorteventid.to_be_bytes())?; .insert(event_id.as_bytes(), &shorteventid.to_be_bytes())?;
self.shorteventid_eventid self.shorteventid_eventid
.insert(&shorteventid.to_be_bytes(), event_id.as_bytes())?; .insert(&shorteventid.to_be_bytes(), event_id.as_bytes())?;
shorteventid shorteventid
} };
};
self.eventidshort_cache self.eventidshort_cache
.lock() .lock()
@ -86,17 +86,16 @@ impl service::rooms::short::Data for KeyValueDatabase {
db_key.push(0xff); db_key.push(0xff);
db_key.extend_from_slice(state_key.as_bytes()); db_key.extend_from_slice(state_key.as_bytes());
let short = match self.statekey_shortstatekey.get(&db_key)? { let short = if let Some(shortstatekey) = self.statekey_shortstatekey.get(&db_key)? {
Some(shortstatekey) => utils::u64_from_bytes(&shortstatekey) utils::u64_from_bytes(&shortstatekey)
.map_err(|_| Error::bad_database("Invalid shortstatekey in db."))?, .map_err(|_| Error::bad_database("Invalid shortstatekey in db."))?
None => { } else {
let shortstatekey = services().globals.next_count()?; let shortstatekey = services().globals.next_count()?;
self.statekey_shortstatekey self.statekey_shortstatekey
.insert(&db_key, &shortstatekey.to_be_bytes())?; .insert(&db_key, &shortstatekey.to_be_bytes())?;
self.shortstatekey_statekey self.shortstatekey_statekey
.insert(&shortstatekey.to_be_bytes(), &db_key)?; .insert(&shortstatekey.to_be_bytes(), &db_key)?;
shortstatekey shortstatekey
}
}; };
self.statekeyshort_cache self.statekeyshort_cache
@ -177,19 +176,20 @@ impl service::rooms::short::Data for KeyValueDatabase {
/// Returns `(shortstatehash, already_existed)` /// Returns `(shortstatehash, already_existed)`
fn get_or_create_shortstatehash(&self, state_hash: &[u8]) -> Result<(u64, bool)> { fn get_or_create_shortstatehash(&self, state_hash: &[u8]) -> Result<(u64, bool)> {
Ok(match self.statehash_shortstatehash.get(state_hash)? { Ok(
Some(shortstatehash) => ( if let Some(shortstatehash) = self.statehash_shortstatehash.get(state_hash)? {
utils::u64_from_bytes(&shortstatehash) (
.map_err(|_| Error::bad_database("Invalid shortstatehash in db."))?, utils::u64_from_bytes(&shortstatehash)
true, .map_err(|_| Error::bad_database("Invalid shortstatehash in db."))?,
), true,
None => { )
} else {
let shortstatehash = services().globals.next_count()?; let shortstatehash = services().globals.next_count()?;
self.statehash_shortstatehash self.statehash_shortstatehash
.insert(state_hash, &shortstatehash.to_be_bytes())?; .insert(state_hash, &shortstatehash.to_be_bytes())?;
(shortstatehash, false) (shortstatehash, false)
} },
}) )
} }
fn get_shortroomid(&self, room_id: &RoomId) -> Result<Option<u64>> { fn get_shortroomid(&self, room_id: &RoomId) -> Result<Option<u64>> {
@ -203,15 +203,16 @@ impl service::rooms::short::Data for KeyValueDatabase {
} }
fn get_or_create_shortroomid(&self, room_id: &RoomId) -> Result<u64> { fn get_or_create_shortroomid(&self, room_id: &RoomId) -> Result<u64> {
Ok(match self.roomid_shortroomid.get(room_id.as_bytes())? { Ok(
Some(short) => utils::u64_from_bytes(&short) if let Some(short) = self.roomid_shortroomid.get(room_id.as_bytes())? {
.map_err(|_| Error::bad_database("Invalid shortroomid in db."))?, utils::u64_from_bytes(&short)
None => { .map_err(|_| Error::bad_database("Invalid shortroomid in db."))?
} else {
let short = services().globals.next_count()?; let short = services().globals.next_count()?;
self.roomid_shortroomid self.roomid_shortroomid
.insert(room_id.as_bytes(), &short.to_be_bytes())?; .insert(room_id.as_bytes(), &short.to_be_bytes())?;
short short
} },
}) )
} }
} }

92
src/service/rooms/event_handler.rs
View file

@ -1153,7 +1153,7 @@ impl Service {
} }
info!("Fetching {} over federation.", next_id); info!("Fetching {} over federation.", next_id);
match services() if let Ok(res) = services()
.sending .sending
.send_federation_request( .send_federation_request(
origin, origin,
@ -1163,44 +1163,41 @@ impl Service {
) )
.await .await
{ {
Ok(res) => { info!("Got {} over federation", next_id);
info!("Got {} over federation", next_id); let Ok((calculated_event_id, value)) =
let Ok((calculated_event_id, value)) = pdu::gen_event_id_canonical_json(&res.pdu, room_version_id)
pdu::gen_event_id_canonical_json(&res.pdu, room_version_id) else {
else {
back_off((*next_id).to_owned()).await;
continue;
};
if calculated_event_id != *next_id {
warn!("Server didn't return event id we requested: requested: {}, we got {}. Event: {:?}",
next_id, calculated_event_id, &res.pdu);
}
if let Some(auth_events) =
value.get("auth_events").and_then(|c| c.as_array())
{
for auth_event in auth_events {
if let Ok(auth_event) =
serde_json::from_value(auth_event.clone().into())
{
let a: Arc<EventId> = auth_event;
todo_auth_events.push(a);
} else {
warn!("Auth event id is not valid");
}
}
} else {
warn!("Auth event list invalid");
}
events_in_reverse_order.push((next_id.clone(), value));
events_all.insert(next_id);
}
Err(_) => {
warn!("Failed to fetch event: {}", next_id);
back_off((*next_id).to_owned()).await; back_off((*next_id).to_owned()).await;
continue;
};
if calculated_event_id != *next_id {
warn!("Server didn't return event id we requested: requested: {}, we got {}. Event: {:?}",
next_id, calculated_event_id, &res.pdu);
} }
if let Some(auth_events) =
value.get("auth_events").and_then(|c| c.as_array())
{
for auth_event in auth_events {
if let Ok(auth_event) =
serde_json::from_value(auth_event.clone().into())
{
let a: Arc<EventId> = auth_event;
todo_auth_events.push(a);
} else {
warn!("Auth event id is not valid");
}
}
} else {
warn!("Auth event list invalid");
}
events_in_reverse_order.push((next_id.clone(), value));
events_all.insert(next_id);
} else {
warn!("Failed to fetch event: {}", next_id);
back_off((*next_id).to_owned()).await;
} }
} }
@ -1670,18 +1667,17 @@ impl Service {
.get(origin) .get(origin)
.map(|s| Arc::clone(s).acquire_owned()); .map(|s| Arc::clone(s).acquire_owned());
let permit = match permit { let permit = if let Some(p) = permit {
Some(p) => p, p
None => { } else {
let mut write = services().globals.servername_ratelimiter.write().await; let mut write = services().globals.servername_ratelimiter.write().await;
let s = Arc::clone( let s = Arc::clone(
write write
.entry(origin.to_owned()) .entry(origin.to_owned())
.or_insert_with(|| Arc::new(Semaphore::new(1))), .or_insert_with(|| Arc::new(Semaphore::new(1))),
); );
s.acquire_owned() s.acquire_owned()
}
} }
.await; .await;

57
src/service/sending.rs
View file

@ -305,41 +305,38 @@ impl Service {
let event: AnySyncEphemeralRoomEvent = let event: AnySyncEphemeralRoomEvent =
serde_json::from_str(read_receipt.json().get()) serde_json::from_str(read_receipt.json().get())
.map_err(|_| Error::bad_database("Invalid edu event in read_receipts."))?; .map_err(|_| Error::bad_database("Invalid edu event in read_receipts."))?;
let federation_event = match event { let federation_event = if let AnySyncEphemeralRoomEvent::Receipt(r) = event {
AnySyncEphemeralRoomEvent::Receipt(r) => { let mut read = BTreeMap::new();
let mut read = BTreeMap::new();
let (event_id, mut receipt) = r let (event_id, mut receipt) = r
.content .content
.0 .0
.into_iter() .into_iter()
.next() .next()
.expect("we only use one event per read receipt"); .expect("we only use one event per read receipt");
let receipt = receipt let receipt = receipt
.remove(&ReceiptType::Read) .remove(&ReceiptType::Read)
.expect("our read receipts always set this") .expect("our read receipts always set this")
.remove(&user_id) .remove(&user_id)
.expect("our read receipts always have the user here"); .expect("our read receipts always have the user here");
read.insert( read.insert(
user_id, user_id,
ReceiptData { ReceiptData {
data: receipt.clone(), data: receipt.clone(),
event_ids: vec![event_id.clone()], event_ids: vec![event_id.clone()],
}, },
); );
let receipt_map = ReceiptMap { read }; let receipt_map = ReceiptMap { read };
let mut receipts = BTreeMap::new(); let mut receipts = BTreeMap::new();
receipts.insert(room_id.clone(), receipt_map); receipts.insert(room_id.clone(), receipt_map);
Edu::Receipt(ReceiptContent { receipts }) Edu::Receipt(ReceiptContent { receipts })
} } else {
_ => { Error::bad_database("Invalid event type in read_receipts");
Error::bad_database("Invalid event type in read_receipts"); continue;
continue;
}
}; };
events.push(serde_json::to_vec(&federation_event).expect("json can be serialized")); events.push(serde_json::to_vec(&federation_event).expect("json can be serialized"));