pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-06 00:58:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove grandpa liveness oracle (#1271)

Browse Source 
* core: support broadcasting consensus message to all peers

* grandpa: remove liveness oracle

* node: always start grandpa on full nodes

* core: don't check for grandpa justifications on failed block imports

* core: fix network connectivity test
This commit is contained in:
André Silva
2018-12-15 22:39:48 +03:00
committed by Robert Habermeier
parent b2ce2f4bd9
commit 45d53ad022
11 changed files with 208 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/core/network/src/consensus_gossip.rs
+48 -14
View File
@@ -40,6 +40,7 @@ struct MessageEntry<B: BlockT> {
topic: B::Hash,
message_hash: B::Hash,
message: ConsensusMessage,
broadcast: bool,
instant: Instant,
}
@@ -78,7 +79,7 @@ impl<B: BlockT> ConsensusGossip<B> {
let mut known_messages = HashSet::new();
for entry in self.messages.iter() {
known_messages.insert((entry.topic, entry.message_hash));
protocol.send_message(who, Message::Consensus(entry.topic.clone(), entry.message.clone()));
protocol.send_message(who, Message::Consensus(entry.topic.clone(), entry.message.clone(), entry.broadcast));
}
self.peers.insert(who, PeerConsensus {
known_messages,
@@ -98,10 +99,27 @@ impl<B: BlockT> ConsensusGossip<B> {
protocol: &mut Context<B>,
message_hash: B::Hash,
topic: B::Hash,
broadcast: bool,
get_message: F,
)
where F: Fn() -> ConsensusMessage,
{
if broadcast {
for (id, ref mut peer) in self.peers.iter_mut() {
if peer.known_messages.insert((topic.clone(), message_hash.clone())) {
let message = get_message();
if peer.is_authority {
trace!(target:"gossip", "Propagating to authority {}: {:?}", id, message);
} else {
trace!(target:"gossip", "Propagating to {}: {:?}", id, message);
}
protocol.send_message(*id, Message::Consensus(topic, message, broadcast));
}
}
return;
}
let mut non_authorities: Vec<_> = self.peers.iter()
.filter_map(|(id, ref peer)| if !peer.is_authority && !peer.known_messages.contains(&(topic, message_hash)) { Some(*id) } else { None })
.collect();
@@ -118,24 +136,25 @@ impl<B: BlockT> ConsensusGossip<B> {
if peer.known_messages.insert((topic.clone(), message_hash.clone())) {
let message = get_message();
trace!(target:"gossip", "Propagating to authority {}: {:?}", id, message);
protocol.send_message(*id, Message::Consensus(topic, message));
protocol.send_message(*id, Message::Consensus(topic, message, broadcast));
}
} else if non_authorities.contains(&id) {
let message = get_message();
trace!(target:"gossip", "Propagating to {}: {:?}", id, message);
peer.known_messages.insert((topic.clone(), message_hash.clone()));
protocol.send_message(*id, Message::Consensus(topic, message));
protocol.send_message(*id, Message::Consensus(topic, message, broadcast));
}
}
}
fn register_message<F>(&mut self, message_hash: B::Hash, topic: B::Hash, get_message: F)
fn register_message<F>(&mut self, message_hash: B::Hash, topic: B::Hash, broadcast: bool, get_message: F)
where F: Fn() -> ConsensusMessage
{
if self.known_messages.insert((topic, message_hash)) {
self.messages.push(MessageEntry {
topic,
message_hash,
broadcast,
instant: Instant::now(),
message: get_message(),
});
@@ -193,6 +212,7 @@ impl<B: BlockT> ConsensusGossip<B> {
who: NodeIndex,
topic: B::Hash,
message: ConsensusMessage,
broadcast: bool,
) -> Option<(B::Hash, ConsensusMessage)> {
let message_hash = HashFor::<B>::hash(&message[..]);
@@ -236,21 +256,34 @@ impl<B: BlockT> ConsensusGossip<B> {
return None;
}
self.multicast_inner(protocol, message_hash, topic, || message.clone());
self.multicast_inner(protocol, message_hash, topic, broadcast, || message.clone());
Some((topic, message))
}
/// Multicast a message to all peers.
pub fn multicast(&mut self, protocol: &mut Context<B>, topic: B::Hash, message: ConsensusMessage) {
pub fn multicast(
&mut self,
protocol: &mut Context<B>,
topic: B::Hash,
message: ConsensusMessage,
broadcast: bool,
) {
let message_hash = HashFor::<B>::hash(&message);
self.multicast_inner(protocol, message_hash, topic, || message.clone());
self.multicast_inner(protocol, message_hash, topic, broadcast, || message.clone());
}
fn multicast_inner<F>(&mut self, protocol: &mut Context<B>, message_hash: B::Hash, topic: B::Hash, get_message: F)
fn multicast_inner<F>(
&mut self,
protocol: &mut Context<B>,
message_hash: B::Hash,
topic: B::Hash,
broadcast: bool,
get_message: F,
)
where F: Fn() -> ConsensusMessage
{
self.register_message(message_hash, topic, &get_message);
self.propagate(protocol, message_hash, topic, get_message);
self.register_message(message_hash, topic, broadcast, &get_message);
self.propagate(protocol, message_hash, topic, broadcast, get_message);
}
/// Note new consensus session.
@@ -287,6 +320,7 @@ mod tests {
message_hash: $hash,
instant: $now,
message: $m,
broadcast: false,
})
}
}
@@ -331,7 +365,7 @@ mod tests {
let message_hash = HashFor::<Block>::hash(&message);
let topic = HashFor::<Block>::hash(&[1,2,3]);
consensus.register_message(message_hash, topic, || message.clone());
consensus.register_message(message_hash, topic, false, || message.clone());
let stream = consensus.messages_for(topic);
assert_eq!(stream.wait().next(), Some(Ok(message)));
@@ -345,8 +379,8 @@ mod tests {
let msg_a = vec![1, 2, 3];
let msg_b = vec![4, 5, 6];
consensus.register_message(HashFor::<Block>::hash(&msg_a), topic, || msg_a.clone());
consensus.register_message(HashFor::<Block>::hash(&msg_b), topic, || msg_b.clone());
consensus.register_message(HashFor::<Block>::hash(&msg_a), topic, false, || msg_a.clone());
consensus.register_message(HashFor::<Block>::hash(&msg_b), topic, false, || msg_b.clone());
assert_eq!(consensus.messages.len(), 2);
}
@@ -362,7 +396,7 @@ mod tests {
let message_hash = HashFor::<Block>::hash(&message);
let topic = HashFor::<Block>::hash(&[1,2,3]);
consensus.register_message(message_hash, topic, || message.clone());
consensus.register_message(message_hash, topic, false, || message.clone());
let stream1 = consensus.messages_for(topic);
let stream2 = consensus.messages_for(topic);
substrate/core/network/src/message.rs
+1 -1
View File
@@ -173,7 +173,7 @@ pub mod generic {
/// Transactions.
Transactions(Transactions<Extrinsic>),
/// Consensus protocol message.
Consensus(Hash, ConsensusMessage), // topic, opaque Vec<u8>
Consensus(Hash, ConsensusMessage, bool), // topic, opaque Vec<u8>, broadcast
/// Remote method call request.
RemoteCallRequest(RemoteCallRequest<Hash>),
/// Remote method call response.
substrate/core/network/src/protocol.rs
+4 -4
View File
@@ -285,8 +285,8 @@ impl<B: BlockT, S: NetworkSpecialization<B>, H: ExHashT> Protocol<B, S, H> {
GenericMessage::RemoteHeaderResponse(response) => self.on_remote_header_response(io, who, response),
GenericMessage::RemoteChangesRequest(request) => self.on_remote_changes_request(io, who, request),
GenericMessage::RemoteChangesResponse(response) => self.on_remote_changes_response(io, who, response),
GenericMessage::Consensus(topic, msg) => {
self.consensus_gossip.write().on_incoming(&mut ProtocolContext::new(&self.context_data, io), who, topic, msg);
GenericMessage::Consensus(topic, msg, broadcast) => {
self.consensus_gossip.write().on_incoming(&mut ProtocolContext::new(&self.context_data, io), who, topic, msg, broadcast);
},
other => self.specialization.write().on_message(&mut ProtocolContext::new(&self.context_data, io), who, &mut Some(other)),
}
@@ -296,10 +296,10 @@ impl<B: BlockT, S: NetworkSpecialization<B>, H: ExHashT> Protocol<B, S, H> {
send_message::<B, H>(&self.context_data.peers, io, who, message)
}
pub fn gossip_consensus_message(&self, io: &mut SyncIo, topic: B::Hash, message: Vec<u8>) {
pub fn gossip_consensus_message(&self, io: &mut SyncIo, topic: B::Hash, message: Vec<u8>, broadcast: bool) {
let gossip = self.consensus_gossip();
self.with_spec(io, move |_s, context|{
gossip.write().multicast(context, topic, message);
gossip.write().multicast(context, topic, message, broadcast);
});
}
substrate/core/network/src/service.rs
+4 -2
View File
@@ -127,11 +127,13 @@ impl<B: BlockT + 'static, S: NetworkSpecialization<B>, H: ExHashT> Service<B, S,
}
/// Send a consensus message through the gossip
pub fn gossip_consensus_message(&self, topic: B::Hash, message: Vec<u8>) {
pub fn gossip_consensus_message(&self, topic: B::Hash, message: Vec<u8>, broadcast: bool) {
self.handler.gossip_consensus_message(
&mut NetSyncIo::new(&self.network, self.protocol_id),
topic,
message)
message,
broadcast,
)
}
/// Execute a closure with the chain-specific network specialization.
pub fn with_spec<F, U>(&self, f: F) -> U
substrate/core/network/src/test/mod.rs
+2 -2
View File
@@ -229,8 +229,8 @@ impl<V: 'static + Verifier<Block>, D> Peer<V, D> {
/// Push a message into the gossip network and relay to peers.
/// `TestNet::sync_step` needs to be called to ensure it's propagated.
pub fn gossip_message(&self, topic: Hash, data: Vec<u8>) {
self.sync.gossip_consensus_message(&mut TestIo::new(&self.queue, None), topic, data);
pub fn gossip_message(&self, topic: Hash, data: Vec<u8>, broadcast: bool) {
self.sync.gossip_consensus_message(&mut TestIo::new(&self.queue, None), topic, data, broadcast);
}
/// Add blocks to the peer -- edit the block before adding