Struct phron_finality::sync::handler::Handler

pub struct Handler<B, I, J, CS, V, F, BI>
where
    J: Justification,
    B: Block<UnverifiedHeader = <<J as Justification>::Header as Header>::Unverified>,
    I: PeerId,
    CS: ChainStatus<B, J>,
    V: Verifier<J>,
    F: Finalizer<J>,
    BI: BlockImport<B>,
{
    chain_status: CS,
    verifier: V,
    finalizer: F,
    forest: Forest<I, J>,
    session_info: SessionBoundaryInfo,
    block_importer: BI,
    missed_import_data: MissedImportData,
    sync_oracle: SyncOracle,
    phantom: PhantomData<B>,
}

Handler for data incoming from the network.

Fields

chain_status: CS

verifier: V

finalizer: F

forest: Forest<I, J>

session_info: SessionBoundaryInfo

block_importer: BI

missed_import_data: MissedImportData

sync_oracle: SyncOracle

phantom: PhantomData<B>

Implementations

impl<B, I, J, CS, V, F, BI> Handler<B, I, J, CS, V, F, BI>

where J: Justification, B: Block<UnverifiedHeader = <<J as Justification>::Header as Header>::Unverified>, I: PeerId, CS: ChainStatus<B, J>, V: Verifier<J>, F: Finalizer<J>, BI: BlockImport<B>,

pub fn new( database_io: DatabaseIO<B, J, CS, F, BI>, verifier: V, sync_oracle: SyncOracle, session_info: SessionBoundaryInfo ) -> Result<Self, <Self as HandlerTypes>::Error>

New handler with the provided chain interfaces.

fn try_finalize(&mut self) -> Result<(), <Self as HandlerTypes>::Error>

pub fn block_imported( &mut self, header: J::Header ) -> Result<(), <Self as HandlerTypes>::Error>

Inform the handler that a block has been imported.

pub fn handle_request( &mut self, request: Request<J> ) -> Result<Action<B, J>, <Self as HandlerTypes>::Error>

Handle a request for potentially substantial amounts of data.

Returns what action we should take in response to the request. We either do nothing, request new interesting block to us or send a response containing path of justifications, blocks and headers. We try to be as helpful as we can, sometimes including more information from what was requested, sometimes ignoring their requested id if we know it makes sense.

pub fn handle_chain_extension_request( &mut self, state: State<J> ) -> Result<Action<B, J>, <Self as HandlerTypes>::Error>

Handle a chain extension request.

First treats it as a request for our favourite block with their favourite block as the top imported. If that fails due to our favourite block not being a descendant of theirs, it falls back to attempting to send any finalized blocks the requester doesn’t have.

fn handle_justification( &mut self, justification: J::Unverified, maybe_peer: Option<I> ) -> Result<bool, <Self as HandlerTypes>::Error>

Handle a single unverified justification. Return whether this justification was higher than the previously known highest justification.

fn verify_header( &mut self, header: <<J as Justification>::Header as Header>::Unverified ) -> Result<J::Header, <Self as HandlerTypes>::Error>

Verify an unverified header.

pub fn handle_justification_from_user( &mut self, justification: J::Unverified ) -> Result<bool, <Self as HandlerTypes>::Error>

Handle a justification from the user, returning whether it became the new highest justification.

pub fn handle_state_response( &mut self, justification: J::Unverified, maybe_justification: Option<J::Unverified>, peer: I ) -> (bool, Option<<Self as HandlerTypes>::Error>)

Handle a state response returning whether it resulted in a new highest justified block and possibly an error.

If no error is returned, it means that the whole state response was processed correctly. Otherwise, the response might have been processed partially, or dropped. In any case, the Handler finishes in a sane state.

pub fn handle_request_response( &mut self, response_items: Vec<ResponseItem<B, J>>, peer: I ) -> (bool, Option<<Self as HandlerTypes>::Error>)

Handle a request response returning whether it resulted in a new highest justified block and possibly an error.

If no error is returned, it means that the whole request response was processed correctly. Otherwise, the response might have been processed partially, or dropped. In any case, the Handler finishes in a sane state.

Note that this method does not verify nor import blocks. The received blocks are stored in a buffer, and might be silently discarded in the future if the import fails.

fn last_justification_unverified( &self, session: SessionId ) -> Result<J::Unverified, <Self as HandlerTypes>::Error>

pub fn handle_state( &mut self, state: State<J>, peer: I ) -> Result<HandleStateAction<B, J>, <Self as HandlerTypes>::Error>

Handle a state broadcast returning the actions we should take in response.

pub fn state(&self) -> Result<State<J>, <Self as HandlerTypes>::Error>

The current state of our database.

pub fn interest_provider(&self) -> InterestProvider<'_, I, J>

A handle for requesting Interest.

pub fn handle_internal_request( &mut self, id: &BlockId ) -> Result<bool, <Self as HandlerTypes>::Error>

Handle an internal block request. Returns true if this was the first time something indicated interest in this block.

pub fn extension_request(&self) -> ExtensionRequest<I>

Returns the extension request we could be making right now.

pub fn handle_own_block(&mut self, block: B) -> Vec<ResponseItem<B, J>>

Handle a block freshly created by this node. Imports it and returns a form of it that can be broadcast.

Trait Implementations

impl<B, I, J, CS, V, F, BI> HandlerTypes for Handler<B, I, J, CS, V, F, BI>

where J: Justification, B: Block<UnverifiedHeader = <<J as Justification>::Header as Header>::Unverified>, I: PeerId, CS: ChainStatus<B, J>, V: Verifier<J>, F: Finalizer<J>, BI: BlockImport<B>,

type Error = Error<B, J, CS, V, F>

What can go wrong when handling a piece of data.