Struct UpgradeLayer 

pub struct UpgradeLayer<O> { /* private fields */ }

UpgradeLayer is a middleware that can be used to upgrade a request.

See UpgradeService for more details.

Implementations

impl<O: Send + 'static> UpgradeLayer<O>

pub fn new<M, R>(exec: Executor, matcher: M, service: R) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeOutput<Request, O>, Error = O> + Clone,

Create a new upgrade layer from one service.

The service responds to the upgrade request with an UpgradeOutput containing the response-local handler for the upgraded connection. This lets that handler directly own resources established before the response. Use Self::new_with_services when the responder and handler are separate.

pub fn new_with_error_sink<M, R, Sink>( exec: Executor, matcher: M, service: R, sink: Sink, ) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeOutput<Request, O>, Error = O> + Clone, Sink: ErrorSink,

Create a single-service upgrade layer with a custom handler error sink.

pub fn new_dropping_errors<M, R>(exec: Executor, matcher: M, service: R) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeOutput<Request, O>, Error = O> + Clone,

Create a single-service upgrade layer which silently drops handler errors.

pub fn new_with_services<M, R, H>( exec: Executor, matcher: M, responder: R, handler: H, ) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeResponse<Request, O>, Error = O> + Clone, H: Service<Upgraded, Error: Into<BoxError>> + Clone,

Create an upgrade layer with separate responder and handler services.

This is useful when the handshake can be acknowledged independently and the upgraded-connection service performs any deferred setup itself.

pub fn new_with_services_and_error_sink<M, R, H, Sink>( exec: Executor, matcher: M, responder: R, handler: H, sink: Sink, ) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeResponse<Request, O>, Error = O> + Clone, H: Service<Upgraded> + Clone, Sink: ErrorSink<H::Error>,

Create a separate-services upgrade layer with a custom handler error sink.

pub fn new_with_services_dropping_errors<M, R, H>( exec: Executor, matcher: M, responder: R, handler: H, ) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeResponse<Request, O>, Error = O> + Clone, H: Service<Upgraded> + Clone,

Create a separate-services upgrade layer which silently drops handler errors.

pub fn on<M, R>(self, matcher: M, service: R) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeOutput<Request, O>, Error = O> + Clone,

Add a single-service upgrade handler.

pub fn on_with_error_sink<M, R, Sink>( self, matcher: M, service: R, sink: Sink, ) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeOutput<Request, O>, Error = O> + Clone, Sink: ErrorSink,

Add a single-service upgrade handler with a custom handler error sink.

pub fn on_dropping_errors<M, R>(self, matcher: M, service: R) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeOutput<Request, O>, Error = O> + Clone,

Add a single-service upgrade handler which silently drops handler errors.

pub fn on_with_services<M, R, H>( self, matcher: M, responder: R, handler: H, ) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeResponse<Request, O>, Error = O> + Clone, H: Service<Upgraded, Error: Into<BoxError>> + Clone,

Add separate responder and upgraded-connection services.

pub fn on_with_services_and_error_sink<M, R, H, Sink>( self, matcher: M, responder: R, handler: H, sink: Sink, ) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeResponse<Request, O>, Error = O> + Clone, H: Service<Upgraded> + Clone, Sink: ErrorSink<H::Error>,

Add separate services with a custom handler error sink.

pub fn on_with_services_dropping_errors<M, R, H>( self, matcher: M, responder: R, handler: H, ) -> Self

where M: Matcher<Request>, R: Service<Request, Output = UpgradeResponse<Request, O>, Error = O> + Clone, H: Service<Upgraded> + Clone,

Add separate services while silently dropping handler errors.

pub fn with_upgrade_error_sink(self, sink: impl ErrorSink) -> Self

Set the ErrorSink used for errors that occur while establishing the upgraded connection (i.e. the HTTP upgrade itself fails, before any handler runs). Per-handler errors are routed to their own sink instead; see Self::on_with_error_sink and Self::on_with_services_and_error_sink.

Defaults to TracingErrorSink::default (traces at DEBUG level).

Trait Implementations

impl<O> Clone for UpgradeLayer<O>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O> Debug for UpgradeLayer<O>

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

Formats the value using the given formatter.

impl<S, O> Layer<S> for UpgradeLayer<O>

type Service = UpgradeService<S, O>

The service produced by the layer.

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

Wrap the given service with the middleware, returning a new service.

fn into_layer(self, inner: S) -> Self::Service

Same as layer but consuming self after the service was created.