Struct brb::net::Net

pub struct Net<DT: BRBDT> {
    pub procs: Vec<DeterministicBRB<Actor, SigningActor, Sig, DT>>,
    pub delivered_packets: Vec<Packet<Actor, Sig, DT::Op>>,
    pub n_packets: u64,
    pub invalid_packets: HashMap<Actor, u64>,
}

Net – a simulated in-memory network specialized to ed25519 keys.

Fields

procs: Vec<DeterministicBRB<Actor, SigningActor, Sig, DT>>

list of processes/nodes comprising the network.

delivered_packets: Vec<Packet<Actor, Sig, DT::Op>>

list of packets that have been delivered

n_packets: u64

total number of packets sent during network’s lifetime

invalid_packets: HashMap<Actor, u64>

count of invalid packets, by actor.

Implementations

impl<DT: BRBDT> Net<DT>

pub fn new() -> Self

Create a new BRBDT instance

pub fn members(&self) -> BTreeSet<Actor>

The largest set of procs who mutually see each other as peers are considered to be the network members.

pub fn actors(&self) -> BTreeSet<Actor>

Fetch the actors for each process in the network

pub fn initialize_proc(&mut self) -> Actor

Initialize a new process (NOTE: we do not request membership from the network automatically)

pub fn on_proc<V>(
    &self,
    actor: &Actor,
    f: impl FnOnce(&DeterministicBRB<Actor, SigningActor, Sig, DT>) -> V
) -> Option<V>

Execute arbitrary code on a proc (immutable)

pub fn on_proc_mut<V>(
    &mut self,
    actor: &Actor,
    f: impl FnOnce(&mut DeterministicBRB<Actor, SigningActor, Sig, DT>) -> V
) -> Option<V>

Execute arbitrary code on a proc (mutating)

pub fn proc_from_actor(
    &self,
    actor: &Actor
) -> Option<&DeterministicBRB<Actor, SigningActor, Sig, DT>>

Get a (immutable) reference to a proc with the given actor.

pub fn proc_from_actor_mut(
    &mut self,
    actor: &Actor
) -> Option<&mut DeterministicBRB<Actor, SigningActor, Sig, DT>>

Get a (mutable) reference to a proc with the given actor.

pub fn anti_entropy(&mut self)

Perform anti-entropy corrections on the network. Currently this is God mode implementations in that we don’t use message passing and we share process state directly.

pub fn deliver_packet(
    &mut self,
    packet: Packet<Actor, Sig, DT::Op>
) -> Vec<Packet<Actor, Sig, DT::Op>>

Delivers a given packet to it’s target recipiant. The recipiant, upon processing this packet, may produce it’s own packets. This next set of packets are returned to the caller.

pub fn members_are_in_agreement(&self) -> bool

Checks if all members of the network have converged to the same state.

pub fn count_invalid_packets(&self) -> u64

counts number of invalid packets received by any proc

pub fn run_packets_to_completion(
    &mut self,
    packets: Vec<Packet<Actor, Sig, DT::Op>>
)

Convenience function to iteratively deliver all packets along with any packets that may result from delivering a packet.

pub fn generate_msc(&self, chart_name: &str)

Generates an MSC file representing a packet sequence diagram. See http://www.mcternan.me.uk/mscgen/ See https://github.com/maidsafe/brb_membership#tests

Trait Implementations

impl<DT: Debug + BRBDT> Debug for Net<DT> where
    DT::Op: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<DT: BRBDT> Default for Net<DT>

fn default() -> Self

create a default BRBDT instance