Merge branch 'master' into blockscompression

Conflicts:
	ethcore/src/blockchain/blockchain.rs

Author: keorn

Cargo.lock

@@ -65,10 +65,6 @@ ipc = ["ethcore/ipc"]
 path = "parity/main.rs"
 name = "parity"
 
-[[bin]]
-path = "parity/sync/main.rs"
-name = "sync"
-
 [profile.release]
 debug = true
 lto = false

Cargo.toml

@@ -31,10 +31,10 @@ install:
 build: off
 
 test_script:
-  - cargo test --verbose --release --no-default-features
+  - cargo test --verbose --release
 
 after_test:
-  - cargo build --verbose --release --no-default-features
+  - cargo build --verbose --release
   - ps: if($env:cert) { Start-FileDownload $env:cert -FileName $env:keyfile }
   - ps: if($env:cert) { signtool sign /f $env:keyfile /p $env:certpass target\release\parity.exe }
   - makensis.exe nsis\installer.nsi

appveyor.yml

@@ -32,4 +32,5 @@ RUN git clone https://github.com/ethcore/parity && \
         cargo build --release --verbose && \
         ls /build/parity/target/release/parity && \
         strip /build/parity/target/release/parity
-RUN file /build/parity/target/release/parity
+        
+ENTRYPOINT ["/build/parity/target/release/parity"]

docker/ubuntu/Dockerfile

