Struct BackendEndpointMux 

pub struct BackendEndpointMux<F> { /* private fields */ }

Sans-io classifier for a backend daemon endpoint.

Construct one per daemon (it is cheap and immutable; sharing behind an Arc is fine) with the daemon’s own DaemonProcess identity, the consumer payload protocols it serves, and a legacy detector closure. In the accept loop, buffer reads as usual and call Self::poll:

use running_process::broker::backend_sdk::{
    BackendEndpointMux, LegacyClassification, MuxPoll,
};
use running_process::broker::backend_handle::DaemonProcess;
use running_process::broker::protocol::Endpoint;

let endpoint = Endpoint::unix_socket("my-daemon", "/tmp/my-daemon.sock")?;
let daemon = DaemonProcess::current_process(endpoint, None)?;
let mux = BackendEndpointMux::new(daemon, &[0x7A63], |buf| {
    // First byte of my legacy wire is always the ASCII 'L' magic.
    match buf.first() {
        None => LegacyClassification::NeedMoreBytes,
        Some(b'L') => LegacyClassification::Legacy,
        Some(_) => LegacyClassification::NotLegacy,
    }
});

let mut read_buf: Vec<u8> = Vec::new();
// ... read bytes into read_buf, then:
match mux.poll(&read_buf)? {
    MuxPoll::NeedMoreBytes => { /* read more */ }
    MuxPoll::Legacy => { /* my own decoder takes over */ }
    MuxPoll::ProbeAnswered { reply, consumed } => {
        // write `reply`, then read_buf.drain(..consumed);
    }
    MuxPoll::Payload { frame, consumed } => {
        // dispatch frame.payload, then read_buf.drain(..consumed);
    }
}

Daemons with no legacy wire pass a detector that always returns LegacyClassification::NotLegacy.

Implementations

impl<F> BackendEndpointMux<F>

where F: Fn(&[u8]) -> LegacyClassification,

pub fn new( daemon: DaemonProcess, served_payload_protocols: &[u32], legacy_detector: F, ) -> Self

Build a mux for daemon, serving the given consumer payload protocols, with a consumer-provided legacy-wire detector.

pub fn poll(&self, buf: &[u8]) -> Result<MuxPoll, MuxError>

Classify the front of buf and, for probes, build the reply.

Pure with respect to I/O: never reads or writes a socket and never consumes from buf — the returned consumed counts tell the caller how far to advance. See MuxPoll for the contract of each verdict and MuxError for connection-fatal outcomes.

pub fn daemon(&self) -> &DaemonProcess

The daemon identity this mux answers probes with.