Struct ServiceAdapter

pub struct ServiceAdapter<T>(/* private fields */);

Adapter to use a tower::Service as a rama::Service, cloning the servicer for each request it has to serve.

Note that:

• you should use SharedServiceAdapter in case you do not want it to be Cloned, but instead shared across serve calls (we’ll wrap your tower service with a Mutex);
• you are required to use the LayerServiceAdapter for tower layer services, which will automatically be the case if you use LayerAdapter to wrap a tower::Layer.

Halting

This adapter assumes that a service will always become ready eventually, as it will call poll_ready until ready prior to calling the tower::Service. Please ensure that your tower::Service does not require a side-step to prevent such halting.

Implementations

impl<T: Clone + Send + Sync + 'static> ServiceAdapter<T>

pub fn new(svc: T) -> Self

Adapt a Clone/call tower::Service into a rama::Service.

See ServiceAdapter for more information.

pub fn into_inner(self) -> T

Consume itself to return the inner tower::Service back.

Trait Implementations

impl<T: Clone> Clone for ServiceAdapter<T>

fn clone(&self) -> ServiceAdapter<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ServiceAdapter<T>

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

Formats the value using the given formatter.

impl<T, State, Request> Service<State, Request> for ServiceAdapter<T>

where T: TowerService<Request, Response: Send + 'static, Error: Send + 'static, Future: Send> + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static,

type Response = <T as Service<Request>>::Response

The type of response returned by the service.

type Error = <T as Service<Request>>::Error

The type of error returned by the service.

fn serve( &self, _ctx: Context<State>, req: Request, ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send + '_

Serve a response or error for the given request, using the given context.

fn boxed(self) -> BoxService<S, Request, Self::Response, Self::Error>

Box this service to allow for dynamic dispatch.