Network crate cleanups

core/cli/src/informant.rs

@@ -44,7 +44,7 @@ where C: Components {
 	let mut last_number = None;
 	let mut last_update = time::Instant::now();
 
-	let display_notifications = service.network_status().for_each(move |net_status| {
+	let display_notifications = service.network_status().for_each(move |(net_status, _)| {
 
 		let info = client.info();
 		let best_number = info.chain.best_number.saturated_into::<u64>();

core/cli/src/lib.rs

@@ -32,8 +32,7 @@ use service::{
 };
 use network::{
 	self, multiaddr::Protocol,
-	config::{NetworkConfiguration, TransportConfig, NonReservedPeerMode, NodeKeyConfig},
-	build_multiaddr,
+	config::{NetworkConfiguration, TransportConfig, NonReservedPeerMode, NodeKeyConfig, build_multiaddr},
 };
 use primitives::H256;
 
@@ -250,16 +249,16 @@ where
 			params.node_key.as_ref().map(parse_secp256k1_secret).unwrap_or_else(||
 				Ok(params.node_key_file
 					.or_else(|| net_config_file(net_config_dir, NODE_KEY_SECP256K1_FILE))
-					.map(network::Secret::File)
-					.unwrap_or(network::Secret::New)))
+					.map(network::config::Secret::File)
+					.unwrap_or(network::config::Secret::New)))
 				.map(NodeKeyConfig::Secp256k1),
 
 		NodeKeyType::Ed25519 =>
 			params.node_key.as_ref().map(parse_ed25519_secret).unwrap_or_else(||
 				Ok(params.node_key_file
 					.or_else(|| net_config_file(net_config_dir, NODE_KEY_ED25519_FILE))
-					.map(network::Secret::File)
-					.unwrap_or(network::Secret::New)))
+					.map(network::config::Secret::File)
+					.unwrap_or(network::config::Secret::New)))
 				.map(NodeKeyConfig::Ed25519)
 	}
 }
@@ -277,18 +276,18 @@ fn invalid_node_key(e: impl std::fmt::Display) -> error::Error {
 }
 
 /// Parse a Secp256k1 secret key from a hex string into a `network::Secret`.
