Enum sc_network_sync::PeerSyncState

pub enum PeerSyncState<B: BlockT> {
    Available,
    AncestorSearch {
        start: NumberFor<B>,
        current: NumberFor<B>,
        state: AncestorSearchState<B>,
    },
    DownloadingNew(NumberFor<B>),
    DownloadingStale(B::Hash),
    DownloadingJustification(B::Hash),
    DownloadingState,
    DownloadingWarpProof,
    DownloadingWarpTargetBlock,
    DownloadingGap(NumberFor<B>),
}

The state of syncing between a Peer and ourselves.

Generally two categories, “busy” or Available. If busy, the enum defines what we are busy with.

Variants

Available

Available for sync requests.

AncestorSearch

Fields

start: NumberFor<B>

current: NumberFor<B>

state: AncestorSearchState<B>

Searching for ancestors the Peer has in common with us.

DownloadingNew(NumberFor<B>)

Actively downloading new blocks, starting from the given Number.

DownloadingStale(B::Hash)

Downloading a stale block with given Hash. Stale means that it is a block with a number that is lower than our best number. It might be from a fork and not necessarily already imported.

DownloadingJustification(B::Hash)

Downloading justification for given block hash.

DownloadingState

Downloading state.

DownloadingWarpProof

Downloading warp proof.

DownloadingWarpTargetBlock

Downloading warp sync target block.

DownloadingGap(NumberFor<B>)

Actively downloading block history after warp sync.

Implementations

impl<B: BlockT> PeerSyncState<B>

pub fn is_available(&self) -> bool

Trait Implementations

impl<B: Clone + BlockT> Clone for PeerSyncState<B>where B::Hash: Clone,

fn clone(&self) -> PeerSyncState<B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Debug + BlockT> Debug for PeerSyncState<B>where B::Hash: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: PartialEq + BlockT> PartialEq<PeerSyncState<B>> for PeerSyncState<B>where B::Hash: PartialEq,

fn eq(&self, other: &PeerSyncState<B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<B: Copy + BlockT> Copy for PeerSyncState<B>where B::Hash: Copy,

impl<B: Eq + BlockT> Eq for PeerSyncState<B>where B::Hash: Eq,

impl<B: BlockT> StructuralEq for PeerSyncState<B>

impl<B: BlockT> StructuralPartialEq for PeerSyncState<B>