Remove the error from network-libp2p (#1950)

substrate/core/network-libp2p/src/error.rs

@@ -1,163 +0,0 @@
-// Copyright 2015-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/>.
-
-use error_chain::*;
-use std::{io, net, fmt};
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum DisconnectReason {
-	DisconnectRequested,
-	TCPError,
-	BadProtocol,
-	UselessPeer,
-	TooManyPeers,
-	DuplicatePeer,
-	IncompatibleProtocol,
-	NullIdentity,
-	ClientQuit,
-	UnexpectedIdentity,
-	LocalIdentity,
-	PingTimeout,
-	Unknown,
-}
-
-impl DisconnectReason {
-	pub fn from_u8(n: u8) -> DisconnectReason {
-		match n {
-			0 => DisconnectReason::DisconnectRequested,
-			1 => DisconnectReason::TCPError,
-			2 => DisconnectReason::BadProtocol,
-			3 => DisconnectReason::UselessPeer,
-			4 => DisconnectReason::TooManyPeers,
-			5 => DisconnectReason::DuplicatePeer,
-			6 => DisconnectReason::IncompatibleProtocol,
-			7 => DisconnectReason::NullIdentity,
-			8 => DisconnectReason::ClientQuit,
-			9 => DisconnectReason::UnexpectedIdentity,
-			10 => DisconnectReason::LocalIdentity,
-			11 => DisconnectReason::PingTimeout,
-			_ => DisconnectReason::Unknown,
-		}
-	}
-}
-
-impl fmt::Display for DisconnectReason {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		use self::DisconnectReason::*;
-
-		let msg = match *self {
-			DisconnectRequested => "disconnect requested",
-			TCPError => "TCP error",
-			BadProtocol => "bad protocol",
-			UselessPeer => "useless peer",
-			TooManyPeers => "too many peers",
-			DuplicatePeer => "duplicate peer",
-			IncompatibleProtocol => "incompatible protocol",
-			NullIdentity => "null identity",
-			ClientQuit => "client quit",
-			UnexpectedIdentity => "unexpected identity",
-			LocalIdentity => "local identity",
-			PingTimeout => "ping timeout",
-			Unknown => "unknown",
-		};
-
-		f.write_str(msg)
-	}
-}
-
-error_chain! {
-	errors {
-		#[doc = "Error concerning the network address parsing subsystem."]
-		AddressParse {
-			description("Failed to parse network address"),
-			display("Failed to parse network address"),
-		}
-
-		#[doc = "Error concerning the network address resolution subsystem."]
-		AddressResolve(err: Option<io::Error>) {
-			description("Failed to resolve network address"),
-			display("Failed to resolve network address {}", err.as_ref().map_or("".to_string(), |e| e.to_string())),
-		}
-
-		#[doc = "Authentication failure"]
-		Auth {
-			description("Authentication failure"),
-			display("Authentication failure"),
-		}
-
-		#[doc = "Unrecognised protocol"]
-		BadProtocol {
-			description("Bad protocol"),
-			display("Bad protocol"),
-		}
-
-		#[doc = "Expired message"]
-		Expired {
-			description("Expired message"),
-			display("Expired message"),
-		}
-
-		#[doc = "Peer not found"]
-		PeerNotFound {
-			description("Peer not found"),
-			display("Peer not found"),
-		}
-
-		#[doc = "Peer is disconnected"]
-		Disconnect(reason: DisconnectReason) {
-			description("Peer disconnected"),
-			display("Peer disconnected: {}", reason),
-		}
-
-		#[doc = "Invalid node id"]
-		InvalidNodeId {
-			description("Invalid node id"),
-			display("Invalid node id"),
-		}
-
-		#[doc = "Packet size is over the protocol limit"]
-		OversizedPacket {
-			description("Packet is too large"),
-			display("Packet is too large"),
-		}
-
-		#[doc = "An unknown IO error occurred."]
-		Io(err: io::Error) {
-			description("IO Error"),
-			display("Unexpected IO error: {}", err),
-		}
-	}
-}
-
-impl From<io::Error> for Error {
-	fn from(err: io::Error) -> Self {
-		Error::from_kind(ErrorKind::Io(err))
-	}
-}
-
-impl From<net::AddrParseError> for Error {
-	fn from(_err: net::AddrParseError) -> Self { ErrorKind::AddressParse.into() }
-}
-
-#[test]
-fn test_errors() {
-	assert_eq!(DisconnectReason::ClientQuit, DisconnectReason::from_u8(8));
-	let mut r = DisconnectReason::DisconnectRequested;
-	for i in 0 .. 20 {
-		r = DisconnectReason::from_u8(i);
-	}
-	assert_eq!(DisconnectReason::Unknown, r);
-}

substrate/core/network-libp2p/src/lib.rs

@@ -18,35 +18,72 @@
 
 mod behaviour;
 mod custom_proto;
-mod error;
 mod secret;
 mod service_task;
 mod traits;
 mod transport;
 
 pub use crate::custom_proto::{CustomMessage, CustomMessageId, RegisteredProtocol};
