Struct NetworkStatusCounter 

pub struct NetworkStatusCounter {
    pub network_status_port: RequiredPort<NetworkStatusPort>,
    pub connection_established: u32,
    pub connection_lost: u32,
    pub connection_dropped: u32,
    pub connection_closed: u32,
    pub connected_systems: Vec<(SystemPath, SessionId)>,
    pub disconnected_systems: Vec<(SystemPath, SessionId)>,
    pub soft_connection_limit_exceeded: u32,
    pub hard_connection_limit_reached: u32,
    pub network_out_of_buffers: u32,
    pub critical_network_failure: u32,
    /* private fields */
}

Actor which can subscribe to the NetworkStatusPort and maintains a counter of how many of each kind of NetworkStatusUpdate has been received.

Fields

network_status_port: RequiredPort<NetworkStatusPort>

The NetworkStatusPort, needs to be exposed to allow connecting to it

connection_established: u32

Counts the number of connection_established messages received

connection_lost: u32

Counts the number of connection_lost messages received

connection_dropped: u32

Counts the number of connection_dropped messages received

connection_closed: u32

Counts the number of connection_closed messages received

connected_systems: Vec<(SystemPath, SessionId)>

Contains all SystemPath’s received in a ConnectionEstablished

disconnected_systems: Vec<(SystemPath, SessionId)>

Contains all SystemPath’s received in a ConnectionLost or ConnectionClosed message

soft_connection_limit_exceeded: u32

Counts the number of SoftConnectionLimitExceeded messages received

hard_connection_limit_reached: u32

Counts the number of HardConnectionLimitReached messages received

network_out_of_buffers: u32

Counts the number of network_out_of_buffers messages received

critical_network_failure: u32

Counts the number of CriticalNetworkFailure messages received

Implementations

impl NetworkStatusCounter

pub fn new() -> NetworkStatusCounter

Creates a new uninitialised NetworkStatusCounter with all counters set to 0

pub fn set_status_sender(&mut self, sender: Sender<NetworkStatus>)

Sets a sender which the NetworkStatusCounter will foward all the NetworkStatus events to

pub fn send_status_request(&mut self, request: NetworkStatusRequest)

triggers the given request on the NetworkStatusPort

pub fn started_future(&mut self) -> KFuture<()>

Creates a future that will be fulfilled when the component starts

pub fn corrupt_network(&mut self) -> Result<(), SerError>

Creates a faulty Message which will cause the local NetworkThread to panic when it tries to send it to the remote host.

Fails to corrupt the network if there are no connected systems to use as receiver for the corrupt message and returns an error instead.

Trait Implementations

impl Actor for NetworkStatusCounter

type Message = ()

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 NetworkStatusCounter

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 NetworkStatusCounter

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 Default for NetworkStatusCounter

fn default() -> Self

Returns the “default value” for a type.

impl DynamicPortAccess for NetworkStatusCounter

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 Require<NetworkStatusPort> for NetworkStatusCounter

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

Handle the port’s event

impl RequireRef<NetworkStatusPort> for NetworkStatusCounter

fn required_ref(&mut self) -> RequiredRef<NetworkStatusPort>

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

fn connect_to_provided(&mut self, prov: ProvidedRef<NetworkStatusPort>)

Connects this component’s required port instance of type P to prov

fn disconnect(&mut self, prov: ProvidedRef<NetworkStatusPort>)

Disconnects this component’s required port instance of type P from prov