@@ -1,5 +1,6 @@
 {
-	"name": "Frontier/Homestead",
+	"name": "Ethereum Classic",
+	"forkName": "classic",
 	"engine": {
 		"Ethash": {
 			"params": {

ethcore/res/ethereum/frontier-dogmatic.json ethcore/res/ethereum/classic.json

@@ -61,8 +61,8 @@ impl Account {
 			nonce: pod.nonce,
 			storage_root: SHA3_NULL_RLP,
 			storage_overlay: RefCell::new(pod.storage.into_iter().map(|(k, v)| (k, (Filth::Dirty, v))).collect()),
-			code_hash: Some(pod.code.sha3()),
-			code_cache: pod.code,
+			code_hash: pod.code.as_ref().map(|c| c.sha3()),
+			code_cache: pod.code.as_ref().map_or_else(|| { warn!("POD account with unknown code is being created! Assuming no code."); vec![] }, |c| c.clone()),
 			filth: Filth::Dirty,
 		}
 	}

ethcore/src/account.rs

@@ -114,8 +114,8 @@ impl KeyDirectory for NullDir {
 		Ok(vec![])
 	}
 
-	fn insert(&self, _account: SafeAccount) -> Result<(), SSError> {
-		Ok(())
+	fn insert(&self, account: SafeAccount) -> Result<SafeAccount, SSError> {
+		Ok(account)
 	}
 
 	fn remove(&self, _address: &SSAddress) -> Result<(), SSError> {
@@ -130,6 +130,27 @@ pub struct AccountProvider {
 	sstore: Box<SecretStore>,
 }
 
+/// Collected account metadata
+#[derive(Clone, Debug, PartialEq)]
+pub struct AccountMeta {
+	/// The name of the account.
+	pub name: String,
+	/// The rest of the metadata of the account.
+	pub meta: String,
+	/// The 128-bit UUID of the account, if it has one (brain-wallets don't).
+	pub uuid: Option<String>,
+}
+
+impl Default for AccountMeta {
+	fn default() -> Self {
+		AccountMeta {
+			name: String::new(),
+			meta: "{}".to_owned(),
+			uuid: None,
+		}
+	}
+}
+
 impl AccountProvider {
 	/// Creates new account provider.
 	pub fn new(sstore: Box<SecretStore>) -> Self {
@@ -167,6 +188,39 @@ impl AccountProvider {
 		self.sstore.accounts().into_iter().map(|a| H160(a.into())).collect()
 	}
 
+	/// Returns each account along with name and meta.
+	pub fn accounts_info(&self) -> Result<HashMap<H160, AccountMeta>, Error> {
+		let r: HashMap<H160, AccountMeta> = self.sstore.accounts()
+			.into_iter()
+			.map(|a| (H160(a.clone().into()), self.account_meta(a).unwrap_or_else(|_| Default::default())))
+			.collect();
+		Ok(r)
+	}
+
+	/// Returns each account along with name and meta.
+	pub fn account_meta<A>(&self, account: A) -> Result<AccountMeta, Error> where Address: From<A> {
+		let account = Address::from(account).into();
+		Ok(AccountMeta {
+			name: try!(self.sstore.name(&account)),
+			meta: try!(self.sstore.meta(&account)),
+			uuid: self.sstore.uuid(&account).ok().map(Into::into),	// allowed to not have a UUID
+		})
+	}
+
+	/// Returns each account along with name and meta.
+	pub fn set_account_name<A>(&self, account: A, name: String) -> Result<(), Error> where Address: From<A> {
+		let account = Address::from(account).into();
+		try!(self.sstore.set_name(&account, name));
+		Ok(())
+	}
+
+	/// Returns each account along with name and meta.
+	pub fn set_account_meta<A>(&self, account: A, meta: String) -> Result<(), Error> where Address: From<A> {
+		let account = Address::from(account).into();
+		try!(self.sstore.set_meta(&account, meta));
+		Ok(())
+	}
+
 	/// Helper method used for unlocking accounts.
 	fn unlock_account<A>(&self, account: A, password: String, unlock: Unlock) -> Result<(), Error> where Address: From<A> {
 		let a = Address::from(account);

ethcore/src/account_provider.rs

@@ -339,7 +339,7 @@ impl<'x> OpenBlock<'x> {
 				let t = outcome.trace;
 				self.block.traces.as_mut().map(|traces| traces.push(t.expect("self.block.traces.is_some(): so we must be tracing: qed")));
 				self.block.receipts.push(outcome.receipt);
-				Ok(&self.block.receipts.last().unwrap())
+				Ok(self.block.receipts.last().unwrap())
 			}
 			Err(x) => Err(From::from(x))
 		}

ethcore/src/block.rs

@@ -18,6 +18,7 @@
 //! Sorts them ready for blockchain insertion.
 use std::thread::{JoinHandle, self};
 use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
+use std::sync::{Condvar as SCondvar, Mutex as SMutex};
 use util::*;
 use verification::*;
 use error::*;
@@ -36,7 +37,7 @@ const MIN_MEM_LIMIT: usize = 16384;
 const MIN_QUEUE_LIMIT: usize = 512;
 
 /// Block queue configuration
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct BlockQueueConfig {
 	/// Maximum number of blocks to keep in unverified queue.
 	/// When the limit is reached, is_full returns true.
@@ -80,12 +81,12 @@ impl BlockQueueInfo {
 pub struct BlockQueue {
 	panic_handler: Arc<PanicHandler>,
 	engine: Arc<Box<Engine>>,
-	more_to_verify: Arc<Condvar>,
+	more_to_verify: Arc<SCondvar>,
 	verification: Arc<Verification>,
 	verifiers: Vec<JoinHandle<()>>,
 	deleting: Arc<AtomicBool>,
 	ready_signal: Arc<QueueSignal>,
-	empty: Arc<Condvar>,
+	empty: Arc<SCondvar>,
 	processing: RwLock<HashSet<H256>>,
 	max_queue_size: usize,
 	max_mem_use: usize,
@@ -133,6 +134,8 @@ struct Verification {
 	verified: Mutex<VecDeque<PreverifiedBlock>>,
 	verifying: Mutex<VecDeque<VerifyingBlock>>,
 	bad: Mutex<HashSet<H256>>,
+	more_to_verify: SMutex<()>,
+	empty: SMutex<()>,
 }
 
 impl BlockQueue {
@@ -143,15 +146,18 @@ impl BlockQueue {
 			verified: Mutex::new(VecDeque::new()),
 			verifying: Mutex::new(VecDeque::new()),
 			bad: Mutex::new(HashSet::new()),
+			more_to_verify: SMutex::new(()),
+			empty: SMutex::new(()),
+
 		});
-		let more_to_verify = Arc::new(Condvar::new());
+		let more_to_verify = Arc::new(SCondvar::new());
 		let deleting = Arc::new(AtomicBool::new(false));
 		let ready_signal = Arc::new(QueueSignal {
 			deleting: deleting.clone(),
 			signalled: AtomicBool::new(false),
 			message_channel: message_channel
 		});
-		let empty = Arc::new(Condvar::new());
+		let empty = Arc::new(SCondvar::new());
 		let panic_handler = PanicHandler::new_in_arc();
 
 		let mut verifiers: Vec<JoinHandle<()>> = Vec::new();
@@ -190,17 +196,17 @@ impl BlockQueue {
 		}
 	}
 
-	fn verify(verification: Arc<Verification>, engine: Arc<Box<Engine>>, wait: Arc<Condvar>, ready: Arc<QueueSignal>, deleting: Arc<AtomicBool>, empty: Arc<Condvar>) {
+	fn verify(verification: Arc<Verification>, engine: Arc<Box<Engine>>, wait: Arc<SCondvar>, ready: Arc<QueueSignal>, deleting: Arc<AtomicBool>, empty: Arc<SCondvar>) {
 		while !deleting.load(AtomicOrdering::Acquire) {
 			{
-				let mut unverified = verification.unverified.lock();
+				let mut more_to_verify = verification.more_to_verify.lock().unwrap();
 
-				if unverified.is_empty() && verification.verifying.lock().is_empty() {
+				if verification.unverified.lock().is_empty() && verification.verifying.lock().is_empty() {
 					empty.notify_all();
 				}
 
-				while unverified.is_empty() && !deleting.load(AtomicOrdering::Acquire) {
-					wait.wait(&mut unverified);
+				while verification.unverified.lock().is_empty() && !deleting.load(AtomicOrdering::Acquire) {
+					more_to_verify = wait.wait(more_to_verify).unwrap();
 				}
 
 				if deleting.load(AtomicOrdering::Acquire) {
@@ -276,18 +282,18 @@ impl BlockQueue {
 
 	/// Wait for unverified queue to be empty
 	pub fn flush(&self) {
-		let mut unverified = self.verification.unverified.lock();
-		while !unverified.is_empty() || !self.verification.verifying.lock().is_empty() {
-			self.empty.wait(&mut unverified);
+		let mut lock = self.verification.empty.lock().unwrap();
+		while !self.verification.unverified.lock().is_empty() || !self.verification.verifying.lock().is_empty() {
+			lock = self.empty.wait(lock).unwrap();
 		}
 	}
 
 	/// Check if the block is currently in the queue
 	pub fn block_status(&self, hash: &H256) -> BlockStatus {
-		if self.processing.read().contains(&hash) {
+		if self.processing.read().contains(hash) {
 			return BlockStatus::Queued;
 		}
-		if self.verification.bad.lock().contains(&hash) {
+		if self.verification.bad.lock().contains(hash) {
 			return BlockStatus::Bad;
 		}
 		BlockStatus::Unknown
@@ -340,7 +346,7 @@ impl BlockQueue {
 		bad.reserve(block_hashes.len());
 		for hash in block_hashes {
 			bad.insert(hash.clone());
-			processing.remove(&hash);
+			processing.remove(hash);
 		}
 
 		let mut new_verified = VecDeque::new();
@@ -362,7 +368,7 @@ impl BlockQueue {
 		}
 		let mut processing = self.processing.write();
 		for hash in block_hashes {
-			processing.remove(&hash);
+			processing.remove(hash);
 		}
 	}