>::Proposer,
I,
>::Input,
>::Output,
>>, P::Error>
where
{
let hash = header.hash();
let mut live_agreement = self.live_agreement.lock();
let can_build = live_agreement.as_ref()
.map_or(true, |x| self.can_build_on_inner(header, x));
if !can_build {
return Ok(None)
}
let authorities = self.client.authorities(&BlockId::Hash(hash.clone()))?;
let n = authorities.len();
let max_faulty = max_faulty_of(n);
trace!(target: "bft", "Initiating agreement on top of #{}, {:?}", header.number(), hash);
trace!(target: "bft", "max_faulty_of({})={}", n, max_faulty);
let local_id = self.local_id();
if !authorities.contains(&local_id) {
// cancel current agreement
live_agreement.take();
Err(ErrorKind::InvalidAuthority(local_id).into())?;
}
let (proposer, input, output) = self.factory.init(header, &authorities, self.key.clone())?;
let bft_instance = BftInstance {
proposer,
parent_hash: hash.clone(),
cache: self.round_cache.clone(),
round_timeout_multiplier: self.round_timeout_multiplier,
key: self.key.clone(),
authorities: authorities,
};
let mut agreement = rhododendron::agree(
bft_instance,
n,
max_faulty,
input,
output,
);
// fast forward round number if necessary.
{
let mut cache = self.round_cache.lock();
trace!(target: "bft", "Round cache: {:?}", &*cache);
if cache.hash.as_ref() == Some(&hash) {
trace!(target: "bft", "Fast-forwarding to round {}", cache.start_round);
let start_round = cache.start_round;
cache.start_round += 1;
drop(cache);
agreement.fast_forward(start_round);
} else {
*cache = RoundCache {
hash: Some(hash.clone()),
start_round: 1,
};
}
}
let status = Arc::new(AtomicUsize::new(status::LIVE));
let (tx, rx) = oneshot::channel();
// cancel current agreement.
*live_agreement = Some((header.clone(), AgreementHandle {
send_cancel: Some(tx),
status: status.clone(),
}));
Ok(Some(BftFuture {
inner: agreement,
status: status,
cancel: rx,
import: self.client.clone(),
}))
}
/// Cancel current agreement if any.
pub fn cancel_agreement(&self) {
self.live_agreement.lock().take();
}
/// Whether we can build using the given header.
pub fn can_build_on(&self, header: &B::Header) -> bool {
self.live_agreement.lock().as_ref()
.map_or(true, |x| self.can_build_on_inner(header, x))
}
/// Get a reference to the underyling client.
pub fn client(&self) -> &I { &*self.client }
fn can_build_on_inner(&self, header: &B::Header, live: &(B::Header, AgreementHandle)) -> bool {
let hash = header.hash();
let &(ref live_header, ref handle) = live;
match handle.status() {
_ if *header != *live_header && *live_header.parent_hash() != hash => true, // can always follow with next block.
status::BAD => hash == live_header.hash(), // bad block can be re-agreed on.
_ => false, // canceled won't appear since we overwrite the handle before returning.
}
}
}
/// Given a total number of authorities, yield the maximum faulty that would be allowed.
/// This will always be under 1/3.
pub fn max_faulty_of(n: usize) -> usize {
n.saturating_sub(1) / 3
}
/// Given a total number of authorities, yield the minimum required signatures.
/// This will always be over 2/3.
pub fn bft_threshold(n: usize) -> usize {
n - max_faulty_of(n)
}
// /// Sign a BFT message with the given key.
pub fn sign_message(
message: RhdMessage,
key: &ed25519::Pair,
parent_hash: B::Hash
) -> LocalizedMessage {
let signer = key.public();
let sign_action = |action: ::rhododendron::Vote| {
let primitive = ::rhododendron::LocalizedVote {
parent: parent_hash.clone(),
action,
};
let to_sign = Encode::encode(&primitive);
LocalizedSignature {
signer: signer.clone(),
signature: key.sign(&to_sign),
}
};
match message {
RhdMessage::Propose(r, proposal) => {
let header_hash = proposal.hash();
let action_header = ::rhododendron::ProposeHeader(r as u32, header_hash.clone());
let action_propose = ::rhododendron::Propose(r as u32, proposal.clone());
::rhododendron::LocalizedMessage::Propose(::rhododendron::LocalizedProposal {
round_number: r,
proposal,
digest: header_hash,
sender: signer.clone().into(),
digest_signature: sign_action(action_header),
full_signature: sign_action(action_propose),
})
}
RhdMessage::Vote(vote) => ::rhododendron::LocalizedMessage::Vote(
::rhododendron::LocalizedVote {
vote: vote,
sender: signer.clone().into(),
signature: sign_action(action),
}
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashSet;
use runtime_primitives::testing::{Block as GenericTestBlock, Header as TestHeader};
use primitives::H256;
use self::keyring::Keyring;
extern crate substrate_keyring as keyring;
type TestBlock = GenericTestBlock<()>;
struct FakeClient {
authorities: Vec,
imported_heights: Mutex>
}
impl BlockImport for FakeClient {
fn import_block(&self, block: TestBlock, _justification: Justification, _authorities: &[AuthorityId]) -> bool {
assert!(self.imported_heights.lock().insert(block.header.number));
true
}
}
impl Authorities for FakeClient {
fn authorities(&self, _at: &BlockId) -> Result, Error> {
Ok(self.authorities.clone())
}
}
// "black hole" output sink.
struct Comms(::std::marker::PhantomData);
impl Sink for Comms {
type SinkItem = Communication;
type SinkError = E;
fn start_send(&mut self, _item: Communication) -> ::futures::StartSend, E> {
Ok(::futures::AsyncSink::Ready)
}
fn poll_complete(&mut self) -> ::futures::Poll<(), E> {
Ok(Async::Ready(()))
}
}
impl Stream for Comms {
type Item = Communication;
type Error = E;
fn poll(&mut self) -> ::futures::Poll, Self::Error> {
Ok(::futures::Async::NotReady)
}
}
struct DummyFactory;
struct DummyProposer(u64);
impl Environment for DummyFactory {
type Proposer = DummyProposer;
type Input = Comms;
type Output = Comms;
type Error = Error;
fn init(&self, parent_header: &TestHeader, _authorities: &[AuthorityId], _sign_with: Arc)
-> Result<(DummyProposer, Self::Input, Self::Output), Error>
{
Ok((DummyProposer(parent_header.number + 1), Comms(::std::marker::PhantomData), Comms(::std::marker::PhantomData)))
}
}
impl Proposer for DummyProposer {
type Error = Error;
type Create = Result;
type Evaluate = Result;
fn propose(&self) -> Result {
Ok(TestBlock {
header: from_block_number(self.0),
extrinsics: Default::default()
})
}
fn evaluate(&self, proposal: &TestBlock) -> Result {
Ok(proposal.header.number == self.0)
}
fn import_misbehavior(&self, _misbehavior: Vec<(AuthorityId, Misbehavior)>) {}
fn round_proposer(&self, round_number: usize, authorities: &[AuthorityId]) -> AuthorityId {
authorities[round_number % authorities.len()].clone()
}
}
fn make_service(client: FakeClient)
-> BftService
{
BftService {
client: Arc::new(client),
live_agreement: Mutex::new(None),
round_cache: Arc::new(Mutex::new(RoundCache {
hash: None,
start_round: 0,
})),
round_timeout_multiplier: 10,
key: Arc::new(Keyring::One.into()),
factory: DummyFactory
}
}
fn sign_vote(vote: ::rhododendron::Vote, key: &ed25519::Pair, parent_hash: H256) -> LocalizedSignature {
match sign_message::(vote.into(), key, parent_hash) {
::rhododendron::LocalizedMessage::Vote(vote) => vote.signature,
_ => panic!("signing vote leads to signed vote"),
}
}
fn from_block_number(num: u64) -> TestHeader {
TestHeader::new(
num,
Default::default(),
Default::default(),
Default::default(),
Default::default(),
)
}
#[test]
fn future_gets_preempted() {
let client = FakeClient {
authorities: vec![
Keyring::One.to_raw_public().into(),
Keyring::Two.to_raw_public().into(),
Keyring::Alice.to_raw_public().into(),
Keyring::Eve.to_raw_public().into(),
],
imported_heights: Mutex::new(HashSet::new()),
};
let service = make_service(client);
let first = from_block_number(2);
let first_hash = first.hash();
let mut second = from_block_number(3);
second.parent_hash = first_hash;
let _second_hash = second.hash();
let mut first_bft = service.build_upon(&first).unwrap().unwrap();
assert!(service.live_agreement.lock().as_ref().unwrap().0 == first);
let _second_bft = service.build_upon(&second).unwrap();
assert!(service.live_agreement.lock().as_ref().unwrap().0 != first);
assert!(service.live_agreement.lock().as_ref().unwrap().0 == second);
// first_bft has been cancelled. need to swap out so we can check it.
let (_tx, mut rx) = oneshot::channel();
::std::mem::swap(&mut rx, &mut first_bft.cancel);
assert!(rx.wait().is_ok());
}
#[test]
fn max_faulty() {
assert_eq!(max_faulty_of(3), 0);
assert_eq!(max_faulty_of(4), 1);
assert_eq!(max_faulty_of(100), 33);
assert_eq!(max_faulty_of(0), 0);
assert_eq!(max_faulty_of(11), 3);
assert_eq!(max_faulty_of(99), 32);
}
#[test]
fn justification_check_works() {
let parent_hash = Default::default();
let hash = [0xff; 32].into();
let authorities = vec![
Keyring::One.to_raw_public().into(),
Keyring::Two.to_raw_public().into(),
Keyring::Alice.to_raw_public().into(),
Keyring::Eve.to_raw_public().into(),
];
let authorities_keys = vec![
Keyring::One.into(),
Keyring::Two.into(),
Keyring::Alice.into(),
Keyring::Eve.into(),
];
let unchecked = UncheckedJustification(rhododendron::UncheckedJustification {
digest: hash,
round_number: 1,
signatures: authorities_keys.iter().take(3).map(|key| {
sign_vote(rhododendron::Vote::Commit(1, hash).into(), key, parent_hash)
}).collect(),
});
assert!(check_justification::(&authorities, parent_hash, unchecked).is_ok());
let unchecked = UncheckedJustification(rhododendron::UncheckedJustification {
digest: hash,
round_number: 0, // wrong round number (vs. the signatures)
signatures: authorities_keys.iter().take(3).map(|key| {
sign_vote(rhododendron::Vote::Commit(1, hash).into(), key, parent_hash)
}).collect(),
});
assert!(check_justification::(&authorities, parent_hash, unchecked).is_err());
// not enough signatures.
let unchecked = UncheckedJustification(rhododendron::UncheckedJustification {
digest: hash,
round_number: 1,
signatures: authorities_keys.iter().take(2).map(|key| {
sign_vote(rhododendron::Vote::Commit(1, hash).into(), key, parent_hash)
}).collect(),
});
assert!(check_justification::(&authorities, parent_hash, unchecked).is_err());
// wrong hash.
let unchecked = UncheckedJustification(rhododendron::UncheckedJustification {
digest: [0xfe; 32].into(),
round_number: 1,
signatures: authorities_keys.iter().take(3).map(|key| {
sign_vote(rhododendron::Vote::Commit(1, hash).into(), key, parent_hash)
}).collect(),
});
assert!(check_justification::(&authorities, parent_hash, unchecked).is_err());
}
#[test]
fn propose_check_works() {
let parent_hash = Default::default();
let authorities = vec![
Keyring::Alice.to_raw_public().into(),
Keyring::Eve.to_raw_public().into(),
];
let block = TestBlock {
header: from_block_number(1),
extrinsics: Default::default()
};
let proposal = sign_message(::rhododendron::Message::Propose(1, block.clone()), &Keyring::Alice.pair(), parent_hash);;
if let ::rhododendron::LocalizedMessage::Propose(proposal) = proposal {
assert!(check_proposal(&authorities, &parent_hash, &proposal).is_ok());
let mut invalid_round = proposal.clone();
invalid_round.round_number = 0;
assert!(check_proposal(&authorities, &parent_hash, &invalid_round).is_err());
let mut invalid_digest = proposal.clone();
invalid_digest.digest = [0xfe; 32].into();
assert!(check_proposal(&authorities, &parent_hash, &invalid_digest).is_err());
} else {
assert!(false);
}
// Not an authority
let proposal = sign_message::(::rhododendron::Message::Propose(1, block), &Keyring::Bob.pair(), parent_hash);;
if let ::rhododendron::LocalizedMessage::Propose(proposal) = proposal {
assert!(check_proposal(&authorities, &parent_hash, &proposal).is_err());
} else {
assert!(false);
}
}
#[test]
fn vote_check_works() {
let parent_hash: H256 = Default::default();
let hash: H256 = [0xff; 32].into();
let authorities = vec![
Keyring::Alice.to_raw_public().into(),
Keyring::Eve.to_raw_public().into(),
];
let vote = sign_message::(::rhododendron::Message::Vote(::rhododendron::Vote::Prepare(1, hash)), &Keyring::Alice.pair(), parent_hash);;
if let ::rhododendron::LocalizedMessage::Vote(vote) = vote {
assert!(check_vote::(&authorities, &parent_hash, &vote).is_ok());
let mut invalid_sender = vote.clone();
invalid_sender.signature.signer = Keyring::Eve.into();
assert!(check_vote::(&authorities, &parent_hash, &invalid_sender).is_err());
} else {
assert!(false);
}
// Not an authority
let vote = sign_message::(::rhododendron::Message::Vote(::rhododendron::Vote::Prepare(1, hash)), &Keyring::Bob.pair(), parent_hash);;
if let ::rhododendron::LocalizedMessage::Vote(vote) = vote {
assert!(check_vote::(&authorities, &parent_hash, &vote).is_err());
} else {
assert!(false);
}
}
#[test]
fn drop_bft_future_does_not_deadlock() {
let client = FakeClient {
authorities: vec![
Keyring::One.to_raw_public().into(),
Keyring::Two.to_raw_public().into(),
Keyring::Alice.to_raw_public().into(),
Keyring::Eve.to_raw_public().into(),
],
imported_heights: Mutex::new(HashSet::new()),
};
let service = make_service(client);
let first = from_block_number(2);
let first_hash = first.hash();
let mut second = from_block_number(3);
second.parent_hash = first_hash;
let _ = service.build_upon(&first).unwrap();
assert!(service.live_agreement.lock().as_ref().unwrap().0 == first);
service.live_agreement.lock().take();
}
#[test]
fn bft_can_build_though_skipped() {
let client = FakeClient {
authorities: vec![
Keyring::One.to_raw_public().into(),
Keyring::Two.to_raw_public().into(),
Keyring::Alice.to_raw_public().into(),
Keyring::Eve.to_raw_public().into(),
],
imported_heights: Mutex::new(HashSet::new()),
};
let service = make_service(client);
let first = from_block_number(2);
let first_hash = first.hash();
let mut second = from_block_number(3);
second.parent_hash = first_hash;
let mut third = from_block_number(4);
third.parent_hash = second.hash();
let _ = service.build_upon(&first).unwrap();
assert!(service.live_agreement.lock().as_ref().unwrap().0 == first);
// BFT has not seen second, but will move forward on third
service.build_upon(&third).unwrap();
assert!(service.live_agreement.lock().as_ref().unwrap().0 == third);
// but we are not walking backwards
service.build_upon(&second).unwrap();
assert!(service.live_agreement.lock().as_ref().unwrap().0 == third);
}
}