Struct hotshot_task_impls::da::DaTaskState

pub struct DaTaskState<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> {
    pub output_event_stream: Sender<Event<TYPES>>,
    pub cur_view: TYPES::View,
    pub cur_epoch: TYPES::Epoch,
    pub consensus: OuterConsensus<TYPES>,
    pub membership: Arc<RwLock<TYPES::Membership>>,
    pub network: Arc<I::Network>,
    pub vote_collectors: VoteCollectorsMap<TYPES, DaVote2<TYPES>, DaCertificate2<TYPES>, V>,
    pub public_key: TYPES::SignatureKey,
    pub private_key: <TYPES::SignatureKey as SignatureKey>::PrivateKey,
    pub id: u64,
    pub storage: Arc<RwLock<I::Storage>>,
    pub upgrade_lock: UpgradeLock<TYPES, V>,
}

Tracks state of a DA task

Fields

output_event_stream: Sender<Event<TYPES>>

Output events to application

cur_view: TYPES::View

View number this view is executing in.

cur_epoch: TYPES::Epoch

Epoch number this node is executing in.

consensus: OuterConsensus<TYPES>

Reference to consensus. Leader will require a read lock on this.

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

Membership for the DA committee and quorum committee. We need the latter only for calculating the proper VID scheme from the number of nodes in the quorum.

network: Arc<I::Network>

The underlying network

vote_collectors: VoteCollectorsMap<TYPES, DaVote2<TYPES>, DaCertificate2<TYPES>, V>

A map of DaVote collector tasks.

public_key: TYPES::SignatureKey

This Nodes public key

private_key: <TYPES::SignatureKey as SignatureKey>::PrivateKey

This Nodes private key

id: u64

This state’s ID

storage: Arc<RwLock<I::Storage>>

This node’s storage ref

upgrade_lock: UpgradeLock<TYPES, V>

Lock for a decided upgrade

Implementations

impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> DaTaskState<TYPES, I, V>

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

main task event handler

Trait Implementations

impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> TaskState for DaTaskState<TYPES, I, V>

task state implementation for DA Task

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.