Struct ractor_cluster::node::NodeServer

pub struct NodeServer { /* private fields */ }

Represents the server which is managing all node session instances

The NodeServer supervises a single ractor_cluster::net::listener::Listener actor which is responsible for hosting a server port for incoming node() connections. It also supervises all of the NodeSession actors which are tied to tcp sessions and manage the FSM around node()s establishing inter connections.

Implementations

impl NodeServer

pub fn new( port: u16, cookie: String, node_name: String, hostname: String, encryption_mode: Option<IncomingEncryptionMode>, connection_mode: Option<NodeConnectionMode> ) -> Self

Create a new node server instance

• port - The port to run the NodeServer on for incoming requests
• cookie - The magic cookie for authentication between NodeServers
• node_name - The name of this node
• hostname - The hostname of the machine
• encryption_mode- (optional) Node socket encryption functionality (Default = IncomingEncryptionMode::Raw)
• connection_mode - (optional) Connection mode for peer nodes (Default = NodeConnectionMode::Isolated)

Trait Implementations

impl Actor for NodeServer

type Msg = NodeServerMessage

The message type for this actor

type State = NodeServerState

The type of state this actor manages internally

type Arguments = ()

Initialization arguments

fn pre_start<'life0, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, __arg2: () ) -> Pin<Box<dyn Future<Output = Result<Self::State, ActorProcessingErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Invoked when an actor is being started by the system.

fn handle<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, message: Self::Msg, state: &'life1 mut Self::State ) -> Pin<Box<dyn Future<Output = Result<(), ActorProcessingErr>> + Send + 'async_trait>>

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

Handle the incoming message from the event processing loop. Unhandled panickes will be captured and sent to the supervisor(s)

fn handle_supervisor_evt<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, message: SupervisionEvent, state: &'life1 mut Self::State ) -> Pin<Box<dyn Future<Output = Result<(), ActorProcessingErr>> + Send + 'async_trait>>

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

Handle the incoming supervision event. Unhandled panicks will captured and sent the the supervisor(s). The default supervision behavior is to exit the supervisor on any child exit. To override this behavior, implement this function.

fn post_start<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, state: &'life1 mut Self::State ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

Invoked after an actor has started.

fn post_stop<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, state: &'life1 mut Self::State ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

Invoked after an actor has been stopped to perform final cleanup. In the event the actor is terminated with Signal::Kill or has self-panicked, post_stop won’t be called.

fn handle_serialized<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, message: SerializedMessage, state: &'life1 mut Self::State ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

Handle the remote incoming message from the event processing loop. Unhandled panickes will be captured and sent to the supervisor(s)

fn spawn<'async_trait>( name: Option<String>, handler: Self, startup_args: Self::Arguments ) -> Pin<Box<dyn Future<Output = Result<(ActorRef<Self::Msg>, JoinHandle<()>), SpawnErr>> + Send + 'async_trait>>

where Self: 'async_trait,

Spawn an actor of this type, which is unsupervised, automatically starting

fn spawn_linked<'async_trait>( name: Option<String>, handler: Self, startup_args: Self::Arguments, supervisor: ActorCell ) -> Pin<Box<dyn Future<Output = Result<(ActorRef<Self::Msg>, JoinHandle<()>), SpawnErr>> + Send + 'async_trait>>

where Self: 'async_trait,

Spawn an actor of this type with a supervisor, automatically starting the actor