Struct SenderQueue 

pub struct SenderQueue<D>
where
    D: SenderQueueableConsensusProtocol,
{ /* private fields */ }

An instance of ConsensusProtocol wrapped with a queue of outgoing messages, that is, a sender queue. This wrapping ensures that the messages sent to remote instances lead to progress of the entire consensus network. In particular, messages to lagging remote nodes are queued and sent only when those nodes’ epochs match the queued messages’ epochs. Thus all nodes can handle incoming messages without queueing them and can ignore messages whose epochs are not currently acccepted.

Implementations

impl<C, N> SenderQueue<DynamicHoneyBadger<C, N>>

where C: Contribution + Serialize + DeserializeOwned, N: NodeIdT + Serialize + DeserializeOwned,

pub fn propose<R: Rng>( &mut self, rng: &mut R, contrib: C, ) -> Result<CpStep<SenderQueue<DynamicHoneyBadger<C, N>>>, Error<Error>>

Proposes a contribution in the current epoch.

Returns an error if we already made a proposal in this epoch.

If we are the only validator, this will immediately output a batch, containing our proposal.

pub fn vote_for( &mut self, change: Change<N>, ) -> Result<CpStep<SenderQueue<DynamicHoneyBadger<C, N>>>, Error<Error>>

Casts a vote to change the set of validators or parameters.

This stores a pending vote for the change. It will be included in some future batch, and once enough validators have been voted for the same change, it will take effect.

pub fn vote_to_add( &mut self, node_id: N, pub_key: PublicKey, ) -> Result<CpStep<SenderQueue<DynamicHoneyBadger<C, N>>>, Error<Error>>

Casts a vote to add a node as a validator.

This stores a pending vote for the change. It will be included in some future batch, and once enough validators have been voted for the same change, it will take effect.

pub fn vote_to_remove( &mut self, node_id: &N, ) -> Result<CpStep<SenderQueue<DynamicHoneyBadger<C, N>>>, Error<Error>>

Casts a vote to demote a validator to observer.

This stores a pending vote for the change. It will be included in some future batch, and once enough validators have been voted for the same change, it will take effect.

pub fn restart<I, R: Rng>( &mut self, join_plan: JoinPlan<N>, peer_ids: I, rng: &mut R, ) -> Result<CpStep<SenderQueue<DynamicHoneyBadger<C, N>>>, Error<Error>>

where I: Iterator<Item = N>,

Restarts the managed algorithm with the given join plan with a new list of peers and with the same secret key. In order to be restarted, the node should have completed the process of removing itself from the network. The node may not output a batch if it were not properly removed.

impl<T, N, Q> SenderQueue<QueueingHoneyBadger<T, N, Q>>

where T: Contribution + Serialize + DeserializeOwned + Clone, N: NodeIdT + Serialize + DeserializeOwned, Q: TransactionQueue<T>, Standard: Distribution<N>,

pub fn push_transaction<R: Rng>( &mut self, tx: T, rng: &mut R, ) -> Result<CpStep<SenderQueue<QueueingHoneyBadger<T, N, Q>>>, Error<Error>>

Adds a transaction to the queue.

This can be called at any time to append to the transaction queue. The new transaction will be proposed in some future epoch.

If no proposal has yet been made for the current epoch, this may trigger one. In this case, a nonempty step will returned, with the corresponding messages. (Or, if we are the only validator, even with the completed batch as an output.)

pub fn vote_for<R: Rng>( &mut self, change: Change<N>, rng: &mut R, ) -> Result<CpStep<SenderQueue<QueueingHoneyBadger<T, N, Q>>>, Error<Error>>

Casts a vote to change the set of validators or parameters.

This stores a pending vote for the change. It will be included in some future batch, and once enough validators have been voted for the same change, it will take effect.

pub fn vote_to_add<R: Rng>( &mut self, node_id: N, pub_key: PublicKey, rng: &mut R, ) -> Result<CpStep<SenderQueue<QueueingHoneyBadger<T, N, Q>>>, Error<Error>>

Casts a vote to add a node as a validator.

This stores a pending vote for the change. It will be included in some future batch, and once enough validators have been voted for the same change, it will take effect.

pub fn vote_to_remove<R: Rng>( &mut self, node_id: &N, rng: &mut R, ) -> Result<CpStep<SenderQueue<QueueingHoneyBadger<T, N, Q>>>, Error<Error>>

Casts a vote to demote a validator to observer.

This stores a pending vote for the change. It will be included in some future batch, and once enough validators have been voted for the same change, it will take effect.

impl<D> SenderQueue<D>

where D: SenderQueueableConsensusProtocol + Debug, D::Message: Clone + SenderQueueableMessage<Epoch = D::Epoch>, D::NodeId: NodeIdT, D::Output: SenderQueueableOutput<D::NodeId, D::Epoch>,

pub fn builder<I>(algo: D, peer_ids: I) -> SenderQueueBuilder<D>

where I: Iterator<Item = D::NodeId>,

Returns a new SenderQueueBuilder configured to manage a given DynamicHoneyBadger instance.

pub fn handle_input<R: Rng>( &mut self, input: D::Input, rng: &mut R, ) -> Result<CpStep<Self>, Error<D::Error>>

Handles an input. This will call the wrapped algorithm’s handle_input.

pub fn handle_message<R: Rng>( &mut self, sender_id: &D::NodeId, message: Message<D::Message>, rng: &mut R, ) -> Result<CpStep<Self>, Error<D::Error>>

Handles a message received from sender_id.

This must be called with every message we receive from another node.

pub fn inner(&self) -> &D

Returns an immutable reference to the wrapped algorithm.

pub fn is_removed(&self) -> bool

Returns true iff the node has been removed from the list of participants.

pub fn algo(&self) -> &D

Returns a reference to the managed algorithm.

pub fn algo_mut(&mut self) -> &mut D

Returns a mutable reference to the managed algorithm.

Trait Implementations

impl<D> ConsensusProtocol for SenderQueue<D>

where D: SenderQueueableConsensusProtocol + Debug, D::Message: Clone + SenderQueueableMessage<Epoch = D::Epoch>, D::NodeId: NodeIdT, D::Output: SenderQueueableOutput<D::NodeId, D::Epoch>,

type NodeId = <D as ConsensusProtocol>::NodeId

Unique node identifier.

type Input = <D as ConsensusProtocol>::Input

The input provided by the user.

type Output = <D as ConsensusProtocol>::Output

The output type. Some algorithms return an output exactly once, others return multiple times.

type Message = Message<<D as ConsensusProtocol>::Message>

The messages that need to be exchanged between the instances in the participating nodes.

type Error = Error<<D as ConsensusProtocol>::Error>

The errors that can occur during execution.

type FaultKind = <D as ConsensusProtocol>::FaultKind

The kinds of message faults that can be detected during execution.

fn handle_input<R: Rng>( &mut self, input: Self::Input, rng: &mut R, ) -> Result<CpStep<Self>, Error<D::Error>>

Handles an input provided by the user, and returns

fn handle_message<R: Rng>( &mut self, sender_id: &D::NodeId, message: Self::Message, rng: &mut R, ) -> Result<CpStep<Self>, Error<D::Error>>

Handles a message received from node sender_id.

fn terminated(&self) -> bool

Returns true if execution has completed and this instance can be dropped.

fn our_id(&self) -> &D::NodeId

Returns this node’s own ID.

impl<D> Debug for SenderQueue<D>

where D: SenderQueueableConsensusProtocol + Debug, D::NodeId: Debug, D::Epoch: Debug,

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

Formats the value using the given formatter.