More code refactoring to integrate Duration (#8322)

* More code refactoring to integrate Duration

* Fix typo

* Fix tests

* More test fix

util/network-devp2p/src/connection.rs

@@ -17,6 +17,7 @@
 use std::collections::VecDeque;
 use std::net::SocketAddr;
 use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
+use std::time::Duration;
 use hash::{keccak, write_keccak};
 use mio::{Token, Ready, PollOpt};
 use mio::deprecated::{Handler, EventLoop, TryRead, TryWrite};
@@ -37,7 +38,7 @@ use crypto;
 use network::{Error, ErrorKind};
 
 const ENCRYPTED_HEADER_LEN: usize = 32;
-const RECIEVE_PAYLOAD_TIMEOUT: u64 = 30000;
+const RECEIVE_PAYLOAD: Duration = Duration::from_secs(30);
 pub const MAX_PAYLOAD_SIZE: usize = (1 << 24) - 1;
 
 pub trait GenericSocket : Read + Write {
@@ -447,7 +448,7 @@ impl EncryptedConnection {
 		if let EncryptedConnectionState::Header = self.read_state {
 			if let Some(data) = self.connection.readable()? {
 				self.read_header(&data)?;
-				io.register_timer(self.connection.token, RECIEVE_PAYLOAD_TIMEOUT)?;
+				io.register_timer(self.connection.token, RECEIVE_PAYLOAD)?;
 			}
 		};
 		if let EncryptedConnectionState::Payload = self.read_state {

util/network-devp2p/src/handshake.rs

@@ -14,6 +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 std::time::Duration;
 use rand::random;
 use hash::write_keccak;
 use mio::tcp::*;
@@ -73,7 +74,7 @@ pub struct Handshake {
 
 const V4_AUTH_PACKET_SIZE: usize = 307;
 const V4_ACK_PACKET_SIZE: usize = 210;
-const HANDSHAKE_TIMEOUT: u64 = 5000;
+const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(5);
 const PROTOCOL_VERSION: u64 = 4;
 // Amount of bytes added when encrypting with encryptECIES.
 const ECIES_OVERHEAD: usize = 113;

util/network-devp2p/src/host.rs

@@ -24,6 +24,7 @@ use std::cmp::{min, max};
 use std::path::{Path, PathBuf};
 use std::io::{Read, Write, self};
 use std::fs;
+use std::time::Duration;
 use ethkey::{KeyPair, Secret, Random, Generator};
 use hash::keccak;
 use mio::*;
@@ -67,13 +68,13 @@ const SYS_TIMER: TimerToken = LAST_SESSION + 1;
 
 // Timeouts
 // for IDLE TimerToken
-const MAINTENANCE_TIMEOUT: u64 = 1000;
+const MAINTENANCE_TIMEOUT: Duration = Duration::from_secs(1);
 // for DISCOVERY_REFRESH TimerToken
-const DISCOVERY_REFRESH_TIMEOUT: u64 = 60_000;
+const DISCOVERY_REFRESH_TIMEOUT: Duration = Duration::from_secs(60);
 // for DISCOVERY_ROUND TimerToken
-const DISCOVERY_ROUND_TIMEOUT: u64 = 300;
+const DISCOVERY_ROUND_TIMEOUT: Duration = Duration::from_millis(300);
 // for NODE_TABLE TimerToken
-const NODE_TABLE_TIMEOUT: u64 = 300_000;
+const NODE_TABLE_TIMEOUT: Duration = Duration::from_secs(300);
 
 #[derive(Debug, PartialEq, Eq)]
 /// Protocol info
@@ -165,10 +166,10 @@ impl<'s> NetworkContextTrait for NetworkContext<'s> {
 		self.session.as_ref().map_or(false, |s| s.lock().expired())
 	}
 
-	fn register_timer(&self, token: TimerToken, ms: u64) -> Result<(), Error> {
+	fn register_timer(&self, token: TimerToken, delay: Duration) -> Result<(), Error> {
 		self.io.message(NetworkIoMessage::AddTimer {
-			token: token,
-			delay: ms,
+			token,
+			delay,
 			protocol: self.protocol,
 		}).unwrap_or_else(|e| warn!("Error sending network IO message: {:?}", e));
 		Ok(())

util/network-devp2p/src/lib.rs

@@ -24,12 +24,13 @@
 //! use net::*;
 //! use devp2p::NetworkService;
 //! use std::sync::Arc;
+//! use std::time::Duration;
 //!
 //! struct MyHandler;
 //!
 //! impl NetworkProtocolHandler for MyHandler {
 //!		fn initialize(&self, io: &NetworkContext, _host_info: &HostInfo) {
-//!			io.register_timer(0, 1000);
+//!			io.register_timer(0, Duration::from_secs(1));
 //!		}
 //!
 //!		fn read(&self, io: &NetworkContext, peer: &PeerId, packet_id: u8, data: &[u8]) {

util/network-devp2p/src/session.rs

@@ -34,8 +34,8 @@ use node_table::NodeId;
 use snappy;
 
 // Timeout must be less than (interval - 1).
-const PING_TIMEOUT_SEC: Duration = Duration::from_secs(60);
-const PING_INTERVAL_SEC: Duration = Duration::from_secs(120);
+const PING_TIMEOUT: Duration = Duration::from_secs(60);
+const PING_INTERVAL: Duration = Duration::from_secs(120);
 const MIN_PROTOCOL_VERSION: u32 = 4;
 const MIN_COMPRESSION_PROTOCOL_VERSION: u32 = 5;
 
@@ -116,7 +116,7 @@ impl Session {
 				protocol_version: 0,
 				capabilities: Vec::new(),
 				peer_capabilities: Vec::new(),
-				ping_ms: None,
+				ping: None,
 				originated: originated,
 				remote_address: "Handshake".to_owned(),
 				local_address: local_addr,
@@ -298,12 +298,12 @@ impl Session {
 			return true;
 		}
 		let timed_out = if let Some(pong) = self.pong_time {
-			pong.duration_since(self.ping_time) > PING_TIMEOUT_SEC
+			pong.duration_since(self.ping_time) > PING_TIMEOUT
 		} else {
-			self.ping_time.elapsed() > PING_TIMEOUT_SEC
+			self.ping_time.elapsed() > PING_TIMEOUT
 		};
 
-		if !timed_out && self.ping_time.elapsed() > PING_INTERVAL_SEC {
+		if !timed_out && self.ping_time.elapsed() > PING_INTERVAL {
 			if let Err(e) = self.send_ping(io) {
 				debug!("Error sending ping message: {:?}", e);
 			}
@@ -368,9 +368,7 @@ impl Session {
 			PACKET_PONG => {
 				let time = Instant::now();
 				self.pong_time = Some(time);
-				let ping_elapsed = time.duration_since(self.ping_time);
-				self.info.ping_ms = Some(ping_elapsed.as_secs() * 1_000 +
-										ping_elapsed.subsec_nanos() as u64 / 1_000_000);
+				self.info.ping = Some(time.duration_since(self.ping_time));
 				Ok(SessionData::Continue)
 			},
 			PACKET_GET_PEERS => Ok(SessionData::None), //TODO;