Struct hotshot::traits::networking::combined_network::CombinedNetworks

pub struct CombinedNetworks<TYPES: NodeType> {
    networks: Arc<UnderlyingCombinedNetworks<TYPES>>,
    message_cache: Arc<RwLock<LruCache<u64, ()>>>,
    primary_fail_counter: Arc<AtomicU64>,
    primary_down: Arc<AtomicBool>,
    delay_duration: Arc<RwLock<Duration>>,
    delayed_tasks_channels: Arc<RwLock<BTreeMap<u64, (Sender<()>, InactiveReceiver<()>)>>>,
    no_delay_counter: Arc<AtomicU64>,
}

A communication channel with 2 networks, where we can fall back to the slower network if the primary fails

Fields

networks: Arc<UnderlyingCombinedNetworks<TYPES>>

The two networks we’ll use for send/recv

message_cache: Arc<RwLock<LruCache<u64, ()>>>

Last n seen messages to prevent processing duplicates

primary_fail_counter: Arc<AtomicU64>

How many times primary failed to deliver

primary_down: Arc<AtomicBool>

Whether primary is considered down

delay_duration: Arc<RwLock<Duration>>

How long to delay

delayed_tasks_channels: Arc<RwLock<BTreeMap<u64, (Sender<()>, InactiveReceiver<()>)>>>

Channels to the delayed tasks

no_delay_counter: Arc<AtomicU64>

How many times messages were sent on secondary without delay because primary is down

Implementations

impl<TYPES: NodeType> CombinedNetworks<TYPES>

pub fn new( primary_network: PushCdnNetwork<TYPES::SignatureKey>, secondary_network: Libp2pNetwork<TYPES>, delay_duration: Option<Duration>, ) -> Self

Constructor

Panics

Panics if COMBINED_NETWORK_CACHE_SIZE is 0

pub fn primary(&self) -> &PushCdnNetwork<TYPES::SignatureKey>

Get a ref to the primary network

pub fn secondary(&self) -> &Libp2pNetwork<TYPES>

Get a ref to the backup network

async fn send_both_networks( &self, _message: Vec<u8>, primary_future: impl Future<Output = Result<(), NetworkError>> + Send + 'static, secondary_future: impl Future<Output = Result<(), NetworkError>> + Send + 'static, broadcast_delay: BroadcastDelay, ) -> Result<(), NetworkError>

a helper function to send messages through both networks (possibly delayed)

Trait Implementations

impl<TYPES: Clone + NodeType> Clone for CombinedNetworks<TYPES>

fn clone(&self) -> CombinedNetworks<TYPES>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TYPES: NodeType> ConnectedNetwork<<TYPES as NodeType>::SignatureKey> for CombinedNetworks<TYPES>

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

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

Receive one or many messages from the underlying network.

Errors

Does not error

fn pause(&self)

Pauses the underlying network

fn resume(&self)

Resumes the underlying network

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 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: Vec<TYPES::SignatureKey>, 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: TYPES::SignatureKey, ) -> 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<TYPES::SignatureKey, Vec<u8>>, ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

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

send messages with vid shares to its recipients blocking

fn queue_node_lookup( &self, view_number: ViewNumber, pk: TYPES::SignatureKey, ) -> Result<(), TrySendError<Option<(ViewNumber, TYPES::SignatureKey)>>>

queues lookup of a node

fn update_view<'a, 'async_trait, T>( &'a self, view: u64, epoch: u64, membership: Arc<RwLock<T::Membership>>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where T: NodeType<SignatureKey = TYPES::SignatureKey> + 'a + 'async_trait, Self: 'async_trait, 'a: '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<TYPES: NodeType> TestableNetworkingImplementation<TYPES> for CombinedNetworks<TYPES>

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

Get the number of messages in-flight.

Some implementations will not be able to tell how many messages there are in-flight. These implementations should return None.

fn generator( expected_node_count: usize, num_bootstrap: usize, network_id: usize, da_committee_size: usize, reliability_config: Option<Box<dyn NetworkReliability>>, secondary_network_delay: Duration, ) -> AsyncGenerator<Arc<Self>>

generates a network given an expected node count