Struct MuxServer 

pub struct MuxServer<M: RemoteMessage, In: RemoteMessage, Out: RemoteMessage> { /* private fields */ }

A muxed server bundling a simplex receiver, a duplex accept server, and the shared shutdown signal that ties them together.

All three components share one underlying listener. Lifecycle:

• Dropping the MuxServer cancels the shared shutdown and tears down the listener and any in-flight sessions.
• MuxServer::stop does the same explicitly.
• MuxServer::split hands out the address, simplex half, duplex half, and a MuxShutdown separately. After splitting, dropping the simplex half, the duplex half, or the MuxShutdown guard cancels the shared shutdown. The address is a plain value and does not own any resources.

The simplex half is a ChannelRx<M> you recv() on; the duplex half is a [DuplexServer<In, Out>] you accept() on. Neither is join()-able — there is no separate per-half task to await.

Implementations

impl<M: RemoteMessage, In: RemoteMessage, Out: RemoteMessage> MuxServer<M, In, Out>

pub fn addr(&self) -> &ChannelAddr

The address the muxed listener is bound to.

pub fn simplex_mut(&mut self) -> &mut ChannelRx<M>

Borrow the simplex receiver.

pub fn duplex_mut(&mut self) -> &mut DuplexServer<In, Out>

Borrow the duplex accept server.

pub fn stop(&self, reason: &str)

Cancel the shared shutdown and tear down both halves.

pub fn split( self, ) -> (ChannelAddr, ChannelRx<M>, DuplexServer<In, Out>, MuxShutdown)

Move the bound address, simplex half, duplex half, and a MuxShutdown guard out of this wrapper. After splitting, dropping the simplex half, the duplex half, or the MuxShutdown guard cancels the shared shutdown and tears the rest down. The address is a plain value and does not own any resources.

pub fn serve<SH, DH, DF>( self, simplex_handler: SH, duplex_handler: DH, ) -> MailboxServerHandle

where SH: FnOnce(ChannelRx<M>) -> MailboxServerHandle, DH: FnOnce(DuplexServer<In, Out>, Receiver<bool>) -> DF, DF: Future<Output = ()> + Send + 'static,

Wire up handlers for both halves, spawn a background task that owns the orderly shutdown (duplex drain → simplex pump → listener), and return a MailboxServerHandle. Calling .stop() on the handle drives the drain.

simplex_handler consumes the simplex receiver and produces the simplex pump’s MailboxServerHandle (typically by calling MailboxServer::serve on a forwarder). duplex_handler receives the DuplexServer and a stop signal, and returns the future driving the duplex pump.

Shutdown ordering. On stop, the coordinator awaits duplex_task first so the duplex handler can drive its own internal drain (e.g., the host’s per-connection forwarder pumps stop and drop their AttachSenders, which lets send_connected flush queued outbound naturally as SendLoopError::AppClosed, before the handler’s terminal duplex_server.stop signals listener shutdown and join waits for it). Stopping the simplex pump and listener happens after the duplex drain to avoid cascading cancellation through dispatch_duplex_stream’s select! while the duplex side still has queued sends.

Mirrors MailboxServer::serve’s shape: take the work to do, return a MailboxServerHandle.