Network crate cleanups (#3049)

* Remove useless internal messages

* Remove NetworkService::disconnect_peer

* Remove NetworkMsg altogether

* Rename ProtocolMsg ServerToWorkerMsg

* Remove useless code

* Add example for parse_str_addr

* Move parse_str_addr and ProtocolId to config

* Don't reexport the content of config

* Rework the imports

* More reexports rework

* Add documentation

* Move finalization report to network future

* Move on_block_imported to worker

* get_value/put_value no longer locking

* local_peer_id() no longer locks

* Remove FetchFuture

* Service imports cleanup

* Produce the network state in the network task

* Merge network task and RPC network task

* Move network methods to NetworkWorker

* Remove Arc peers system from network

* add_reserved_peer now goes through the channel

* Remove Mutex around network swarm

* Remove the FnOnce alias traits

* Replace is_offline with num_connected

* Improve style of poll()

* Fix network tests

* Some doc in service module

* Remove macro export

* Minor doc changes

* Remove the synchronized() method of the import queue

* Line width

* Line widths

* Fix import queue tests

* Fix CLI tests

substrate/core/network/src/config.rs

@@ -14,11 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
-//! Configuration for the networking layer of Substrate.
+//! Configuration of the networking layer.
+//!
+//! The [`Params`] struct is the struct that must be passed in order to initialize the networking.
+//! See the documentation of [`Params`].
 
 pub use crate::protocol::ProtocolConfig;
+pub use libp2p::{identity, core::PublicKey, wasm_ext::ExtTransport, build_multiaddr};
 
-use crate::ProtocolId;
 use crate::chain::{Client, FinalityProofProvider};
 use crate::on_demand_layer::OnDemand;
 use crate::service::{ExHashT, TransactionPool};
@@ -29,30 +32,49 @@ use runtime_primitives::traits::{Block as BlockT};
 use std::sync::Arc;
 use libp2p::identity::{Keypair, secp256k1, ed25519};
 use libp2p::wasm_ext;
-use libp2p::{Multiaddr, multiaddr::Protocol};
+use libp2p::{PeerId, Multiaddr, multiaddr};
 use std::error::Error;
-use std::{io::{self, Write}, iter, fs, net::Ipv4Addr, path::{Path, PathBuf}};
+use std::{io::{self, Write}, iter, fmt, fs, net::Ipv4Addr, path::{Path, PathBuf}};
 use zeroize::Zeroize;
 
-/// Service initialization parameters.
+/// Network initialization parameters.
 pub struct Params<B: BlockT, S, H: ExHashT> {
-	/// Assigned roles for our node.
+	/// Assigned roles for our node (full, light, ...).
 	pub roles: Roles,
+
 	/// Network layer configuration.
 	pub network_config: NetworkConfiguration,
-	/// Substrate relay chain access point.
+
+	/// Client that contains the blockchain.
 	pub chain: Arc<dyn Client<B>>,
+
 	/// Finality proof provider.
+	///
+	/// This object, if `Some`, is used when a node on the network requests a proof of finality
+	/// from us.
 	pub finality_proof_provider: Option<Arc<dyn FinalityProofProvider<B>>>,
-	/// On-demand service reference.
+
+	/// The `OnDemand` object acts as a "receiver" for block data requests from the client.
+	/// If `Some`, the network worker will process these requests and answer them.
+	/// Normally used only for light clients.
 	pub on_demand: Option<Arc<OnDemand<B>>>,
-	/// Transaction pool.
+
+	/// Pool of transactions.
+	///
+	/// The network worker will fetch transactions from this object in order to propagate them on
+	/// the network.
 	pub transaction_pool: Arc<dyn TransactionPool<H, B>>,
+
 	/// Name of the protocol to use on the wire. Should be different for each chain.
 	pub protocol_id: ProtocolId,
+
 	/// Import queue to use.
+	///
+	/// The import queue is the component that verifies that blocks received from other nodes are
+	/// valid.
 	pub import_queue: Box<dyn ImportQueue<B>>,
-	/// Protocol specialization.
+
+	/// Customization of the network. Use this to plug additional networking capabilities.
 	pub specialization: S,
 }
 
@@ -94,6 +116,85 @@ impl parity_codec::Decode for Roles {
 	}
 }
 
