1 use std::fmt;
2 use std::future::Future;
3 use std::task::{Context, Poll};
4 use tower_service::Service;
5
6 /// Returns a new [`ServiceFn`] with the given closure.
7 ///
8 /// This lets you build a [`Service`] from an async function that returns a [`Result`].
9 ///
10 /// # Example
11 ///
12 /// ```
13 /// use tower::{service_fn, Service, ServiceExt, BoxError};
14 /// # struct Request;
15 /// # impl Request {
16 /// # fn new() -> Self { Self }
17 /// # }
18 /// # struct Response(&'static str);
19 /// # impl Response {
20 /// # fn new(body: &'static str) -> Self {
21 /// # Self(body)
22 /// # }
23 /// # fn into_body(self) -> &'static str { self.0 }
24 /// # }
25 ///
26 /// # #[tokio::main]
27 /// # async fn main() -> Result<(), BoxError> {
28 /// async fn handle(request: Request) -> Result<Response, BoxError> {
29 /// let response = Response::new("Hello, World!");
30 /// Ok(response)
31 /// }
32 ///
33 /// let mut service = service_fn(handle);
34 ///
35 /// let response = service
36 /// .ready()
37 /// .await?
38 /// .call(Request::new())
39 /// .await?;
40 ///
41 /// assert_eq!("Hello, World!", response.into_body());
42 /// #
43 /// # Ok(())
44 /// # }
45 /// ```
service_fn<T>(f: T) -> ServiceFn<T>46 pub fn service_fn<T>(f: T) -> ServiceFn<T> {
47 ServiceFn { f }
48 }
49
50 /// A [`Service`] implemented by a closure.
51 ///
52 /// See [`service_fn`] for more details.
53 #[derive(Copy, Clone)]
54 pub struct ServiceFn<T> {
55 f: T,
56 }
57
58 impl<T> fmt::Debug for ServiceFn<T> {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result59 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
60 f.debug_struct("ServiceFn")
61 .field("f", &format_args!("{}", std::any::type_name::<T>()))
62 .finish()
63 }
64 }
65
66 impl<T, F, Request, R, E> Service<Request> for ServiceFn<T>
67 where
68 T: FnMut(Request) -> F,
69 F: Future<Output = Result<R, E>>,
70 {
71 type Response = R;
72 type Error = E;
73 type Future = F;
74
poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), E>>75 fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), E>> {
76 Ok(()).into()
77 }
78
call(&mut self, req: Request) -> Self::Future79 fn call(&mut self, req: Request) -> Self::Future {
80 (self.f)(req)
81 }
82 }
83