Struct 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: Option<TYPES::Epoch>,
    pub membership_coordinator: EpochMembershipCoordinator<TYPES>,
    pub storage: S,
    pub storage_metrics: Arc<StorageMetricsValue>,
    pub consensus: OuterConsensus<TYPES>,
    pub upgrade_lock: UpgradeLock<TYPES, V>,
    pub transmit_tasks: BTreeMap<TYPES::View, Vec<JoinHandle<()>>>,
    pub epoch_height: u64,
    pub id: u64,
}

network event task state

Fields

network: Arc<NET>

comm network

view: TYPES::View

view number

epoch: Option<TYPES::Epoch>

epoch number

membership_coordinator: EpochMembershipCoordinator<TYPES>

network memberships

storage: S

Storage to store actionable events

storage_metrics: Arc<StorageMetricsValue>

Storage metrics

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

epoch_height: u64

Number of blocks in an epoch, zero means there are no epochs

id: u64

Node’s id

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: S, consensus: OuterConsensus<TYPES>, view: <TYPES as NodeType>::View, epoch: Option<<TYPES as NodeType>::Epoch>, ) -> 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.