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: AccessConfig, metrics: Arc<Metrics>, ) -> Self

Creates a new RelayService.

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

pub async fn shutdown(&self)

Shuts down the relay service, disconnecting all clients.

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

Handle the incoming connection.

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

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,
    AccessConfig::Everyone,
    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))
    .await;

// Or serve with plain HTTP
relay_service.handle_connection(stream, None).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.

impl Service<Request<Incoming>> for RelayService

type Response = Response<Full<Bytes>>

Responses given by the service.

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

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<RelayService as Service<Request<Incoming>>>::Response, <RelayService as Service<Request<Incoming>>>::Error>> + Send>>

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: