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. Note this is not the same as the AddListener command, which will not replace the existing listener.

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

where A: RemoteActor,

Adds an actor which implements RemoteActor trait to the node.

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

where A: RemoteActorFactory,

Adds an actor factory so that remote peers can create instances of A by sending a CreateActor node command to this node.

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 run<S>( self, label: S, ) -> Result<(Address<Self>, JoinHandle<()>), Self::Error>

where S: AsRef<str>,

Starts an actor and spawns it to the tokio runtime, returns its actor 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 spawns it to the tokio runtime, returns its actor address and the join handle.

fn create_in_span<S, F>( label: S, parent_span: Option<&Span>, f: F, ) -> Result<(Address<Self>, JoinHandle<()>), Self::Error>

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

Like create but allows the caller to specify the parent tracing span.

fn type_erased_recipient_fn() -> Option<fn(&Address<Self>) -> TypeErasedRecipient>

Available on crate feature type-erased-recipient-hook only.

Opt-in hook that turns an Address<A> into a type-erased trait object which can be downcast into a concrete Recipient<M>, where M is a specific message type chosen in the overridden implementation of this method.

impl Default for Node

fn default() -> Node

Returns the “default value” for a type.

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

where A: RemoteActor,

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 Handler<CreateRemoteActor> for Node

type Result = FutureMessageResult<CreateRemoteActor>

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

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

Handles a message.

impl Handler<GetRemoteActor> for Node

type Result = FutureMessageResult<GetRemoteActor>

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

async fn handle( &mut self, msg: GetRemoteActor, _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.