Struct concorde::Participant

pub struct Participant<ObjLD: LatticeDef, Peer: Ord + Clone + Debug + Hash> where
    ObjLD::T: Clone + Debug + Default,  {
    pub id: Peer,
    pub final_state: Option<StateLE<ObjLD, Peer>>,
    // some fields omitted
}

Participants represent parties participating in lattice agreement. They support a low-level, explicit-state-machine interface that must be manually initialized and stepped, with each step consuming input messages, producing output messages, and possibly performing a state transition. When complete, a final proposal-agreement value can be read out of the Participant.

Note that unlike in a full consensus system, the response from propose is not guaranteed to be equal at all Participants, nor is it guaranteed to even be a value any Participant proposed.

(The exact guarantees on the proposal, its response, and its relationships to other proposals and responses on other peers are somewhat subtle, see the paper.)

Responsibility for routing Message::Requests and Message::Responses to their destination Peers is left to the client of this library, as is responsibility for distributing broadcast Message::Commits.

All such communication is assumed to be (eventually) reliable, though no timing assumptions are made. Lost messages, or a sufficient number of quorum-peer failures, may cause Participants to get stuck. If this is a concern, the state machine should be embedded in a higher-level retry protocol that uses timeouts to ensure eventual delivery.

Fields

id: Peer

final_state: Option<StateLE<ObjLD, Peer>>

Implementations

impl<ObjLD: LatticeDef + 'static, Peer: Ord + Clone + Debug + Hash + 'static> Participant<ObjLD, Peer> where
    ObjLD::T: Clone + Debug + Default, 

pub fn new(id: Peer) -> Self

pub fn propose_step<'a, MI>(
    &mut self,
    incoming: MI,
    outgoing: &mut Vec<Message<ObjLD, Peer>>
) where
    MI: Iterator<Item = &'a Message<ObjLD, Peer>>, 

pub fn propose_is_fini(&self) -> bool

Returns true iff the participant's proposal state-machine is fini.

pub fn propose(&mut self, prop: &StateLE<ObjLD, Peer>)

Starts a new proposal, resetting necessary state, so can be called at any time,

Trait Implementations

impl<ObjLD: LatticeDef, Peer: Ord + Clone + Debug + Hash> Clone for Participant<ObjLD, Peer> where
    ObjLD::T: Clone + Debug + Default, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<ObjLD: Debug + LatticeDef, Peer: Debug + Ord + Clone + Hash> Debug for Participant<ObjLD, Peer> where
    ObjLD::T: Clone + Debug + Default, 

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

Formats the value using the given formatter.

impl<ObjLD: LatticeDef, Peer: Ord + Clone + Debug + Hash> Hash for Participant<ObjLD, Peer> where
    ObjLD::T: Clone + Debug + Default + Hash, 

fn hash<H: Hasher>(&self, hstate: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].