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: ProcAddr, listener: Option<TcpListener>, gateway: Gateway, via: Option<ChannelAddr>, ) -> Result<Self, HostError>

Like [new_with_default], but uses a caller-provided Gateway and service ProcAddr.

addr is a startup specification: its proc id becomes the service proc identity, and its direct location is used to serve the frontend. The final service proc location comes from the gateway after binding, so it may differ because of an alias, an ephemeral address, or via. A source-routed Location::Via is therefore rejected here.

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 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.

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.

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.