cleanup some error callsites

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

src/api/router/args.rs

@@ -2,11 +2,8 @@ use std::{mem, ops::Deref};
 
 use axum::{async_trait, body::Body, extract::FromRequest};
 use bytes::{BufMut, BytesMut};
-use conduit::{debug, debug_warn, trace, warn, Error, Result};
-use ruma::{
-	api::{client::error::ErrorKind, IncomingRequest},
-	CanonicalJsonValue, OwnedDeviceId, OwnedServerName, OwnedUserId, UserId,
-};
+use conduit::{debug, err, trace, Error, Result};
+use ruma::{api::IncomingRequest, CanonicalJsonValue, OwnedDeviceId, OwnedServerName, OwnedUserId, UserId};
 
 use super::{auth, auth::Auth, request, request::Request};
 use crate::{service::appservice::RegistrationInfo, services};
@@ -103,21 +100,14 @@ where
 	let mut http_request = hyper::Request::builder()
 		.uri(request.parts.uri.clone())
 		.method(request.parts.method.clone());
-	*http_request.headers_mut().unwrap() = request.parts.headers.clone();
-	let http_request = http_request.body(body).unwrap();
-	debug!(
-		"{:?} {:?} {:?}",
-		http_request.method(),
-		http_request.uri(),
-		http_request.headers()
-	);
+	*http_request.headers_mut().expect("mutable http headers") = request.parts.headers.clone();
+	let http_request = http_request.body(body).expect("http request body");
 
-	trace!("{:?} {:?} {:?}", http_request.method(), http_request.uri(), json_body);
-	let body = T::try_from_http_request(http_request, &request.path).map_err(|e| {
-		warn!("try_from_http_request failed: {e:?}",);
-		debug_warn!("JSON body: {:?}", json_body);
-		Error::BadRequest(ErrorKind::BadJson, "Failed to deserialize request.")
-	})?;
+	let headers = http_request.headers();
+	let method = http_request.method();
+	let uri = http_request.uri();
+	debug!("{method:?} {uri:?} {headers:?}");
+	trace!("{method:?} {uri:?} {json_body:?}");
 
-	Ok(body)
+	T::try_from_http_request(http_request, &request.path).map_err(|e| err!(Request(BadJson(debug_warn!("{e}")))))
 }

src/api/router/request.rs

@@ -2,11 +2,11 @@ use std::str;
 
 use axum::{extract::Path, RequestExt, RequestPartsExt};
 use bytes::Bytes;
+use conduit::err;
 use http::request::Parts;
-use ruma::api::client::error::ErrorKind;
 use serde::Deserialize;
 
-use crate::{services, Error, Result};
+use crate::{services, Result};
 
 #[derive(Deserialize)]
 pub(super) struct QueryParams {
@@ -26,14 +26,15 @@ pub(super) async fn from(request: hyper::Request<axum::body::Body>) -> Result<Re
 	let (mut parts, body) = limited.into_parts();
 
 	let path: Path<Vec<String>> = parts.extract().await?;
-	let query = serde_html_form::from_str(parts.uri.query().unwrap_or_default())
-		.map_err(|_| Error::BadRequest(ErrorKind::Unknown, "Failed to read query parameters"))?;
+	let query = parts.uri.query().unwrap_or_default();
+	let query =
+		serde_html_form::from_str(query).map_err(|e| err!(Request(Unknown("Failed to read query parameters: {e}"))))?;
 
 	let max_body_size = services().globals.config.max_request_size;
 
 	let body = axum::body::to_bytes(body, max_body_size)
 		.await
-		.map_err(|_| Error::BadRequest(ErrorKind::TooLarge, "Request body too large"))?;
+		.map_err(|e| err!(Request(TooLarge("Request body too large: {e}"))))?;
 
 	Ok(Request {
 		path,

src/api/server/send.rs

@@ -1,7 +1,7 @@
 use std::{collections::BTreeMap, net::IpAddr, time::Instant};
 
 use axum_client_ip::InsecureClientIp;
-use conduit::debug_warn;
+use conduit::{debug, debug_warn, err, trace, warn, Err};
 use ruma::{
 	api::{
 		client::error::ErrorKind,
@@ -18,7 +18,6 @@ use ruma::{
 	OwnedEventId, ServerName,
 };
 use tokio::sync::RwLock;
-use tracing::{debug, error, trace, warn};
 
 use crate::{
 	service::rooms::event_handler::parse_incoming_pdu,
@@ -39,24 +38,17 @@ pub(crate) async fn send_transaction_message_route(
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
 	if *origin != body.body.origin {
-		return Err(Error::BadRequest(
-			ErrorKind::forbidden(),
-			"Not allowed to send transactions on behalf of other servers",
-		));
+		return Err!(Request(Forbidden(
+			"Not allowed to send transactions on behalf of other servers"
+		)));
 	}
 
 	if body.pdus.len() > 50_usize {
-		return Err(Error::BadRequest(
-			ErrorKind::forbidden(),
-			"Not allowed to send more than 50 PDUs in one transaction",
-		));
+		return Err!(Request(Forbidden("Not allowed to send more than 50 PDUs in one transaction")));
 	}
 
 	if body.edus.len() > 100_usize {
-		return Err(Error::BadRequest(
-			ErrorKind::forbidden(),
-			"Not allowed to send more than 100 EDUs in one transaction",
-		));
+		return Err!(Request(Forbidden("Not allowed to send more than 100 EDUs in one transaction")));
 	}
 
 	let txn_start_time = Instant::now();
@@ -392,10 +384,9 @@ async fn handle_edu_direct_to_device(
 						target_user_id,
 						target_device_id,
 						&ev_type.to_string(),
-						event.deserialize_as().map_err(|e| {
-							error!("To-Device event is invalid: {event:?} {e}");
-							Error::BadRequest(ErrorKind::InvalidParam, "Event is invalid")
-						})?,
+						event
+							.deserialize_as()
+							.map_err(|e| err!(Request(InvalidParam(error!("To-Device event is invalid: {e}")))))?,
 					)?;
 				},
 
@@ -408,7 +399,7 @@ async fn handle_edu_direct_to_device(
 							&ev_type.to_string(),
 							event
 								.deserialize_as()
-								.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Event is invalid"))?,
+								.map_err(|e| err!(Request(InvalidParam("Event is invalid: {e}"))))?,
 						)?;
 					}
 				},