Struct BoxCloneSyncServiceLayer

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

Available on crate feature util only.

A Clone + Send + Sync boxed Layer.

BoxCloneSyncServiceLayer 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 BoxCloneSyncService instances erasing the type of the Service produced by the wrapped Layer.

This is similar to BoxCloneServiceLayer except the layer and resulting service implements Sync.

Example

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

use std::time::Duration;
use tower::{Service, ServiceBuilder, BoxError};
use tower::util::{BoxCloneSyncServiceLayer, BoxCloneSyncService};


fn common_layer<S, T>() -> BoxCloneSyncServiceLayer<S, T, S::Response, BoxError>
where
    S: Service<T> + Clone + Send + Sync + '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();

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

        BoxCloneSyncServiceLayer::new(layer)
    }
}

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

let cloned_sync_layer = boxed_clone_sync_layer.clone();

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


// And we can still clone the service
let cloned_service = service.clone();

Implementations

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

pub fn new<L>(inner_layer: L) -> Self

where L: Layer<In> + Send + Sync + 'static, L::Service: Service<T, Response = U, Error = E> + Send + Sync + Clone + 'static, <L::Service as Service<T>>::Future: Send + 'static,

Create a new BoxCloneSyncServiceLayer.

Trait Implementations

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

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

type Service = BoxCloneSyncService<T, U, E>

The wrapped service

fn layer(&self, inner: In) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes