Struct WebSocketBridge 

pub struct WebSocketBridge { /* private fields */ }

Accepts panels, broadcasts events to them, and collects their commands.

Built on the engine’s thread and used from there; the server runs elsewhere and shares nothing but data.

Implementations

impl WebSocketBridge

pub fn bind(address: &str) -> Result<Self, Error>

Binds a listener and starts serving in the background.

The socket is bound synchronously, so a port already in use is reported to the caller that can do something about it rather than disappearing into a thread.

Errors

Error::Transport if the address cannot be bound, or Error::ThreadNotStarted if the server thread cannot be created.

pub fn bind_with_page( address: &str, page: Option<String>, ) -> Result<Self, Error>

Binds, and also serves page to a browser asking for the root.

One address for both, so opening the host’s address is the whole setup and the panel need not be found on disk. It also gives the page and the socket the same origin, which is what makes an origin check meaningful; a page loaded from a file has an origin of null.

A browser request never consumes a connection slot or a subscription: it is answered and closed before either is taken.

Errors

Error::Transport if the address cannot be bound, or Error::ThreadNotStarted if the server thread will not start.

pub fn bind_with(address: &str, options: Options) -> Result<Self, Error>

Binds with everything the host wants to decide up front.

The way to reach the origin allowlist. See Options.

Errors

Error::Transport if the address cannot be bound, or Error::ThreadNotStarted if the server thread will not start.

pub const fn address(&self) -> SocketAddr

The address actually bound, which resolves a port of 0.

pub fn client_count(&self) -> usize

How many panels are connected.

pub fn publish(&self, event: &MessageEvent)

Sends an event to every connected panel.

Never blocks and never fails for want of an audience: with nobody connected the event is dropped, because a station must not stop testing because no one is watching.

pub fn reply(&self, request: &Request, response: &Response)

Answers one request, addressed to the panel that made it.

pub fn next_command(&self) -> Option<Request>

Takes the next command, if one is waiting.

Non-blocking on purpose. The engine thread has its own queue to pump and cannot afford to wait here; it drains what has arrived and gets on with the run.

Trait Implementations

impl Debug for WebSocketBridge

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

Formats the value using the given formatter.

impl Drop for WebSocketBridge

fn drop(&mut self)

Closes the sessions rather than abandoning them.

The server runs on its own thread and does not stop when this type is dropped. Without telling the sessions to close, a panel is left holding a socket to a host that has gone, blocked on a read that never returns.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.