+/// Name of a protocol, transmitted on the wire. Should be unique for each chain.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ProtocolId(smallvec::SmallVec<[u8; 6]>);
+
+impl<'a> From<&'a [u8]> for ProtocolId {
+	fn from(bytes: &'a [u8]) -> ProtocolId {
+		ProtocolId(bytes.into())
+	}
+}
+
+impl ProtocolId {
+	/// Exposes the `ProtocolId` as bytes.
+	pub fn as_bytes(&self) -> &[u8] {
+		self.0.as_ref()
+	}
+}
+
+/// Parses a string address and returns the component, if valid.
+///
+/// # Example
+///
+/// ```
+/// # use substrate_network::{Multiaddr, PeerId, config::parse_str_addr};
+/// let (peer_id, addr) = parse_str_addr(
+/// 	"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"
+/// ).unwrap();
+/// assert_eq!(peer_id, "QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".parse::<PeerId>().unwrap());
+/// assert_eq!(addr, "/ip4/198.51.100.19/tcp/30333".parse::<Multiaddr>().unwrap());
+/// ```
+///
+pub fn parse_str_addr(addr_str: &str) -> Result<(PeerId, Multiaddr), ParseErr> {
+	let mut addr: Multiaddr = addr_str.parse()?;
+
+	let who = match addr.pop() {
+		Some(multiaddr::Protocol::P2p(key)) => PeerId::from_multihash(key)
+			.map_err(|_| ParseErr::InvalidPeerId)?,
+		_ => return Err(ParseErr::PeerIdMissing),
+	};
+
+	Ok((who, addr))
+}
+
+/// Error that can be generated by `parse_str_addr`.
+#[derive(Debug)]
+pub enum ParseErr {
+	/// Error while parsing the multiaddress.
+	MultiaddrParse(multiaddr::Error),
+	/// Multihash of the peer ID is invalid.
+	InvalidPeerId,
+	/// The peer ID is missing from the address.
+	PeerIdMissing,
+}
+
+impl fmt::Display for ParseErr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ParseErr::MultiaddrParse(err) => write!(f, "{}", err),
+            ParseErr::InvalidPeerId => write!(f, "Peer id at the end of the address is invalid"),
+            ParseErr::PeerIdMissing => write!(f, "Peer id is missing from the address"),
+        }
+    }
+}
+
+impl std::error::Error for ParseErr {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            ParseErr::MultiaddrParse(err) => Some(err),
+            ParseErr::InvalidPeerId => None,
+            ParseErr::PeerIdMissing => None,
+        }
+    }
+}
+
+impl From<multiaddr::Error> for ParseErr {
+	fn from(err: multiaddr::Error) -> ParseErr {
+		ParseErr::MultiaddrParse(err)
+	}
+}
+
 /// Network service configuration.
 #[derive(Clone)]
 pub struct NetworkConfiguration {
@@ -158,8 +259,8 @@ impl NetworkConfiguration {
 	pub fn new_local() -> NetworkConfiguration {
 		let mut config = NetworkConfiguration::new();
 		config.listen_addresses = vec![
-			iter::once(Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1)))
-				.chain(iter::once(Protocol::Tcp(0)))
+			iter::once(multiaddr::Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1)))
+				.chain(iter::once(multiaddr::Protocol::Tcp(0)))
 				.collect()
 		];
 		config
@@ -169,8 +270,8 @@ impl NetworkConfiguration {
 	pub fn new_memory() -> NetworkConfiguration {
 		let mut config = NetworkConfiguration::new();
 		config.listen_addresses = vec![
-			iter::once(Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1)))
-				.chain(iter::once(Protocol::Tcp(0)))
+			iter::once(multiaddr::Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1)))
+				.chain(iter::once(multiaddr::Protocol::Tcp(0)))
 				.collect()
 		];
 		config