matrix/authentication-service
1
0
Fork 0
mirror of https://github.com/matrix-org/matrix-authentication-service.git synced 2025-07-31 09:24:31 +03:00
Code Activity

Improve errors when MAS contacts the Synapse homeserver (#2794)

Browse Source 
* Add some drive-by docstrings

* Change text rendering of catch_http_codes::HttpError

Using `#[source]` is unnatural here because it makes it look like
two distinct errors (one being a cause of the other),
when in reality it is just one error, with 2 parts.

Using `Display` formatting for that leads to a more natural error.

* Add constraints to `catch_http_code{,s}` methods

Not strictly required, but does two things:

- documents what kind of function is expected
- provides a small extra amount of type enforcement at the call site,
  rather than later on when you find the result doesn't implement Service

* Add a `catch_http_errors` shorthand

Nothing major, just a quality of life improvement so you don't have to
repetitively write out what a HTTP error is

* Unexpected error page: remove leading whitespace from preformatted 'details' section

The extra whitespace was probably unintentional and makes the error harder to read,
particularly when it wraps onto a new line unnecessarily

* Capture and log Matrix errors received from Synapse

* Drive-by clippy fix: use clamp instead of min().max()

* Convert `err(Display)` to `err(Debug)` for `anyhow::Error`s in matrix-synapse support module
This commit is contained in:
reivilibre
2024-06-07 12:14:04 +01:00
committed by GitHub
parent d76b54b13f
commit 49e8fe57f4
9 changed files with 236 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
crates/http/src/ext.rs
View File

@ -14,7 +14,7 @@
use std::{ops::RangeBounds, sync::OnceLock};
use http::{header::HeaderName, Request, StatusCode};
use http::{header::HeaderName, Request, Response, StatusCode};
use tower::Service;
use tower_http::cors::CorsLayer;
@ -70,6 +70,9 @@ pub trait ServiceExt<Body>: Sized {
BytesToBodyRequest::new(self)
}
/// Adds a layer which collects all the response body into a contiguous
/// byte buffer.
/// This makes the response type `Response<Bytes>`.
fn response_body_to_bytes(self) -> BodyToBytesResponse<Self> {
BodyToBytesResponse::new(self)
}
@ -86,20 +89,40 @@ pub trait ServiceExt<Body>: Sized {
FormUrlencodedRequest::new(self)
}
fn catch_http_code<M>(self, status_code: StatusCode, mapper: M) -> CatchHttpCodes<Self, M>
/// Catches responses with the given status code and then maps those
/// responses to an error type using the provided `mapper` function.
fn catch_http_code<M, ResBody, E>(
self,
status_code: StatusCode,
mapper: M,
) -> CatchHttpCodes<Self, M>
where
M: Clone,
M: Fn(Response<ResBody>) -> E + Send + Clone + 'static,
{
self.catch_http_codes(status_code..=status_code, mapper)
}
fn catch_http_codes<B, M>(self, bounds: B, mapper: M) -> CatchHttpCodes<Self, M>
/// Catches responses with the given status codes and then maps those
/// responses to an error type using the provided `mapper` function.
fn catch_http_codes<B, M, ResBody, E>(self, bounds: B, mapper: M) -> CatchHttpCodes<Self, M>
where
B: RangeBounds<StatusCode>,
M: Clone,
M: Fn(Response<ResBody>) -> E + Send + Clone + 'static,
{
CatchHttpCodes::new(self, bounds, mapper)
}
/// Shorthand for [`Self::catch_http_codes`] which catches all client errors
/// (4xx) and server errors (5xx).
fn catch_http_errors<M, ResBody, E>(self, mapper: M) -> CatchHttpCodes<Self, M>
where
M: Fn(Response<ResBody>) -> E + Send + Clone + 'static,
{
self.catch_http_codes(
StatusCode::from_u16(400).unwrap()..StatusCode::from_u16(600).unwrap(),
mapper,
)
}
}
impl<S, B> ServiceExt<B> for S where S: Service<Request<B>> {}

14
crates/http/src/layers/catch_http_codes.rs
View File

@ -24,12 +24,8 @@ pub enum Error<S, E> {
#[error(transparent)]
Service { inner: S },
#[error("request failed with status {status_code}")]
HttpError {
status_code: StatusCode,
#[source]
inner: E,
},
#[error("request failed with status {status_code}: {inner}")]
HttpError { status_code: StatusCode, inner: E },
}
impl<S, E> Error<S, E> {
@ -45,10 +41,16 @@ impl<S, E> Error<S, E> {
}
}
/// A layer that catches responses with the HTTP status codes lying within
/// `bounds` and then maps the requests into a custom error type using `mapper`.
#[derive(Clone)]
pub struct CatchHttpCodes<S, M> {
/// The inner service
inner: S,
/// Which HTTP status codes to catch
bounds: (Bound<StatusCode>, Bound<StatusCode>),
/// The function used to convert errors, which must be
/// `Fn(Response<ResBody>) -> E + Send + Clone + 'static`.
mapper: M,
}

1
crates/http/src/layers/json_response.rs
View File

@ -23,6 +23,7 @@ use tower::{Layer, Service};
#[derive(Debug, Error)]
pub enum Error<Service> {
/// An error from the inner service.
#[error(transparent)]
Service { inner: Service },