Struct FakeNetwork 

pub struct FakeNetwork<Spec: FakeNetworkSpec, CtxId, Links> { /* private fields */ }

A fake network, composed of many FakeCoreCtxs.

Provides a utility to have many contexts keyed by CtxId that can exchange frames.

Implementations

impl<Spec, CtxId, Links> FakeNetwork<Spec, CtxId, Links>

where CtxId: Eq + Hash, Spec: FakeNetworkSpec,

pub fn context<K: Into<CtxId>>(&mut self, context: K) -> &mut Spec::Context

Retrieves a context named context.

pub fn with_context<K: Into<CtxId>, O, F: FnOnce(&mut Spec::Context) -> O>( &mut self, context: K, f: F, ) -> O

Calls f with a mutable reference to the context named context.

impl<Spec, CtxId, Links> FakeNetwork<Spec, CtxId, Links>

where Spec: FakeNetworkSpec, CtxId: Eq + Hash + Copy + Debug, Links: FakeNetworkLinks<Spec::SendMeta, Spec::RecvMeta, CtxId>,

pub fn new<I: IntoIterator<Item = (CtxId, Spec::Context)>>( contexts: I, links: Links, ) -> Self

Creates a new FakeNetwork.

Creates a new FakeNetwork with the collection of FakeCoreCtxs in contexts. Ctxs are named by type parameter CtxId.

Panics

Calls to new will panic if given a FakeCoreCtx with timer events. FakeCoreCtxs given to FakeNetwork must not have any timer events already attached to them, because FakeNetwork maintains all the internal timers in dispatchers in sync to enable synchronous simulation steps.

pub fn iter_pending_frames( &self, ) -> impl Iterator<Item = &PendingFrame<CtxId, Spec::RecvMeta>>

Iterates over pending frames in an arbitrary order.

pub fn assert_no_pending_frames(&self)

where Spec::RecvMeta: Debug,

Asserts no pending frames exist.

pub fn drop_pending_frames(&mut self)

Drops all pending frames; they will not be delivered.

pub fn step(&mut self) -> StepResult

where Spec::TimerId: Debug,

Performs a single step in network simulation.

step performs a single logical step in the collection of Ctxs held by this FakeNetwork. A single step consists of the following operations:

• All pending frames, kept in each FakeCoreCtx, are mapped to their destination context/device pairs and moved to an internal collection of pending frames.
• The collection of pending timers and scheduled frames is inspected and a simulation time step is retrieved, which will cause a next event to trigger. The simulation time is updated to the new time.
• All scheduled frames whose deadline is less than or equal to the new simulation time are sent to their destinations, handled using handle_frame.
• All timer events whose deadline is less than or equal to the new simulation time are fired, handled using handle_timer.

If any new events are created during the operation of frames or timers, they will not be taken into account in the current step. That is, step collects all the pending events before dispatching them, ensuring that an infinite loop can’t be created as a side effect of calling step.

The return value of step indicates which of the operations were performed.

Panics

If FakeNetwork was set up with a bad links, calls to step may panic when trying to route frames to their context/device destinations.

pub fn step_with<F: FnMut(&mut Spec::Context, Spec::RecvMeta, Buf<Vec<u8>>) -> Option<(Spec::RecvMeta, Buf<Vec<u8>>)>>( &mut self, filter_map_frame: F, ) -> StepResult

where Spec::TimerId: Debug,

Like FakeNetwork::step, but receives a function filter_map_frame that can modify the an inbound frame before delivery or drop it altogether by returning None.

pub fn step_deliver_frames(&mut self) -> StepResult

where Spec::TimerId: Debug,

Collects and dispatches all pending frames without advancing time or triggering any timers.

Panics

Panics under the same conditions as [dispatch_pending_frames].

pub fn step_deliver_frames_with<F: FnMut(&mut Spec::Context, Spec::RecvMeta, Buf<Vec<u8>>) -> Option<(Spec::RecvMeta, Buf<Vec<u8>>)>>( &mut self, filter_map_frame: F, ) -> StepResult

where Spec::TimerId: Debug,

Like FakeNetwork::step_deliver_frames, but receives a function filter_map_frame that can modify frames, or drop them if it returns None.

pub fn run_until_idle(&mut self)

where Spec::TimerId: Debug,

Runs the network until it is starved of events.

Panics

Panics if 1,000,000 steps are performed without becoming idle. Also panics under the same conditions as [step].

pub fn run_until_idle_with<F: FnMut(&mut Spec::Context, Spec::RecvMeta, Buf<Vec<u8>>) -> Option<(Spec::RecvMeta, Buf<Vec<u8>>)>>( &mut self, filter_map_frame: F, )

where Spec::TimerId: Debug,

Like FakeNetwork::run_until_idle but receives a function filter_map_frame that can modify the an inbound frame before delivery or drop it altogether by returning None.

pub fn collect_frames(&mut self)

Collects all queued frames.

Collects all pending frames and schedules them for delivery to the destination context/device based on the result of links. The collected frames are queued for dispatching in the FakeNetwork, ordered by their scheduled delivery time given by the latency result provided by links.

pub fn dispatch_pending_frames<F: FnMut(&mut Spec::Context, Spec::RecvMeta, Buf<Vec<u8>>) -> Option<(Spec::RecvMeta, Buf<Vec<u8>>)>>( &mut self, filter_map_frame: F, ) -> usize

Dispatches scheduled frames that were previously collected with [collect_frames].

Only frames for which the current deadline is less than or equal to the current simulation time are delivered.

Panics

If FakeNetwork was set up with a bad links, calls may panic when trying to route frames to their context/device destinations.

pub fn next_step(&self) -> Option<FakeInstant>

Calculates the next FakeInstant when events are available.

Returns the smallest FakeInstant greater than or equal to the current time for which an event is available. If no events are available, returns None.