Struct BoxCloneServiceLayer

pub struct BoxCloneServiceLayer<In, T, U, E> { /* private fields */ }

A Clone + Send boxed Layer.

BoxCloneServiceLayer turns a layer into a trait object, allowing both the Layer itself and the output Service to be dynamic, while having consistent types.

This Layer produces BoxCloneService instances erasing the type of the Service produced by the wrapped Layer.

This is similar to BoxLayer except the layer and resulting service implements Clone.

Example

BoxCloneServiceLayer can, for example, be useful to create layers dynamically that otherwise wouldn't have the same types, when the underlying service must be clone (for example, when building a MakeService) In this example, we include a Timeout layer only if an environment variable is set. We can use BoxCloneService to return a consistent type regardless of runtime configuration:

use std::time::Duration;
use tower::{Service, ServiceBuilder, BoxError};
use tower::util::{BoxCloneServiceLayer, BoxCloneService};

#
# struct Request;
# struct Response;
# impl Response {
#     fn new() -> Self { Self }
# }

fn common_layer<S, T>() -> BoxCloneServiceLayer<S, T, S::Response, BoxError>
where
    S: Service<T> + Clone + Send + 'static,
    S::Future: Send + 'static,
    S::Error: Into<BoxError> + 'static,
{
    let builder = ServiceBuilder::new()
        .concurrency_limit(100);

    if std::env::var("SET_TIMEOUT").is_ok() {
        let layer = builder
            .timeout(Duration::from_secs(30))
            .into_inner();

        BoxCloneServiceLayer::new(layer)
    } else {
        let layer = builder
            .map_err(Into::into)
            .into_inner();

        BoxCloneServiceLayer::new(layer)
    }
}

// We can clone the layer (this is true of BoxLayer as well)
let boxed_clone_layer = common_layer();

let cloned_layer = boxed_clone_layer.clone();

// Using the `BoxCloneServiceLayer` we can create a `BoxCloneService`
let service: BoxCloneService<Request, Response, BoxError> = ServiceBuilder::new().layer(boxed_clone_layer)
     .service_fn(|req: Request| async {
        Ok::<_, BoxError>(Response::new())
    });

# let service = assert_service(service);

// And we can still clone the service
let cloned_service = service.clone();
#
# fn assert_service<S, R>(svc: S) -> S
# where S: Service<R> { svc }

Implementations

impl<In, T, U, E> BoxCloneServiceLayer<In, T, U, E>

fn new<L>(inner_layer: L) -> Self
where
    L: Layer<In> + Send + Sync + 'static,
    L::Service: Service<T, Response = U, Error = E> + Send + Clone + 'static,
    <L::Service as Service<T>>::Future: Send + 'static,

Create a new BoxCloneServiceLayer.

Trait Implementations

impl<In, T, U, E> Clone for BoxCloneServiceLayer<In, T, U, E>

fn clone(&self) -> Self

impl<In, T, U, E> Debug for BoxCloneServiceLayer<In, T, U, E>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl<In, T, U, E> Layer<In> for BoxCloneServiceLayer<In, T, U, E>

type Service = BoxCloneService<T, U, E>;
fn layer(&self, inner: In) -> Self::Service

Auto Trait Implementations

impl<In, T, U, E> !RefUnwindSafe for BoxCloneServiceLayer<In, T, U, E>

impl<In, T, U, E> !UnwindSafe for BoxCloneServiceLayer<In, T, U, E>

impl<In, T, U, E> Freeze for BoxCloneServiceLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxCloneService<T, U, E>> + Sync + Send>: Freeze,

impl<In, T, U, E> Send for BoxCloneServiceLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxCloneService<T, U, E>> + Sync + Send>: Send,

impl<In, T, U, E> Sync for BoxCloneServiceLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxCloneService<T, U, E>> + Sync + Send>: Sync,

impl<In, T, U, E> Unpin for BoxCloneServiceLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxCloneService<T, U, E>> + Sync + Send>: Unpin,

impl<In, T, U, E> UnsafeUnpin for BoxCloneServiceLayer<In, T, U, E> where Arc<dyn Layer<In, Service = BoxCloneService<T, U, E>> + Sync + Send>: UnsafeUnpin,

Blanket Implementations

impl<T> Any for BoxCloneServiceLayer<In, T, U, E> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for BoxCloneServiceLayer<In, T, U, E> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for BoxCloneServiceLayer<In, T, U, E> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for BoxCloneServiceLayer<In, T, U, E> where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for BoxCloneServiceLayer<In, T, U, E>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for BoxCloneServiceLayer<In, T, U, E>

impl<T> ToOwned for BoxCloneServiceLayer<In, T, U, E> where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T> WithSubscriber for BoxCloneServiceLayer<In, T, U, E>

impl<T, U> Into<U> for BoxCloneServiceLayer<In, T, U, E> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for BoxCloneServiceLayer<In, T, U, E> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for BoxCloneServiceLayer<In, T, U, E> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>