Struct EngineHandle

Source

pub struct EngineHandle<R: Reactor = TokioReactor, N: Network = TokioNetwork, F: FileSystem = TokioFileSystem> { /* private fields */ }

Expand description

Handle for interacting with the engine from external (test) code.

Implementations§

Source §

impl<R: Reactor, N: Network, F: FileSystem> EngineHandle<R, N, F>

Source

pub fn type_registry(&self) -> TypeRegistry

Source

pub fn send_to<M: Message>( &self, target: AddrHash, msg: M, ) -> Result<(), SendError>

Send a message to an actor by its AddrHash.

Fast path: after the first send to a local actor, the MailboxSender is cached in send_cache, bypassing the TransportRegistry DashMap on subsequent sends. Stale entries are evicted on ActorStopped.

Source

pub fn send_many<M: Message + Clone>( &self, target: AddrHash, msg: M, n: usize, ) -> Result<usize, SendError>

Send up to n messages to one target using a producer-side batch fast path.

For local destinations this uses MailboxSender::try_send_batch_owned, reducing wake/schedule overhead vs repeated send_to calls.

Returns the number of messages successfully enqueued. On local mailbox backpressure this may be less than n without returning an error.

Source

pub fn addr_for<M: Message>(&self, target: AddrHash) -> Addr<M>
where R: Send + Sync,

Create an Addr<M> that sends to target via this engine’s transport.

Source

pub fn remote_addr<M: RemoteMessage>(&self, target: AddrHash) -> Addr<M>

Create a remote Addr<M> that always serializes payloads before routing.

This is intended for explicit remote sends; it rejects local destinations to avoid accidental local delivery of serialized payloads.

Source

pub fn transport(&self) -> &Arc<InProcessTransport>

Source

pub fn transport_registry(&self) -> &Arc<TransportRegistry>

Source

pub async fn attach_quic_transport( &self, config: QuicTransportConfig, peers: HashMap<EngineId, SocketAddr>, ) -> Result<Arc<QuicTransport<R, N>>, TransportError>
where R: Clone, N: Clone,

Source

pub async fn attach_tcp_transport( &self, config: TcpTransportConfig, peers: HashMap<EngineId, SocketAddr>, ) -> Result<Arc<TcpTransport<R, N>>, TransportError>
where R: Clone, N: Clone,

Source

pub fn actor_list(&self, query: ActorQuery) -> Vec<ActorInfo>

List actors, optionally filtered by query.

Source

pub fn actor_info(&self, path: &ActorPath) -> Option<ActorInfo>

Get info for a single actor by path.

Source

pub fn snapshot(&self) -> EngineSnapshot

System-level snapshot: all actors + uptime.

Source

pub fn lookup_path(&self, path: &ActorPath) -> Option<AddrHash>

Lookup an actor’s address by its path.

Source

pub fn resolve_path(&self, path: &ActorPath) -> Result<AddrHash, SendError>

Resolve an actor’s address by path with routing errors.

Source

pub fn stop_actor(&self, path: &ActorPath) -> bool

Send a hard-stop signal to an actor by path.

Returns true if the actor was found and the signal was sent. The actor may still be running until the signal is processed by the reactor. Used by FaultInjector::crash_actor.

Source

pub fn fill_mailbox(&self, path: &ActorPath) -> usize

Fill an actor’s mailbox to capacity by sending dummy messages.

Returns the number of messages that were successfully enqueued. Subsequent sends to the same actor will return SendError::MailboxFull until the actor drains messages. Used by FaultInjector::fill_mailbox.

Source

pub fn spawn_user_actor(&self, spec: ChildSpec<R>)

Dynamically spawn a user actor by sending a signal to the root /user supervisor.

Source

pub fn spawn_worker_pool<M, G>( &self, config: &PoolConfig, factory: G, ) -> WorkerPool<M>
where M: Message, R: Clone + Send + Sync + 'static, G: Fn() -> Box<dyn Actor<R>> + Send + Sync + Clone + 'static,

Spawn a pool of N identical worker actors under the /user supervisor and return a WorkerPool<M> routing handle.

Each worker gets a [StableAddr<M>] backed by an [AddrRefresher] so that the pool transparently routes to new incarnations after restarts.

§Ordering

Spawn requests are sent asynchronously to the /user supervisor. The returned pool’s StableAddrs are initially None; they are populated once the supervisor task processes each SpawnChild signal. Yield at least once (e.g. tokio::task::yield_now().await) before sending messages through the pool.