Struct hotshot_task_impls::network::NetworkEventTaskState

pub struct NetworkEventTaskState<TYPES: NodeType, V: Versions, NET: ConnectedNetwork<TYPES::SignatureKey>, S: Storage<TYPES>> {
    pub network: Arc<NET>,
    pub view: TYPES::View,
    pub epoch: TYPES::Epoch,
    pub membership: Arc<RwLock<TYPES::Membership>>,
    pub storage: Arc<RwLock<S>>,
    pub consensus: OuterConsensus<TYPES>,
    pub upgrade_lock: UpgradeLock<TYPES, V>,
    pub transmit_tasks: BTreeMap<TYPES::View, Vec<JoinHandle<()>>>,
}

network event task state

Fields

network: Arc<NET>

comm network

view: TYPES::View

view number

epoch: TYPES::Epoch

epoch number

membership: Arc<RwLock<TYPES::Membership>>

network memberships

storage: Arc<RwLock<S>>

Storage to store actionable events

consensus: OuterConsensus<TYPES>

Shared consensus state

upgrade_lock: UpgradeLock<TYPES, V>

Lock for a decided upgrade

transmit_tasks: BTreeMap<TYPES::View, Vec<JoinHandle<()>>>

map view number to transmit tasks

Implementations

impl<TYPES: NodeType, V: Versions, NET: ConnectedNetwork<TYPES::SignatureKey>, S: Storage<TYPES> + 'static> NetworkEventTaskState<TYPES, V, NET, S>

pub async fn handle(&mut self, event: Arc<HotShotEvent<TYPES>>)

Handle the given event.

Returns the completion status.

async fn handle_vid_disperse_proposal( &self, vid_proposal: Proposal<TYPES, VidDisperse<TYPES>>, sender: &<TYPES as NodeType>::SignatureKey, ) -> Option<HotShotTaskCompleted>

handle VidDisperseSend

async fn maybe_record_action( maybe_action: Option<HotShotAction>, storage: Arc<RwLock<S>>, consensus: OuterConsensus<TYPES>, view: <TYPES as NodeType>::View, ) -> Result<(), ()>

Record HotShotAction if available

pub fn cancel_tasks(&mut self, view: TYPES::View)

Cancel all tasks for previous views

async fn parse_event( &mut self, event: Arc<HotShotEvent<TYPES>>, maybe_action: &mut Option<HotShotAction>, ) -> Option<(<TYPES as NodeType>::SignatureKey, MessageKind<TYPES>, TransmitType<TYPES>)>

Parses a HotShotEvent and returns a tuple of: (sender’s public key, MessageKind, TransmitType) which will be used to create a message and transmit on the wire. Returns None if the parsing result should not be sent on the wire. Handles the VidDisperseSend event separately using a helper method.

async fn spawn_transmit_task( &mut self, message_kind: MessageKind<TYPES>, maybe_action: Option<HotShotAction>, transmit: TransmitType<TYPES>, sender: TYPES::SignatureKey, )

Creates a network message and spawns a task that transmits it on the wire.

Trait Implementations

impl<TYPES: NodeType, V: Versions, NET: ConnectedNetwork<TYPES::SignatureKey>, S: Storage<TYPES> + 'static> TaskState for NetworkEventTaskState<TYPES, V, NET, S>

type Event = HotShotEvent<TYPES>

Type of event sent and received by the task

fn handle_event<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, event: Arc<Self::Event>, _sender: &'life1 Sender<Arc<Self::Event>>, _receiver: &'life2 Receiver<Arc<Self::Event>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handles an event, providing direct access to the specific channel we received the event on.

fn cancel_subtasks(&mut self)

Joins all subtasks.