Backports for 2.0.5 stable (#9519)

* parity-version: mark 2.0.5 track stable

* deps: bump fs-swap to 0.2.4

* Remove initial token for WS. (#9545)

* version: mark release critical

* Increase Gas-floor-target and Gas Cap (#9564)

+ Gas-floor-target increased to 8M by default

+ Gas-cap increased to 10M by default

* Improve P2P discovery (#9526)

* Add `target` to Rust traces

* network-devp2p: Don't remove discovery peer in main sync

* network-p2p: Refresh discovery more often

* Update Peer discovery protocol

* Run discovery more often when not enough nodes connected

* Start the first discovery early

* Update fast discovery rate

* Fix tests

* Fix `ping` tests

* Fixing remote Node address ; adding PingPong round

* Fix tests: update new +1 PingPong round

* Increase slow Discovery rate
Check in flight FindNode before pings

* Add `deprecated` to deprecated_echo_hash

* Refactor `discovery_round` branching

* net_version caches network_id to avoid redundant aquire of sync read lock (#9544)

* net_version caches network_id to avoid redundant aquire of sync read lock, #8746

* use lower_hex display formatting for net_peerCount rpc method

Author: 5chdn

Cargo.lock

@@ -2,7 +2,7 @@
 description = "Parity Ethereum client"
 name = "parity-ethereum"
 # NOTE Make sure to update util/version/Cargo.toml as well
-version = "2.0.4"
+version = "2.0.5"
 license = "GPL-3.0"
 authors = ["Parity Technologies <admin@parity.io>"]
 

Cargo.toml

@@ -202,7 +202,7 @@ impl SyncPropagator {
 								let appended = packet.append_raw_checked(&transaction.drain(), 1, MAX_TRANSACTION_PACKET_SIZE);
 								if !appended {
 									// Maximal packet size reached just proceed with sending
-									debug!("Transaction packet size limit reached. Sending incomplete set of {}/{} transactions.", pushed, to_send.len());
+									debug!(target: "sync", "Transaction packet size limit reached. Sending incomplete set of {}/{} transactions.", pushed, to_send.len());
 									to_send = to_send.into_iter().take(pushed).collect();
 									break;
 								}

ethcore/sync/src/chain/propagator.rs

@@ -700,11 +700,11 @@ usage! {
 			"--price-update-period=[T]",
 			"T will be allowed to pass between each gas price update. T may be daily, hourly, a number of seconds, or a time string of the form \"2 days\", \"30 minutes\" etc..",
 
-			ARG arg_gas_floor_target: (String) = "4700000", or |c: &Config| c.mining.as_ref()?.gas_floor_target.clone(),
+			ARG arg_gas_floor_target: (String) = "8000000", or |c: &Config| c.mining.as_ref()?.gas_floor_target.clone(),
 			"--gas-floor-target=[GAS]",
 			"Amount of gas per block to target when sealing a new block.",
 
-			ARG arg_gas_cap: (String) = "6283184", or |c: &Config| c.mining.as_ref()?.gas_cap.clone(),
+			ARG arg_gas_cap: (String) = "10000000", or |c: &Config| c.mining.as_ref()?.gas_cap.clone(),
 			"--gas-cap=[GAS]",
 			"A cap on how large we will raise the gas limit per block due to transaction volume.",
 
@@ -1712,7 +1712,7 @@ mod tests {
 			arg_reseal_max_period: 60000u64,
 			flag_reseal_on_uncle: false,
 			arg_work_queue_size: 20usize,
-			arg_tx_gas_limit: Some("6283184".into()),
+			arg_tx_gas_limit: Some("10000000".into()),
 			arg_tx_time_limit: Some(100u64),
 			arg_relay_set: "cheap".into(),
 			arg_min_gas_price: Some(0u64),
@@ -1721,8 +1721,8 @@ mod tests {
 			arg_poll_lifetime: 60u32,
 			arg_usd_per_eth: "auto".into(),
 			arg_price_update_period: "hourly".into(),
-			arg_gas_floor_target: "4700000".into(),
-			arg_gas_cap: "6283184".into(),
+			arg_gas_floor_target: "8000000".into(),
+			arg_gas_cap: "10000000".into(),
 			arg_extra_data: Some("Parity".into()),
 			flag_tx_queue_no_unfamiliar_locals: false,
 			arg_tx_queue_size: 8192usize,

parity/cli/mod.rs

@@ -125,14 +125,14 @@ min_gas_price = 0
 usd_per_tx = "0.0001"
 usd_per_eth = "auto"
 price_update_period = "hourly"
-gas_floor_target = "4700000"
-gas_cap = "6283184"
+gas_floor_target = "8000000"
+gas_cap = "10000000"
 tx_queue_size = 8192
 tx_queue_gas = "off"
 tx_queue_strategy = "gas_factor"
 tx_queue_ban_count = 1
 tx_queue_ban_time = 180 #s
-tx_gas_limit = "6283184"
+tx_gas_limit = "10000000"
 tx_time_limit = 100 #ms
 tx_queue_no_unfamiliar_locals = false
 extra_data = "Parity"

parity/cli/tests/config.full.toml

@@ -286,7 +286,7 @@ impl Default for MinerExtras {
 			author: Default::default(),
 			engine_signer: Default::default(),
 			extra_data: version_data(),
-			gas_range_target: (4_700_000.into(), 6_283_184.into()),
+			gas_range_target: (8_000_000.into(), 10_000_000.into()),
 			work_notify: Default::default(),
 		}
 	}

parity/params.rs

@@ -50,8 +50,6 @@ impl TimeProvider for DefaultTimeProvider {
 const TIME_THRESHOLD: u64 = 7;
 /// minimal length of hash
 const TOKEN_LENGTH: usize = 16;
-/// special "initial" token used for authorization when there are no tokens yet.
-const INITIAL_TOKEN: &'static str = "initial";
 /// Separator between fields in serialized tokens file.
 const SEPARATOR: &'static str = ";";
 /// Number of seconds to keep unused tokens.
@@ -163,16 +161,6 @@ impl<T: TimeProvider> AuthCodes<T> {
 
 		let as_token = |code| keccak(format!("{}:{}", code, time));
 
-		// Check if it's the initial token.
-		if self.is_empty() {
-			let initial = &as_token(INITIAL_TOKEN) == hash;
-			// Initial token can be used only once.
-			if initial {
-				let _ = self.generate_new();
-			}
-			return initial;
-		}
-
 		// look for code
 		for code in &mut self.codes {
 			if &as_token(&code.code) == hash {
@@ -239,7 +227,7 @@ mod tests {
 	}
 
 	#[test]
-	fn should_return_true_if_code_is_initial_and_store_is_empty() {
+	fn should_return_false_even_if_code_is_initial_and_store_is_empty() {
 		// given
 		let code = "initial";
 		let time = 99;
@@ -250,7 +238,7 @@ mod tests {
 		let res2 = codes.is_valid(&generate_hash(code, time), time);
 
 		// then
-		assert_eq!(res1, true);
+		assert_eq!(res1, false);
 		assert_eq!(res2, false);
 	}
 

rpc/src/authcodes.rs

@@ -136,7 +136,7 @@ mod testing {
 	}
 
 	#[test]
-	fn should_allow_initial_connection_but_only_once() {
+	fn should_not_allow_initial_connection_even_once() {
 		// given
 		let (server, port, authcodes) = serve();
 		let code = "initial";
@@ -160,26 +160,9 @@ mod testing {
 			timestamp,
 			)
 		);
-		let response2 = http_client::request(server.addr(),
-			&format!("\
-				GET / HTTP/1.1\r\n\
-				Host: 127.0.0.1:{}\r\n\
-				Connection: Close\r\n\
-				Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n\
-				Sec-WebSocket-Protocol:{:?}_{}\r\n\
-				Sec-WebSocket-Version: 13\r\n\
-				\r\n\
-				{{}}
-			",
-			port,
-			keccak(format!("{}:{}", code, timestamp)),
-			timestamp,
-			)
-		);
 
 		// then
-		assert_eq!(response1.status, "HTTP/1.1 101 Switching Protocols".to_owned());
-		assert_eq!(response2.status, "HTTP/1.1 403 Forbidden".to_owned());
-		http_client::assert_security_headers_present(&response2.headers, None);
+		assert_eq!(response1.status, "HTTP/1.1 403 Forbidden".to_owned());
+		http_client::assert_security_headers_present(&response1.headers, None);
 	}
 }

rpc/src/tests/ws.rs

@@ -22,25 +22,31 @@ use v1::traits::Net;
 
 /// Net rpc implementation.
 pub struct NetClient<S: ?Sized> {
-	sync: Arc<S>
+	sync: Arc<S>,
+	/// Cached `network_id`.
+	///
+	/// We cache it to avoid redundant aquire of sync read lock.
+	/// https://github.com/paritytech/parity-ethereum/issues/8746
+	network_id: u64,
 }
 
 impl<S: ?Sized> NetClient<S> where S: SyncProvider {
 	/// Creates new NetClient.
 	pub fn new(sync: &Arc<S>) -> Self {
 		NetClient {
 			sync: sync.clone(),
+			network_id: sync.status().network_id,
 		}
 	}
 }
 
 impl<S: ?Sized> Net for NetClient<S> where S: SyncProvider + 'static {
 	fn version(&self) -> Result<String> {
-		Ok(format!("{}", self.sync.status().network_id).to_owned())
+		Ok(format!("{}", self.network_id))
 	}
 
 	fn peer_count(&self) -> Result<String> {
-		Ok(format!("0x{:x}", self.sync.status().num_peers as u64).to_owned())
+		Ok(format!("{:#x}", self.sync.status().num_peers as u64))
 	}
 
 	fn is_listening(&self) -> Result<bool> {