elaborate error macro and apply at various callsites

Signed-off-by: Jason Volk <jason@zemos.net>

src/service/appservice/mod.rs

@@ -2,7 +2,7 @@ mod data;
 
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduit::Result;
+use conduit::{err, Result};
 use data::Data;
 use futures_util::Future;
 use regex::RegexSet;
@@ -171,7 +171,7 @@ impl Service {
 			.write()
 			.await
 			.remove(service_name)
-			.ok_or_else(|| crate::Error::Err("Appservice not found".to_owned()))?;
+			.ok_or(err!("Appservice not found"))?;
 
 		// remove the appservice from the database
 		self.db.unregister_appservice(service_name)?;

src/service/manager.rs

@@ -1,6 +1,6 @@
 use std::{panic::AssertUnwindSafe, sync::Arc, time::Duration};
 
-use conduit::{debug, debug_warn, error, trace, utils::time, warn, Error, Result, Server};
+use conduit::{debug, debug_warn, error, trace, utils::time, warn, Err, Error, Result, Server};
 use futures_util::FutureExt;
 use tokio::{
 	sync::{Mutex, MutexGuard},
@@ -129,10 +129,7 @@ impl Manager {
 	/// Start the worker in a task for the service.
 	async fn start_worker(&self, workers: &mut WorkersLocked<'_>, service: &Arc<dyn Service>) -> Result<()> {
 		if !self.server.running() {
-			return Err(Error::Err(format!(
-				"Service {:?} worker not starting during server shutdown.",
-				service.name()
-			)));
+			return Err!("Service {:?} worker not starting during server shutdown.", service.name());
 		}
 
 		debug!("Service {:?} worker starting...", service.name());

src/service/mod.rs

@@ -24,7 +24,7 @@ extern crate conduit_database as database;
 
 use std::sync::{Arc, RwLock};
 
-pub(crate) use conduit::{config, debug_error, debug_info, debug_warn, utils, Config, Error, Result, Server};
+pub(crate) use conduit::{config, debug_error, debug_warn, utils, Config, Error, Result, Server};
 pub use conduit::{pdu, PduBuilder, PduCount, PduEvent};
 use database::Database;
 pub(crate) use service::{Args, Service};

src/service/rooms/alias/mod.rs

@@ -171,7 +171,7 @@ impl Service {
 						.rooms
 						.alias
 						.resolve_local_alias(room_alias)?
-						.ok_or_else(|| err!(BadConfig("Room does not exist.")))?,
+						.ok_or_else(|| err!(Request(NotFound("Room does not exist."))))?,
 				));
 			}
 		}

src/service/rooms/auth_chain/mod.rs

@@ -5,9 +5,9 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{debug, error, trace, validated, warn, Error, Result};
+use conduit::{debug, error, trace, validated, warn, Err, Result};
 use data::Data;
-use ruma::{api::client::error::ErrorKind, EventId, RoomId};
+use ruma::{EventId, RoomId};
 
 use crate::services;
 
@@ -143,8 +143,11 @@ impl Service {
 			match services().rooms.timeline.get_pdu(&event_id) {
 				Ok(Some(pdu)) => {
 					if pdu.room_id != room_id {
-						error!(?event_id, ?pdu, "auth event for incorrect room_id");
-						return Err(Error::BadRequest(ErrorKind::forbidden(), "Evil event in db"));
+						return Err!(Request(Forbidden(
+							"auth event {event_id:?} for incorrect room {} which is not {}",
+							pdu.room_id,
+							room_id
+						)));
 					}
 					for auth_event in &pdu.auth_events {
 						let sauthevent = services()

src/service/rooms/event_handler/mod.rs

@@ -10,7 +10,7 @@ use std::{
 };
 
 use conduit::{
-	debug, debug_error, debug_info, error, info, trace,
+	debug, debug_error, debug_info, err, error, info, trace,
 	utils::{math::continue_exponential_backoff_secs, MutexMap},
 	warn, Error, Result,
 };
@@ -1382,11 +1382,8 @@ impl Service {
 	}
 
 	fn get_room_version_id(create_event: &PduEvent) -> Result<RoomVersionId> {
-		let create_event_content: RoomCreateEventContent =
-			serde_json::from_str(create_event.content.get()).map_err(|e| {
-				error!("Invalid create event: {}", e);
-				Error::BadDatabase("Invalid create event in db")
-			})?;
+		let create_event_content: RoomCreateEventContent = serde_json::from_str(create_event.content.get())
+			.map_err(|e| err!(Database("Invalid create event: {e}")))?;
 
 		Ok(create_event_content.room_version)
 	}

src/service/rooms/event_handler/parse_incoming_pdu.rs

@@ -1,4 +1,4 @@
-use conduit::{Error, Result};
+use conduit::{Err, Error, Result};
 use ruma::{api::client::error::ErrorKind, CanonicalJsonObject, OwnedEventId, OwnedRoomId, RoomId};
 use serde_json::value::RawValue as RawJsonValue;
 use tracing::warn;
@@ -17,15 +17,12 @@ pub fn parse_incoming_pdu(pdu: &RawJsonValue) -> Result<(OwnedEventId, Canonical
 		.ok_or(Error::BadRequest(ErrorKind::InvalidParam, "Invalid room id in pdu"))?;
 
 	let Ok(room_version_id) = services().rooms.state.get_room_version(&room_id) else {
-		return Err(Error::Err(format!("Server is not in room {room_id}")));
+		return Err!("Server is not in room {room_id}");
 	};
 
 	let Ok((event_id, value)) = gen_event_id_canonical_json(pdu, &room_version_id) else {
 		// Event could not be converted to canonical json
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Could not convert event to canonical json.",
-		));
+		return Err!(Request(InvalidParam("Could not convert event to canonical json.")));
 	};
 
 	Ok((event_id, value, room_id))

src/service/rooms/spaces/mod.rs

@@ -7,7 +7,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{checked, debug_info, utils::math::usize_from_f64};
+use conduit::{checked, debug, debug_info, err, utils::math::usize_from_f64, warn, Error, Result};
 use lru_cache::LruCache;
 use ruma::{
 	api::{
@@ -27,9 +27,8 @@ use ruma::{
 	OwnedRoomId, OwnedServerName, RoomId, ServerName, UInt, UserId,
 };
 use tokio::sync::Mutex;
-use tracing::{debug, error, warn};
 
-use crate::{services, Error, Result};
+use crate::services;
 
 pub struct CachedSpaceHierarchySummary {
 	summary: SpaceHierarchyParentSummary,
@@ -380,10 +379,7 @@ impl Service {
 			.map(|s| {
 				serde_json::from_str(s.content.get())
 					.map(|c: RoomJoinRulesEventContent| c.join_rule)
-					.map_err(|e| {
-						error!("Invalid room join rule event in database: {}", e);
-						Error::BadDatabase("Invalid room join rule event in database.")
-					})
+					.map_err(|e| err!(Database(error!("Invalid room join rule event in database: {e}"))))
 			})
 			.transpose()?
 			.unwrap_or(JoinRule::Invite);

src/service/rooms/state_accessor/mod.rs

@@ -6,7 +6,7 @@ use std::{
 	sync::{Arc, Mutex as StdMutex, Mutex},
 };
 
-use conduit::{error, utils::math::usize_from_f64, warn, Error, Result};
+use conduit::{err, error, utils::math::usize_from_f64, warn, Error, Result};
 use data::Data;
 use lru_cache::LruCache;
 use ruma::{
@@ -454,10 +454,7 @@ impl Service {
 					.map(|c: RoomJoinRulesEventContent| {
 						(c.join_rule.clone().into(), self.allowed_room_ids(c.join_rule))
 					})
-					.map_err(|e| {
-						error!("Invalid room join rule event in database: {e}");
-						Error::BadDatabase("Invalid room join rule event in database.")
-					})
+					.map_err(|e| err!(Database(error!("Invalid room join rule event in database: {e}"))))
 			})
 			.transpose()?
 			.unwrap_or((SpaceRoomJoinRule::Invite, vec![])))
@@ -483,10 +480,8 @@ impl Service {
 		Ok(self
 			.room_state_get(room_id, &StateEventType::RoomCreate, "")?
 			.map(|s| {
-				serde_json::from_str::<RoomCreateEventContent>(s.content.get()).map_err(|e| {
-					error!("Invalid room create event in database: {e}");
-					Error::BadDatabase("Invalid room create event in database.")
-				})
+				serde_json::from_str::<RoomCreateEventContent>(s.content.get())
+					.map_err(|e| err!(Database(error!("Invalid room create event in database: {e}"))))
 			})
 			.transpose()?
 			.and_then(|e| e.room_type))
@@ -499,10 +494,7 @@ impl Service {
 			.map_or(Ok(None), |s| {
 				serde_json::from_str::<RoomEncryptionEventContent>(s.content.get())
 					.map(|content| Some(content.algorithm))
-					.map_err(|e| {
-						error!("Invalid room encryption event in database: {e}");
-						Error::BadDatabase("Invalid room encryption event in database.")
-					})
+					.map_err(|e| err!(Database(error!("Invalid room encryption event in database: {e}"))))
 			})
 	}
 }

src/service/rooms/state_cache/mod.rs

@@ -2,7 +2,7 @@ mod data;
 
 use std::sync::Arc;
 
-use conduit::{error, warn, Error, Result};
+use conduit::{err, error, warn, Error, Result};
 use data::Data;
 use itertools::Itertools;
 use ruma::{
@@ -128,10 +128,8 @@ impl Service {
 							.account_data
 							.get(Some(&predecessor.room_id), user_id, RoomAccountDataEventType::Tag)?
 							.map(|event| {
-								serde_json::from_str(event.get()).map_err(|e| {
-									warn!("Invalid account data event in db: {e:?}");
-									Error::BadDatabase("Invalid account data event in db.")
-								})
+								serde_json::from_str(event.get())
+									.map_err(|e| err!(Database(warn!("Invalid account data event in db: {e:?}"))))
 							}) {
 							services()
 								.account_data
@@ -144,10 +142,8 @@ impl Service {
 							.account_data
 							.get(None, user_id, GlobalAccountDataEventType::Direct.to_string().into())?
 							.map(|event| {
-								serde_json::from_str::<DirectEvent>(event.get()).map_err(|e| {
-									warn!("Invalid account data event in db: {e:?}");
-									Error::BadDatabase("Invalid account data event in db.")
-								})
+								serde_json::from_str::<DirectEvent>(event.get())
+									.map_err(|e| err!(Database(warn!("Invalid account data event in db: {e:?}"))))
 							}) {
 							let mut direct_event = direct_event?;
 							let mut room_ids_updated = false;
@@ -185,10 +181,8 @@ impl Service {
 							.into(),
 					)?
 					.map(|event| {
-						serde_json::from_str::<IgnoredUserListEvent>(event.get()).map_err(|e| {
-							warn!("Invalid account data event in db: {e:?}");
-							Error::BadDatabase("Invalid account data event in db.")
-						})
+						serde_json::from_str::<IgnoredUserListEvent>(event.get())
+							.map_err(|e| err!(Database(warn!("Invalid account data event in db: {e:?}"))))
 					})
 					.transpose()?
 					.map_or(false, |ignored| {

src/service/sending/mod.rs

@@ -6,7 +6,7 @@ mod sender;
 
 use std::fmt::Debug;
 
-use conduit::{Error, Result};
+use conduit::{err, Result};
 pub use resolve::{resolve_actual_dest, CachedDest, CachedOverride, FedDest};
 use ruma::{
 	api::{appservice::Registration, OutgoingRequest},
@@ -224,7 +224,7 @@ impl Service {
 	fn dispatch(&self, msg: Msg) -> Result<()> {
 		debug_assert!(!self.sender.is_full(), "channel full");
 		debug_assert!(!self.sender.is_closed(), "channel closed");
-		self.sender.send(msg).map_err(|e| Error::Err(e.to_string()))
+		self.sender.send(msg).map_err(|e| err!("{e}"))
 	}
 }
 

src/service/sending/resolve.rs

@@ -5,13 +5,12 @@ use std::{
 	time::SystemTime,
 };
 
-use conduit::Err;
+use conduit::{debug, debug_error, debug_info, debug_warn, trace, utils::rand, Err, Error, Result};
 use hickory_resolver::{error::ResolveError, lookup::SrvLookup};
 use ipaddress::IPAddress;
 use ruma::{OwnedServerName, ServerName};
-use tracing::{debug, error, trace};
 
-use crate::{debug_error, debug_info, debug_warn, services, utils::rand, Error, Result};
+use crate::services;
 
 /// Wraps either an literal IP address plus port, or a hostname plus complement
 /// (colon-plus-port if it was specified).
@@ -346,10 +345,7 @@ fn handle_resolve_error(e: &ResolveError) -> Result<()> {
 			debug!("{e}");
 			Ok(())
 		},
-		_ => {
-			error!("DNS {e}");
-			Err(Error::Err(e.to_string()))
-		},
+		_ => Err!(error!("DNS {e}")),
 	}
 }
 

src/service/updates/mod.rs

@@ -72,7 +72,7 @@ impl Service {
 			.await?;
 
 		let response = serde_json::from_str::<CheckForUpdatesResponse>(&response.text().await?)
-			.map_err(|e| Error::Err(format!("Bad check for updates response: {e}")))?;
+			.map_err(|e| err!("Bad check for updates response: {e}"))?;
 
 		let mut last_update_id = self.last_check_for_updates_id()?;
 		for update in response.updates {