chore: Merge origin/main into nex/perf/get-missing-events

src/core/config/manager.rs

@@ -10,7 +10,7 @@ use std::{
 };
 
 use super::Config;
-use crate::{Result, implement};
+use crate::Result;
 
 /// The configuration manager is an indirection to reload the configuration for
 /// the server while it is running. In order to not burden or clutter the many
@@ -39,6 +39,48 @@ impl Manager {
 			active: AtomicPtr::new(Arc::into_raw(config).cast_mut()),
 		}
 	}
+
+	/// Update the active configuration, returning prior configuration.
+	#[tracing::instrument(skip_all, level = "info")]
+	pub fn update(&self, config: Config) -> Result<Arc<Config>> {
+		let config = Arc::new(config);
+		let new = Arc::into_raw(config);
+		let old = self.active.swap(new.cast_mut(), Ordering::AcqRel);
+
+		// SAFETY: The old active pointer was set using an Arc::into_raw(). We're
+		// obliged to reconstitute that into Arc otherwise it will leak.
+		Ok(unsafe { Arc::from_raw(old) })
+	}
+
+	fn load(&self, handle: &mut [Option<Arc<Config>>]) -> &'static Arc<Config> {
+		let config = self.active.load(Ordering::Acquire);
+
+		// Branch taken after config reload or first access by this thread.
+		if handle[INDEX.get()]
+			.as_ref()
+			.is_none_or(|handle| !ptr::eq(config, Arc::as_ptr(handle)))
+		{
+			INDEX.set(INDEX.get().wrapping_add(1).wrapping_rem(HISTORY));
+			return load_miss(handle, INDEX.get(), config);
+		}
+
+		let config: &Arc<Config> = handle[INDEX.get()]
+			.as_ref()
+			.expect("handle was already cached for this thread");
+
+		// SAFETY: The caller should not hold multiple references at a time directly
+		// into Config, as a subsequent reference might invalidate the thread's cache
+		// causing another reference to dangle.
+		//
+		// This is a highly unusual pattern as most config values are copied by value or
+		// used immediately without running overlap with another value. Even if it does
+		// actually occur somewhere, the window of danger is limited to the config being
+		// reloaded while the reference is held and another access is made by the same
+		// thread into a different config value. This is mitigated by creating a buffer
+		// of old configs rather than discarding at the earliest opportunity; the odds
+		// of this scenario are thus astronomical.
+		unsafe { std::mem::transmute(config) }
+	}
 }
 
 impl Drop for Manager {
@@ -57,50 +99,6 @@ impl Deref for Manager {
 	fn deref(&self) -> &Self::Target { HANDLE.with_borrow_mut(|handle| self.load(handle)) }
 }
 
-/// Update the active configuration, returning prior configuration.
-#[implement(Manager)]
-#[tracing::instrument(skip_all, level = "info")]
-pub fn update(&self, config: Config) -> Result<Arc<Config>> {
-	let config = Arc::new(config);
-	let new = Arc::into_raw(config);
-	let old = self.active.swap(new.cast_mut(), Ordering::AcqRel);
-
-	// SAFETY: The old active pointer was set using an Arc::into_raw(). We're
-	// obliged to reconstitute that into Arc otherwise it will leak.
-	Ok(unsafe { Arc::from_raw(old) })
-}
-
-#[implement(Manager)]
-fn load(&self, handle: &mut [Option<Arc<Config>>]) -> &'static Arc<Config> {
-	let config = self.active.load(Ordering::Acquire);
-
-	// Branch taken after config reload or first access by this thread.
-	if handle[INDEX.get()]
-		.as_ref()
-		.is_none_or(|handle| !ptr::eq(config, Arc::as_ptr(handle)))
-	{
-		INDEX.set(INDEX.get().wrapping_add(1).wrapping_rem(HISTORY));
-		return load_miss(handle, INDEX.get(), config);
-	}
-
-	let config: &Arc<Config> = handle[INDEX.get()]
-		.as_ref()
-		.expect("handle was already cached for this thread");
-
-	// SAFETY: The caller should not hold multiple references at a time directly
-	// into Config, as a subsequent reference might invalidate the thread's cache
-	// causing another reference to dangle.
-	//
-	// This is a highly unusual pattern as most config values are copied by value or
-	// used immediately without running overlap with another value. Even if it does
-	// actually occur somewhere, the window of danger is limited to the config being
-	// reloaded while the reference is held and another access is made by the same
-	// thread into a different config value. This is mitigated by creating a buffer
-	// of old configs rather than discarding at the earliest opportunity; the odds
-	// of this scenario are thus astronomical.
-	unsafe { std::mem::transmute(config) }
-}
-
 #[tracing::instrument(
 	name = "miss",
 	level = "trace",

src/core/matrix/pdu/redact.rs

@@ -1,32 +1,34 @@
 use ruma::{RoomVersionId, canonical_json::redact_content_in_place};
 use serde_json::{Value as JsonValue, json, value::to_raw_value};
 
