Struct RelayServiceWithNotify 

pub struct RelayServiceWithNotify { /* private fields */ }

Available on crate feature server only.

Combines RelayService with a notification token.

This struct implements [Service]. Note that the service has to be called with hyper’s io argument set to MaybeTlsStream wrapped by [hyper_util::rt::TokioIo], otherwise handling WebSocket requests at /relay will fail at runtime with ConnectionHandlerError::DowncastUpgrade.

The notification token is triggered once the relay connection is fully established. It can be used to cancel a timeout aborting the TCP connection if no upgrade request is received in some time.

Example

let service = RelayService::new(
    Handlers::default(),
    HeaderMap::new(),
    None,
    KeyCache::new(1024),
    Arc::new(AllowAll),
    Arc::new(Metrics::default()),
);
let service = RelayServiceWithNotify::with_timeout(
    service,
    Arc::new(Notify::new()),
    Duration::from_secs(30),
);

let listener = TcpListener::bind("127.0.0.1:0").await?;
let (stream, _peer) = listener.accept().await?;
// Wrap the TCP stream in `MaybeTlsStream`, otherwise the relay WebSocket handler will error at runtime
// for all WebSocket requests to `/relay`.
let stream = MaybeTlsStream::Plain(stream);
http1::Builder::new()
    .serve_connection(TokioIo::new(stream), service)
    .with_upgrades()
    .await?;

Implementations

impl RelayServiceWithNotify

pub fn new(service: RelayService, on_establish: Arc<Notify>) -> Self

Creates a new service wrapper for a connection.

The on_establish notification is triggered once the connection is passed to the relay protocol, i.e. after a WebSocket request on /relay is received and established. Upgraded connections must finish authentication and authorization within 30 seconds of receiving the upgrade request.

pub fn with_timeout( service: RelayService, on_establish: Arc<Notify>, timeout: Duration, ) -> Self

Creates a service wrapper with a relay establishment timeout.

Each upgrade request starts a new timeout covering the WebSocket upgrade, authentication, and authorization. The on_establish notification is triggered once the connection is passed to the relay protocol. Established connections are not subject to this timeout.

The caller must separately bound TLS handshakes and HTTP requests before an upgrade request reaches this service.

Trait Implementations

impl Clone for RelayServiceWithNotify

fn clone(&self) -> RelayServiceWithNotify

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RelayServiceWithNotify

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

Formats the value using the given formatter.

impl Service<Request<Incoming>> for RelayServiceWithNotify

type Response = Response<Box<dyn Body<Data = Bytes, Error = Infallible> + Unpin + Send>>

Responses given by the service.

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.

type Future = Ready<Result<<RelayServiceWithNotify as Service<Request<Incoming>>>::Response, <RelayServiceWithNotify as Service<Request<Incoming>>>::Error>>

The future response value.

fn call(&self, req: Request<Incoming>) -> Self::Future

Process the request and return the response asynchronously. call takes &self instead of mut &self because: