Struct RelayService 

pub struct RelayService(/* private fields */);

Available on crate feature server only.

The hyper Service that serves the actual relay endpoints.

This service can be used standalone or embedded into an existing HTTP server.

Implementations

impl RelayService

pub fn new( handlers: Handlers, headers: HeaderMap, rate_limit: Option<ClientRateLimit>, key_cache: KeyCache, access: Arc<dyn DynAccessControl>, metrics: Arc<Metrics>, ) -> Self

Creates a new RelayService.

This allows embedding the relay service into an existing HTTP server.

pub fn set_client_rate_limit(&self, rate_limit: Option<ClientRateLimit>)

Updates the per-client receive rate limit.

The new rate limit will be applied to all current and future client connections. Passing None will remove rate limiting from all connections.

pub async fn shutdown(&self)

Shuts down the relay service, disconnecting all clients.

pub fn clients(&self) -> &Clients

Returns a reference to the registry of currently connected clients.

The returned Clients handle can be used at runtime to disconnect a connected endpoint via Clients::disconnect.

pub async fn handle_connection( self, stream: TcpStream, tls_config: Option<TlsConfig>, establish_timeout: Duration, )

Handle the incoming connection.

If a tls_config is given, will serve the connection using HTTPS, otherwise HTTP.

TLS and HTTP establishment are bounded by establish_timeout. An upgrade request starts a separate timeout of the same duration for the WebSocket upgrade, authentication, and authorization. The connection is aborted if either timeout expires.

Example

// Create a relay service
let handlers = Handlers::default();
let headers = HeaderMap::new();
let key_cache = KeyCache::new(1024);
let metrics = Arc::new(Metrics::default());
let relay_service = RelayService::new(
    handlers,
    headers,
    None, // No rate limiting
    key_cache,
    Arc::new(AllowAll),
    metrics,
);

// Generate a self-signed certificate for HTTPS
let cert = rcgen::generate_simple_self_signed(vec!["localhost".to_string()])?;
let cert_der = cert.cert.der().to_vec();
let private_key_der = cert.signing_key.serialize_der();
let cert_chain = vec![CertificateDer::from(cert_der)];
let private_key = PrivateKeyDer::try_from(private_key_der)?;

// Serve with HTTPS
let server_config = Arc::new(
    rustls::ServerConfig::builder()
        .with_no_client_auth()
        .with_single_cert(cert_chain, private_key)?,
);
let tls_config = TlsConfig::new(server_config);
relay_service
    .clone()
    .handle_connection(stream, Some(tls_config), Duration::from_secs(30))
    .await;

// Or serve with plain HTTP
relay_service
    .handle_connection(stream, None, Duration::from_secs(30))
    .await;

Trait Implementations

impl Clone for RelayService

fn clone(&self) -> RelayService

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RelayService

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

Formats the value using the given formatter.