Struct Host 

pub struct Host<M> { /* private fields */ }

Lifecycle manager for the procs on one machine.

The host delegates all connectivity to its Gateway. It creates built-in service/local procs, asks its ProcManager to spawn children, and keeps the gateway peer registrations for those children alive.

Implementations

impl<M: ProcManager> Host<M>

pub async fn new(manager: M, addr: ChannelAddr) -> Result<Self, HostError>

Construct a host and start its gateway frontend server on addr.

pub async fn new_with_default( manager: M, addr: ChannelAddr, listener: Option<TcpListener>, ) -> Result<Self, HostError>

Like [new], but optionally uses an already-bound listener.

When listener is Some, it is used as the frontend listening socket instead of binding a new one.

pub async fn new_with_gateway( manager: M, addr: ChannelAddr, listener: Option<TcpListener>, gateway: Gateway, via: Option<ChannelAddr>, ) -> Result<Self, HostError>

Like [new_with_default], but uses a caller-provided Gateway instead of creating one internally.

Serving the backend and frontend endpoints, choosing the frontend transport, and adopting the frontend address as the gateway’s advertised location are all owned by the gateway. The host operates on a vanilla gateway: it never inspects the transport nor rewrites the gateway’s location. Adopting the bound frontend address makes the legacy pseudo-singleton proc ids (system, local) carry it so remote hosts can reach them by name.

When via is Some, the gateway attaches to that remote duplex address with Gateway::serve_via after the local frontend/backend serves but before minting the built-in procs, so the via session is the newest active serve. That ordering makes every ref minted on this host advertise the routable Via location rather than the bare local frontend, which is what lets an out-of-cluster client receive return traffic over the duplex.

pub fn manager(&self) -> &M

The underlying proc manager.

pub fn addr(&self) -> &ChannelAddr

The address which accepts messages destined for this host.

pub fn system_proc(&self) -> &Proc

The system proc associated with this host. This is used to run host-level system services like host managers.

pub fn local_proc(&self) -> &Proc

The local proc associated with this host (LOCAL_PROC_NAME).

Starts with zero actors; see invariant LP-1 on LOCAL_PROC_NAME for activation semantics.

pub async fn spawn( &mut self, name: String, config: M::Config, ) -> Result<(ProcAddr, ActorRef<ManagerAgent<M>>), HostError>

Spawn a child proc with the given name.

On success, the proc is ready and reachable through the returned ProcAddr. The proc id is derived from name; its location is advertised through this host’s frontend gateway using a Via(child_uid, host_location) source route.

pub fn gateway(&self) -> &Gateway

The host’s Gateway. All incoming traffic addressed to this host’s procs is routed through the gateway: in-process procs via the gateway’s local delivery path, and spawned child proc gateways through peer routes registered with Gateway::attach_peer.

impl<M: ProcManager + BulkTerminate> Host<M>

pub async fn terminate_children( &mut self, cx: &impl Actor, timeout: Duration, max_in_flight: usize, reason: &str, ) -> TerminateSummary

Gracefully terminate all procs spawned by this host.

Delegates to the underlying manager’s BulkTerminate::terminate_all implementation. Use this to perform orderly teardown during scale-down or shutdown.

Parameters

• timeout: Per-child grace period before escalation.
• max_in_flight: Upper bound on concurrent terminations.

Returns

A TerminateSummary with counts of attempted/ok/failed terminations.

Trait Implementations

impl<M> Drop for Host<M>

fn drop(&mut self)

Executes the destructor for this type.

impl<M: ProcManager + SingleTerminate> SingleTerminate for Host<M>

fn terminate_proc<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor), proc: &'life2 ProcAddr, timeout: Duration, reason: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(Vec<ActorAddr>, Vec<ActorAddr>), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Gracefully terminate the given proc.