Struct Server 

pub struct Server { /* private fields */ }

Server for accepting MoQ connections.

Accepts QUIC (and optionally WebSocket), plus plaintext qmux over TCP (--server-tcp-bind) and Unix sockets (--server-unix-bind). Create via ServerConfig::init or Server::new.

Implementations

impl Server

pub fn new(config: ServerConfig) -> Result<Self>

Build a server from its config, binding the QUIC socket up front.

The stream (tcp/unix) listeners bind lazily on the first accept, since they need a runtime.

pub fn with_websocket(self, websocket: Listener) -> Self

Add a standalone WebSocket listener on a separate TCP port.

This is useful for simple applications that want WebSocket on a dedicated port. For applications that need WebSocket on the same HTTP port (e.g. moq-relay), use qmux::Session::accept() with your own HTTP framework instead.

pub fn with_publisher(self, publish: impl Consume<Consumer>) -> Self

Publish the given origin to every session this server accepts.

pub fn with_subscriber(self, subscribe: Producer) -> Self

Subscribe to every session’s broadcasts, ingesting them into the given origin.

pub fn with_stats(self, stats: Session) -> Self

Attach a per-connection moq_net::stats::Session context to all sessions accepted by this server.

pub async fn serve_publish(self, origin: Consumer) -> Result<()>

Accept sessions until the listener stops, serving origin to each subscriber.

Spawns a task per session and logs (rather than propagates) per-session errors, so one bad peer never tears down the listener. Returns when interrupted (Ctrl-C) or on a fatal bind failure. For per-session auth or routing, drive accept yourself instead.

pub async fn serve_consume(self, origin: Producer) -> Result<()>

Accept sessions until the listener stops, ingesting each publisher into origin.

The mirror of serve_publish for the consume direction.

pub fn certificates(&self) -> Certificates

A live handle to the certificates this server is serving.

Use it to publish the SHA-256 fingerprints of a generated certificate at /certificate.sha256, which an http:// client pins to reach a self-signed server. The handle tracks cert hot reloads, so hold it rather than the values it returns.

Empty when no TLS-bearing backend is configured (e.g. a stream-only server).

pub async fn accept(&mut self) -> Option<Request>

Returns the next partially established session, across every configured transport (QUIC, WebSocket, and plaintext qmux over TCP/Unix).

This returns a Request instead of a session so the connection can be rejected early on an invalid path or missing auth. Call Request::ok or Request::close to complete the handshake.

pub fn local_addr(&self) -> Result<SocketAddr>

The address the QUIC listener bound to, useful when the config asked for port 0.

Errors with Error::NoBackend on a stream-only server, which has no QUIC listener.

pub fn websocket_local_addr(&self) -> Option<SocketAddr>

The address the WebSocket listener from with_websocket bound to, if one was set.

pub async fn close(&mut self)

Close every listener, giving in-flight connections a moment to see the shutdown.

accept calls this for you on Ctrl-C.