Struct Node 

pub struct Node { /* private fields */ }

An actor which helps to manage the IPC connections.

The node can hold multiple IpcListeners to accept incoming IPC connections on several endpoints in parallel. Outbound connections are initiated by sending a Connect<C> command.

Implementations

impl Node

pub fn new() -> Self

Constructs a new Node.

pub fn with_listener<L>(self, listener: L) -> Self

where L: IpcListener,

Adds an IPC listener to the node.

If the node already has a listener listening on the same endpoint, the new listener will replace the existing one, since the node is not started yet when this method is available. Note this is not the same as the AddListener command, which will not replace the existing listener.

pub fn with_actor<A, S>(self, label: S, actor: Address<A>) -> Self

where A: Actor + RemoteAddressable, S: AsRef<str>,

Adds an remote addressable actor to the node.

It also registers a label for the actor so that remote actors can look it up by a more user-friendly name.

Duplicate actors and labels are silently skipped.

pub fn with_factory<A>(self) -> Self

where A: Actor + RemoteSpawnable,

Adds an remote spawnable actor factory to the node.

Remote nodes can create instances of this actor type by sending a CreateActor node command.

Trait Implementations

impl Actor for Node

type Context = NodeContext

The execution context type for this actor.

type Error = NodeError

The error type returned by lifecycle hooks and message handlers.

async fn post_start( &mut self, _ctx: &mut Self::Context, ) -> Result<(), NodeError>

Invoked after an actor is spawned into the tokio runtime. The actor should be in Starting state.

async fn post_stop(&mut self, _ctx: &mut Self::Context) -> Result<(), NodeError>

Invoked after an actor is stopped. The actor should be in Stopped state.

fn pre_start(&mut self, ctx: &mut Self::Context) -> Result<(), Self::Error>

Invoked before an actor is spawned into the tokio runtime. The actor should be in Unstarted state.

fn stopping( &mut self, ctx: &mut Self::Context, ) -> impl Future<Output = Result<Stopping, Self::Error>> + Send

Invoked when an actor is being stopped. The actor should be in Stopping state.

fn start<S>( self, label: S, ) -> Result<(Address<Self>, JoinHandle<()>), Self::Error>

where S: AsRef<str>,

Starts an actor, returns its address and the join handle.

fn create<S, F>( label: S, f: F, ) -> Result<(Address<Self>, JoinHandle<()>), Self::Error>

where S: AsRef<str>, F: FnOnce(&mut Self::Context) -> Result<Self, Self::Error>,

Creates a new actor, starts it and returns its address and the join handle.

impl Default for Node

fn default() -> Self

Returns the “default value” for a type.

impl<A> Handler<AddActor<A>> for Node

where A: Actor + RemoteAddressable,

type Result = bool

The return type of the handler, which must implement MessageResponse.

async fn handle( &mut self, msg: AddActor<A>, _ctx: &mut Self::Context, ) -> Self::Result

Handles a message.

impl<L> Handler<AddListener<L>> for Node

where L: IpcListener,

type Result = bool

The return type of the handler, which must implement MessageResponse.

async fn handle( &mut self, msg: AddListener<L>, _ctx: &mut Self::Context, ) -> Self::Result

Handles a message.

impl<T> Handler<Connect<T>> for Node

where T: IpcConnection,

type Result = Result<Address<Session>, NodeError>

The return type of the handler, which must implement MessageResponse.

async fn handle( &mut self, msg: Connect<T>, ctx: &mut Self::Context, ) -> Self::Result

Handles a message.

impl<A> Handler<RemoteCreateActor<A>> for Node

where A: Actor + RemoteSpawnable,

type Result = FutureMessageResult<RemoteCreateActor<A>>

The return type of the handler, which must implement MessageResponse.

async fn handle( &mut self, msg: RemoteCreateActor<A>, _ctx: &mut Self::Context, ) -> Self::Result

Handles a message.

impl<A> Handler<RemoteGetActor<A>> for Node

where A: Actor + RemoteAddressable,

type Result = FutureMessageResult<RemoteGetActor<A>>

The return type of the handler, which must implement MessageResponse.

async fn handle( &mut self, msg: RemoteGetActor<A>, _ctx: &mut Self::Context, ) -> Self::Result

Handles a message.

impl Handler<RemoveActor> for Node

type Result = bool

The return type of the handler, which must implement MessageResponse.

async fn handle( &mut self, msg: RemoveActor, _ctx: &mut Self::Context, ) -> Self::Result

Handles a message.

impl Handler<RemoveListener> for Node

type Result = bool

The return type of the handler, which must implement MessageResponse.

async fn handle( &mut self, msg: RemoveListener, ctx: &mut Self::Context, ) -> Self::Result

Handles a message.

impl Handler<SupervisionEvent<Session>> for Node

type Result = ()

The return type of the handler, which must implement MessageResponse.

async fn handle( &mut self, msg: SupervisionEvent<Session>, _ctx: &mut Self::Context, ) -> Self::Result

Handles a message.

impl SubjectActor<NodeEvent> for Node

fn observers_mut(&mut self) -> &mut ObserverSet<NodeEvent>

Returns a mutable reference to the set of observers for this event type.

fn register_observer(&mut self, observer: Recipient<Event>)

Registers an observer.

fn unregister_observer(&mut self, observer: Recipient<Event>)

Unregisters an observer.

fn notify_observers(&mut self, event: Event) -> impl Future<Output = ()> + Send

Notifies all observers.

fn try_notify_observers(&mut self, event: Event)

Notifies all observers.