Merge remote-tracking branch 'parity/master' into auth-round-no-mocknet

ethcore/src/account_provider.rs

@@ -36,7 +36,7 @@ enum Unlock {
 	/// Use with caution.
 	Perm,
 	/// Account unlocked with a timeout
-	Timed((Instant, u32)),
+	Timed(Instant),
 }
 
 /// Data associated with account.
@@ -308,8 +308,8 @@ impl AccountProvider {
 		if let Unlock::Temp = data.unlock {
 			unlocked.remove(account).expect("data exists: so key must exist: qed");
 		}
-		if let Unlock::Timed((ref start, ref duration)) = data.unlock {
-			if start.elapsed() > Duration::from_millis(*duration as u64) {
+		if let Unlock::Timed(ref end) = data.unlock {
+			if Instant::now() > *end {
 				unlocked.remove(account).expect("data exists: so key must exist: qed");
 				return Err(Error::NotUnlocked);
 			}
@@ -329,7 +329,7 @@ impl AccountProvider {
 
 	/// Unlocks account temporarily with a timeout.
 	pub fn unlock_account_timed(&self, account: Address, password: String, duration_ms: u32) -> Result<(), Error> {
-		self.unlock_account(account, password, Unlock::Timed((Instant::now(), duration_ms)))
+		self.unlock_account(account, password, Unlock::Timed(Instant::now() + Duration::from_millis(duration_ms as u64)))
 	}
 
 	/// Checks if given account is unlocked
@@ -363,11 +363,11 @@ impl AccountProvider {
 
 #[cfg(test)]
 mod tests {
-	use super::{AccountProvider, AddressBook};
+	use super::{AccountProvider, AddressBook, Unlock};
 	use std::collections::HashMap;
+	use std::time::Instant;
 	use ethjson::misc::AccountMeta;
 	use ethstore::ethkey::{Generator, Random};
-	use std::time::Duration;
 	use devtools::RandomTempPath;
 
 	#[test]
@@ -411,10 +411,10 @@ mod tests {
 		let kp = Random.generate().unwrap();
 		let ap = AccountProvider::transient_provider();
 		assert!(ap.insert_account(kp.secret().clone(), "test").is_ok());
-		assert!(ap.unlock_account_timed(kp.address(), "test1".into(), 2000).is_err());
-		assert!(ap.unlock_account_timed(kp.address(), "test".into(), 2000).is_ok());
+		assert!(ap.unlock_account_timed(kp.address(), "test1".into(), 60000).is_err());
+		assert!(ap.unlock_account_timed(kp.address(), "test".into(), 60000).is_ok());
 		assert!(ap.sign(kp.address(), None, Default::default()).is_ok());
-		::std::thread::sleep(Duration::from_millis(2000));
+		ap.unlocked.lock().get_mut(&kp.address()).unwrap().unlock = Unlock::Timed(Instant::now());
 		assert!(ap.sign(kp.address(), None, Default::default()).is_err());
 	}
 }

ethcore/src/client/client.rs

@@ -45,6 +45,7 @@ use block::*;
 use transaction::{LocalizedTransaction, SignedTransaction, Action};
 use blockchain::extras::TransactionAddress;
 use types::filter::Filter;
+use types::mode::Mode as IpcMode;
 use log_entry::LocalizedLogEntry;
 use verification::queue::BlockQueue;
 use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute};
@@ -123,7 +124,7 @@ impl SleepState {
 /// Blockchain database client backed by a persistent database. Owns and manages a blockchain and a block queue.
 /// Call `import_block()` to import a block asynchronously; `flush_queue()` flushes the queue.
 pub struct Client {
-	mode: Mode,
+	mode: Mutex<Mode>,
 	chain: RwLock<Arc<BlockChain>>,
 	tracedb: RwLock<TraceDB<BlockChain>>,
 	engine: Arc<Engine>,
@@ -221,7 +222,7 @@ impl Client {
 		let client = Client {
 			sleep_state: Mutex::new(SleepState::new(awake)),
 			liveness: AtomicBool::new(awake),
-			mode: config.mode.clone(),
+			mode: Mutex::new(config.mode.clone()),
 			chain: RwLock::new(chain),
 			tracedb: tracedb,
 			engine: engine,
@@ -620,7 +621,8 @@ impl Client {
 		self.block_queue.collect_garbage();
 		self.tracedb.read().collect_garbage();
 
-		match self.mode {
+		let mode = self.mode.lock().clone();
+		match mode {
 			Mode::Dark(timeout) => {
 				let mut ss = self.sleep_state.lock();
 				if let Some(t) = ss.last_activity {
@@ -772,7 +774,7 @@ impl BlockChainClient for Client {
 	fn call(&self, t: &SignedTransaction, block: BlockID, analytics: CallAnalytics) -> Result<Executed, CallError> {
 		let header = try!(self.block_header(block).ok_or(CallError::StatePruned));
 		let view = HeaderView::new(&header);
-		let last_hashes = self.build_last_hashes(view.hash());
+		let last_hashes = self.build_last_hashes(view.parent_hash());
 		let env_info = EnvInfo {
 			number: view.number(),
 			author: view.author(),
@@ -844,12 +846,24 @@ impl BlockChainClient for Client {
 	}
 
 	fn keep_alive(&self) {
-		if self.mode != Mode::Active {
+		let mode = self.mode.lock().clone();
+		if mode != Mode::Active {
 			self.wake_up();
 			(*self.sleep_state.lock()).last_activity = Some(Instant::now());
 		}
 	}
 
+	fn mode(&self) -> IpcMode { self.mode.lock().clone().into() }
+
+	fn set_mode(&self, mode: IpcMode) {
+		*self.mode.lock() = mode.clone().into();
+		match mode {
+			IpcMode::Active => self.wake_up(),
+			IpcMode::Off => self.sleep(),
+			_ => {(*self.sleep_state.lock()).last_activity = Some(Instant::now()); }
+		}
+	}
+
 	fn best_block_header(&self) -> Bytes {
 		self.chain.read().best_block_header()
 	}

ethcore/src/client/config.rs

@@ -76,6 +76,8 @@ pub enum Mode {
 	/// Goes offline after RLP is inactive for some (given) time and
 	/// stays inactive.
 	Dark(Duration),
+	/// Always off.
+	Off,
 }
 
 impl Default for Mode {

ethcore/src/client/test_client.rs

@@ -37,6 +37,7 @@ use error::{ImportResult};
 use evm::{Factory as EvmFactory, VMType, Schedule};
 use miner::{Miner, MinerService, TransactionImportResult};
 use spec::Spec;
+use types::mode::Mode;
 
 use verification::queue::QueueInfo;
 use block::{OpenBlock, SealedBlock};
@@ -83,6 +84,10 @@ pub struct TestBlockChainClient {
 	pub vm_factory: EvmFactory,
 	/// Timestamp assigned to latest sealed block
 	pub latest_block_timestamp: RwLock<u64>,
+	/// Ancient block info.
+	pub ancient_block: RwLock<Option<(H256, u64)>>,
+	/// First block info.
+	pub first_block: RwLock<Option<(H256, u64)>>,
 }
 
 #[derive(Clone)]
@@ -142,6 +147,8 @@ impl TestBlockChainClient {
 			spec: spec,
 			vm_factory: EvmFactory::new(VMType::Interpreter, 1024 * 1024),
 			latest_block_timestamp: RwLock::new(10_000_000),
+			ancient_block: RwLock::new(None),
+			first_block: RwLock::new(None),
 		};
 		client.add_blocks(1, EachBlockWith::Nothing); // add genesis block
 		client.genesis_hash = client.last_hash.read().clone();
@@ -603,10 +610,10 @@ impl BlockChainClient for TestBlockChainClient {
 			genesis_hash: self.genesis_hash.clone(),
 			best_block_hash: self.last_hash.read().clone(),
 			best_block_number: self.blocks.read().len() as BlockNumber - 1,
-			first_block_hash: None,
-			first_block_number: None,
-			ancient_block_hash: None,
-			ancient_block_number: None,
+			first_block_hash: self.first_block.read().as_ref().map(|x| x.0),
+			first_block_number: self.first_block.read().as_ref().map(|x| x.1),
+			ancient_block_hash: self.ancient_block.read().as_ref().map(|x| x.0),
+			ancient_block_number: self.ancient_block.read().as_ref().map(|x| x.1)
 		}
 	}
 
@@ -635,4 +642,8 @@ impl BlockChainClient for TestBlockChainClient {
 	fn pending_transactions(&self) -> Vec<SignedTransaction> {
 		self.miner.pending_transactions(self.chain_info().best_block_number)
 	}
+
+	fn mode(&self) -> Mode { Mode::Active }
+
+	fn set_mode(&self, _: Mode) { unimplemented!(); }
 }

ethcore/src/client/traits.rs

@@ -16,6 +16,7 @@
 
 use std::collections::BTreeMap;
 use util::{U256, Address, H256, H2048, Bytes, Itertools};
+use util::stats::Histogram;
 use blockchain::TreeRoute;
 use verification::queue::QueueInfo as BlockQueueInfo;
 use block::{OpenBlock, SealedBlock};
@@ -37,6 +38,7 @@ use block_import_error::BlockImportError;
 use ipc::IpcConfig;
 use types::blockchain_info::BlockChainInfo;
 use types::block_status::BlockStatus;
+use types::mode::Mode;
 
 #[ipc(client_ident="RemoteClient")]
 /// Blockchain database client. Owns and manages a blockchain and a block queue.
@@ -190,8 +192,8 @@ pub trait BlockChainClient : Sync + Send {
 	/// list all transactions
 	fn pending_transactions(&self) -> Vec<SignedTransaction>;
 
-	/// Get the gas price distribution.
-	fn gas_price_statistics(&self, sample_size: usize, distribution_size: usize) -> Result<Vec<U256>, ()> {
+	/// Sorted list of transaction gas prices from at least last sample_size blocks.
+	fn gas_price_corpus(&self, sample_size: usize) -> Vec<U256> {
 		let mut h = self.chain_info().best_block_hash;
 		let mut corpus = Vec::new();
 		while corpus.is_empty() {
@@ -200,26 +202,34 @@ pub trait BlockChainClient : Sync + Send {
 				let block = BlockView::new(&block_bytes);
 				let header = block.header_view();
 				if header.number() == 0 {
-					if corpus.is_empty() {
-						corpus.push(20_000_000_000u64.into());	// we have literally no information - it' as good a number as any.
-					}
-					break;
+					return corpus;
 				}
 				block.transaction_views().iter().foreach(|t| corpus.push(t.gas_price()));
 				h = header.parent_hash().clone();
 			}
 		}
 		corpus.sort();
-		let n = corpus.len();
-		if n > 0 {
-			Ok((0..(distribution_size + 1))
-				.map(|i| corpus[i * (n - 1) / distribution_size])
-				.collect::<Vec<_>>()
-			)
-		} else {
-			Err(())
-		}
+		corpus
 	}
+
+	/// Calculate median gas price from recent blocks if they have any transactions.
+	fn gas_price_median(&self, sample_size: usize) -> Option<U256> {
+		let corpus = self.gas_price_corpus(sample_size);
+		corpus.get(corpus.len()/2).cloned()
+	}
+
+	/// Get the gas price distribution based on recent blocks if they have any transactions.
+	fn gas_price_histogram(&self, sample_size: usize, bucket_number: usize) -> Option<Histogram> {
+		let raw_corpus = self.gas_price_corpus(sample_size);
+		let raw_len = raw_corpus.len();
+		// Throw out outliers.
+		let (corpus, _) = raw_corpus.split_at(raw_len-raw_len/40);
+		Histogram::new(corpus, bucket_number)
+	}
+
+	fn mode(&self) -> Mode;
+
+	fn set_mode(&self, mode: Mode);
 }
 
 /// Extended client interface used for mining

ethcore/src/miner/mod.rs

@@ -158,7 +158,7 @@ pub trait MinerService : Send + Sync {
 	fn is_sealing(&self) -> bool;
 
 	/// Suggested gas price.
-	fn sensible_gas_price(&self) -> U256 { 20000000000u64.into() }
+	fn sensible_gas_price(&self) -> U256;
 
 	/// Suggested gas limit.
 	fn sensible_gas_limit(&self) -> U256 { 21000.into() }

ethcore/src/service.rs

@@ -192,6 +192,8 @@ impl IoHandler<ClientIoMessage> for ClientIoHandler {
 
 	#[cfg_attr(feature="dev", allow(single_match))]
 	fn message(&self, _io: &IoContext<ClientIoMessage>, net_message: &ClientIoMessage) {
+		use std::thread;
+
 		match *net_message {
 			ClientIoMessage::BlockVerified => { self.client.import_verified_blocks(); }
 			ClientIoMessage::NewTransactions(ref transactions) => { self.client.import_queued_transactions(transactions); }
@@ -203,8 +205,17 @@ impl IoHandler<ClientIoMessage> for ClientIoHandler {
 			ClientIoMessage::FeedStateChunk(ref hash, ref chunk) => self.snapshot.feed_state_chunk(*hash, chunk),
 			ClientIoMessage::FeedBlockChunk(ref hash, ref chunk) => self.snapshot.feed_block_chunk(*hash, chunk),
 			ClientIoMessage::TakeSnapshot(num) => {
-				if let Err(e) = self.snapshot.take_snapshot(&*self.client, num) {
-					warn!("Failed to take snapshot at block #{}: {}", num, e);
+				let client = self.client.clone();
+				let snapshot = self.snapshot.clone();
+
+				let res = thread::Builder::new().name("Periodic Snapshot".into()).spawn(move || {
+					if let Err(e) = snapshot.take_snapshot(&*client, num) {
+						warn!("Failed to take snapshot at block #{}: {}", num, e);
+					}
+				});
+
+				if let Err(e) = res {
+					debug!(target: "snapshot", "Failed to initialize periodic snapshot thread: {:?}", e);
 				}
 			},
 			ClientIoMessage::UpdateSealing => {

ethcore/src/tests/client.rs

@@ -26,6 +26,7 @@ use miner::Miner;
 use rlp::{Rlp, View};
 use spec::Spec;
 use views::BlockView;
+use util::stats::Histogram;
 
 #[test]
 fn imports_from_empty() {
@@ -198,19 +199,37 @@ fn can_collect_garbage() {
 	assert!(client.blockchain_cache_info().blocks < 100 * 1024);
 }
 
+
 #[test]
-#[cfg_attr(feature="dev", allow(useless_vec))]
-fn can_generate_gas_price_statistics() {
-	let client_result = generate_dummy_client_with_data(16, 1, &vec_into![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
+fn can_generate_gas_price_median() {
+	let client_result = generate_dummy_client_with_data(3, 1, &vec_into![1, 2, 3]);
 	let client = client_result.reference();
-	let s = client.gas_price_statistics(8, 8).unwrap();
-	assert_eq!(s, vec_into![8, 8, 9, 10, 11, 12, 13, 14, 15]);
-	let s = client.gas_price_statistics(16, 8).unwrap();
-	assert_eq!(s, vec_into![0, 1, 3, 5, 7, 9, 11, 13, 15]);
-	let s = client.gas_price_statistics(32, 8).unwrap();
-	assert_eq!(s, vec_into![0, 1, 3, 5, 7, 9, 11, 13, 15]);
+	assert_eq!(Some(U256::from(2)), client.gas_price_median(3));
+
+	let client_result = generate_dummy_client_with_data(4, 1, &vec_into![1, 4, 3, 2]);
+	let client = client_result.reference();
+	assert_eq!(Some(U256::from(3)), client.gas_price_median(4));
 }
 
+#[test]
+fn can_generate_gas_price_histogram() {
+	let client_result = generate_dummy_client_with_data(20, 1, &vec_into![6354,8593,6065,4842,7845,7002,689,4958,4250,6098,5804,4320,643,8895,2296,8589,7145,2000,2512,1408]);
+	let client = client_result.reference();
+
+	let hist = client.gas_price_histogram(20, 5).unwrap();
+	let correct_hist = Histogram { bucket_bounds: vec_into![643,2293,3943,5593,7243,8893], counts: vec![4,2,4,6,3] };
+	assert_eq!(hist, correct_hist);
+}
+
+#[test]
+fn empty_gas_price_histogram() {
+	let client_result = generate_dummy_client_with_data(20, 0, &vec_into![]);
+	let client = client_result.reference();
+
+	assert!(client.gas_price_histogram(20, 5).is_none());
+}
+
+
 #[test]
 fn can_handle_long_fork() {
 	let client_result = generate_dummy_client(1200);

ethcore/src/types/mod.rs.in

@@ -33,3 +33,4 @@ pub mod transaction_import;
 pub mod block_import_error;
 pub mod restoration_status;
 pub mod snapshot_manifest;
+pub mod mode;

ethcore/src/types/mode.rs

@@ -0,0 +1,55 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity 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.
+
+// Parity 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 Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Mode type
+
+pub use std::time::Duration;
+use client::Mode as ClientMode;
+
+/// IPC-capable shadow-type for client::config::Mode
+#[derive(Clone, Binary)]
+pub enum Mode {
+	/// Same as ClientMode::Off.
+	Off,
+	/// Same as ClientMode::Dark; values in seconds.
+	Dark(u64),
+	/// Same as ClientMode::Passive; values in seconds.
+	Passive(u64, u64),
+	/// Same as ClientMode::Active.
+	Active,
+}
+
+impl From<ClientMode> for Mode {
+	fn from(mode: ClientMode) -> Self {
+		match mode {
+			ClientMode::Off => Mode::Off,
+			ClientMode::Dark(timeout) => Mode::Dark(timeout.as_secs()),
+			ClientMode::Passive(timeout, alarm) => Mode::Passive(timeout.as_secs(), alarm.as_secs()),
+			ClientMode::Active => Mode::Active,
+		}
+	}
+}
+
+impl From<Mode> for ClientMode {
+	fn from(mode: Mode) -> Self {
+		match mode {
+			Mode::Off => ClientMode::Off,
+			Mode::Dark(timeout) => ClientMode::Dark(Duration::from_secs(timeout)),
+			Mode::Passive(timeout, alarm) => ClientMode::Passive(Duration::from_secs(timeout), Duration::from_secs(alarm)),
+			Mode::Active => ClientMode::Active,
+		}
+	}
+}