ServiceBuilder

#[derive(Clone)]
pub struct ServiceBuilder<L> {
    layer: L,
}

impl ServiceBuilder<Identity> {
    pub const fn new() -> Self {
        ServiceBuilder {
            layer: Identity::new(),
        }
    }
}

impl<L> ServiceBuilder<L> {
    pub fn layer<T>(self, layer: T) -> ServiceBuilder<Stack<T, L>> {
        ServiceBuilder {
            layer: Stack::new(layer, self.layer),
        }
    }

    // ...

    pub fn service<S>(&self, service: S) -> L::Service
    where
        L: Layer<S>,
    {
        self.layer.layer(service)
    }
}

/// The order in which layers are added impacts how requests are handled. Layers
/// that are added first will be called with the request first. The argument to
/// `service` will be last to see the request.

tower = { version = "=0.5.3", features = ["timeout", "limit", "util"] }
tokio = { version = "=1.54.1", features = ["full"] }

use std::any::type_name_of_val;
use std::convert::Infallible;
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use tower::{service_fn, Layer, Service, ServiceBuilder, ServiceExt};

#[derive(Clone, Debug)]
struct LogLayer(&'static str);

struct Log<S> {
  name: &'static str,
  inner: S,
}

impl<S> Layer<S> for LogLayer {
  type Service = Log<S>;
  fn layer(&self, inner: S) -> Log<S> {
    Log { name: self.0, inner }
  }
}

impl<S, R> Service<R> for Log<S>
where
  S: Service<R>,
  S::Future: 'static,
{
  type Response = S::Response;
  type Error = S::Error;
  type Future = Pin<Box<dyn Future<Output = Result<S::Response, S::Error>>>>;

  fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
    println!("{} poll_ready", self.name);
    self.inner.poll_ready(cx)
  }

  fn call(&mut self, req: R) -> Self::Future {
    println!("{} call", self.name);
    let name = self.name;
    let fut = self.inner.call(req);
    Box::pin(async move {
      let res = fut.await;
      println!("{} response", name);
      res
    })
  }
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let builder = ServiceBuilder::new().layer(LogLayer("A")).layer(LogLayer("B"));
  println!("{:?}", builder);
  let svc = builder.service(service_fn(|req: u32| async move {
    println!("inner handles {req}");
    Ok::<_, Infallible>(req)
  }));
  println!("{}", type_name_of_val(&builder));
  println!("{}", type_name_of_val(&svc));
  svc.oneshot(7).await.unwrap();

  let b2 = ServiceBuilder::new()
    .timeout(std::time::Duration::from_secs(1))
    .concurrency_limit(10);
  let s2 = b2.service(service_fn(|req: u32| async move { Ok::<_, Infallible>(req) }));
  println!("{}", type_name_of_val(&b2));
  println!("{}", type_name_of_val(&s2));
}

ServiceBuilder(Identity, LogLayer("A"), LogLayer("B"))
tower::builder::ServiceBuilder<tower_layer::stack::Stack<order::LogLayer, tower_layer::stack::Stack<order::LogLayer, tower_layer::identity::Identity>>>
order::Log<order::Log<tower::util::service_fn::ServiceFn<order::main::{{closure}}::{{closure}}>>>
A poll_ready
B poll_ready
A call
B call
inner handles 7
B response
A response
tower::builder::ServiceBuilder<tower_layer::stack::Stack<tower::limit::concurrency::layer::ConcurrencyLimitLayer, tower_layer::stack::Stack<tower::timeout::layer::TimeoutLayer, tower_layer::identity::Identity>>>
tower::timeout::Timeout<tower::limit::concurrency::service::ConcurrencyLimit<tower::util::service_fn::ServiceFn<order::main::{{closure}}::{{closure}}>>>

pub fn option_layer<L>(layer: Option<L>) -> Either<L, Identity> {
    if let Some(layer) = layer {
        Either::Left(layer)
    } else {
        Either::Right(Identity::new())
    }
}

impl<A, B, Request> Service<Request> for Either<A, B>
where
    A: Service<Request>,
    B: Service<Request, Response = A::Response, Error = A::Error>,

    #[inline]
    pub fn check_service<S, T, U, E>(self) -> Self
    where
        L: Layer<S>,
        L::Service: Service<T, Response = U, Error = E>,
    {
        self
    }

