Struct AdaptiveEndpoint 

pub struct AdaptiveEndpoint<S> { /* private fields */ }

A Tower service with per-endpoint adaptive pacing and bounded admission.

poll_ready reports whether another request can enter the endpoint’s bounded scheduling horizon. call reserves a virtual GCRA slot; the returned future waits until that slot is due, waits for the inner service to be ready, and only then records the actual dispatch. Queue delay therefore never contaminates the RTT sample.

Implementations

impl<S> AdaptiveEndpoint<S>

pub fn new(inner: S, config: EndpointConfig) -> Self

pub fn new_at(inner: S, config: EndpointConfig, now: Instant) -> Self

pub fn controller(&self) -> &Mutex<EndpointController>

pub fn snapshot(&self) -> ControllerSnapshot

pub fn load_metric(&self) -> LoadMetric

Trait Implementations

impl<S> Clone for AdaptiveEndpoint<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Drop for AdaptiveEndpoint<S>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<S> Load for AdaptiveEndpoint<S>

type Metric = LoadMetric

A comparable load metric.

fn load(&self) -> Self::Metric

Estimate the service’s current load.

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

where S: Service<Request> + Send + 'static, S::Future: Send + 'static, S::Response: Send + 'static, S::Error: Send + 'static, Request: Send + 'static,

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

Responses given by the service.

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

Errors produced by the service.

type Future = ResponseFuture<<S as Service<Request>>::Response, <S as Service<Request>>::Error>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, request: Request) -> Self::Future

Process the request and return the response asynchronously.