Struct hotshot_task_impls::request::NetworkRequestState

pub struct NetworkRequestState<TYPES: NodeType, I: NodeImplementation<TYPES>> {
    pub network: Arc<I::Network>,
    pub consensus: OuterConsensus<TYPES>,
    pub view: TYPES::View,
    pub delay: Duration,
    pub membership: Arc<RwLock<TYPES::Membership>>,
    pub public_key: TYPES::SignatureKey,
    pub private_key: <TYPES::SignatureKey as SignatureKey>::PrivateKey,
    pub id: u64,
    pub shutdown_flag: Arc<AtomicBool>,
    pub spawned_tasks: BTreeMap<TYPES::View, Vec<JoinHandle<()>>>,
}

Long running task which will request information after a proposal is received. The task will wait a it’s delay and then send a request iteratively to peers for any data they don’t have related to the proposal. For now it’s just requesting VID shares.

Fields

network: Arc<I::Network>

Network to send requests over The underlying network

consensus: OuterConsensus<TYPES>

Consensus shared state so we can check if we’ve gotten the information before sending a request

view: TYPES::View

Last seen view, we won’t request for proposals before older than this view

delay: Duration

Delay before requesting peers

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

Membership (Used here only for DA)

public_key: TYPES::SignatureKey

This nodes public key

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

This nodes private/signing key, used to sign requests.

id: u64

The node’s id

shutdown_flag: Arc<AtomicBool>

A flag indicating that HotShotEvent::Shutdown has been received

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

A flag indicating that HotShotEvent::Shutdown has been received

Implementations

impl<TYPES: NodeType, I: NodeImplementation<TYPES>> NetworkRequestState<TYPES, I>

async fn spawn_requests( &mut self, view: TYPES::View, epoch: TYPES::Epoch, sender: &Sender<Arc<HotShotEvent<TYPES>>>, receiver: &Receiver<Arc<HotShotEvent<TYPES>>>, )

Creates and signs the payload, then will create a request task

async fn create_vid_request_task( &mut self, request: RequestKind<TYPES>, signature: <<TYPES as NodeType>::SignatureKey as SignatureKey>::PureAssembledSignatureType, sender: Sender<Arc<HotShotEvent<TYPES>>>, receiver: Receiver<Arc<HotShotEvent<TYPES>>>, view: TYPES::View, epoch: TYPES::Epoch, )

Creates a task that will request a VID share from a DA member and wait for the HotShotEvent::VidResponseRecvevent If we get the VID disperse share, broadcast HotShotEvent::VidShareRecv and terminate task

async fn handle_vid_request_task( sender: &Sender<Arc<HotShotEvent<TYPES>>>, receiver: &Receiver<Arc<HotShotEvent<TYPES>>>, data_request: &DataRequest<TYPES>, recipient: &TYPES::SignatureKey, da_committee_for_view: &BTreeSet<<TYPES as NodeType>::SignatureKey>, public_key: &<TYPES as NodeType>::SignatureKey, view: TYPES::View, ) -> bool

Handles main logic for the Request / Response of a vid share Make the request to get VID share to a DA member and wait for the response. Returns true if response received, otherwise false

async fn handle_event_dependency( receiver: &Receiver<Arc<HotShotEvent<TYPES>>>, da_members_for_view: BTreeSet<<TYPES as NodeType>::SignatureKey>, view: TYPES::View, ) -> Option<Arc<HotShotEvent<TYPES>>>

Create event dependency and wait for VidResponseRecv after we send out the request Returns an optional with VidResponseRecv if received, otherwise None

async fn cancel_vid_request_task( consensus: &OuterConsensus<TYPES>, sender: &Sender<Arc<HotShotEvent<TYPES>>>, public_key: &<TYPES as NodeType>::SignatureKey, view: &TYPES::View, shutdown_flag: &Arc<AtomicBool>, ) -> bool

Returns true if we got the data we wanted, a shutdown event was received, or the view has moved on.

fn serialize_and_sign( &self, request: &RequestKind<TYPES>, ) -> Option<<<TYPES as NodeType>::SignatureKey as SignatureKey>::PureAssembledSignatureType>

Sign the serialized version of the request

Trait Implementations

impl<TYPES: NodeType, I: NodeImplementation<TYPES>> Drop for NetworkRequestState<TYPES, I>

fn drop(&mut self)

Executes the destructor for this type.

impl<TYPES: NodeType, I: NodeImplementation<TYPES>> TaskState for NetworkRequestState<TYPES, I>

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.