Struct ractor_cluster::node::node_session::NodeSession

pub struct NodeSession { /* private fields */ }

Represents a remote connection to a node(). The NodeSession is the main handler for all inter-node communication and handles

1. The state of the authentication handshake
2. Control messages for actor synchronization + group membership changes
3. RemoteActors wishing to send messages to their remote counterparts on the remote system (and receive replies)

A NodeSession can either be a client or server session, depending on the connection sequence. If it was an incoming request to the crate::NodeServer then it’s a “server” session, as the server spawned this actor. Otherwise it’s an outgoing “client” request.

If the NodeSession is a client session, it will start the authentication handshake with a auth_protocol::NameMessage announcing this node’s name to the remote system for deduplication and starting the rest of the handshake. For full authentication pattern details, see

1. src/protocol/auth.proto
2. src/node/auth.rs

Lastly the node’s have an intern-node “ping” operation which occurs to keep the TCP session alive and additionally measure peer latency.

Implementations

impl NodeSession

pub fn new( node_id: NodeId, is_server: bool, cookie: String, node_server: ActorRef<NodeServerMessage>, node_name: NameMessage, connection_mode: NodeConnectionMode ) -> Self

Construct a new NodeSession with the supplied arguments

• node_id: This peer’s node id
• is_server: Is a server-received session (if false, this is the client)
• cookie: The authorization cookie
• node_server: The parent node server
• node_name: This node’s name and connection details
• connection_mode: The connection mode for peer connections

Trait Implementations

impl Actor for NodeSession

type Msg = NodeSessionMessage

The message type for this actor

type Arguments = NetworkStream

Initialization arguments

type State = NodeSessionState

The type of state this actor manages internally

fn pre_start<'life0, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, stream: Self::Arguments ) -> 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 post_stop<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<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,

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