Struct NetworkDispatcher 

pub struct NetworkDispatcher { /* private fields */ }

A network-capable dispatcher for sending messages to remote actors

Construct this using NetworkConfig.

This dispatcher automatically creates channels to requested target systems on demand and maintains them while in use.

The current implementation only supports TCP as a transport protocol.

If possible, this implementation will “reflect” messages to local actors directly back up, instead of serialising them first.

Implementations

impl NetworkDispatcher

pub fn new(notify_ready: KPromise<()>) -> Self

Create a new dispatcher with the default configuration

See also NetworkConfig.

Example

This example binds to local host on a free port chosen by the operating system.

use kompact::prelude::*;
use kompact_net::NetworkDispatcher;

let mut conf = KompactConfig::default();
conf.system_components(DeadletterBox::new, NetworkDispatcher::new);
let system = conf.build().wait().expect("system");

pub fn with_config(cfg: NetworkConfig, notify_ready: KPromise<()>) -> Self

Create a new dispatcher with the given configuration

For better readability in combination with system_components, use NetworkConfig::build instead.

pub fn system_path_ref(&mut self) -> &SystemPath

Return a reference to the cached system path

Mutable, since it will update the cached value, if necessary.

impl NetworkDispatcher

pub fn network_status_port(&mut self) -> &mut ProvidedPort<NetworkStatusPort>

Returns the provided network status port for this dispatcher.

Trait Implementations

impl Actor for NetworkDispatcher

type Message = DispatchEnvelope

The type of local messages the actor accepts

fn receive_local(&mut self, msg: Self::Message) -> HandlerResult

Handle an incoming local message

fn receive_network(&mut self, msg: NetMessage) -> HandlerResult

Handle an incoming network message

impl ComponentDefinition for NetworkDispatcher

fn setup(&mut self, self_component: Arc<Component<Self>>)

Prepare the component for being run

fn execute(&mut self, max_events: usize, skip: usize) -> ExecuteResult

Execute events on the component’s ports

fn ctx_mut(&mut self) -> &mut ComponentContext<Self>

Return a mutable reference the component’s context field

fn ctx(&self) -> &ComponentContext<Self>

Return a reference the component’s context field

fn type_name() -> &'static str

Return the name of the component’s type

fn spawn_local<F>( &mut self, f: impl FnOnce(ComponentDefinitionAccess<Self>) -> F, )

where Self: 'static, F: Future<Output = Result<Handled, HandlerError>> + Send + 'static,

Run a Future on this component, allowing it mutable access to the component’s internal state on every poll.

fn spawn_off<R>( &self, future: impl Future<Output = R> + Send + 'static, ) -> Receiver<R>

where R: Send + 'static,

Run a Future on this system’s executor pool and return a handle to the result

impl ComponentLifecycle for NetworkDispatcher

fn on_start(&mut self) -> HandlerResult

Gets invoked every time a component receives a Start event

fn on_stop(&mut self) -> HandlerResult

Gets invoked every time a component receives a Stop event

fn on_kill(&mut self) -> HandlerResult

Gets invoked every time a component receives a Kill event

impl Dispatcher for NetworkDispatcher

fn system_path(&mut self) -> SystemPath

Generates a SystemPath from this dispatcher’s configuration

This is only possible after the socket is bound and will panic if attempted earlier!

impl DynamicPortAccess for NetworkDispatcher

fn get_provided_port_as_any(&mut self, port_id: TypeId) -> Option<&mut dyn Any>

Internal API. Dynamically obtain a mutable reference to a ProvidedPort if self provides a port of the type indicated by the passed port_id.

fn get_required_port_as_any(&mut self, port_id: TypeId) -> Option<&mut dyn Any>

Internal API. Dynamically obtain a mutable reference to a RequiredPort if self requires a port of the type indicated by the passed port_id.

impl Provide<NetworkStatusPort> for NetworkDispatcher

fn handle( &mut self, event: <NetworkStatusPort as Port>::Request, ) -> HandlerResult

Handle the port’s event

impl ProvideRef<NetworkStatusPort> for NetworkDispatcher

fn provided_ref(&mut self) -> ProvidedRef<NetworkStatusPort>

Returns a provided reference to this component’s port instance of type P

fn connect_to_required(&mut self, req: RequiredRef<NetworkStatusPort>)

Connects this component’s provided port instance of type P to req

fn disconnect(&mut self, req: RequiredRef<NetworkStatusPort>)

Disconnects this component’s provided port instance of type P from req