2017-10-07 04:48:14 +00:00
|
|
|
use std::rc::Rc;
|
2017-10-29 13:05:31 +00:00
|
|
|
use std::cell::RefCell;
|
2017-10-07 04:48:14 +00:00
|
|
|
use std::marker::PhantomData;
|
|
|
|
|
|
|
|
use actix::Actor;
|
2017-10-15 22:52:52 +00:00
|
|
|
use http::{header, Version};
|
2017-10-15 21:17:41 +00:00
|
|
|
use futures::Stream;
|
2017-10-07 04:48:14 +00:00
|
|
|
|
2017-10-29 13:05:31 +00:00
|
|
|
use task::{Task, DrainFut};
|
2017-11-10 21:42:32 +00:00
|
|
|
use body::Binary;
|
2017-11-20 03:51:14 +00:00
|
|
|
use error::{Error, ExpectError};
|
2017-10-07 04:48:14 +00:00
|
|
|
use context::HttpContext;
|
2017-10-08 21:56:51 +00:00
|
|
|
use resource::Reply;
|
2017-10-15 05:52:38 +00:00
|
|
|
use httprequest::HttpRequest;
|
2017-10-24 06:25:32 +00:00
|
|
|
use httpresponse::HttpResponse;
|
2017-10-07 04:48:14 +00:00
|
|
|
|
2017-10-07 06:14:13 +00:00
|
|
|
#[doc(hidden)]
|
2017-10-07 04:48:14 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub enum Frame {
|
2017-10-13 21:43:17 +00:00
|
|
|
Message(HttpResponse),
|
2017-11-10 21:42:32 +00:00
|
|
|
Payload(Option<Binary>),
|
2017-10-29 13:05:31 +00:00
|
|
|
Drain(Rc<RefCell<DrainFut>>),
|
2017-10-07 04:48:14 +00:00
|
|
|
}
|
|
|
|
|
2017-11-03 20:35:34 +00:00
|
|
|
impl Frame {
|
|
|
|
pub fn eof() -> Frame {
|
|
|
|
Frame::Payload(None)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-08 21:56:51 +00:00
|
|
|
/// Trait defines object that could be regestered as resource route
|
2017-10-16 08:19:23 +00:00
|
|
|
#[allow(unused_variables)]
|
2017-10-07 04:48:14 +00:00
|
|
|
pub trait RouteHandler<S>: 'static {
|
2017-10-10 06:07:32 +00:00
|
|
|
/// Handle request
|
2017-11-27 05:18:38 +00:00
|
|
|
fn handle(&self, req: HttpRequest<S>) -> Task;
|
2017-10-10 06:07:32 +00:00
|
|
|
|
|
|
|
/// Set route prefix
|
2017-10-16 08:19:23 +00:00
|
|
|
fn set_prefix(&mut self, prefix: String) {}
|
2017-10-07 04:48:14 +00:00
|
|
|
}
|
|
|
|
|
2017-10-22 16:13:29 +00:00
|
|
|
/// Request handling result.
|
2017-11-16 06:06:28 +00:00
|
|
|
pub type RouteResult<T> = Result<Reply<T>, Error>;
|
2017-10-22 16:13:29 +00:00
|
|
|
|
2017-10-15 22:59:26 +00:00
|
|
|
/// Actors with ability to handle http requests.
|
2017-10-15 22:52:52 +00:00
|
|
|
#[allow(unused_variables)]
|
2017-10-10 06:07:32 +00:00
|
|
|
pub trait Route: Actor {
|
2017-10-15 22:59:26 +00:00
|
|
|
/// Shared state. State is shared with all routes within same application
|
2017-11-27 05:18:38 +00:00
|
|
|
/// and could be accessed with `HttpRequest::state()` method.
|
2017-10-07 04:48:14 +00:00
|
|
|
type State;
|
|
|
|
|
2017-10-16 08:19:23 +00:00
|
|
|
/// Handle `EXPECT` header. By default respones with `HTTP/1.1 100 Continue`
|
2017-11-27 05:18:38 +00:00
|
|
|
fn expect(req: &mut HttpRequest<Self::State>, ctx: &mut Self::Context) -> Result<(), Error>
|
2017-10-15 22:52:52 +00:00
|
|
|
where Self: Actor<Context=HttpContext<Self>>
|
|
|
|
{
|
|
|
|
// handle expect header only for HTTP/1.1
|
|
|
|
if req.version() == Version::HTTP_11 {
|
|
|
|
if let Some(expect) = req.headers().get(header::EXPECT) {
|
|
|
|
if let Ok(expect) = expect.to_str() {
|
|
|
|
if expect.to_lowercase() == "100-continue" {
|
|
|
|
ctx.write("HTTP/1.1 100 Continue\r\n\r\n");
|
|
|
|
Ok(())
|
|
|
|
} else {
|
2017-11-20 03:51:14 +00:00
|
|
|
Err(ExpectError::UnknownExpect.into())
|
2017-10-15 22:52:52 +00:00
|
|
|
}
|
|
|
|
} else {
|
2017-11-20 03:51:14 +00:00
|
|
|
Err(ExpectError::Encoding.into())
|
2017-10-15 22:52:52 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-08 06:59:57 +00:00
|
|
|
/// Handle incoming request. Route actor can return
|
2017-10-15 22:59:26 +00:00
|
|
|
/// result immediately with `Reply::reply`.
|
2017-10-16 08:19:23 +00:00
|
|
|
/// Actor itself can be returned with `Reply::stream` for handling streaming
|
|
|
|
/// request/response or websocket connection.
|
2017-10-15 22:59:26 +00:00
|
|
|
/// In that case `HttpContext::start` and `HttpContext::write` has to be used
|
|
|
|
/// for writing response.
|
2017-11-27 05:18:38 +00:00
|
|
|
fn request(req: HttpRequest<Self::State>, ctx: &mut Self::Context) -> RouteResult<Self>;
|
2017-10-07 04:48:14 +00:00
|
|
|
|
2017-10-08 06:59:57 +00:00
|
|
|
/// This method creates `RouteFactory` for this actor.
|
2017-10-07 04:48:14 +00:00
|
|
|
fn factory() -> RouteFactory<Self, Self::State> {
|
|
|
|
RouteFactory(PhantomData)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-08 21:56:51 +00:00
|
|
|
/// This is used for routes registration within `Resource`
|
2017-10-07 04:48:14 +00:00
|
|
|
pub struct RouteFactory<A: Route<State=S>, S>(PhantomData<A>);
|
|
|
|
|
|
|
|
impl<A, S> RouteHandler<S> for RouteFactory<A, S>
|
2017-10-10 06:07:32 +00:00
|
|
|
where A: Actor<Context=HttpContext<A>> + Route<State=S>,
|
2017-10-07 04:48:14 +00:00
|
|
|
S: 'static
|
|
|
|
{
|
2017-11-27 05:18:38 +00:00
|
|
|
fn handle(&self, mut req: HttpRequest<A::State>) -> Task {
|
2017-11-27 05:47:33 +00:00
|
|
|
let mut ctx = HttpContext::new(req.clone_state());
|
2017-10-15 22:52:52 +00:00
|
|
|
|
|
|
|
// handle EXPECT header
|
|
|
|
if req.headers().contains_key(header::EXPECT) {
|
2017-11-27 04:32:12 +00:00
|
|
|
if let Err(resp) = A::expect(&mut req, &mut ctx) {
|
2017-10-15 22:52:52 +00:00
|
|
|
return Task::reply(resp)
|
|
|
|
}
|
|
|
|
}
|
2017-11-27 03:00:57 +00:00
|
|
|
match A::request(req, &mut ctx) {
|
2017-10-22 16:13:29 +00:00
|
|
|
Ok(reply) => reply.into(ctx),
|
|
|
|
Err(err) => Task::reply(err),
|
|
|
|
}
|
2017-10-07 04:48:14 +00:00
|
|
|
}
|
|
|
|
}
|
2017-10-15 21:17:41 +00:00
|
|
|
|
2017-10-15 22:59:26 +00:00
|
|
|
/// Fn() route handler
|
2017-10-15 21:17:41 +00:00
|
|
|
pub(crate)
|
|
|
|
struct FnHandler<S, R, F>
|
2017-11-27 05:18:38 +00:00
|
|
|
where F: Fn(HttpRequest<S>) -> R + 'static,
|
2017-10-15 21:17:41 +00:00
|
|
|
R: Into<HttpResponse>,
|
|
|
|
S: 'static,
|
|
|
|
{
|
|
|
|
f: Box<F>,
|
|
|
|
s: PhantomData<S>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S, R, F> FnHandler<S, R, F>
|
2017-11-27 05:18:38 +00:00
|
|
|
where F: Fn(HttpRequest<S>) -> R + 'static,
|
2017-10-15 21:17:41 +00:00
|
|
|
R: Into<HttpResponse> + 'static,
|
|
|
|
S: 'static,
|
|
|
|
{
|
|
|
|
pub fn new(f: F) -> Self {
|
|
|
|
FnHandler{f: Box::new(f), s: PhantomData}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S, R, F> RouteHandler<S> for FnHandler<S, R, F>
|
2017-11-27 05:18:38 +00:00
|
|
|
where F: Fn(HttpRequest<S>) -> R + 'static,
|
2017-10-15 21:17:41 +00:00
|
|
|
R: Into<HttpResponse> + 'static,
|
|
|
|
S: 'static,
|
|
|
|
{
|
2017-11-27 05:18:38 +00:00
|
|
|
fn handle(&self, req: HttpRequest<S>) -> Task {
|
|
|
|
Task::reply((self.f)(req).into())
|
2017-10-15 21:17:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Async route handler
|
|
|
|
pub(crate)
|
|
|
|
struct StreamHandler<S, R, F>
|
2017-11-27 05:18:38 +00:00
|
|
|
where F: Fn(HttpRequest<S>) -> R + 'static,
|
2017-11-16 06:06:28 +00:00
|
|
|
R: Stream<Item=Frame, Error=Error> + 'static,
|
2017-10-15 21:17:41 +00:00
|
|
|
S: 'static,
|
|
|
|
{
|
|
|
|
f: Box<F>,
|
|
|
|
s: PhantomData<S>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S, R, F> StreamHandler<S, R, F>
|
2017-11-27 05:18:38 +00:00
|
|
|
where F: Fn(HttpRequest<S>) -> R + 'static,
|
2017-11-16 06:06:28 +00:00
|
|
|
R: Stream<Item=Frame, Error=Error> + 'static,
|
2017-10-15 21:17:41 +00:00
|
|
|
S: 'static,
|
|
|
|
{
|
|
|
|
pub fn new(f: F) -> Self {
|
|
|
|
StreamHandler{f: Box::new(f), s: PhantomData}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S, R, F> RouteHandler<S> for StreamHandler<S, R, F>
|
2017-11-27 05:18:38 +00:00
|
|
|
where F: Fn(HttpRequest<S>) -> R + 'static,
|
2017-11-16 06:06:28 +00:00
|
|
|
R: Stream<Item=Frame, Error=Error> + 'static,
|
2017-10-15 21:17:41 +00:00
|
|
|
S: 'static,
|
|
|
|
{
|
2017-11-27 05:18:38 +00:00
|
|
|
fn handle(&self, req: HttpRequest<S>) -> Task {
|
|
|
|
Task::with_stream((self.f)(req))
|
2017-10-15 21:17:41 +00:00
|
|
|
}
|
|
|
|
}
|