-pub use crate::error::{Error, ErrorKind, DisconnectReason};
 pub use crate::secret::obtain_private_key;
 pub use crate::service_task::{start_service, Service, ServiceEvent};
 pub use crate::traits::{NetworkConfiguration, NodeIndex, NodeId, NonReservedPeerMode};
 pub use crate::traits::{ProtocolId, Secret, Severity};
-pub use libp2p::{Multiaddr, multiaddr::Protocol, build_multiaddr, PeerId, core::PublicKey};
+pub use libp2p::{Multiaddr, multiaddr::Error as MultiaddrError, multiaddr::Protocol, build_multiaddr, PeerId, core::PublicKey};
 
 use libp2p::core::nodes::ConnectedPoint;
 use serde_derive::Serialize;
-use std::{collections::{HashMap, HashSet}, time::Duration};
+use std::{collections::{HashMap, HashSet}, error, fmt, time::Duration};
 
 /// Parses a string address and returns the component, if valid.
-pub fn parse_str_addr(addr_str: &str) -> Result<(PeerId, Multiaddr), Error> {
-	let mut addr: Multiaddr = addr_str.parse().map_err(|_| ErrorKind::AddressParse)?;
+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(Protocol::P2p(key)) =>
-			PeerId::from_multihash(key).map_err(|_| ErrorKind::AddressParse)?,
-		_ => return Err(ErrorKind::AddressParse.into()),
+		Some(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(MultiaddrError),
+	/// 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 error::Error for ParseErr {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            ParseErr::MultiaddrParse(err) => Some(err),
+            ParseErr::InvalidPeerId => None,
+            ParseErr::PeerIdMissing => None,
+        }
+    }
+}
+
+impl From<MultiaddrError> for ParseErr {
+	fn from(err: MultiaddrError) -> ParseErr {
+		ParseErr::MultiaddrParse(err)
+	}
+}
+
 /// Returns general information about the networking.
 ///
 /// Meant for general diagnostic purposes.

substrate/core/network-libp2p/src/service_task.rs

@@ -19,7 +19,7 @@ use crate::{
 	transport, NetworkState, NetworkStatePeer, NetworkStateNotConnectedPeer
 };
 use crate::custom_proto::{CustomMessage, RegisteredProtocol, RegisteredProtocols};
-use crate::{Error, NetworkConfiguration, NodeIndex, ProtocolId, parse_str_addr};
+use crate::{NetworkConfiguration, NodeIndex, ProtocolId, parse_str_addr};
 use fnv::FnvHashMap;
 use futures::{prelude::*, Stream};
 use libp2p::{multiaddr::Protocol, Multiaddr, PeerId, build_multiaddr};
@@ -41,7 +41,7 @@ use tokio_timer::Interval;
 pub fn start_service<TProtos, TMessage>(
 	config: NetworkConfiguration,
 	registered_custom: TProtos,
-) -> Result<Service<TMessage>, Error>
+) -> Result<Service<TMessage>, IoError>
 where TProtos: IntoIterator<Item = RegisteredProtocol<TMessage>>,
 	TMessage: CustomMessage + Send + 'static {
 

substrate/core/network/src/error.rs

@@ -22,12 +22,10 @@
 
 use error_chain::*;
 use std::io::Error as IoError;
-use network_libp2p::Error as NetworkError;
 use client;
 
 error_chain! {
 	foreign_links {
-		Network(NetworkError) #[doc = "Devp2p error."];
 		Io(IoError) #[doc = "IO error."];
 	}
 

substrate/core/network/src/service.rs

@@ -21,7 +21,7 @@ use std::{io, thread};
 use log::{warn, debug, error, trace, info};
 use futures::{Async, Future, Stream, stream, sync::oneshot, sync::mpsc};
 use parking_lot::{Mutex, RwLock};
-use network_libp2p::{ProtocolId, NetworkConfiguration, NodeIndex, ErrorKind, Severity};
+use network_libp2p::{ProtocolId, NetworkConfiguration, NodeIndex, Severity};
 use network_libp2p::{start_service, parse_str_addr, Service as NetworkService, ServiceEvent as NetworkServiceEvent};
 use network_libp2p::{Protocol as Libp2pProtocol, RegisteredProtocol, NetworkState};
 use consensus::import_queue::{ImportQueue, Link};
@@ -469,11 +469,7 @@ fn start_thread<B: BlockT + 'static>(
 	let service = match start_service(config, Some(registered)) {
 		Ok(service) => Arc::new(Mutex::new(service)),
 		Err(err) => {
-			match err.kind() {
-				ErrorKind::Io(ref e) if e.kind() == io::ErrorKind::AddrInUse =>
-					warn!("Network port is already in use, make sure that another instance of Substrate client is not running or change the port using the --port option."),
-				_ => warn!("Error starting network: {}", err),
-			};
+			warn!("Error starting network: {}", err);
 			return Err(err.into())
 		},
 	};