Extract consensus_gossip.rs and put it in its own crate (#4284)

* Extract gossiping system from network

* Finish porting GRANDPA tests

* Try put correct engine ID

* Fix messages encoding

* Fix communication tests

* Use a threads pool to spawn stuff

* Fix compilation everywhere

* Fix bad merge conflict

* Remove dependency on async-std

* Apply suggestions from code review

Co-Authored-By: Robert Habermeier <rphmeier@gmail.com>

* More suggestions

* Remove network startup GP future

* Update to futures_timer

* adjust wait_when_behind test

* Pass correct Roles after handshake

* Revert "adjust wait_when_behind test"

This reverts commit 23cb3a0a6d25ed732c2cd648607bc44ef2ab0919.

* Crate root documentation

* Remove MessageRecipient

* Address concerns

* Fix more concerns

* Forgot Cargo.lock

substrate/client/network-gossip/src/lib.rs

@@ -0,0 +1,140 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Polite gossiping.
+//!
+//! This crate provides gossiping capabilities on top of a network.
+//!
+//! Gossip messages are separated by two categories: "topics" and consensus engine ID.
+//! The consensus engine ID is sent over the wire with the message, while the topic is not,
+//! with the expectation that the topic can be derived implicitly from the content of the
+//! message, assuming it is valid.
+//!
+//! Topics are a single 32-byte tag associated with a message, used to group those messages
+//! in an opaque way. Consensus code can invoke `broadcast_topic` to attempt to send all messages
+//! under a single topic to all peers who don't have them yet, and `send_topic` to
+//! send all messages under a single topic to a specific peer.
+//!
+//! # Usage
+//!
+//! - Implement the `Network` trait, representing the low-level networking primitives. It is
+//!   already implemented on `sc_network::NetworkService`.
+//! - Implement the `Validator` trait. See the section below.
+//! - Decide on a `ConsensusEngineId`. Each gossiping protocol should have a different one.
+//! - Build a `GossipEngine` using these three elements.
+//! - Use the methods of the `GossipEngine` in order to send out messages and receive incoming
+//!   messages.
+//!
+//! # What is a validator?
+//!
+//! The primary role of a `Validator` is to process incoming messages from peers, and decide
+//! whether to discard them or process them. It also decides whether to re-broadcast the message.
+//!
+//! The secondary role of the `Validator` is to check if a message is allowed to be sent to a given
+//! peer. All messages, before being sent, will be checked against this filter.
+//! This enables the validator to use information it's aware of about connected peers to decide
+//! whether to send messages to them at any given moment in time - In particular, to wait until
+//! peers can accept and process the message before sending it.
+//!
+//! Lastly, the fact that gossip validators can decide not to rebroadcast messages
+//! opens the door for neighbor status packets to be baked into the gossip protocol.
+//! These status packets will typically contain light pieces of information
+//! used to inform peers of a current view of protocol state.
+
+pub use self::bridge::GossipEngine;
+pub use self::state_machine::{TopicNotification, MessageIntent};
+pub use self::state_machine::{Validator, ValidatorContext, ValidationResult};
+pub use self::state_machine::DiscardAll;
+
+use network::{specialization::NetworkSpecialization, Event, ExHashT, NetworkService, PeerId, ReputationChange};
+use sp_runtime::{traits::{Block as BlockT, NumberFor}, ConsensusEngineId};
+use std::sync::Arc;
+
+mod bridge;
+mod state_machine;
+
+/// Abstraction over a network.
+pub trait Network<B: BlockT> {
+	/// Returns a stream of events representing what happens on the network.
+	fn event_stream(&self) -> Box<dyn futures01::Stream<Item = Event, Error = ()> + Send>;
+
+	/// Adjust the reputation of a node.
+	fn report_peer(&self, peer_id: PeerId, reputation: ReputationChange);
+
+	/// Force-disconnect a peer.
+	fn disconnect_peer(&self, who: PeerId);
+
+	/// Send a notification to a peer.
+	fn write_notification(&self, who: PeerId, engine_id: ConsensusEngineId, message: Vec<u8>);
+
+	/// Registers a notifications protocol.
+	///
+	/// See the documentation of [`NetworkService:register_notifications_protocol`] for more information.
+	fn register_notifications_protocol(
+		&self,
+		engine_id: ConsensusEngineId
+	);
+
+	/// Notify everyone we're connected to that we have the given block.
+	///
+	/// Note: this method isn't strictly related to gossiping and should eventually be moved
+	/// somewhere else.
+	fn announce(&self, block: B::Hash, associated_data: Vec<u8>);
+
+	/// Notifies the sync service to try and sync the given block from the given
+	/// peers.
+	///
+	/// If the given vector of peers is empty then the underlying implementation
+	/// should make a best effort to fetch the block from any peers it is
+	/// connected to (NOTE: this assumption will change in the future #3629).
+	///
+	/// Note: this method isn't strictly related to gossiping and should eventually be moved
+	/// somewhere else.
+	fn set_sync_fork_request(&self, peers: Vec<PeerId>, hash: B::Hash, number: NumberFor<B>);
+}
+
+impl<B: BlockT, S: NetworkSpecialization<B>, H: ExHashT> Network<B> for Arc<NetworkService<B, S, H>> {
+	fn event_stream(&self) -> Box<dyn futures01::Stream<Item = Event, Error = ()> + Send> {
+		Box::new(NetworkService::event_stream(self))
+	}
+
+	fn report_peer(&self, peer_id: PeerId, reputation: ReputationChange) {
+		NetworkService::report_peer(self, peer_id, reputation);
+	}
+
+	fn disconnect_peer(&self, who: PeerId) {
+		NetworkService::disconnect_peer(self, who)
+	}
+
+	fn write_notification(&self, who: PeerId, engine_id: ConsensusEngineId, message: Vec<u8>) {
+		NetworkService::write_notification(self, who, engine_id, message)
+	}
+
+	fn register_notifications_protocol(
+		&self,
+		engine_id: ConsensusEngineId,
+	) {
+		NetworkService::register_notifications_protocol(self, engine_id)
+	}
+
+	fn announce(&self, block: B::Hash, associated_data: Vec<u8>) {
+		NetworkService::announce_block(self, block, associated_data)
+	}
+
+	fn set_sync_fork_request(&self, peers: Vec<network::PeerId>, hash: B::Hash, number: NumberFor<B>) {
+		NetworkService::set_sync_fork_request(self, peers, hash, number)
+	}
+}