-use crate::{Err, Result, err, implement};
+use crate::{Err, Result, err};
 
-#[implement(super::Pdu)]
-pub fn redact(&mut self, room_version_id: &RoomVersionId, reason: JsonValue) -> Result {
-	let Some(rules) = room_version_id.rules() else {
-		return Err!("Cannot redact event for unknown room version {room_version_id}");
-	};
+impl super::Pdu {
+	pub fn redact(&mut self, room_version_id: &RoomVersionId, reason: JsonValue) -> Result {
+		let Some(rules) = room_version_id.rules() else {
+			return Err!("Cannot redact event for unknown room version {room_version_id}");
+		};
 
-	self.unsigned = None;
+		self.unsigned = None;
 
-	let mut content = serde_json::from_str(self.content.get())
-		.map_err(|e| err!(Request(BadJson("Failed to deserialize content into type: {e}"))))?;
+		let mut content = serde_json::from_str(self.content.get()).map_err(|e| {
+			err!(Request(BadJson("Failed to deserialize content into type: {e}")))
+		})?;
 
-	redact_content_in_place(&mut content, &rules.redaction, self.kind.to_string());
+		redact_content_in_place(&mut content, &rules.redaction, self.kind.to_string());
 
-	let reason = serde_json::to_value(reason).expect("Failed to preserialize reason");
+		let reason = serde_json::to_value(reason).expect("Failed to preserialize reason");
 
-	let redacted_because = json!({
-		"redacted_because": reason,
-	});
+		let redacted_because = json!({
+			"redacted_because": reason,
+		});
 
-	self.unsigned = to_raw_value(&redacted_because)
-		.expect("Failed to serialize unsigned")
-		.into();
+		self.unsigned = to_raw_value(&redacted_because)
+			.expect("Failed to serialize unsigned")
+			.into();
 
-	self.content = to_raw_value(&content).expect("Failed to serialize content");
+		self.content = to_raw_value(&content).expect("Failed to serialize content");
 
-	Ok(())
+		Ok(())
+	}
 }

src/core/matrix/pdu/unsigned.rs

@@ -4,85 +4,83 @@ use ruma::MilliSecondsSinceUnixEpoch;
 use serde_json::value::{RawValue as RawJsonValue, Value as JsonValue, to_raw_value};
 
 use super::Pdu;
-use crate::{Result, err, implement, result::LogErr};
+use crate::{Result, err, result::LogErr};
 
-/// Set the `unsigned` field of the PDU using only information in the PDU.
-/// Some unsigned data is already set within the database (eg. prev events,
-/// threads). Once this is done, other data must be calculated from the database
-/// (eg. relations) This is for server-to-client events.
-/// Backfill handles this itself.
-#[implement(Pdu)]
-pub fn set_unsigned(&mut self, user_id: Option<&ruma::UserId>) {
-	if Some(self.sender.borrow()) != user_id {
-		self.remove_transaction_id().log_err().ok();
+impl Pdu {
+	/// Set the `unsigned` field of the PDU using only information in the PDU.
+	/// Some unsigned data is already set within the database (eg. prev events,
+	/// threads). Once this is done, other data must be calculated from the
+	/// database (eg. relations) This is for server-to-client events.
+	/// Backfill handles this itself.
+	pub fn set_unsigned(&mut self, user_id: Option<&ruma::UserId>) {
+		if Some(self.sender.borrow()) != user_id {
+			self.remove_transaction_id().log_err().ok();
+		}
+		self.add_age().log_err().ok();
+	}
+
+	pub fn remove_transaction_id(&mut self) -> Result {
+		use BTreeMap as Map;
+
+		let Some(unsigned) = &self.unsigned else {
+			return Ok(());
+		};
+
+		let mut unsigned: Map<&str, Box<RawJsonValue>> = serde_json::from_str(unsigned.get())
+			.map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?;
+
+		unsigned.remove("transaction_id");
+		self.unsigned = to_raw_value(&unsigned)
+			.map(Some)
+			.expect("unsigned is valid");
+
+		Ok(())
+	}
+
+	pub fn add_age(&mut self) -> Result {
+		use BTreeMap as Map;
+
+		let mut unsigned: Map<&str, Box<RawJsonValue>> = self
+			.unsigned
+			.as_deref()
+			.map(RawJsonValue::get)
+			.map_or_else(|| Ok(Map::new()), serde_json::from_str)
+			.map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?;
+
+		// deliberately allowing for the possibility of negative age
+		let now: i128 = MilliSecondsSinceUnixEpoch::now().get().into();
+		let then: i128 = self.origin_server_ts.into();
+		let this_age = now.saturating_sub(then);
+
+		unsigned.insert("age", to_raw_value(&this_age)?);
+		self.unsigned = Some(to_raw_value(&unsigned)?);
+
+		Ok(())
+	}
+
+	pub fn add_relation(&mut self, name: &str, pdu: Option<&Self>) -> Result {
+		use serde_json::Map;
+
+		let mut unsigned: Map<String, JsonValue> = self
+			.unsigned
+			.as_deref()
+			.map(RawJsonValue::get)
+			.map_or_else(|| Ok(Map::new()), serde_json::from_str)
+			.map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?;
+
+		let pdu = pdu
+			.map(serde_json::to_value)
+			.transpose()?
+			.unwrap_or_else(|| JsonValue::Object(Map::new()));
+
+		unsigned
+			.entry("m.relations")
+			.or_insert(JsonValue::Object(Map::new()))
+			.as_object_mut()
+			.map(|object| object.insert(name.to_owned(), pdu));
+
+		self.unsigned = Some(to_raw_value(&unsigned)?);
+
+		Ok(())
 	}
-	self.add_age().log_err().ok();
-}
-
-#[implement(Pdu)]
-pub fn remove_transaction_id(&mut self) -> Result {
-	use BTreeMap as Map;
-
-	let Some(unsigned) = &self.unsigned else {
-		return Ok(());
-	};
-
-	let mut unsigned: Map<&str, Box<RawJsonValue>> = serde_json::from_str(unsigned.get())
-		.map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?;
-
-	unsigned.remove("transaction_id");
-	self.unsigned = to_raw_value(&unsigned)
-		.map(Some)
-		.expect("unsigned is valid");
-
-	Ok(())
-}
-
-#[implement(Pdu)]
-pub fn add_age(&mut self) -> Result {
-	use BTreeMap as Map;
-
-	let mut unsigned: Map<&str, Box<RawJsonValue>> = self
-		.unsigned
-		.as_deref()
-		.map(RawJsonValue::get)
-		.map_or_else(|| Ok(Map::new()), serde_json::from_str)
-		.map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?;
-
-	// deliberately allowing for the possibility of negative age
-	let now: i128 = MilliSecondsSinceUnixEpoch::now().get().into();
-	let then: i128 = self.origin_server_ts.into();
-	let this_age = now.saturating_sub(then);
-
-	unsigned.insert("age", to_raw_value(&this_age)?);
-	self.unsigned = Some(to_raw_value(&unsigned)?);
-
-	Ok(())
-}
-
-#[implement(Pdu)]
-pub fn add_relation(&mut self, name: &str, pdu: Option<&Pdu>) -> Result {
-	use serde_json::Map;
-
-	let mut unsigned: Map<String, JsonValue> = self
-		.unsigned
-		.as_deref()
-		.map(RawJsonValue::get)
-		.map_or_else(|| Ok(Map::new()), serde_json::from_str)
-		.map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?;
-
-	let pdu = pdu
-		.map(serde_json::to_value)
-		.transpose()?
-		.unwrap_or_else(|| JsonValue::Object(Map::new()));
-
-	unsigned
-		.entry("m.relations")
-		.or_insert(JsonValue::Object(Map::new()))
-		.as_object_mut()
-		.map(|object| object.insert(name.to_owned(), pdu));
-
-	self.unsigned = Some(to_raw_value(&unsigned)?);
-
-	Ok(())
 }

src/core/matrix/versions.rs

@@ -44,5 +44,6 @@ pub fn unstable_features() -> BTreeMap<String, bool> {
 		("uk.timedout.msc4323".to_owned(), true), /* agnostic suspend (https://github.com/matrix-org/matrix-spec-proposals/pull/4323) */
 		("org.matrix.msc4155".to_owned(), true), /* invite filtering (https://github.com/matrix-org/matrix-spec-proposals/pull/4155) */
 		("computer.gingershaped.msc4466".to_owned(), true), /* profile change propagation (https://github.com/matrix-org/matrix-spec-proposals/pull/4466) */
+		("org.matrix.msc4380.stable".to_owned(), true),
 	])
 }

src/core/mod.rs

@@ -41,7 +41,7 @@ pub use info::{
 pub use matrix::{Event, EventTypeExt, Pdu, PduCount, PduEvent, PduId, pdu, state_res};
 pub use parking_lot::{Mutex as SyncMutex, RwLock as SyncRwLock};
 pub use server::Server;
-pub use utils::{implement, result, result::Result};
+pub use utils::{result, result::Result};
 
 pub use crate as conduwuit_core;
 

src/core/utils/mod.rs

@@ -22,8 +22,6 @@ mod tests;
 pub mod time;
 pub mod with_lock;
 
-pub use ::conduwuit_macros::implement;
-
 pub use self::{
 	arrayvec::ArrayVecExt,
 	bool::BoolExt,

src/core/utils/time/exponential_backoff.rs

@@ -27,3 +27,12 @@ pub fn continue_exponential_backoff(
 	let min = cmp::min(min, max);
 	elapsed < min
 }
+
+/// Determines the minimum number of backoff seconds
+#[must_use]
+pub fn min_exp_backoff_duration(min: u64, max: u64, retries: u32) -> Duration {
+	let min = Duration::from_secs(min)
+		.saturating_mul(retries)
+		.saturating_mul(retries);
+	Duration::from_secs(max).min(min)
+}