-
Notifications
You must be signed in to change notification settings - Fork 153
/
service.rs
69 lines (57 loc) · 2.04 KB
/
service.rs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
use Body;
use http::{Request, Response};
use futures::{Future, Poll};
use tower_service::Service;
use sealed::Sealed;
use util::{AsService, IntoService};
/// An HTTP service
///
/// This is not intended to be implemented directly. Instead, it is a trait
/// alias of sorts. Implements the `tower_service::Service` trait using
/// `http::Request` and `http::Response` types.
pub trait HttpService<RequestBody>: Sealed<RequestBody> {
/// Response payload.
type ResponseBody: Body;
/// Errors produced by the service.
type Error;
/// The future response value.
type Future: Future<Item = Response<Self::ResponseBody>, Error = Self::Error>;
/// Returns `Ready` when the service is able to process requests.
fn poll_ready(&mut self) -> Poll<(), Self::Error>;
/// Process the request and return the response asynchronously.
fn call(&mut self, request: Request<RequestBody>) -> Self::Future;
/// Wrap the HttpService so that it implements tower_service::Service
/// directly.
///
/// Since `HttpService` does not directly implement `Service`, if an
/// `HttpService` instance needs to be used where a `T: Service` is
/// required, it must be wrapped with a type that provides that
/// implementation. `IntoService` does this.
fn into_service(self) -> IntoService<Self> where Self: Sized {
IntoService::new(self)
}
/// Same as `into_service` but operates on an HttpService reference.
fn as_service(&mut self) -> AsService<Self> where Self: Sized {
AsService::new(self)
}
}
impl<T, B1, B2> HttpService<B1> for T
where
T: Service<Request<B1>, Response = Response<B2>>,
B2: Body,
{
type ResponseBody = B2;
type Error = T::Error;
type Future = T::Future;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
Service::poll_ready(self)
}
fn call(&mut self, request: Request<B1>) -> Self::Future {
Service::call(self, request)
}
}
impl<T, B1, B2> Sealed<B1> for T
where
T: Service<Request<B1>, Response = Response<B2>>,
B2: Body,
{}