Trait Service

pub trait Service<Request> {
    type Response;
    type Permit<'a>
       where Self: 'a;

    // Required methods
    async fn acquire(&self) -> Self::Permit<'_>;
    async fn call<'a>(
        permit: Self::Permit<'a>,
        request: Request,
    ) -> Self::Response
       where Self: 'a;
}

An asynchronous function call, which can only be executed after obtaining a permit.

Example

use burger::{service_fn::ServiceFn, *};

let svc = service_fn(|x: usize| async move { x.to_string() });
let permit = svc.acquire().await;
let response = ServiceFn::call(permit, 32).await;

Required Associated Types

type Response

The type produced by the service call.

type Permit<'a> where Self: 'a

The type of the permit required to call the service.

Required Methods

async fn acquire(&self) -> Self::Permit<'_>

Obtains a permit.

async fn call<'a>(permit: Self::Permit<'a>, request: Request) -> Self::Response

where Self: 'a,

Consumes a permit to call the service.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'t, Request, S> Service<Request> for &'t S

where S: Service<Request>,

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

type Permit<'a> = <S as Service<Request>>::Permit<'a> where S: 'a, 't: 'a

async fn acquire(&self) -> Self::Permit<'_>

async fn call<'a>(permit: Self::Permit<'a>, request: Request) -> Self::Response

where Self: 'a,

impl<Request, Permit, S> Service<Request> for Mutex<S>

where for<'a> S: Service<Request, Permit<'a> = Permit> + 'static,

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

type Permit<'a> = Permit where S: 'a

async fn acquire(&self) -> Self::Permit<'_>

async fn call(permit: Self::Permit<'_>, request: Request) -> Self::Response

impl<Request, S> Service<Request> for Arc<S>

where S: Service<Request>,

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

type Permit<'a> = <S as Service<Request>>::Permit<'a> where S: 'a

async fn acquire(&self) -> Self::Permit<'_>

async fn call(permit: Self::Permit<'_>, request: Request) -> Self::Response

impl<Request, S, Permit> Service<Request> for RwLock<S>

where for<'a> S: Service<Request, Permit<'a> = Permit> + 'static,

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

type Permit<'a> = <S as Service<Request>>::Permit<'a> where Self: 'a

async fn acquire(&self) -> Self::Permit<'_>

async fn call(permit: Self::Permit<'_>, request: Request) -> Self::Response

Implementors

impl Service<Infallible> for MiddlewareBuilder

type Permit<'a> = ()

type Response = Infallible

impl<'t, Request, S> Service<Request> for Leak<'t, S>

where S: Service<Request> + 't,

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

type Permit<'a> = LeakPermit<'t, S, Request> where S: 'a, 't: 'a

impl<Request, A, B> Service<Request> for Either<A, B>

where A: Service<Request>, B: Service<Request, Response = A::Response>,

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

type Permit<'a> = Either<<A as Service<Request>>::Permit<'a>, <B as Service<Request>>::Permit<'a>> where Self: 'a

impl<Request, Fut, F> Service<Request> for ServiceFn<F>

where F: Fn(Request) -> Fut, Fut: Future,

type Response = <Fut as Future>::Output

type Permit<'a> = &'a F where F: 'a

impl<Request, S> Service<Request> for Buffer<S>

where S: Service<Request>,

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

type Permit<'a> = BufferPermit<'a, S, Request> where S: 'a

impl<Request, S> Service<Request> for ConcurrencyLimit<S>

where S: Service<Request>,

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

type Permit<'a> = ConcurrencyLimitPermit<'a, S, Request> where S: 'a

impl<Request, S> Service<Request> for Depressurize<S>

where S: Service<Request>,

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

type Permit<'a> = &'a S where S: 'a

impl<Request, S> Service<Request> for PendingRequests<S>

where S: Service<Request>,

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

type Permit<'a> = PendingRequestsPermit<'a, S, Request> where Self: 'a

impl<Request, S> Service<Request> for LoadShed<S>

where S: Service<Request>,

type Response = Result<<S as Service<Request>>::Response, Request>

type Permit<'a> = Option<<S as Service<Request>>::Permit<'a>> where S: 'a

impl<Request, S> Service<Request> for RateLimit<S>

where S: Service<Request>,

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

type Permit<'a> = RateLimitPermit<'a, S, Request> where Self: 'a

impl<Request, S, F, Fut> Service<Request> for Then<S, F>

where S: Service<Request>, F: Fn(S::Response) -> Fut, Fut: Future,

type Response = <Fut as Future>::Output

type Permit<'a> = ThenPermit<'a, S, F, Request> where S: 'a, F: 'a

impl<Request, S, F, Output> Service<Request> for Map<S, F>

where S: Service<Request>, F: Fn(S::Response) -> Output,

type Response = Output

type Permit<'a> = MapPermit<'a, S, F, Request> where S: 'a, F: 'a

impl<Request, S, I> Service<Request> for Select<S, I>

where for<'a> &'a I: IntoIterator<Item = &'a S>, S: Service<Request>,

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

type Permit<'a> = <S as Service<Request>>::Permit<'a> where S: 'a, I: 'a

impl<Request, S, Key> Service<Request> for Balance<S, Key>

where S: Service<Request> + Load + 'static, Key: Eq + Hash + 'static,

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

type Permit<'a> = LeakPermit<'static, S, Request> where Self: 'a

impl<Request, S, P> Service<Request> for Retry<S, P>

where S: Service<Request>, P: Policy<S, Request>,

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

type Permit<'a> = RetryPermit<'a, S, P, Request> where Self: 'a

impl<Request, S, P> Service<Request> for Steer<S, P>

where S: Service<Request>, P: Picker<S, Request>,

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

type Permit<'a> = SteerPermit<'a, S, P, Request> where Self: 'a