Struct hotshot::traits::implementations::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::SignatureKey>, 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::SignatureKey>

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_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

Does not error

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

where T: 'async_trait + NodeType, Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: '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 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: BTreeSet<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, 'life0, 'async_trait, T>( &'a self, view: u64, membership: &'life0 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, 'life0: '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, is_da: bool, reliability_config: Option<Box<dyn NetworkReliability>>, secondary_network_delay: Duration ) -> AsyncGenerator<Arc<Self>>

generates a network given an expected node count