-fn parse_secp256k1_secret(hex: &String) -> error::Result<network::Secp256k1Secret> {
+fn parse_secp256k1_secret(hex: &String) -> error::Result<network::config::Secp256k1Secret> {
 	H256::from_str(hex).map_err(invalid_node_key).and_then(|bytes|
-		network::identity::secp256k1::SecretKey::from_bytes(bytes)
-			.map(network::Secret::Input)
+		network::config::identity::secp256k1::SecretKey::from_bytes(bytes)
+			.map(network::config::Secret::Input)
 			.map_err(invalid_node_key))
 }
 
 /// Parse a Ed25519 secret key from a hex string into a `network::Secret`.
-fn parse_ed25519_secret(hex: &String) -> error::Result<network::Ed25519Secret> {
+fn parse_ed25519_secret(hex: &String) -> error::Result<network::config::Ed25519Secret> {
 	H256::from_str(&hex).map_err(invalid_node_key).and_then(|bytes|
-		network::identity::ed25519::SecretKey::from_bytes(bytes)
-			.map(network::Secret::Input)
+		network::config::identity::ed25519::SecretKey::from_bytes(bytes)
+			.map(network::config::Secret::Input)
 			.map_err(invalid_node_key))
 }
 
@@ -810,7 +809,7 @@ fn kill_color(s: &str) -> String {
 mod tests {
 	use super::*;
 	use tempdir::TempDir;
-	use network::identity::{secp256k1, ed25519};
+	use network::config::identity::{secp256k1, ed25519};
 
 	#[test]
 	fn tests_node_name_good() {
@@ -842,10 +841,10 @@ mod tests {
 					node_key_file: None
 				};
 				node_key_config(params, &net_config_dir).and_then(|c| match c {
-					NodeKeyConfig::Secp256k1(network::Secret::Input(ref ski))
+					NodeKeyConfig::Secp256k1(network::config::Secret::Input(ref ski))
 						if node_key_type == NodeKeyType::Secp256k1 &&
 							&sk[..] == ski.to_bytes() => Ok(()),
-					NodeKeyConfig::Ed25519(network::Secret::Input(ref ski))
+					NodeKeyConfig::Ed25519(network::config::Secret::Input(ref ski))
 						if node_key_type == NodeKeyType::Ed25519 &&
 							&sk[..] == ski.as_ref() => Ok(()),
 					_ => Err(error::Error::Input("Unexpected node key config".into()))
@@ -870,9 +869,9 @@ mod tests {
 					node_key_file: Some(file.clone())
 				};
 				node_key_config(params, &net_config_dir).and_then(|c| match c {
-					NodeKeyConfig::Secp256k1(network::Secret::File(ref f))
+					NodeKeyConfig::Secp256k1(network::config::Secret::File(ref f))
 						if node_key_type == NodeKeyType::Secp256k1 && f == &file => Ok(()),
-					NodeKeyConfig::Ed25519(network::Secret::File(ref f))
+					NodeKeyConfig::Ed25519(network::config::Secret::File(ref f))
 						if node_key_type == NodeKeyType::Ed25519 && f == &file => Ok(()),
 					_ => Err(error::Error::Input("Unexpected node key config".into()))
 				})
@@ -904,9 +903,9 @@ mod tests {
 				let typ = params.node_key_type;
 				node_key_config::<String>(params, &None)
 					.and_then(|c| match c {
-						NodeKeyConfig::Secp256k1(network::Secret::New)
+						NodeKeyConfig::Secp256k1(network::config::Secret::New)
 							if typ == NodeKeyType::Secp256k1 => Ok(()),
-						NodeKeyConfig::Ed25519(network::Secret::New)
+						NodeKeyConfig::Ed25519(network::config::Secret::New)
 							if typ == NodeKeyType::Ed25519 => Ok(()),
 						_ => Err(error::Error::Input("Unexpected node key config".into()))
 					})
@@ -919,10 +918,10 @@ mod tests {
 				let typ = params.node_key_type;
 				node_key_config(params, &Some(net_config_dir.clone()))
 					.and_then(move |c| match c {
-						NodeKeyConfig::Secp256k1(network::Secret::File(ref f))
+						NodeKeyConfig::Secp256k1(network::config::Secret::File(ref f))
 							if typ == NodeKeyType::Secp256k1 &&
 								f == &dir.join(NODE_KEY_SECP256K1_FILE) => Ok(()),
-						NodeKeyConfig::Ed25519(network::Secret::File(ref f))
+						NodeKeyConfig::Ed25519(network::config::Secret::File(ref f))
 							if typ == NodeKeyType::Ed25519 &&
 								f == &dir.join(NODE_KEY_ED25519_FILE) => Ok(()),
 						_ => Err(error::Error::Input("Unexpected node key config".into()))

core/consensus/aura/src/lib.rs

@@ -797,8 +797,8 @@ mod tests {
 			}
 		}
 
-		fn peer(&self, i: usize) -> &Peer<Self::PeerData, DummySpecialization> {
-			&self.peers[i]
+		fn peer(&mut self, i: usize) -> &mut Peer<Self::PeerData, DummySpecialization> {
+			&mut self.peers[i]
 		}
 
 		fn peers(&self) -> &Vec<Peer<Self::PeerData, DummySpecialization>> {

core/consensus/babe/src/lib.rs

@@ -960,9 +960,9 @@ mod tests {
 			})
 		}
 
-		fn peer(&self, i: usize) -> &Peer<Self::PeerData, DummySpecialization> {
+		fn peer(&mut self, i: usize) -> &mut Peer<Self::PeerData, DummySpecialization> {
 			trace!(target: "babe", "Retreiving a peer");
-			&self.peers[i]
+			&mut self.peers[i]
 		}
 
 		fn peers(&self) -> &Vec<Peer<Self::PeerData, DummySpecialization>> {

core/consensus/common/Cargo.toml

@@ -25,4 +25,3 @@ test-client = { package = "substrate-test-runtime-client", path = "../../test-ru
 
 [features]
 default = []
-test-helpers = []

core/consensus/common/src/import_queue.rs

@@ -145,9 +145,6 @@ pub trait Link<B: BlockT>: Send {
 	fn report_peer(&mut self, _who: Origin, _reputation_change: i32) {}
 	/// Restart sync.
 	fn restart(&mut self) {}
-	/// Synchronization request has been processed.
-	#[cfg(any(test, feature = "test-helpers"))]
-	fn synchronized(&mut self) {}
 }
 
 /// Block import successful result.

core/consensus/common/src/import_queue/basic_queue.rs

@@ -85,15 +85,6 @@ impl<B: BlockT> BasicQueue<B> {
 			manual_poll: None,
 		}
 	}
-
-	/// Send synchronization request to the block import channel.
-	///
-	/// The caller should wait for Link::synchronized() call to ensure that it
-	/// has synchronized with ImportQueue.
-	#[cfg(any(test, feature = "test-helpers"))]
-	pub fn synchronize(&self) {
-		let _ = self.sender.unbounded_send(ToWorkerMsg::Synchronize);
-	}
 }
 
 impl<B: BlockT> ImportQueue<B> for BasicQueue<B> {
@@ -153,8 +144,6 @@ enum ToWorkerMsg<B: BlockT> {
 	ImportBlocks(BlockOrigin, Vec<IncomingBlock<B>>),
 	ImportJustification(Origin, B::Hash, NumberFor<B>, Justification),
 	ImportFinalityProof(Origin, B::Hash, NumberFor<B>, Vec<u8>),
-	#[cfg(any(test, feature = "test-helpers"))]
-	Synchronize,
 }
 
 struct BlockImportWorker<B: BlockT, V: Verifier<B>> {
@@ -213,11 +202,6 @@ impl<B: BlockT, V: 'static + Verifier<B>> BlockImportWorker<B, V> {
 					ToWorkerMsg::ImportJustification(who, hash, number, justification) => {
 						worker.import_justification(who, hash, number, justification);
 					}
-					#[cfg(any(test, feature = "test-helpers"))]
-					ToWorkerMsg::Synchronize => {
-						trace!(target: "sync", "Sending sync message");
-						worker.result_sender.synchronized();
-					},
 				}
 			}
 		});

core/consensus/common/src/import_queue/buffered_link.rs

@@ -63,8 +63,6 @@ enum BlockImportWorkerMsg<B: BlockT> {
 	SetFinalityProofRequestBuilder(SharedFinalityProofRequestBuilder<B>),
 	ReportPeer(Origin, i32),
 	Restart,
-	#[cfg(any(test, feature = "test-helpers"))]
-	Synchronized,
 }
 
 impl<B: BlockT> Link<B> for BufferedLinkSender<B> {
@@ -120,11 +118,6 @@ impl<B: BlockT> Link<B> for BufferedLinkSender<B> {
 	fn restart(&mut self) {
 		let _ = self.tx.unbounded_send(BlockImportWorkerMsg::Restart);
 	}
-
-	#[cfg(any(test, feature = "test-helpers"))]
-	fn synchronized(&mut self) {
-		let _ = self.tx.unbounded_send(BlockImportWorkerMsg::Synchronized);
-	}
 }
 
 /// See [`buffered_link`].
@@ -168,9 +161,6 @@ impl<B: BlockT> BufferedLinkReceiver<B> {
 					link.report_peer(who, reput),
 				BlockImportWorkerMsg::Restart =>
 					link.restart(),
-				#[cfg(any(test, feature = "test-helpers"))]
-				BlockImportWorkerMsg::Synchronized =>
-					link.synchronized(),
 			}
 		}
 	}

core/finality-grandpa/Cargo.toml

@@ -27,7 +27,6 @@ fg_primitives = { package = "substrate-finality-grandpa-primitives", path = "pri
 grandpa = { package = "finality-grandpa", version = "0.8.1", features = ["derive-codec"] }
 
 [dev-dependencies]
-consensus_common = { package = "substrate-consensus-common", path = "../consensus/common", features = ["test-helpers"] }
 grandpa = { package = "finality-grandpa", version = "0.8.1", features = ["derive-codec", "test-helpers"] }
 network = { package = "substrate-network", path = "../network", features = ["test-helpers"] }
 keyring = { package = "substrate-keyring", path = "../keyring" }

core/finality-grandpa/src/tests.rs

@@ -158,8 +158,8 @@ impl TestNetFactory for GrandpaTestNet {
 		}
 	}
 
-	fn peer(&self, i: usize) -> &GrandpaPeer {
-		&self.peers[i]
+	fn peer(&mut self, i: usize) -> &mut GrandpaPeer {
+		&mut self.peers[i]
 	}
 
 	fn peers(&self) -> &Vec<GrandpaPeer> {
@@ -949,7 +949,7 @@ fn allows_reimporting_change_blocks() {
 	let peers_b = &[AuthorityKeyring::Alice, AuthorityKeyring::Bob];
 	let voters = make_ids(peers_a);
 	let api = TestApi::new(voters);
-	let net = GrandpaTestNet::new(api.clone(), 3);
+	let mut net = GrandpaTestNet::new(api.clone(), 3);
 
 	let client = net.peer(0).client().clone();
 	let (block_import, ..) = net.make_block_import(client.clone());
@@ -998,7 +998,7 @@ fn test_bad_justification() {
 	let peers_b = &[AuthorityKeyring::Alice, AuthorityKeyring::Bob];
 	let voters = make_ids(peers_a);
 	let api = TestApi::new(voters);
-	let net = GrandpaTestNet::new(api.clone(), 3);
+	let mut net = GrandpaTestNet::new(api.clone(), 3);
 
 	let client = net.peer(0).client().clone();
 	let (block_import, ..) = net.make_block_import(client.clone());

core/network/Cargo.toml

@@ -50,10 +50,9 @@ quickcheck = "0.8.5"
 rand = "0.6.5"
 test-client = { package = "substrate-test-runtime-client", path = "../../core/test-runtime/client" }
 test_runtime = { package = "substrate-test-runtime", path = "../../core/test-runtime" }
-consensus = { package = "substrate-consensus-common", path = "../../core/consensus/common", features = ["test-helpers"] }
 tempdir = "0.3"
 tokio = "0.1.11"
 
 [features]
 default = []
-test-helpers = ["keyring", "test-client", "consensus/test-helpers", "tokio"]
+test-helpers = ["keyring", "test-client", "tokio"]

core/network/src/behaviour.rs

@@ -15,7 +15,8 @@
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::{
-	debug_info, discovery::DiscoveryBehaviour, discovery::DiscoveryOut, DiscoveryNetBehaviour, event::DhtEvent
+	debug_info, discovery::DiscoveryBehaviour, discovery::DiscoveryOut, DiscoveryNetBehaviour,
+	protocol::event::DhtEvent
 };
 use crate::{ExHashT, specialization::NetworkSpecialization};
 use crate::protocol::{CustomMessageOutcome, Protocol};