diff --git a/crates/apollo_consensus/src/manager.rs b/crates/apollo_consensus/src/manager.rs index f995a96e231..0d86b8e8944 100644 --- a/crates/apollo_consensus/src/manager.rs +++ b/crates/apollo_consensus/src/manager.rs @@ -39,7 +39,7 @@ use crate::metrics::{ CONSENSUS_REPROPOSALS, }; use crate::single_height_consensus::{ShcReturn, SingleHeightConsensus}; -use crate::state_machine::{SMRequest, StateMachineEvent}; +use crate::state_machine::{SMRequest, StateMachineEvent, Step}; use crate::storage::HeightVotedStorageTrait; use crate::types::{ BroadcastVoteChannel, @@ -785,29 +785,24 @@ impl MultiHeightManager { .boxed(); Ok(Some(fut)) } - SMRequest::ScheduleTimeoutPropose(round) => { - let duration = timeouts.get_proposal_timeout(round); - let fut = async move { - tokio::time::sleep(duration).await; - StateMachineEvent::TimeoutPropose(round) - } - .boxed(); - Ok(Some(fut)) - } - SMRequest::ScheduleTimeoutPrevote(round) => { - let duration = timeouts.get_prevote_timeout(round); - let fut = async move { - tokio::time::sleep(duration).await; - StateMachineEvent::TimeoutPrevote(round) - } - .boxed(); - Ok(Some(fut)) - } - SMRequest::ScheduleTimeoutPrecommit(round) => { - let duration = timeouts.get_precommit_timeout(round); + SMRequest::ScheduleTimeout(step, round) => { + let (duration, event) = match step { + Step::Propose => ( + timeouts.get_proposal_timeout(round), + StateMachineEvent::TimeoutPropose(round), + ), + Step::Prevote => ( + timeouts.get_prevote_timeout(round), + StateMachineEvent::TimeoutPrevote(round), + ), + Step::Precommit => ( + timeouts.get_precommit_timeout(round), + StateMachineEvent::TimeoutPrecommit(round), + ), + }; let fut = async move { tokio::time::sleep(duration).await; - StateMachineEvent::TimeoutPrecommit(round) + event } .boxed(); Ok(Some(fut)) diff --git a/crates/apollo_consensus/src/single_height_consensus_test.rs b/crates/apollo_consensus/src/single_height_consensus_test.rs index bf5da8fb59a..b527cd58696 100644 --- a/crates/apollo_consensus/src/single_height_consensus_test.rs +++ b/crates/apollo_consensus/src/single_height_consensus_test.rs @@ -8,7 +8,7 @@ use test_case::test_case; use super::SingleHeightConsensus; use crate::single_height_consensus::ShcReturn; -use crate::state_machine::{SMRequest, StateMachineEvent}; +use crate::state_machine::{SMRequest, StateMachineEvent, Step}; use crate::test_utils::{precommit, prevote, TestBlock}; use crate::types::{ProposalCommitment, ValidatorId}; use crate::votes_threshold::QuorumType; @@ -63,7 +63,7 @@ fn proposer() { shc.handle_vote(&leader_fn, prevote(Some(BLOCK.id.0), 0, 0, *VALIDATOR_ID_2)).unwrap(); // Expect a precommit broadcast request present. assert_matches!(ret, ShcReturn::Requests(mut reqs) => { - assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeoutPrevote(0))); + assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeout(Step::Prevote, 0))); assert_matches!(reqs.pop_front(), Some(SMRequest::BroadcastVote(v)) if v.vote_type == VoteType::Precommit); assert!(reqs.is_empty()); }); @@ -125,7 +125,7 @@ fn validator(repeat_proposal: bool) { shc.handle_vote(&leader_fn, prevote(Some(BLOCK.id.0), 0, 0, *VALIDATOR_ID_3)).unwrap(); // Expect a precommit broadcast request present. assert_matches!(ret, ShcReturn::Requests(mut reqs) => { - assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeoutPrevote(0))); + assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeout(Step::Prevote, 0))); assert_matches!(reqs.pop_front(), Some(SMRequest::BroadcastVote(v)) if v.vote_type == VoteType::Precommit); assert!(reqs.is_empty()); }); @@ -169,7 +169,7 @@ fn vote_twice(same_vote: bool) { .unwrap(); // On quorum of prevotes, expect a precommit broadcast request. assert_matches!(res, ShcReturn::Requests(mut reqs) => { - assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeoutPrevote(0))); + assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeout(Step::Prevote, 0))); assert_matches!(reqs.pop_front(), Some(SMRequest::BroadcastVote(v)) if v.vote_type == VoteType::Precommit); assert!(reqs.is_empty()); }); @@ -227,7 +227,7 @@ fn rebroadcast_votes() { shc.handle_vote(&leader_fn, prevote(Some(BLOCK.id.0), 0, 0, *VALIDATOR_ID_2)).unwrap(); // Expect a precommit broadcast at round 0. assert_matches!(ret, ShcReturn::Requests(mut reqs) => { - assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeoutPrevote(0))); + assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeout(Step::Prevote, 0))); assert_matches!(reqs.pop_front(), Some(SMRequest::BroadcastVote(v)) if v.vote_type == VoteType::Precommit && v.round == 0); assert!(reqs.is_empty()); }); @@ -250,7 +250,7 @@ fn rebroadcast_votes() { let ret = shc.handle_vote(&leader_fn, prevote(Some(BLOCK.id.0), 0, 1, *VALIDATOR_ID_3)).unwrap(); assert_matches!(ret, ShcReturn::Requests(mut reqs) => { - assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeoutPrevote(1))); + assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeout(Step::Prevote, 1))); assert_matches!(reqs.pop_front(), Some(SMRequest::BroadcastVote(v)) if v.vote_type == VoteType::Precommit && v.round == 1); assert!(reqs.is_empty()); }); @@ -303,9 +303,9 @@ fn repropose() { // and schedule a prevote timeout for round 0. let ret = shc.handle_vote(&leader_fn, prevote(Some(BLOCK.id.0), 0, 0, *VALIDATOR_ID_2)).unwrap(); - // Expect ScheduleTimeoutPrevote{round:0} and BroadcastVote(Precommit). + // Expect ScheduleTimeout(Step::Prevote, 0) and BroadcastVote(Precommit). assert_matches!(ret, ShcReturn::Requests(mut reqs) => { - assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeoutPrevote(0))); + assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeout(Step::Prevote, 0))); assert_matches!(reqs.pop_front(), Some(SMRequest::BroadcastVote(v)) if v.vote_type == VoteType::Precommit && v.round == 0); assert!(reqs.is_empty()); }); @@ -315,7 +315,7 @@ fn repropose() { let ret = shc.handle_vote(&leader_fn, precommit(None, 0, 0, *VALIDATOR_ID_2)).unwrap(); // assert that ret is ScheduleTimeoutPrecommit assert_matches!(ret, ShcReturn::Requests(mut reqs) => { - assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeoutPrecommit(0))); + assert_matches!(reqs.pop_front(), Some(SMRequest::ScheduleTimeout(Step::Precommit, 0))); assert!(reqs.is_empty()); }); // No precommit quorum is reached. On TimeoutPrecommit(0) the proposer advances to round 1 with diff --git a/crates/apollo_consensus/src/state_machine.rs b/crates/apollo_consensus/src/state_machine.rs index 968a13e764c..e317cb28e83 100644 --- a/crates/apollo_consensus/src/state_machine.rs +++ b/crates/apollo_consensus/src/state_machine.rs @@ -67,12 +67,8 @@ pub(crate) enum SMRequest { StartValidateProposal(ProposalInit), /// Request to broadcast a Prevote or Precommit vote. BroadcastVote(Vote), - /// Request to schedule a TimeoutPropose. - ScheduleTimeoutPropose(Round), - /// Request to schedule a TimeoutPrevote. - ScheduleTimeoutPrevote(Round), - /// Request to schedule a TimeoutPrecommit. - ScheduleTimeoutPrecommit(Round), + /// Request to schedule a timeout for a specific step and round. + ScheduleTimeout(Step, Round), /// Decision reached for the given proposal and round. DecisionReached(ProposalCommitment, Round), /// Request to re-propose (sent by the leader after advancing to a new round @@ -511,7 +507,7 @@ impl StateMachine { } } else { info!("START_ROUND_VALIDATOR: Starting round {round} as Validator"); - VecDeque::from([SMRequest::ScheduleTimeoutPropose(self.round)]) + VecDeque::from([SMRequest::ScheduleTimeout(Step::Propose, self.round)]) }; output.append(&mut self.current_round_upons()); output @@ -625,7 +621,7 @@ impl StateMachine { if !self.mixed_prevote_quorum.insert(self.round) { return VecDeque::new(); } - VecDeque::from([SMRequest::ScheduleTimeoutPrevote(self.round)]) + VecDeque::from([SMRequest::ScheduleTimeout(Step::Prevote, self.round)]) } // LOC 36 in the paper. @@ -684,7 +680,7 @@ impl StateMachine { if !self.mixed_precommit_quorum.insert(self.round) { return VecDeque::new(); } - VecDeque::from([SMRequest::ScheduleTimeoutPrecommit(self.round)]) + VecDeque::from([SMRequest::ScheduleTimeout(Step::Precommit, self.round)]) } // LOC 49 in the paper. diff --git a/crates/apollo_consensus/src/state_machine_test.rs b/crates/apollo_consensus/src/state_machine_test.rs index c06d8a0cf54..edc7e6df144 100644 --- a/crates/apollo_consensus/src/state_machine_test.rs +++ b/crates/apollo_consensus/src/state_machine_test.rs @@ -7,7 +7,7 @@ use starknet_types_core::felt::Felt; use test_case::test_case; use super::Round; -use crate::state_machine::{SMRequest, StateMachine, StateMachineEvent}; +use crate::state_machine::{SMRequest, StateMachine, StateMachineEvent, Step}; use crate::types::{ProposalCommitment, ValidatorId}; use crate::votes_threshold::QuorumType; @@ -142,7 +142,10 @@ fn events_arrive_in_ideal_order(is_proposer: bool) { wrapper.send_finished_building(PROPOSAL_ID, ROUND); } else { // Waiting for the proposal. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!( + wrapper.next_request().unwrap(), + SMRequest::ScheduleTimeout(Step::Propose, ROUND) + ); assert!(wrapper.next_request().is_none()); wrapper.send_finished_validation(PROPOSAL_ID, ROUND); } @@ -157,7 +160,7 @@ fn events_arrive_in_ideal_order(is_proposer: bool) { wrapper.send_prevote(PROPOSAL_ID, ROUND); // The Node got a Prevote quorum. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); assert_eq!( wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Precommit, ROUND, PROPOSAL_ID, id)) @@ -169,7 +172,7 @@ fn events_arrive_in_ideal_order(is_proposer: bool) { wrapper.send_precommit(PROPOSAL_ID, ROUND); // The Node got a Precommit quorum. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); assert_eq!( wrapper.next_request().unwrap(), SMRequest::DecisionReached(PROPOSAL_ID.unwrap(), ROUND) @@ -184,7 +187,7 @@ fn validator_receives_votes_first() { wrapper.start(); // Waiting for the proposal. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Propose, ROUND)); assert!(wrapper.next_request().is_none()); // Receives votes from all the other nodes first (more than minimum for a quorum). @@ -196,7 +199,7 @@ fn validator_receives_votes_first() { wrapper.send_precommit(PROPOSAL_ID, ROUND); // The Node got a Precommit quorum. TimeoutPrevote is only initiated once the SM reaches the // prevote step. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); assert!(wrapper.next_request().is_none()); // Finally the proposal arrives. @@ -205,7 +208,7 @@ fn validator_receives_votes_first() { wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Prevote, ROUND, PROPOSAL_ID, *VALIDATOR_ID)) ); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); assert_eq!( wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Precommit, ROUND, PROPOSAL_ID, *VALIDATOR_ID)) @@ -238,7 +241,7 @@ fn buffer_events_during_get_proposal(vote: Option) { wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Prevote, ROUND, PROPOSAL_ID, *PROPOSER_ID)) ); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); assert_eq!( wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Precommit, ROUND, vote, *PROPOSER_ID)) @@ -253,7 +256,7 @@ fn only_send_precommit_with_prevote_quorum_and_proposal() { wrapper.start(); // Waiting for the proposal. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Propose, ROUND)); assert!(wrapper.next_request().is_none()); // Receives votes from all the other nodes first (more than minimum for a quorum). @@ -268,7 +271,7 @@ fn only_send_precommit_with_prevote_quorum_and_proposal() { wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Prevote, ROUND, PROPOSAL_ID, *VALIDATOR_ID)) ); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); assert_eq!( wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Precommit, ROUND, PROPOSAL_ID, *VALIDATOR_ID)) @@ -283,7 +286,7 @@ fn only_decide_with_prcommit_quorum_and_proposal() { wrapper.start(); // Waiting for the proposal. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Propose, ROUND)); assert!(wrapper.next_request().is_none()); // Receives votes from all the other nodes first (more than minimum for a quorum). @@ -300,12 +303,12 @@ fn only_decide_with_prcommit_quorum_and_proposal() { wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Prevote, ROUND, PROPOSAL_ID, *VALIDATOR_ID)) ); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); assert_eq!( wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Precommit, ROUND, PROPOSAL_ID, *VALIDATOR_ID)) ); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); assert_eq!( wrapper.next_request().unwrap(), SMRequest::DecisionReached(PROPOSAL_ID.unwrap(), ROUND) @@ -320,7 +323,7 @@ fn advance_to_the_next_round() { wrapper.start(); // Waiting for the proposal. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Propose, ROUND)); assert!(wrapper.next_request().is_none()); wrapper.send_finished_validation(PROPOSAL_ID, ROUND); @@ -336,10 +339,13 @@ fn advance_to_the_next_round() { assert!(wrapper.next_request().is_none()); wrapper.send_precommit(None, ROUND); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); wrapper.send_timeout_precommit(ROUND); // The Node sends Prevote after advancing to the next round. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND + 1)); + assert_eq!( + wrapper.next_request().unwrap(), + SMRequest::ScheduleTimeout(Step::Propose, ROUND + 1) + ); assert_eq!( wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Prevote, ROUND + 1, PROPOSAL_ID, *VALIDATOR_ID)) @@ -352,18 +358,21 @@ fn prevote_when_receiving_proposal_in_current_round() { TestWrapper::new(*VALIDATOR_ID, 4, |_: Round| *PROPOSER_ID, false, QuorumType::Byzantine); wrapper.start(); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Propose, ROUND)); assert!(wrapper.next_request().is_none()); wrapper.send_precommit(None, ROUND); wrapper.send_precommit(None, ROUND); wrapper.send_precommit(None, ROUND); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); wrapper.send_timeout_precommit(ROUND); // The node starts the next round, shouldn't prevote when receiving a proposal for the // previous round. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND + 1)); + assert_eq!( + wrapper.next_request().unwrap(), + SMRequest::ScheduleTimeout(Step::Propose, ROUND + 1) + ); wrapper.send_finished_validation(PROPOSAL_ID, ROUND); assert!(wrapper.next_request().is_none()); // The node should prevote when receiving a proposal for the current round. @@ -382,7 +391,7 @@ fn mixed_quorum(send_proposal: bool) { wrapper.start(); // Waiting for the proposal. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Propose, ROUND)); assert!(wrapper.requests.is_empty()); if send_proposal { @@ -401,7 +410,7 @@ fn mixed_quorum(send_proposal: bool) { wrapper.send_prevote(PROPOSAL_ID, ROUND); wrapper.send_prevote(None, ROUND); // The Node got a Prevote quorum. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); wrapper.send_timeout_prevote(ROUND); assert_eq!( wrapper.next_request().unwrap(), @@ -410,9 +419,12 @@ fn mixed_quorum(send_proposal: bool) { wrapper.send_precommit(PROPOSAL_ID, ROUND); wrapper.send_precommit(PROPOSAL_ID, ROUND); // The Node got a Precommit quorum. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); wrapper.send_timeout_precommit(ROUND); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND + 1)); + assert_eq!( + wrapper.next_request().unwrap(), + SMRequest::ScheduleTimeout(Step::Propose, ROUND + 1) + ); } #[test] @@ -445,13 +457,13 @@ fn dont_handle_enqueued_while_awaiting_get_proposal() { wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Prevote, ROUND, PROPOSAL_ID, *PROPOSER_ID)) ); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); // Nil Prevote quorum, so we broadcast a nil Precommit. assert_eq!( wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Precommit, ROUND, None, *PROPOSER_ID)) ); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); // Timeout and advance on to the next round. wrapper.send_timeout_precommit(ROUND); @@ -464,13 +476,19 @@ fn dont_handle_enqueued_while_awaiting_get_proposal() { wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Prevote, ROUND + 1, PROPOSAL_ID, *PROPOSER_ID)) ); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND + 1)); + assert_eq!( + wrapper.next_request().unwrap(), + SMRequest::ScheduleTimeout(Step::Prevote, ROUND + 1) + ); // Nil Prevote quorum, so we broadcast a nil Precommit. assert_eq!( wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Precommit, ROUND + 1, None, *PROPOSER_ID)) ); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND + 1)); + assert_eq!( + wrapper.next_request().unwrap(), + SMRequest::ScheduleTimeout(Step::Precommit, ROUND + 1) + ); } #[test] @@ -490,7 +508,7 @@ fn return_proposal_if_locked_value_is_set() { // locked_value is set after receiving a Prevote quorum. wrapper.send_prevote(PROPOSAL_ID, ROUND); wrapper.send_prevote(PROPOSAL_ID, ROUND); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); assert_eq!( wrapper.next_request().unwrap(), SMRequest::BroadcastVote(mk_vote(VoteType::Precommit, ROUND, PROPOSAL_ID, *PROPOSER_ID)) @@ -498,7 +516,7 @@ fn return_proposal_if_locked_value_is_set() { wrapper.send_precommit(None, ROUND); wrapper.send_precommit(None, ROUND); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); wrapper.send_timeout_precommit(ROUND); @@ -529,7 +547,7 @@ fn observer_node_reaches_decision() { wrapper.start(); // Waiting for the proposal. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Propose, ROUND)); assert!(wrapper.next_request().is_none()); wrapper.send_finished_validation(PROPOSAL_ID, ROUND); // The observer node does not respond to the proposal by sending votes. @@ -538,7 +556,7 @@ fn observer_node_reaches_decision() { wrapper.send_precommit(PROPOSAL_ID, ROUND); wrapper.send_precommit(PROPOSAL_ID, ROUND); wrapper.send_precommit(PROPOSAL_ID, ROUND); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); // Once a quorum of precommits is observed, the node should generate a decision event. assert_eq!( wrapper.next_request().unwrap(), @@ -555,7 +573,7 @@ fn number_of_required_votes(quorum_type: QuorumType) { wrapper.start(); // Waiting for the proposal. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Propose, ROUND)); assert!(wrapper.next_request().is_none()); wrapper.send_finished_validation(PROPOSAL_ID, ROUND); @@ -580,7 +598,7 @@ fn number_of_required_votes(quorum_type: QuorumType) { // In honest case, the second vote is enough for a quorum. // The Node got a Prevote quorum. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); // The Node sends a Precommit (vote 1). assert_eq!( @@ -603,7 +621,7 @@ fn number_of_required_votes(quorum_type: QuorumType) { // In honest case, the second vote is enough for a quorum. // The Node got a Precommit quorum. - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); assert_eq!( wrapper.next_request().unwrap(), SMRequest::DecisionReached(PROPOSAL_ID.unwrap(), ROUND) @@ -619,7 +637,7 @@ fn observer_does_not_record_self_votes() { // Start and receive proposal validation completion. wrapper.start(); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPropose(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Propose, ROUND)); assert!(wrapper.next_request().is_none()); wrapper.send_finished_validation(PROPOSAL_ID, ROUND); @@ -629,7 +647,7 @@ fn observer_does_not_record_self_votes() { // No quorum yet, we didn't vote. assert!(wrapper.next_request().is_none()); wrapper.send_prevote(PROPOSAL_ID, ROUND); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrevote(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Prevote, ROUND)); // Timeout prevote triggers self precommit(nil) path, which observers must not record/broadcast. wrapper.send_timeout_prevote(ROUND); @@ -642,5 +660,5 @@ fn observer_does_not_record_self_votes() { // No quorum yet, we didn't vote. assert!(wrapper.next_request().is_none()); wrapper.send_precommit(PROPOSAL_ID, ROUND); - assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeoutPrecommit(ROUND)); + assert_eq!(wrapper.next_request().unwrap(), SMRequest::ScheduleTimeout(Step::Precommit, ROUND)); }