Split IO and network crates (#1828)

* Abort on panic

* Split IO and network crates

* Restore panic handler

* Fixed doc tests

sync/Cargo.toml

@@ -13,6 +13,8 @@ ethcore-ipc-codegen = { path = "../ipc/codegen" }
 
 [dependencies]
 ethcore-util = { path = "../util" }
+ethcore-network = { path = "../util/network" }
+ethcore-io = { path = "../util/io" }
 ethcore = { path = "../ethcore" }
 clippy = { version = "0.0.80", optional = true}
 log = "0.3"

sync/src/api.rs

@@ -16,17 +16,19 @@
 
 use std::ops::*;
 use std::sync::Arc;
-use util::network::{NetworkProtocolHandler, NetworkService, NetworkContext, PeerId,
-	NetworkConfiguration as BasicNetworkConfiguration, NonReservedPeerMode};
-use util::{TimerToken, U256, H256, UtilError, Secret, Populatable};
+use network::{NetworkProtocolHandler, NetworkService, NetworkContext, PeerId,
+	NetworkConfiguration as BasicNetworkConfiguration, NonReservedPeerMode, NetworkError};
+use util::{U256, H256, Secret, Populatable};
+use io::{TimerToken};
 use ethcore::client::{BlockChainClient, ChainNotify};
 use ethcore::header::BlockNumber;
-use io::NetSyncIo;
+use sync_io::NetSyncIo;
 use chain::{ChainSync, SyncStatus};
 use std::net::{SocketAddr, AddrParseError};
 use ipc::{BinaryConvertable, BinaryConvertError, IpcConfig};
 use std::mem;
 use std::collections::VecDeque;
+use std::str::FromStr;
 use parking_lot::RwLock;
 
 /// Ethereum sync protocol
@@ -72,7 +74,7 @@ pub struct EthSync {
 
 impl EthSync {
 	/// Creates and register protocol with the network service
-	pub fn new(config: SyncConfig, chain: Arc<BlockChainClient>, network_config: NetworkConfiguration) -> Result<Arc<EthSync>, UtilError> {
+	pub fn new(config: SyncConfig, chain: Arc<BlockChainClient>, network_config: NetworkConfiguration) -> Result<Arc<EthSync>, NetworkError> {
 		let chain_sync = ChainSync::new(config, chain.deref());
 		let service = try!(NetworkService::new(try!(network_config.into_basic())));
 		let sync = Arc::new(EthSync{
@@ -213,7 +215,7 @@ impl ManageNetwork for EthSync {
 	}
 }
 
-#[derive(Binary, Debug, Clone)]
+#[derive(Binary, Debug, Clone, PartialEq, Eq)]
 /// Network service configuration
 pub struct NetworkConfiguration {
 	/// Directory path to store network configuration. None means nothing will be saved
@@ -243,8 +245,25 @@ pub struct NetworkConfiguration {
 }
 
 impl NetworkConfiguration {
+	pub fn new() -> Self {
+		From::from(BasicNetworkConfiguration::new())
+	}
+
+	pub fn new_local() -> Self {
+		From::from(BasicNetworkConfiguration::new_local())
+	}
+
+	fn validate(&self) -> Result<(), AddrParseError> {
+		if let Some(ref addr) = self.listen_address {
+			try!(SocketAddr::from_str(&addr));
+		}
+		if let Some(ref addr) = self.public_address {
+			try!(SocketAddr::from_str(&addr));
+		}
+		Ok(())
+	}
+
 	pub fn into_basic(self) -> Result<BasicNetworkConfiguration, AddrParseError> {
-		use std::str::FromStr;
 
 		Ok(BasicNetworkConfiguration {
 			config_path: self.config_path,

sync/src/blocks.rs

@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::*;
+use network::NetworkError;
 use ethcore::header::{ Header as BlockHeader};
 
 known_heap_size!(0, HeaderId, SyncBlock);
@@ -228,7 +229,7 @@ impl BlockCollection {
 		self.downloading_headers.contains(hash) || self.downloading_bodies.contains(hash)
 	}
 
-	fn insert_body(&mut self, b: Bytes) -> Result<(), UtilError> {
+	fn insert_body(&mut self, b: Bytes) -> Result<(), NetworkError> {
 		let body = UntrustedRlp::new(&b);
 		let tx = try!(body.at(0));
 		let tx_root = ordered_trie_root(tx.iter().map(|r| r.as_raw().to_vec()).collect()); //TODO: get rid of vectors here
@@ -249,13 +250,13 @@ impl BlockCollection {
 					},
 					None => {
 						warn!("Got body with no header {}", h);
-						Err(UtilError::Network(NetworkError::BadProtocol))
+						Err(NetworkError::BadProtocol)
 					}
 				}
 			}
 			None => {
 				trace!(target: "sync", "Ignored unknown/stale block body");
-				Err(UtilError::Network(NetworkError::BadProtocol))
+				Err(NetworkError::BadProtocol)
 			}
 		}
 	}

sync/src/chain.rs

@@ -88,13 +88,14 @@
 ///
 
 use util::*;
+use network::*;
 use std::mem::{replace};
 use ethcore::views::{HeaderView, BlockView};
 use ethcore::header::{BlockNumber, Header as BlockHeader};
 use ethcore::client::{BlockChainClient, BlockStatus, BlockID, BlockChainInfo, BlockImportError};
 use ethcore::error::*;
 use ethcore::block::Block;
-use io::SyncIo;
+use sync_io::SyncIo;
 use time;
 use super::SyncConfig;
 use blocks::BlockCollection;
@@ -1045,7 +1046,7 @@ impl ChainSync {
 	}
 
 	/// Send Status message
-	fn send_status(&mut self, io: &mut SyncIo) -> Result<(), UtilError> {
+	fn send_status(&mut self, io: &mut SyncIo) -> Result<(), NetworkError> {
 		let mut packet = RlpStream::new_list(5);
 		let chain = io.chain().chain_info();
 		packet.append(&(PROTOCOL_VERSION as u32));
@@ -1191,7 +1192,7 @@ impl ChainSync {
 
 	fn return_rlp<FRlp, FError>(io: &mut SyncIo, rlp: &UntrustedRlp, peer: PeerId, rlp_func: FRlp, error_func: FError) -> Result<(), PacketDecodeError>
 		where FRlp : Fn(&SyncIo, &UntrustedRlp, PeerId) -> RlpResponseResult,
-			FError : FnOnce(UtilError) -> String
+			FError : FnOnce(NetworkError) -> String
 	{
 		let response = rlp_func(io, rlp, peer);
 		match response {

sync/src/lib.rs

@@ -30,11 +30,12 @@
 //!
 //! ```rust
 //! extern crate ethcore_util as util;
+//! extern crate ethcore_io as io;
 //! extern crate ethcore;
 //! extern crate ethsync;
 //! use std::env;
 //! use std::sync::Arc;
-//! use util::io::IoChannel;
+//! use io::IoChannel;
 //! use ethcore::client::{Client, ClientConfig};
 //! use ethsync::{EthSync, SyncConfig, ManageNetwork, NetworkConfiguration};
 //! use ethcore::ethereum;
@@ -55,7 +56,7 @@
 //!			miner,
 //!			IoChannel::disconnected()
 //!		).unwrap();
-//! 	let sync = EthSync::new(SyncConfig::default(), client, NetworkConfiguration::from(util::NetworkConfiguration::new())).unwrap();
+//! 	let sync = EthSync::new(SyncConfig::default(), client, NetworkConfiguration::from(NetworkConfiguration::new())).unwrap();
 //! 	sync.start_network();
 //! }
 //! ```
@@ -64,6 +65,8 @@
 extern crate log;
 #[macro_use]
 extern crate ethcore_util as util;
+extern crate ethcore_network as network;
+extern crate ethcore_io as io;
 extern crate ethcore;
 extern crate env_logger;
 extern crate time;
@@ -77,7 +80,7 @@ extern crate parking_lot;
 
 mod chain;
 mod blocks;
-mod io;
+mod sync_io;
 
 #[cfg(test)]
 mod tests;
@@ -88,6 +91,7 @@ mod api {
 }
 
 pub use api::{EthSync, SyncProvider, SyncClient, NetworkManagerClient, ManageNetwork, SyncConfig,
-	NetworkConfiguration, ServiceConfiguration};
+	ServiceConfiguration, NetworkConfiguration};
 pub use chain::{SyncStatus, SyncState};
+pub use network::{is_valid_node_url, NonReservedPeerMode, NetworkError};
 

sync/src/sync_io.rs

@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::{NetworkContext, PeerId, PacketId,};
-use util::error::UtilError;
+use network::{NetworkContext, PeerId, PacketId, NetworkError};
 use ethcore::client::BlockChainClient;
 
 /// IO interface for the syning handler.
@@ -27,9 +26,9 @@ pub trait SyncIo {
 	/// Disconnect peer
 	fn disconnect_peer(&mut self, peer_id: PeerId);
 	/// Respond to current request with a packet. Can be called from an IO handler for incoming packet.
-	fn respond(&mut self, packet_id: PacketId, data: Vec<u8>) -> Result<(), UtilError>;
+	fn respond(&mut self, packet_id: PacketId, data: Vec<u8>) -> Result<(), NetworkError>;
 	/// Send a packet to a peer.
-	fn send(&mut self, peer_id: PeerId, packet_id: PacketId, data: Vec<u8>) -> Result<(), UtilError>;
+	fn send(&mut self, peer_id: PeerId, packet_id: PacketId, data: Vec<u8>) -> Result<(), NetworkError>;
 	/// Get the blockchain
 	fn chain(&self) -> &BlockChainClient;
 	/// Returns peer client identifier string
@@ -69,11 +68,11 @@ impl<'s, 'h> SyncIo for NetSyncIo<'s, 'h> {
 		self.network.disconnect_peer(peer_id);
 	}
 
-	fn respond(&mut self, packet_id: PacketId, data: Vec<u8>) -> Result<(), UtilError>{
+	fn respond(&mut self, packet_id: PacketId, data: Vec<u8>) -> Result<(), NetworkError>{
 		self.network.respond(packet_id, data)
 	}
 
-	fn send(&mut self, peer_id: PeerId, packet_id: PacketId, data: Vec<u8>) -> Result<(), UtilError>{
+	fn send(&mut self, peer_id: PeerId, packet_id: PacketId, data: Vec<u8>) -> Result<(), NetworkError>{
 		self.network.send(peer_id, packet_id, data)
 	}
 

sync/src/tests/helpers.rs

@@ -15,9 +15,10 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::*;
+use network::*;
 use ethcore::client::{TestBlockChainClient, BlockChainClient};
 use ethcore::header::BlockNumber;
-use io::SyncIo;
+use sync_io::SyncIo;
 use chain::ChainSync;
 use ::SyncConfig;
 
@@ -48,7 +49,7 @@ impl<'p> SyncIo for TestIo<'p> {
 		false
 	}
 
-	fn respond(&mut self, packet_id: PacketId, data: Vec<u8>) -> Result<(), UtilError> {
+	fn respond(&mut self, packet_id: PacketId, data: Vec<u8>) -> Result<(), NetworkError> {
 		self.queue.push_back(TestPacket {
 			data: data,
 			packet_id: packet_id,
@@ -57,7 +58,7 @@ impl<'p> SyncIo for TestIo<'p> {
 		Ok(())
 	}
 
-	fn send(&mut self, peer_id: PeerId, packet_id: PacketId, data: Vec<u8>) -> Result<(), UtilError> {
+	fn send(&mut self, peer_id: PeerId, packet_id: PacketId, data: Vec<u8>) -> Result<(), NetworkError> {
 		self.queue.push_back(TestPacket {
 			data: data,
 			packet_id: packet_id,

sync/src/tests/rpc.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::super::NetworkConfiguration;
-use util::NetworkConfiguration as BasicNetworkConfiguration;
+use network::NetworkConfiguration as BasicNetworkConfiguration;
 use std::convert::From;
 use ipc::binary::{serialize, deserialize};