rwf2
/
Rocket
mirror of https://github.com/rwf2/Rocket.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Rocket/lib/src/catcher.rs

96 lines
2.4 KiB
Rust
Raw Normal View History

Progress on error handling. Calling them 'catchers' for now. Added `error` decorator and `errors` macro. The current idea is that you can have "catchers" for all valid errors code (in range [400, 500). At the moment, catchers are just request handlers, and the decorator expected an empty function signature for the error handler. Obviously, this is pretty useless. Not sure on what the API should be here. But, progress. Oh, one more thing: who should handle forwarding a request to a catcher? Probably not the router. So, the main Rocket should?
2016-04-06 10:26:43 +00:00
use handler::Handler;
Progress on errors. Started Todo example. The error function now takes in a "RoutingError" structure. The idea is that the structure includes all of the information necessary for a user to processor the error as they wish. This interface is very incomplete and may change. At a minimum, the error structure should include: 1) The request that failed. 2) Why the request failed. 3) The chain of attempted route matches, if any. 4) Something else?
2016-07-16 04:09:08 +00:00
use response::Response;
use error::RoutingError;
Progress on error handling. Calling them 'catchers' for now. Added `error` decorator and `errors` macro. The current idea is that you can have "catchers" for all valid errors code (in range [400, 500). At the moment, catchers are just request handlers, and the decorator expected an empty function signature for the error handler. Obviously, this is pretty useless. Not sure on what the API should be here. But, progress. Oh, one more thing: who should handle forwarding a request to a catcher? Probably not the router. So, the main Rocket should?
2016-04-06 10:26:43 +00:00
use codegen::StaticCatchInfo;
use std::fmt;
use term_painter::ToStyle;
use term_painter::Color::*;
pub struct Catcher {
pub code: u16,
Progress on errors. Started Todo example. The error function now takes in a "RoutingError" structure. The idea is that the structure includes all of the information necessary for a user to processor the error as they wish. This interface is very incomplete and may change. At a minimum, the error structure should include: 1) The request that failed. 2) Why the request failed. 3) The chain of attempted route matches, if any. 4) Something else?
2016-07-16 04:09:08 +00:00
handler: Handler,
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
is_default: bool
Progress on error handling. Calling them 'catchers' for now. Added `error` decorator and `errors` macro. The current idea is that you can have "catchers" for all valid errors code (in range [400, 500). At the moment, catchers are just request handlers, and the decorator expected an empty function signature for the error handler. Obviously, this is pretty useless. Not sure on what the API should be here. But, progress. Oh, one more thing: who should handle forwarding a request to a catcher? Probably not the router. So, the main Rocket should?
2016-04-06 10:26:43 +00:00
}
Progress on errors. Started Todo example. The error function now takes in a "RoutingError" structure. The idea is that the structure includes all of the information necessary for a user to processor the error as they wish. This interface is very incomplete and may change. At a minimum, the error structure should include: 1) The request that failed. 2) Why the request failed. 3) The chain of attempted route matches, if any. 4) Something else?
2016-07-16 04:09:08 +00:00
// TODO: Should `Catcher` be an interface? Should there be an `ErrorHandler`
// that takes in a `RoutingError` and returns a `Response`? What's the right
// interface here?
Progress on error handling. Calling them 'catchers' for now. Added `error` decorator and `errors` macro. The current idea is that you can have "catchers" for all valid errors code (in range [400, 500). At the moment, catchers are just request handlers, and the decorator expected an empty function signature for the error handler. Obviously, this is pretty useless. Not sure on what the API should be here. But, progress. Oh, one more thing: who should handle forwarding a request to a catcher? Probably not the router. So, the main Rocket should?
2016-04-06 10:26:43 +00:00
impl Catcher {
pub fn new(code: u16, handler: Handler) -> Catcher {
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
Catcher::new_with_default(code, handler, false)
}
Progress on errors. Started Todo example. The error function now takes in a "RoutingError" structure. The idea is that the structure includes all of the information necessary for a user to processor the error as they wish. This interface is very incomplete and may change. At a minimum, the error structure should include: 1) The request that failed. 2) Why the request failed. 3) The chain of attempted route matches, if any. 4) Something else?
2016-07-16 04:09:08 +00:00
pub fn handle<'a>(&'a self, error: RoutingError<'a>) -> Response {
(self.handler)(error.request)
}
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
fn new_with_default(code: u16, handler: Handler, default: bool) -> Catcher {
Progress on error handling. Calling them 'catchers' for now. Added `error` decorator and `errors` macro. The current idea is that you can have "catchers" for all valid errors code (in range [400, 500). At the moment, catchers are just request handlers, and the decorator expected an empty function signature for the error handler. Obviously, this is pretty useless. Not sure on what the API should be here. But, progress. Oh, one more thing: who should handle forwarding a request to a catcher? Probably not the router. So, the main Rocket should?
2016-04-06 10:26:43 +00:00
Catcher {
code: code,
handler: handler,
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
is_default: default
Progress on error handling. Calling them 'catchers' for now. Added `error` decorator and `errors` macro. The current idea is that you can have "catchers" for all valid errors code (in range [400, 500). At the moment, catchers are just request handlers, and the decorator expected an empty function signature for the error handler. Obviously, this is pretty useless. Not sure on what the API should be here. But, progress. Oh, one more thing: who should handle forwarding a request to a catcher? Probably not the router. So, the main Rocket should?
2016-04-06 10:26:43 +00:00
}
}
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
pub fn is_default(&self) -> bool {
self.is_default
}
Progress on error handling. Calling them 'catchers' for now. Added `error` decorator and `errors` macro. The current idea is that you can have "catchers" for all valid errors code (in range [400, 500). At the moment, catchers are just request handlers, and the decorator expected an empty function signature for the error handler. Obviously, this is pretty useless. Not sure on what the API should be here. But, progress. Oh, one more thing: who should handle forwarding a request to a catcher? Probably not the router. So, the main Rocket should?
2016-04-06 10:26:43 +00:00
}
impl<'a> From<&'a StaticCatchInfo> for Catcher {
fn from(info: &'a StaticCatchInfo) -> Catcher {
Catcher::new(info.code, info.handler)
}
}
impl fmt::Display for Catcher {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
write!(f, "{}", Blue.paint(&self.code))
Progress on error handling. Calling them 'catchers' for now. Added `error` decorator and `errors` macro. The current idea is that you can have "catchers" for all valid errors code (in range [400, 500). At the moment, catchers are just request handlers, and the decorator expected an empty function signature for the error handler. Obviously, this is pretty useless. Not sure on what the API should be here. But, progress. Oh, one more thing: who should handle forwarding a request to a catcher? Probably not the router. So, the main Rocket should?
2016-04-06 10:26:43 +00:00
}
}
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
pub mod defaults {
use request::Request;
Added Response::with_status. Using it for catchers.
2016-04-11 09:12:45 +00:00
use response::{StatusCode, Response};
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
use super::Catcher;
use std::collections::HashMap;
pub fn not_found(_request: Request) -> Response {
Added Response::with_status. Using it for catchers.
2016-04-11 09:12:45 +00:00
Response::with_status(StatusCode::NotFound, "\
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
<head>\
<meta charset=\"utf-8\">\
<title>404: Not Found</title>\
</head>\
<body align=\"center\">\
<h1>404: Not Found</h1>\
<p>The page you were looking for could not be found.<p>\
<hr />\
<small>Rocket</small>\
</body>\
")
}
pub fn internal_error(_request: Request) -> Response {
Added Response::with_status. Using it for catchers.
2016-04-11 09:12:45 +00:00
Response::with_status(StatusCode::InternalServerError, "\
Working error handling! Not quite there yet though. A few important things needs to get this to be 'right': 1a. Have a way to return a response with a status code. 1b. Use that mechanism in the default catchers. 2. Automatically fill in that code from the #[error] handler. 3. Have a way for a responder to say if responding succeeded. 4. Try next highest ranking route if responding with one handler fails.
2016-04-06 20:50:02 +00:00
<head>\
<meta charset=\"utf-8\">\
<title>404: Not Found</title>\
</head>\
<body align=\"center\">\
<h1>500: Internal Server Error</h1>\
<p>The server encountered a problem processing your request.<p>\
<hr />\
<small>Rocket</small>\
")
}
Progress on errors. Started Todo example. The error function now takes in a "RoutingError" structure. The idea is that the structure includes all of the information necessary for a user to processor the error as they wish. This interface is very incomplete and may change. At a minimum, the error structure should include: 1) The request that failed. 2) Why the request failed. 3) The chain of attempted route matches, if any. 4) Something else?
2016-07-16 04:09:08 +00:00
pub fn get() -> HashMap<u16, Catcher> {
let mut map = HashMap::new();
map.insert(404, Catcher::new_with_default(404, not_found, true));
map.insert(500, Catcher::new_with_default(500, internal_error, true));
map
}
}