Compiler won't recognize that I'm implementing rocket::response::Responder

help
#1

Rocket 0.4.5 was complaining that my response struct did not implement the 'Responder' trait:

    => Matched: POST /send/<to_address>/<amount> (http_send)
Form(SendAuth { token: "linuxize" })
    => Error: Response was a non-`Responder` `Err`: AuthError { details: "Your token was wrong" }.
    => Warning: This `Responder` implementation has been deprecated.
    => Warning: In Rocket v0.5, `Result<T, E>` implements `Responder` only if `E` implements `Responder`. For the previous behavior, use `Result<T, Debug<E>>` where `Debug` is `rocket::response::Debug`.
    => Outcome: Failure
    => Warning: Responding with 500 Internal Server Error catcher.
    => Response succeeded.

But I did implement it here (github repo)

#[derive(Debug)]
struct AuthError {
    details: String,
}
impl AuthError {
    fn new(msg: &str) -> AuthError {
        AuthError {
            details: msg.to_string(),
        }
    }
}
impl fmt::Display for AuthError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.details)
    }
}

impl error::Error for AuthError {
    fn description(&self) -> &str {
        &self.details
    }
}
impl<'r> Responder<'r> for AuthError {
    fn respond_to(self, _: &rocket::Request) ->rocket::response::Result<'r> {
        Err(rocket::http::Status::new(401, "BAD TOKEN"))
    }
}

Overall I'm unsure as what to return from respond_to(). Since it's an AuthError struct, there's no reason to respond with an Ok().

#2

You haven't stated which code triggers the error, but you don't appear to have functions returning an AuthError in the code you linked. You are instead returning a Result with an error type of Box<dyn Error>. Since that isn't guaranteed to implement Responder, it seems it is using the deprecated fallback implementation for Results with a non-Responder error type, rather than the implementation for error types implenting Error and Responder. Using AuthError directly as the error type should give the behaviour you expect.

#3

Hmm... the reason I return Box<dyn Error> is because the functions below can error for any kind of reason - it could return a io::Error or my custom CommandError, or AuthError. What should I return then?

#4

I would suggest you want a custom error type, either an enum with variants for each error type you might generate and a From implementation to convert each to the custom type, or a trait combining Responder and Error that you can make a trait object of. The first approach gives you a lot of control but is a lot of work. The second approach requires you to make sure every error returned implements Responder, but that should just be a case of wrapping things that don't implement it in rocket::response::Debug.