Enum state_sync_v1::chunk_request::TargetType

pub enum TargetType {
    TargetLedgerInfo(LedgerInfoWithSignatures),
    HighestAvailable {
        target_li: Option<LedgerInfoWithSignatures>,
        timeout_ms: u64,
    },
    Waypoint(Version),
}

We’re currently considering several types of chunk requests depending on the information available on the requesting side.

Variants

TargetLedgerInfo(LedgerInfoWithSignatures)

The response is built relative to the target (or end of epoch). DEPRECATED: TargetLedgerInfo is only required for backward compatibility. State sync avoids sending these target types and instead uses HighestAvailable below. This message will be removed on the next breaking release: https://github.com/diem/diem/issues/8013

HighestAvailable

Fields

target_li: Option<LedgerInfoWithSignatures>

timeout_ms: u64

The response is built relative to the highest available LedgerInfo (or end of epoch). The value specifies the timeout in ms to wait for an available response. This “long poll” approach allows a responding node to add the request to the list of its subscriptions for the duration of a timeout until some new information becomes available.

target_li: While asking for the highest available ledger info, this request also provides the option to the sync requester to specify a target LI. This is to support the scenario where the sync requester is lagging too much behind the responding node in the sync process. If the highest ledger info version keeps advancing on the responding node, even though the sync requester continues to receive and sync txns, those txns will never be backed an LI, since a LI can only be committed once all the transactions up to the LI’s version has been received. (It is important for a transaction to be backed by an LI, because transactions need to be backed by an LI to be shown as committed upon storage query) To prevent the above problem where the transactions are never backed by a LI during sync catch-up (or the difference between synced version and committed LI version keeps growing on sync requester), this TargetType can simultaneously (1) ask for the highest ledger info, and (2) specify a target to build the requested transactions w.r.t.. With (1), the sync requester can store the LI later to target-sync once it is ready for that LI after syncing to an earlier target LI via (2).

If target_li is not specified, the responding node will build the responses against its highest LI

Waypoint(Version)

The response is built relative to a LedgerInfo at a given version.

Implementations

impl TargetType

pub fn epoch(&self) -> Option<u64>

pub fn version(&self) -> Option<u64>

Trait Implementations

impl Arbitrary for TargetType

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

fn arbitrary_with(_args: ()) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

type Strategy = BoxedStrategy<TargetType>

The type of Strategy used to generate values of type Self.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for TargetType

fn clone(&self) -> TargetType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TargetType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TargetType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TargetType

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

Formats the value using the given formatter.

impl PartialEq<TargetType> for TargetType

fn eq(&self, other: &TargetType) -> 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 Serialize for TargetType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TargetType

impl StructuralEq for TargetType

impl StructuralPartialEq for TargetType