macltok

public

Star0

Fork 0

Watch0

31 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `9a25b6ce66f4`

tarball

atagen <boss@atagen.co>2026-10-08 13:08 UTC

4 files changed+96-5

error: carry the homeserver's errcode and message

Modified file: docs/design-decisions.md+9 additions−3 deletions@@ -20,11 +20,17 @@ rooms, connection, encryption, verification, upload progress, session. no
 command results ride on it. drain it from its own task, it's bounded and the
 engine waits for you
 
-one error type for everything, `Error { kind, message, challenge }`. match on
-`kind`. `Interrupted` means the engine stopped, the room closed, or the task
-doing the work died before it could answer. `challenge` turns up with
+one error type for everything, `Error { kind, message, challenge, server }`.
+match on `kind`. `Interrupted` means the engine stopped, the room closed, or the
+task doing the work died before it could answer. `challenge` turns up with
 `InteractiveAuthRequired`
 
+`message` is ours and says what we were doing. `server` is the homeserver's
+errcode and message, dug out of the source chain when the error is built, so a
+host can show "invalid password" without walking the chain. `AccountError`
+carries the same, plus a `kind`. neither folds it into `Display`, since anything
+printing the chain would say it twice
+
 ## engine
 
 the run loop routes and does nothing slow. every task it spawns is registered

Modified file: src/account.rs+18 additions−1 deletions@@ -25,7 +25,8 @@ use tokio::sync::{broadcast, mpsc};
 use url::Url;
 
 use crate::{
-    ClientHandle, Engine, EngineConfig, EngineError, ErrorKind, EventStream, SessionStore,
+    ClientHandle, Engine, EngineConfig, EngineError, ErrorKind, EventStream, ServerError,
+    SessionStore,
     engine::{Persistence, StoreLock},
     error::SourceError,
 };
@@ -348,6 +349,8 @@ pub enum AccountError {
     #[error("{context} failed")]
     Operation {
         context: &'static str,
+        kind: ErrorKind,
+        server: Option<ServerError>,
         #[source]
         source: Box<SourceError>,
     },
@@ -376,6 +379,18 @@ pub enum AccountError {
     Engine(#[from] EngineError),
 }
 
+impl AccountError {
+    /// what the homeserver said, when it refused
+    #[must_use]
+    pub fn server(&self) -> Option<&ServerError> {
+        match self {
+            Self::Operation { server, .. } => server.as_ref(),
+            Self::Unsaved { source, .. } => source.server(),
+            _ => None,
+        }
+    }
+}
+
 /// a live login whose record never reached its `SessionStore`
 pub struct UnsavedSession {
     session: Session,
@@ -684,6 +699,8 @@ pub(crate) fn account_error(
 ) -> AccountError {
     AccountError::Operation {
         context,
+        kind: crate::error::classify(&source),
+        server: ServerError::find(&source),
         source: Box::new(source),
     }
 }

Modified file: src/error.rs+68 additions@@ -33,6 +33,8 @@ pub struct Error {
     pub message: String,
     /// set when the server wants interactive auth before it'll do the thing
     pub challenge: Option<Box<InteractiveAuthChallenge>>,
+    /// set when the homeserver refused with a matrix error
+    pub server: Option<ServerError>,
     #[source]
     #[cfg_attr(feature = "serde", serde(skip))]
     source: Option<Arc<SourceError>>,
@@ -68,12 +70,76 @@ pub enum ErrorKind {
     Other,
 }
 
+/// the homeserver's own answer, worth showing a person as it stands
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct ServerError {
+    pub status: u16,
+    pub errcode: String,
+    pub message: String,
+}
+
+impl ServerError {
+    pub(crate) fn find(source: &(dyn std::error::Error + 'static)) -> Option<Self> {
+        let mut current = Some(source);
+        while let Some(error) = current {
+            let api = if let Some(error) = error.downcast_ref::<matrix_sdk::Error>() {
+                error.as_client_api_error()
+            } else if let Some(error) = error.downcast_ref::<HttpError>() {
+                error.as_client_api_error()
+            } else {
+                error.downcast_ref::<ruma::api::error::Error>()
+            };
+            if let Some(api) = api
+                && let ruma::api::error::ErrorBody::Standard(body) = &api.body
+            {
+                return Some(Self {
+                    status: api.status_code.as_u16(),
+                    errcode: body.kind.errcode().to_string(),
+                    message: body.message.clone(),
+                });
+            }
+            current = error.source();
+        }
+        None
+    }
+}
+
+impl std::fmt::Display for ServerError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(formatter, "{} ({})", self.message, self.errcode)
+    }
+}
+
+#[cfg(any(feature = "sqlite", feature = "indexeddb"))]
+pub(crate) fn classify(source: &(dyn std::error::Error + 'static)) -> ErrorKind {
+    let mut current = Some(source);
+    while let Some(error) = current {
+        if let Some(error) = error.downcast_ref::<matrix_sdk::Error>() {
+            return classify_sdk_error(error);
+        }
+        if let Some(error) = error.downcast_ref::<HttpError>() {
+            return classify_http_error(error);
+        }
+        if let Some(error) = error.downcast_ref::<OAuthError>() {
+            return classify_oauth_error(error);
+        }
+        if let Some(error) = error.downcast_ref::<RefreshTokenError>() {
+            return classify_refresh_token_error(error);
+        }
+        current = error.source();
+    }
+    ErrorKind::Other
+}
+
 impl Error {
     pub(crate) fn new(kind: ErrorKind, message: impl Into<String>) -> Self {
         Self {
             kind,
             message: message.into(),
             challenge: None,
+            server: None,
             source: None,
         }
     }
@@ -84,6 +150,7 @@ impl Error {
         source: impl std::error::Error + SendOutsideWasm + SyncOutsideWasm + 'static,
     ) -> Self {
         Self {
+            server: ServerError::find(&source),
             source: Some(Arc::new(source)),
             ..Self::new(kind, message)
         }
@@ -174,6 +241,7 @@ impl PartialEq for Error {
         self.kind == other.kind
             && self.message == other.message
             && self.challenge == other.challenge
+            && self.server == other.server
     }
 }
 

Modified file: src/lib.rs+1−1

@@ -34,7 +34,7 @@ pub use account::{

3434 pub use session_store::{EncryptedSessionStore, SessionStore};

3535

3636 pub use engine::{Engine, EngineConfig, EngineError};

37-pub use error::{Error, ErrorKind};

37+pub use error::{Error, ErrorKind, ServerError};

3838 pub use imbl;

3939 #[cfg(feature = "mirror")]

4040 pub use mirror::{

macltok

Commit 9a25b6ce66f4

Commit `9a25b6ce66f4`