tower = { version = "=0.5.3", features = ["timeout", "util"] }
tokio = { version = "=1.54.1", features = ["full"] }

use std::convert::Infallible;
use std::future::{ready, Ready};
use std::task::{Context, Poll};
use std::time::Duration;
use tower::timeout::TimeoutLayer;
use tower::{Service, ServiceBuilder, ServiceExt};

struct Echo;

impl Service<String> for Echo {
  type Response = String;
  type Error = Infallible;
  type Future = Ready<Result<String, Infallible>>;
  fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Infallible>> {
    Poll::Ready(Ok(()))
  }
  fn call(&mut self, req: String) -> Self::Future {
    ready(Ok(req))
  }
}

#[tokio::main]
async fn main() {
  let timeout = Some(TimeoutLayer::new(Duration::from_secs(1)));
  let svc = ServiceBuilder::new()
    .option_layer(timeout)
    .map_request(|req: String| req.to_uppercase())
    .service(Echo);
  let rsp = svc.oneshot("hi".to_string()).await;
  println!("{rsp:?}");
}

error[E0599]: the method `oneshot` exists for enum `Either<Timeout<MapRequest<Echo, {closure@...}>>, _>`, but its trait bounds were not satisfied
  --> examples/nocheck.rs:29:17
   |
29 |   let rsp = svc.oneshot("hi".to_string()).await;
   |                 ^^^^^^^ method cannot be called due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `Either<tower::timeout::Timeout<MapRequest<Echo, {closure@examples/nocheck.rs:27:18: 27:31}>>, MapRequest<Echo, {closure@examples/nocheck.rs:27:18: 27:31}>>: Service<_>`
           which is required by `Either<tower::timeout::Timeout<MapRequest<Echo, {closure@examples/nocheck.rs:27:18: 27:31}>>, MapRequest<Echo, {closure@examples/nocheck.rs:27:18: 27:31}>>: ServiceExt<_>`

    .option_layer(timeout)
    .check_service::<Echo, String, String, tower::BoxError>()

error[E0271]: type mismatch resolving `<Echo as Service<String>>::Error == Box<dyn Error + Send + Sync>`
   --> examples/withcheck.rs:27:6
    |
 27 |     .check_service::<Echo, String, String, tower::BoxError>()
    |      ^^^^^^^^^^^^^ type mismatch resolving `<Echo as Service<String>>::Error == Box<dyn Error + Send + Sync>`
    |
note: expected this to be `Box<(dyn std::error::Error + Send + Sync + 'static)>`
   --> examples/withcheck.rs:12:16
    |
 12 |   type Error = Infallible;
    |                ^^^^^^^^^^
    = note: expected struct `Box<(dyn std::error::Error + Send + Sync + 'static)>`
                 found enum `Infallible`
    = note: required for `Either<tower::timeout::Timeout<Echo>, Echo>` to implement `Service<String>`
note: required by a bound in `ServiceBuilder::<L>::check_service`

  for timeout in [Some(TimeoutLayer::new(Duration::from_secs(1))), None] {
    let svc = ServiceBuilder::new()
      .option_layer(timeout)
      .map_err(tower::BoxError::from)
      .check_service::<Echo, String, String, tower::BoxError>()
      .map_request(|req: String| req.to_uppercase())
      .service(Echo);
    let variant = match &svc {
      Either::Left(_) => "Left",
      Either::Right(_) => "Right",
    };
    let rsp = svc.oneshot("hi".to_string()).await;
    println!("{variant}: {rsp:?}");
  }

Left: Ok("HI")
Right: Ok("HI")

  let _builder = ServiceBuilder::new()
    .concurrency_limit(10)
    .check_service_clone::<Echo>()
    .rate_limit(100, Duration::from_secs(1))
    .check_service_clone::<Echo>();

ServiceBuilder(Identity, LogLayer("A"), ServiceBuilder(Identity, LogLayer("B"), LogLayer("C")), LogLayer("D"))
A poll_ready
B poll_ready
C poll_ready
D poll_ready
A call
B call
C call
D call
D response
C response
B response
A response