2018-03-29 22:41:13 +00:00
|
|
|
use std::ops::Deref;
|
2017-10-07 04:48:14 +00:00
|
|
|
use std::marker::PhantomData;
|
2018-04-02 23:19:18 +00:00
|
|
|
use futures::Poll;
|
2018-03-29 22:41:13 +00:00
|
|
|
use futures::future::{Future, FutureResult, ok, err};
|
2017-10-07 04:48:14 +00:00
|
|
|
|
2017-11-29 21:26:55 +00:00
|
|
|
use error::Error;
|
2017-10-15 05:52:38 +00:00
|
|
|
use httprequest::HttpRequest;
|
2017-10-24 06:25:32 +00:00
|
|
|
use httpresponse::HttpResponse;
|
2017-11-03 20:35:34 +00:00
|
|
|
|
2018-01-15 21:47:25 +00:00
|
|
|
/// Trait defines object that could be registered as route handler
|
2017-10-16 08:19:23 +00:00
|
|
|
#[allow(unused_variables)]
|
2017-11-29 21:26:55 +00:00
|
|
|
pub trait Handler<S>: 'static {
|
2017-11-29 23:07:49 +00:00
|
|
|
|
|
|
|
/// The type of value that handler will return.
|
2017-12-14 17:43:42 +00:00
|
|
|
type Result: Responder;
|
2017-11-29 21:26:55 +00:00
|
|
|
|
2017-10-10 06:07:32 +00:00
|
|
|
/// Handle request
|
2017-12-26 17:00:45 +00:00
|
|
|
fn handle(&mut self, req: HttpRequest<S>) -> Self::Result;
|
2017-10-07 04:48:14 +00:00
|
|
|
}
|
|
|
|
|
2017-12-14 17:43:42 +00:00
|
|
|
/// Trait implemented by types that generate responses for clients.
|
|
|
|
///
|
|
|
|
/// Types that implement this trait can be used as the return type of a handler.
|
|
|
|
pub trait Responder {
|
2017-12-03 22:22:04 +00:00
|
|
|
/// The associated item which can be returned.
|
|
|
|
type Item: Into<Reply>;
|
|
|
|
|
|
|
|
/// The associated error which can be returned.
|
|
|
|
type Error: Into<Error>;
|
|
|
|
|
2017-12-14 17:43:42 +00:00
|
|
|
/// Convert itself to `Reply` or `Error`.
|
|
|
|
fn respond_to(self, req: HttpRequest) -> Result<Self::Item, Self::Error>;
|
2017-12-03 00:37:21 +00:00
|
|
|
}
|
|
|
|
|
2018-03-29 20:12:28 +00:00
|
|
|
/// Trait implemented by types that can be extracted from request.
|
|
|
|
///
|
|
|
|
/// Types that implement this trait can be used with `Route::with()` method.
|
|
|
|
pub trait FromRequest<S>: Sized where S: 'static
|
|
|
|
{
|
2018-04-04 05:06:18 +00:00
|
|
|
/// Configuration for conversion process
|
|
|
|
type Config: Default;
|
|
|
|
|
|
|
|
/// Future that resolves to a Self
|
2018-03-29 20:12:28 +00:00
|
|
|
type Result: Future<Item=Self, Error=Error>;
|
|
|
|
|
2018-04-04 05:06:18 +00:00
|
|
|
/// Convert request to a Self
|
|
|
|
fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result;
|
2018-03-29 20:12:28 +00:00
|
|
|
}
|
|
|
|
|
2018-03-11 16:36:54 +00:00
|
|
|
/// Combines two different responder types into a single type
|
2018-03-10 18:12:44 +00:00
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// # extern crate actix_web;
|
|
|
|
/// # extern crate futures;
|
|
|
|
/// # use futures::future::Future;
|
|
|
|
/// use futures::future::result;
|
2018-03-31 06:07:33 +00:00
|
|
|
/// use actix_web::{Either, Error, HttpRequest, HttpResponse, AsyncResponder};
|
2018-03-10 18:12:44 +00:00
|
|
|
///
|
|
|
|
/// type RegisterResult = Either<HttpResponse, Box<Future<Item=HttpResponse, Error=Error>>>;
|
|
|
|
///
|
2018-03-11 16:28:22 +00:00
|
|
|
///
|
2018-03-10 18:12:44 +00:00
|
|
|
/// fn index(req: HttpRequest) -> RegisterResult {
|
2018-03-11 16:28:22 +00:00
|
|
|
/// if is_a_variant() { // <- choose variant A
|
2018-03-10 18:12:44 +00:00
|
|
|
/// Either::A(
|
2018-03-31 06:07:33 +00:00
|
|
|
/// HttpResponse::BadRequest().body("Bad data"))
|
2018-03-10 18:12:44 +00:00
|
|
|
/// } else {
|
2018-03-11 21:50:13 +00:00
|
|
|
/// Either::B( // <- variant B
|
2018-03-31 06:07:33 +00:00
|
|
|
/// result(Ok(HttpResponse::Ok()
|
2018-03-10 18:12:44 +00:00
|
|
|
/// .content_type("text/html")
|
2018-03-31 06:07:33 +00:00
|
|
|
/// .body("Hello!")))
|
|
|
|
/// .responder())
|
2018-03-10 18:12:44 +00:00
|
|
|
/// }
|
|
|
|
/// }
|
2018-03-11 16:28:22 +00:00
|
|
|
/// # fn is_a_variant() -> bool { true }
|
2018-03-10 18:12:44 +00:00
|
|
|
/// # fn main() {}
|
|
|
|
/// ```
|
2018-03-10 17:39:43 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub enum Either<A, B> {
|
|
|
|
/// First branch of the type
|
|
|
|
A(A),
|
|
|
|
/// Second branch of the type
|
|
|
|
B(B),
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<A, B> Responder for Either<A, B>
|
|
|
|
where A: Responder, B: Responder
|
|
|
|
{
|
|
|
|
type Item = Reply;
|
|
|
|
type Error = Error;
|
|
|
|
|
|
|
|
fn respond_to(self, req: HttpRequest) -> Result<Reply, Error> {
|
|
|
|
match self {
|
|
|
|
Either::A(a) => match a.respond_to(req) {
|
|
|
|
Ok(val) => Ok(val.into()),
|
|
|
|
Err(err) => Err(err.into()),
|
|
|
|
},
|
|
|
|
Either::B(b) => match b.respond_to(req) {
|
|
|
|
Ok(val) => Ok(val.into()),
|
|
|
|
Err(err) => Err(err.into()),
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-02 23:19:18 +00:00
|
|
|
impl<A, B, I, E> Future for Either<A, B>
|
|
|
|
where A: Future<Item=I, Error=E>,
|
|
|
|
B: Future<Item=I, Error=E>,
|
|
|
|
{
|
|
|
|
type Item = I;
|
|
|
|
type Error = E;
|
|
|
|
|
|
|
|
fn poll(&mut self) -> Poll<I, E> {
|
|
|
|
match *self {
|
|
|
|
Either::A(ref mut fut) => fut.poll(),
|
|
|
|
Either::B(ref mut fut) => fut.poll(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-31 07:16:55 +00:00
|
|
|
/// Convenience trait that converts `Future` object to a `Boxed` future
|
2018-03-30 16:34:03 +00:00
|
|
|
///
|
|
|
|
/// For example loading json from request's body is async operation.
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// # extern crate actix_web;
|
|
|
|
/// # extern crate futures;
|
|
|
|
/// # #[macro_use] extern crate serde_derive;
|
|
|
|
/// use futures::future::Future;
|
2018-03-31 06:07:33 +00:00
|
|
|
/// use actix_web::{
|
2018-03-31 07:16:55 +00:00
|
|
|
/// App, HttpRequest, HttpResponse, HttpMessage, Error, AsyncResponder};
|
2018-03-30 16:34:03 +00:00
|
|
|
///
|
|
|
|
/// #[derive(Deserialize, Debug)]
|
|
|
|
/// struct MyObj {
|
|
|
|
/// name: String,
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
|
|
|
|
/// req.json() // <- get JsonBody future
|
|
|
|
/// .from_err()
|
|
|
|
/// .and_then(|val: MyObj| { // <- deserialized value
|
2018-03-31 06:07:33 +00:00
|
|
|
/// Ok(HttpResponse::Ok().into())
|
2018-03-30 16:34:03 +00:00
|
|
|
/// })
|
|
|
|
/// // Construct boxed future by using `AsyncResponder::responder()` method
|
|
|
|
/// .responder()
|
|
|
|
/// }
|
|
|
|
/// # fn main() {}
|
|
|
|
/// ```
|
2017-12-21 04:30:54 +00:00
|
|
|
pub trait AsyncResponder<I, E>: Sized {
|
|
|
|
fn responder(self) -> Box<Future<Item=I, Error=E>>;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<F, I, E> AsyncResponder<I, E> for F
|
|
|
|
where F: Future<Item=I, Error=E> + 'static,
|
|
|
|
I: Responder + 'static,
|
|
|
|
E: Into<Error> + 'static,
|
|
|
|
{
|
|
|
|
fn responder(self) -> Box<Future<Item=I, Error=E>> {
|
|
|
|
Box::new(self)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-29 21:26:55 +00:00
|
|
|
/// Handler<S> for Fn()
|
|
|
|
impl<F, R, S> Handler<S> for F
|
2017-11-27 05:18:38 +00:00
|
|
|
where F: Fn(HttpRequest<S>) -> R + 'static,
|
2017-12-14 17:43:42 +00:00
|
|
|
R: Responder + 'static
|
2017-10-15 21:17:41 +00:00
|
|
|
{
|
2017-11-29 21:26:55 +00:00
|
|
|
type Result = R;
|
2017-10-15 21:17:41 +00:00
|
|
|
|
2017-12-26 17:00:45 +00:00
|
|
|
fn handle(&mut self, req: HttpRequest<S>) -> R {
|
2017-11-29 21:26:55 +00:00
|
|
|
(self)(req)
|
2017-10-15 21:17:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-29 21:26:55 +00:00
|
|
|
/// Represents response process.
|
|
|
|
pub struct Reply(ReplyItem);
|
2017-11-29 03:49:17 +00:00
|
|
|
|
2017-11-30 23:13:56 +00:00
|
|
|
pub(crate) enum ReplyItem {
|
2017-12-16 00:24:15 +00:00
|
|
|
Message(HttpResponse),
|
2017-11-30 22:42:20 +00:00
|
|
|
Future(Box<Future<Item=HttpResponse, Error=Error>>),
|
2017-11-29 03:49:17 +00:00
|
|
|
}
|
|
|
|
|
2017-11-29 21:26:55 +00:00
|
|
|
impl Reply {
|
2017-11-29 03:49:17 +00:00
|
|
|
|
|
|
|
/// Create async response
|
2017-12-13 05:32:58 +00:00
|
|
|
#[inline]
|
2017-11-30 22:42:20 +00:00
|
|
|
pub fn async<F>(fut: F) -> Reply
|
|
|
|
where F: Future<Item=HttpResponse, Error=Error> + 'static
|
2017-11-29 03:49:17 +00:00
|
|
|
{
|
2017-11-30 22:42:20 +00:00
|
|
|
Reply(ReplyItem::Future(Box::new(fut)))
|
2017-11-29 03:49:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Send response
|
2017-12-13 05:32:58 +00:00
|
|
|
#[inline]
|
2017-11-30 23:13:56 +00:00
|
|
|
pub fn response<R: Into<HttpResponse>>(response: R) -> Reply {
|
2017-12-16 00:24:15 +00:00
|
|
|
Reply(ReplyItem::Message(response.into()))
|
2017-11-29 03:49:17 +00:00
|
|
|
}
|
|
|
|
|
2017-12-13 05:32:58 +00:00
|
|
|
#[inline]
|
2017-11-30 23:13:56 +00:00
|
|
|
pub(crate) fn into(self) -> ReplyItem {
|
|
|
|
self.0
|
2017-11-29 03:49:17 +00:00
|
|
|
}
|
2017-12-09 21:25:06 +00:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
pub(crate) fn as_response(&self) -> Option<&HttpResponse> {
|
|
|
|
match self.0 {
|
|
|
|
ReplyItem::Message(ref resp) => Some(resp),
|
|
|
|
_ => None,
|
|
|
|
}
|
|
|
|
}
|
2017-11-29 03:49:17 +00:00
|
|
|
}
|
|
|
|
|
2017-12-14 17:43:42 +00:00
|
|
|
impl Responder for Reply {
|
2017-12-03 22:22:04 +00:00
|
|
|
type Item = Reply;
|
|
|
|
type Error = Error;
|
|
|
|
|
2017-12-14 17:43:42 +00:00
|
|
|
fn respond_to(self, _: HttpRequest) -> Result<Reply, Error> {
|
2017-12-03 22:22:04 +00:00
|
|
|
Ok(self)
|
2017-12-03 00:37:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-14 17:43:42 +00:00
|
|
|
impl Responder for HttpResponse {
|
2017-12-03 22:22:04 +00:00
|
|
|
type Item = Reply;
|
|
|
|
type Error = Error;
|
|
|
|
|
2017-12-16 04:00:12 +00:00
|
|
|
#[inline]
|
2017-12-14 17:43:42 +00:00
|
|
|
fn respond_to(self, _: HttpRequest) -> Result<Reply, Error> {
|
2017-12-16 00:24:15 +00:00
|
|
|
Ok(Reply(ReplyItem::Message(self)))
|
2017-10-15 21:17:41 +00:00
|
|
|
}
|
|
|
|
}
|
2017-11-29 18:31:24 +00:00
|
|
|
|
2017-12-03 22:22:04 +00:00
|
|
|
impl From<HttpResponse> for Reply {
|
|
|
|
|
2017-12-16 04:00:12 +00:00
|
|
|
#[inline]
|
2017-12-03 22:22:04 +00:00
|
|
|
fn from(resp: HttpResponse) -> Reply {
|
2017-12-16 00:24:15 +00:00
|
|
|
Reply(ReplyItem::Message(resp))
|
2017-12-02 05:29:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-14 17:43:42 +00:00
|
|
|
impl<T: Responder, E: Into<Error>> Responder for Result<T, E>
|
2017-12-04 00:57:25 +00:00
|
|
|
{
|
2017-12-14 17:43:42 +00:00
|
|
|
type Item = <T as Responder>::Item;
|
2017-12-04 00:57:25 +00:00
|
|
|
type Error = Error;
|
2017-12-03 22:22:04 +00:00
|
|
|
|
2017-12-14 17:43:42 +00:00
|
|
|
fn respond_to(self, req: HttpRequest) -> Result<Self::Item, Self::Error> {
|
2017-12-03 00:37:21 +00:00
|
|
|
match self {
|
2017-12-14 17:43:42 +00:00
|
|
|
Ok(val) => match val.respond_to(req) {
|
2017-12-04 00:57:25 +00:00
|
|
|
Ok(val) => Ok(val),
|
|
|
|
Err(err) => Err(err.into()),
|
|
|
|
},
|
|
|
|
Err(err) => Err(err.into()),
|
2017-12-03 00:37:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-03 22:22:04 +00:00
|
|
|
impl<E: Into<Error>> From<Result<Reply, E>> for Reply {
|
2018-01-03 07:43:17 +00:00
|
|
|
#[inline]
|
2017-12-03 22:22:04 +00:00
|
|
|
fn from(res: Result<Reply, E>) -> Self {
|
2017-11-29 18:31:24 +00:00
|
|
|
match res {
|
|
|
|
Ok(val) => val,
|
2017-12-16 00:24:15 +00:00
|
|
|
Err(err) => Reply(ReplyItem::Message(err.into().into())),
|
2017-12-03 00:37:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-03 07:43:17 +00:00
|
|
|
impl<E: Into<Error>> From<Result<HttpResponse, E>> for Reply {
|
|
|
|
#[inline]
|
|
|
|
fn from(res: Result<HttpResponse, E>) -> Self {
|
|
|
|
match res {
|
|
|
|
Ok(val) => Reply(ReplyItem::Message(val)),
|
|
|
|
Err(err) => Reply(ReplyItem::Message(err.into().into())),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<Box<Future<Item=HttpResponse, Error=Error>>> for Reply {
|
|
|
|
#[inline]
|
|
|
|
fn from(fut: Box<Future<Item=HttpResponse, Error=Error>>) -> Reply {
|
|
|
|
Reply(ReplyItem::Future(fut))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-26 22:58:30 +00:00
|
|
|
/// Convenience type alias
|
|
|
|
pub type FutureResponse<I, E=Error> = Box<Future<Item=I, Error=E>>;
|
|
|
|
|
2017-12-20 23:26:28 +00:00
|
|
|
impl<I, E> Responder for Box<Future<Item=I, Error=E>>
|
|
|
|
where I: Responder + 'static,
|
|
|
|
E: Into<Error> + 'static
|
2017-11-30 23:13:56 +00:00
|
|
|
{
|
2017-12-03 22:22:04 +00:00
|
|
|
type Item = Reply;
|
|
|
|
type Error = Error;
|
|
|
|
|
2017-12-16 04:00:12 +00:00
|
|
|
#[inline]
|
2017-12-20 23:26:28 +00:00
|
|
|
fn respond_to(self, req: HttpRequest) -> Result<Reply, Error> {
|
|
|
|
let fut = self.map_err(|e| e.into())
|
|
|
|
.then(move |r| {
|
|
|
|
match r.respond_to(req) {
|
|
|
|
Ok(reply) => match reply.into().0 {
|
|
|
|
ReplyItem::Message(resp) => ok(resp),
|
|
|
|
_ => panic!("Nested async replies are not supported"),
|
|
|
|
},
|
|
|
|
Err(e) => err(e),
|
|
|
|
}
|
|
|
|
});
|
|
|
|
Ok(Reply::async(fut))
|
2017-11-30 23:13:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-15 21:47:25 +00:00
|
|
|
/// Trait defines object that could be registered as resource route
|
2017-11-29 21:26:55 +00:00
|
|
|
pub(crate) trait RouteHandler<S>: 'static {
|
2017-12-26 17:00:45 +00:00
|
|
|
fn handle(&mut self, req: HttpRequest<S>) -> Reply;
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Route handler wrapper for Handler
|
|
|
|
pub(crate)
|
|
|
|
struct WrapHandler<S, H, R>
|
|
|
|
where H: Handler<S, Result=R>,
|
2017-12-14 17:43:42 +00:00
|
|
|
R: Responder,
|
2017-11-29 21:26:55 +00:00
|
|
|
S: 'static,
|
|
|
|
{
|
|
|
|
h: H,
|
|
|
|
s: PhantomData<S>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S, H, R> WrapHandler<S, H, R>
|
|
|
|
where H: Handler<S, Result=R>,
|
2017-12-14 17:43:42 +00:00
|
|
|
R: Responder,
|
2017-11-29 21:26:55 +00:00
|
|
|
S: 'static,
|
|
|
|
{
|
|
|
|
pub fn new(h: H) -> Self {
|
2018-02-26 22:33:56 +00:00
|
|
|
WrapHandler{h, s: PhantomData}
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S, H, R> RouteHandler<S> for WrapHandler<S, H, R>
|
|
|
|
where H: Handler<S, Result=R>,
|
2017-12-14 17:43:42 +00:00
|
|
|
R: Responder + 'static,
|
2017-11-29 21:26:55 +00:00
|
|
|
S: 'static,
|
|
|
|
{
|
2017-12-26 17:00:45 +00:00
|
|
|
fn handle(&mut self, req: HttpRequest<S>) -> Reply {
|
2018-04-11 19:27:17 +00:00
|
|
|
let req2 = req.drop_state();
|
2017-12-14 17:43:42 +00:00
|
|
|
match self.h.handle(req).respond_to(req2) {
|
2017-12-03 22:22:04 +00:00
|
|
|
Ok(reply) => reply.into(),
|
|
|
|
Err(err) => Reply::response(err.into()),
|
|
|
|
}
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Async route handler
|
|
|
|
pub(crate)
|
2017-12-20 20:51:39 +00:00
|
|
|
struct AsyncHandler<S, H, F, R, E>
|
|
|
|
where H: Fn(HttpRequest<S>) -> F + 'static,
|
|
|
|
F: Future<Item=R, Error=E> + 'static,
|
|
|
|
R: Responder + 'static,
|
|
|
|
E: Into<Error> + 'static,
|
2017-11-29 21:26:55 +00:00
|
|
|
S: 'static,
|
|
|
|
{
|
2017-12-20 20:51:39 +00:00
|
|
|
h: Box<H>,
|
2017-11-29 21:26:55 +00:00
|
|
|
s: PhantomData<S>,
|
|
|
|
}
|
|
|
|
|
2017-12-20 20:51:39 +00:00
|
|
|
impl<S, H, F, R, E> AsyncHandler<S, H, F, R, E>
|
|
|
|
where H: Fn(HttpRequest<S>) -> F + 'static,
|
|
|
|
F: Future<Item=R, Error=E> + 'static,
|
|
|
|
R: Responder + 'static,
|
|
|
|
E: Into<Error> + 'static,
|
2017-11-29 21:26:55 +00:00
|
|
|
S: 'static,
|
|
|
|
{
|
2017-12-20 20:51:39 +00:00
|
|
|
pub fn new(h: H) -> Self {
|
|
|
|
AsyncHandler{h: Box::new(h), s: PhantomData}
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-20 20:51:39 +00:00
|
|
|
impl<S, H, F, R, E> RouteHandler<S> for AsyncHandler<S, H, F, R, E>
|
|
|
|
where H: Fn(HttpRequest<S>) -> F + 'static,
|
|
|
|
F: Future<Item=R, Error=E> + 'static,
|
|
|
|
R: Responder + 'static,
|
|
|
|
E: Into<Error> + 'static,
|
2017-11-29 21:26:55 +00:00
|
|
|
S: 'static,
|
|
|
|
{
|
2017-12-26 17:00:45 +00:00
|
|
|
fn handle(&mut self, req: HttpRequest<S>) -> Reply {
|
2018-04-11 19:27:17 +00:00
|
|
|
let req2 = req.drop_state();
|
2017-12-20 20:51:39 +00:00
|
|
|
let fut = (self.h)(req)
|
|
|
|
.map_err(|e| e.into())
|
|
|
|
.then(move |r| {
|
|
|
|
match r.respond_to(req2) {
|
|
|
|
Ok(reply) => match reply.into().0 {
|
|
|
|
ReplyItem::Message(resp) => ok(resp),
|
|
|
|
_ => panic!("Nested async replies are not supported"),
|
2017-12-20 21:23:50 +00:00
|
|
|
},
|
2017-12-20 20:51:39 +00:00
|
|
|
Err(e) => err(e),
|
|
|
|
}
|
|
|
|
});
|
|
|
|
Reply::async(fut)
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
}
|
2018-03-29 22:41:13 +00:00
|
|
|
|
2018-04-02 21:00:18 +00:00
|
|
|
/// Access an application state
|
2018-03-29 22:41:13 +00:00
|
|
|
///
|
|
|
|
/// `S` - application state type
|
|
|
|
///
|
|
|
|
/// ## Example
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// # extern crate bytes;
|
|
|
|
/// # extern crate actix_web;
|
|
|
|
/// # extern crate futures;
|
|
|
|
/// #[macro_use] extern crate serde_derive;
|
2018-03-31 07:16:55 +00:00
|
|
|
/// use actix_web::{App, Path, State, http};
|
2018-03-29 22:41:13 +00:00
|
|
|
///
|
|
|
|
/// /// Application state
|
2018-03-31 07:16:55 +00:00
|
|
|
/// struct MyApp {msg: &'static str}
|
2018-03-29 22:41:13 +00:00
|
|
|
///
|
|
|
|
/// #[derive(Deserialize)]
|
|
|
|
/// struct Info {
|
|
|
|
/// username: String,
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// /// extract path info using serde
|
2018-03-31 07:16:55 +00:00
|
|
|
/// fn index(state: State<MyApp>, info: Path<Info>) -> String {
|
2018-03-31 00:31:18 +00:00
|
|
|
/// format!("{} {}!", state.msg, info.username)
|
2018-03-29 22:41:13 +00:00
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// fn main() {
|
2018-03-31 07:16:55 +00:00
|
|
|
/// let app = App::with_state(MyApp{msg: "Welcome"}).resource(
|
2018-03-31 00:31:18 +00:00
|
|
|
/// "/{username}/index.html", // <- define path parameters
|
|
|
|
/// |r| r.method(http::Method::GET).with2(index)); // <- use `with` extractor
|
2018-03-29 22:41:13 +00:00
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
pub struct State<S> (HttpRequest<S>);
|
|
|
|
|
|
|
|
impl<S> Deref for State<S> {
|
|
|
|
type Target = S;
|
|
|
|
|
|
|
|
fn deref(&self) -> &S {
|
|
|
|
self.0.state()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S: 'static> FromRequest<S> for State<S>
|
|
|
|
{
|
2018-04-04 05:06:18 +00:00
|
|
|
type Config = ();
|
2018-03-29 22:41:13 +00:00
|
|
|
type Result = FutureResult<Self, Error>;
|
|
|
|
|
|
|
|
#[inline]
|
2018-04-04 05:06:18 +00:00
|
|
|
fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
|
2018-03-29 22:41:13 +00:00
|
|
|
ok(State(req.clone()))
|
|
|
|
}
|
|
|
|
}
|