Struct hotshot::traits::implementations::MemoryNetwork

pub struct MemoryNetwork<K: SignatureKey> {
    inner: Arc<MemoryNetworkInner<K>>,
}

In memory only network simulator.

This provides an in memory simulation of a networking implementation, allowing nodes running on the same machine to mock networking while testing other functionality.

Under the hood, this simply maintains mpmc channels to every other MemoryNetwork insane of the same group.

Fields

inner: Arc<MemoryNetworkInner<K>>

The actual internal state

Implementations

impl<K: SignatureKey> MemoryNetwork<K>

pub fn new( pub_key: &K, master_map: &Arc<MasterMap<K>>, subscribed_topics: &[Topic], reliability_config: Option<Box<dyn NetworkReliability>> ) -> MemoryNetwork<K>

Creates a new MemoryNetwork and hooks it up to the group through the provided MasterMap

async fn input(&self, message: Vec<u8>) -> Result<(), SendError<Vec<u8>>>

Send a Vec<u8> message to the inner input

Trait Implementations

impl<K: Clone + SignatureKey> Clone for MemoryNetwork<K>

fn clone(&self) -> MemoryNetwork<K>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K: SignatureKey + 'static> ConnectedNetwork<K> for MemoryNetwork<K>

fn recv_msgs<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<u8>>, NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Receive one or many messages from the underlying network.

Errors

If the other side of the channel is closed

fn wait_for_ready<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Blocks until the network is successfully initialized

fn pause(&self)

Pauses the underlying network

fn resume(&self)

Resumes the underlying network

fn shut_down<'a, 'b>(&'a self) -> BoxSyncFuture<'b, ()>

where Self: 'b, 'a: 'b,

Blocks until the network is shut down

fn broadcast_message<'life0, 'async_trait>( &'life0 self, message: Vec<u8>, topic: Topic, _broadcast_delay: BroadcastDelay ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

broadcast message to some subset of nodes blocking

fn da_broadcast_message<'life0, 'async_trait>( &'life0 self, message: Vec<u8>, recipients: BTreeSet<K>, broadcast_delay: BroadcastDelay ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

broadcast a message only to a DA committee blocking

fn direct_message<'life0, 'async_trait>( &'life0 self, message: Vec<u8>, recipient: K ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sends a direct message to a specific node blocking

fn vid_broadcast_message<'life0, 'async_trait>( &'life0 self, messages: HashMap<K, Vec<u8>> ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

send messages with vid shares to its recipients blocking

fn request_data<'life0, 'life1, 'async_trait, TYPES>( &'life0 self, _request: Vec<u8>, _recipient: &'life1 K ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, NetworkError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, TYPES: 'async_trait + NodeType, Self: 'async_trait,

Ask request the network for some data. Returns the request ID for that data, The ID returned can be used for cancelling the request

fn spawn_request_receiver_task<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Option<Receiver<(Vec<u8>, NetworkMsgResponseChannel<Vec<u8>>)>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Spawn a request task in the given network layer. If it supports Request and responses it will return the receiving end of a channel. Requests the network receives will be sent over this channel along with a return channel to send the response back to.

fn queue_node_lookup( &self, _view_number: ViewNumber, _pk: K ) -> Result<(), TrySendError<Option<(ViewNumber, K)>>>

queues lookup of a node

fn update_view<'a, 'life0, 'async_trait, TYPES>( &'a self, _view: u64, _membership: &'life0 <TYPES as NodeType>::Membership ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'a: 'async_trait, 'life0: 'async_trait, TYPES: NodeType<SignatureKey = K> + 'a + 'async_trait, Self: 'async_trait,

Update view can be used for any reason, but mostly it’s for canceling tasks, and looking up the address of the leader of a future view.

fn is_primary_down(&self) -> bool

Is primary network down? Makes sense only for combined network

impl<K: SignatureKey> Debug for MemoryNetwork<K>

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

Formats the value using the given formatter.

impl<TYPES: NodeType> TestableNetworkingImplementation<TYPES> for MemoryNetwork<TYPES::SignatureKey>

fn generator( _expected_node_count: usize, _num_bootstrap: usize, _network_id: usize, da_committee_size: usize, _is_da: bool, reliability_config: Option<Box<dyn NetworkReliability>>, _secondary_network_delay: Duration ) -> AsyncGenerator<Arc<Self>>

generates a network given an expected node count

fn in_flight_message_count(&self) -> Option<usize>

Get the number of messages in-flight.