Merge remote-tracking branch 'origin/tx_queue_integration' into tx_queue_rpc

rpc/src/lib.rs

@@ -27,9 +27,35 @@ extern crate jsonrpc_http_server;
 extern crate ethcore_util as util;
 extern crate ethcore;
 extern crate ethsync;
+extern crate transient_hashmap;
 
-#[cfg(feature = "serde_macros")]
-include!("lib.rs.in");
+use self::jsonrpc_core::{IoHandler, IoDelegate};
 
-#[cfg(not(feature = "serde_macros"))]
-include!(concat!(env!("OUT_DIR"), "/lib.rs"));
+pub mod v1;
+
+/// Http server.
+pub struct HttpServer {
+	handler: IoHandler,
+	threads: usize
+}
+
+impl HttpServer {
+	/// Construct new http server object with given number of threads.
+	pub fn new(threads: usize) -> HttpServer {
+		HttpServer {
+			handler: IoHandler::new(),
+			threads: threads
+		}
+	}
+
+	/// Add io delegate.
+	pub fn add_delegate<D>(&mut self, delegate: IoDelegate<D>) where D: Send + Sync + 'static {
+		self.handler.add_delegate(delegate);
+	}
+
+	/// Start server asynchronously in new thread
+	pub fn start_async(self, addr: &str, cors_domain: &str) {
+		let server = jsonrpc_http_server::Server::new(self.handler, self.threads);
+		server.start_async(addr, jsonrpc_http_server::AccessControlAllowOrigin::Value(cors_domain.to_owned()))
+	}
+}

rpc/src/lib.rs.in

@@ -1,30 +0,0 @@
-use self::jsonrpc_core::{IoHandler, IoDelegate};
-
-pub mod v1;
-
-/// Http server.
-pub struct HttpServer {
-	handler: IoHandler,
-	threads: usize
-}
-
-impl HttpServer {
-	/// Construct new http server object with given number of threads.
-	pub fn new(threads: usize) -> HttpServer {
-		HttpServer {
-			handler: IoHandler::new(),
-			threads: threads
-		}
-	}
-
-	/// Add io delegate.
-	pub fn add_delegate<D>(&mut self, delegate: IoDelegate<D>) where D: Send + Sync + 'static {
-		self.handler.add_delegate(delegate);
-	}
-
-	/// Start server asynchronously in new thread
-	pub fn start_async(self, addr: &str, cors_domain: &str) {
-		let server = jsonrpc_http_server::Server::new(self.handler, self.threads);
-		server.start_async(addr, jsonrpc_http_server::AccessControlAllowOrigin::Value(cors_domain.to_owned()))
-	}
-}

rpc/src/v1/helpers/mod.rs

@@ -0,0 +1,21 @@
+// 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/>.
+
+mod poll_manager;
+mod poll_filter;
+
+pub use self::poll_manager::PollManager;
+pub use self::poll_filter::PollFilter;

rpc/src/v1/helpers/poll_filter.rs

@@ -0,0 +1,10 @@
+//! Helper type with all filter possibilities.
+
+use ethcore::filter::Filter;
+
+#[derive(Clone)]
+pub enum PollFilter {
+	Block,
+	PendingTransaction,
+	Logs(Filter)
+}

rpc/src/v1/helpers/poll_manager.rs

@@ -0,0 +1,144 @@
+// 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/>.
+
+//! Indexes all rpc poll requests.
+
+use transient_hashmap::{TransientHashMap, Timer, StandardTimer};
+
+/// Lifetime of poll (in seconds).
+const POLL_LIFETIME: u64 = 60;
+
+pub type PollId = usize;
+pub type BlockNumber = u64;
+
+pub struct PollInfo<F> {
+	pub filter: F,
+	pub block_number: BlockNumber
+}
+
+impl<F> Clone for PollInfo<F> where F: Clone {
+	fn clone(&self) -> Self {
+		PollInfo {
+			filter: self.filter.clone(),
+			block_number: self.block_number.clone()
+		}
+	}
+}
+
+/// Indexes all poll requests.
+///
+/// Lazily garbage collects unused polls info.
+pub struct PollManager<F, T = StandardTimer> where T: Timer {
+	polls: TransientHashMap<PollId, PollInfo<F>, T>,
+	next_available_id: PollId
+}
+
+impl<F> PollManager<F, StandardTimer> {
+	/// Creates new instance of indexer.
+	pub fn new() -> Self {
+		PollManager::new_with_timer(Default::default())
+	}
+}
+
+impl<F, T> PollManager<F, T> where T: Timer {
+	pub fn new_with_timer(timer: T) -> Self {
+		PollManager {
+			polls: TransientHashMap::new_with_timer(POLL_LIFETIME, timer),
+			next_available_id: 0,
+		}
+	}
+
+	/// Returns id which can be used for new poll.
+	///
+	/// Stores information when last poll happend.
+	pub fn create_poll(&mut self, filter: F, block: BlockNumber) -> PollId {
+		self.polls.prune();
+		let id = self.next_available_id;
+		self.next_available_id += 1;
+		self.polls.insert(id, PollInfo {
+			filter: filter,
+			block_number: block,
+		});
+		id
+	}
+
+	/// Updates information when last poll happend.
+	pub fn update_poll(&mut self, id: &PollId, block: BlockNumber) {
+		self.polls.prune();
+		if let Some(info) = self.polls.get_mut(id) {
+			info.block_number = block;
+		}
+	}
+
+	/// Returns number of block when last poll happend.
+	pub fn get_poll_info(&mut self, id: &PollId) -> Option<&PollInfo<F>> {
+		self.polls.prune();
+		self.polls.get(id)
+	}
+
+	/// Removes poll info.
+	pub fn remove_poll(&mut self, id: &PollId) {
+		self.polls.remove(id);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::cell::RefCell;
+	use transient_hashmap::Timer;
+	use v1::helpers::PollManager;
+
+	struct TestTimer<'a> {
+		time: &'a RefCell<i64>,
+	}
+
+	impl<'a> Timer for TestTimer<'a> {
+		fn get_time(&self) -> i64 {
+			*self.time.borrow()
+		}
+	}
+
+	#[test]
+	fn test_poll_indexer() {
+		let time = RefCell::new(0);
+		let timer = TestTimer {
+			time: &time,
+		};
+
+		let mut indexer = PollManager::new_with_timer(timer);
+		assert_eq!(indexer.create_poll(false, 20), 0);
+		assert_eq!(indexer.create_poll(true, 20), 1);
+
+		*time.borrow_mut() = 10;
+		indexer.update_poll(&0, 21);
+		assert_eq!(indexer.get_poll_info(&0).unwrap().filter, false);
+		assert_eq!(indexer.get_poll_info(&0).unwrap().block_number, 21);
+
+		*time.borrow_mut() = 30;
+		indexer.update_poll(&1, 23);
+		assert_eq!(indexer.get_poll_info(&1).unwrap().filter, true);
+		assert_eq!(indexer.get_poll_info(&1).unwrap().block_number, 23);
+
+		*time.borrow_mut() = 75;
+		indexer.update_poll(&0, 30);
+		assert!(indexer.get_poll_info(&0).is_none());
+		assert_eq!(indexer.get_poll_info(&1).unwrap().filter, true);
+		assert_eq!(indexer.get_poll_info(&1).unwrap().block_number, 23);
+
+		indexer.remove_poll(&1);
+		assert!(indexer.get_poll_info(&1).is_none());
+	}
+}

rpc/src/v1/impls/eth.rs

@@ -15,11 +15,12 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Eth rpc implementation.
+use std::collections::HashMap;
+use std::sync::{Arc, Weak, Mutex, RwLock};
 use ethsync::{EthSync, SyncState};
 use jsonrpc_core::*;
 use util::numbers::*;
 use util::sha3::*;
-use util::standard::{RwLock, HashMap, Arc, Weak};
 use util::rlp::encode;
 use ethcore::client::*;
 use ethcore::block::{IsBlock};
@@ -29,6 +30,7 @@ use ethcore::ethereum::Ethash;
 use ethcore::ethereum::denominations::shannon;
 use v1::traits::{Eth, EthFilter};
 use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, OptionalValue, Index, Filter, Log};
+use v1::helpers::{PollFilter, PollManager};
 
 /// Eth rpc implementation.
 pub struct EthClient {
@@ -266,28 +268,98 @@ impl Eth for EthClient {
 
 /// Eth filter rpc implementation.
 pub struct EthFilterClient {
-	client: Weak<Client>
+	client: Weak<Client>,
+	polls: Mutex<PollManager<PollFilter>>,
 }
 
 impl EthFilterClient {
 	/// Creates new Eth filter client.
 	pub fn new(client: &Arc<Client>) -> Self {
 		EthFilterClient {
-			client: Arc::downgrade(client)
+			client: Arc::downgrade(client),
+			polls: Mutex::new(PollManager::new())
 		}
 	}
 }
 
 impl EthFilter for EthFilterClient {
-	fn new_block_filter(&self, _params: Params) -> Result<Value, Error> {
-		Ok(Value::U64(0))
+	fn new_filter(&self, params: Params) -> Result<Value, Error> {
+		from_params::<(Filter,)>(params)
+			.and_then(|(filter,)| {
+				let mut polls = self.polls.lock().unwrap();
+				let id = polls.create_poll(PollFilter::Logs(filter.into()), take_weak!(self.client).chain_info().best_block_number);
+				to_value(&U256::from(id))
+			})
 	}
 
-	fn new_pending_transaction_filter(&self, _params: Params) -> Result<Value, Error> {
-		Ok(Value::U64(1))
+	fn new_block_filter(&self, params: Params) -> Result<Value, Error> {
+		match params {
+			Params::None => {
+				let mut polls = self.polls.lock().unwrap();
+				let id = polls.create_poll(PollFilter::Block, take_weak!(self.client).chain_info().best_block_number);
+				to_value(&U256::from(id))
+			},
+			_ => Err(Error::invalid_params())
+		}
 	}
 
-	fn filter_changes(&self, _: Params) -> Result<Value, Error> {
-		to_value(&take_weak!(self.client).chain_info().best_block_hash).map(|v| Value::Array(vec![v]))
+	fn new_pending_transaction_filter(&self, params: Params) -> Result<Value, Error> {
+		match params {
+			Params::None => {
+				let mut polls = self.polls.lock().unwrap();
+				let id = polls.create_poll(PollFilter::PendingTransaction, take_weak!(self.client).chain_info().best_block_number);
+				to_value(&U256::from(id))
+			},
+			_ => Err(Error::invalid_params())
+		}
+	}
+
+	fn filter_changes(&self, params: Params) -> Result<Value, Error> {
+		let client = take_weak!(self.client);
+		from_params::<(Index,)>(params)
+			.and_then(|(index,)| {
+				let info = self.polls.lock().unwrap().get_poll_info(&index.value()).cloned();
+				match info {
+					None => Ok(Value::Array(vec![] as Vec<Value>)),
+					Some(info) => match info.filter {
+						PollFilter::Block => {
+							let current_number = client.chain_info().best_block_number;
+							let hashes = (info.block_number..current_number).into_iter()
+								.map(BlockId::Number)
+								.filter_map(|id| client.block_hash(id))
+								.collect::<Vec<H256>>();
+
+							self.polls.lock().unwrap().update_poll(&index.value(), current_number);
+
+							to_value(&hashes)
+						},
+						PollFilter::PendingTransaction => {
+							// TODO: fix implementation once TransactionQueue is merged
+							to_value(&vec![] as &Vec<H256>)
+						},
+						PollFilter::Logs(mut filter) => {
+							filter.from_block = BlockId::Number(info.block_number);
+							filter.to_block = BlockId::Latest;
+							let logs = client.logs(filter)
+								.into_iter()
+								.map(From::from)
+								.collect::<Vec<Log>>();
+
+							let current_number = client.chain_info().best_block_number;
+							self.polls.lock().unwrap().update_poll(&index.value(), current_number);
+
+							to_value(&logs)
+						}
+					}
+				}
+			})
+	}
+
+	fn uninstall_filter(&self, params: Params) -> Result<Value, Error> {
+		from_params::<(Index,)>(params)
+			.and_then(|(index,)| {
+				self.polls.lock().unwrap().remove_poll(&index.value());
+				to_value(&true)
+			})
 	}
 }

rpc/src/v1/impls/mod.rs

@@ -28,7 +28,9 @@ macro_rules! take_weak {
 mod web3;
 mod eth;
 mod net;
+mod personal;
 
 pub use self::web3::Web3Client;
 pub use self::eth::{EthClient, EthFilterClient};
 pub use self::net::NetClient;
+pub use self::personal::PersonalClient;

rpc/src/v1/impls/personal.rs

@@ -0,0 +1,78 @@
+// 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/>.
+
+//! Account management (personal) rpc implementation
+use std::sync::{Arc, Weak};
+use jsonrpc_core::*;
+use v1::traits::Personal;
+use util::keys::store::*;
+use util::Address;
+use std::sync::RwLock;
+
+/// Account management (personal) rpc implementation.
+pub struct PersonalClient {
+	secret_store: Weak<RwLock<SecretStore>>,
+}
+
+impl PersonalClient {
+	/// Creates new PersonalClient
+	pub fn new(store: &Arc<RwLock<SecretStore>>) -> Self {
+		PersonalClient {
+			secret_store: Arc::downgrade(store),
+		}
+	}
+}
+
+impl Personal for PersonalClient {
+	fn accounts(&self, _: Params) -> Result<Value, Error> {
+		let store_wk = take_weak!(self.secret_store);
+		let store = store_wk.read().unwrap();
+		match store.accounts() {
+			Ok(account_list) => {
+				Ok(Value::Array(account_list.iter()
+					.map(|&(account, _)| Value::String(format!("{:?}", account)))
+					.collect::<Vec<Value>>())
+				)
+			}
+			Err(_) => Err(Error::internal_error())
+		}
+	}
+
+	fn new_account(&self, params: Params) -> Result<Value, Error> {
+		from_params::<(String, )>(params).and_then(
+			|(pass, )| {
+				let store_wk = take_weak!(self.secret_store);
+				let mut store = store_wk.write().unwrap();
+				match store.new_account(&pass) {
+					Ok(address) => Ok(Value::String(format!("{:?}", address))),
+					Err(_) => Err(Error::internal_error())
+				}
+			}
+		)
+	}
+
+	fn unlock_account(&self, params: Params) -> Result<Value, Error> {
+		from_params::<(Address, String, u64)>(params).and_then(
+			|(account, account_pass, _)|{
+				let store_wk = take_weak!(self.secret_store);
+				let store = store_wk.read().unwrap();
+				match store.unlock_account(&account, &account_pass) {
+					Ok(_) => Ok(Value::Bool(true)),
+					Err(_) => Ok(Value::Bool(false)),
+				}
+			})
+	}
+}

rpc/src/v1/impls/web3.rs

@@ -30,9 +30,7 @@ impl Web3Client {
 impl Web3 for Web3Client {
 	fn client_version(&self, params: Params) -> Result<Value, Error> {
 		match params {
-			Params::None => {
-				Ok(Value::String(version().to_owned().replace("Parity/", "Parity//"))),
-			}
+			Params::None => Ok(Value::String(version().to_owned().replace("Parity/", "Parity//"))),
 			_ => Err(Error::invalid_params())
 		}
 	}

rpc/src/v1/mod.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Ethcore rpc v1.
-//! 
+//!
 //! Compliant with ethereum rpc.
 
 pub mod traits;
@@ -23,6 +23,7 @@ mod impls;
 mod types;
 #[cfg(test)]
 mod tests;
+mod helpers;
 
-pub use self::traits::{Web3, Eth, EthFilter, Net};
+pub use self::traits::{Web3, Eth, EthFilter, Personal, Net};
 pub use self::impls::*;

rpc/src/v1/traits/mod.rs

@@ -23,7 +23,9 @@ macro_rules! rpc_unimplemented {
 pub mod web3;
 pub mod eth;
 pub mod net;
+pub mod personal;
 
 pub use self::web3::Web3;
 pub use self::eth::{Eth, EthFilter};
 pub use self::net::Net;
+pub use self::personal::Personal;

rpc/src/v1/traits/personal.rs

@@ -0,0 +1,41 @@
+// 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/>.
+
+//! Personal rpc interface.
+use std::sync::Arc;
+use jsonrpc_core::*;
+
+/// Personal rpc interface.
+pub trait Personal: Sized + Send + Sync + 'static {
+
+	/// Lists all stored accounts
+	fn accounts(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Creates new account (it becomes new current unlocked account)
+	fn new_account(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Unlocks specified account for use (can only be one unlocked account at one moment)
+	fn unlock_account(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Should be used to convert object to io delegate.
+	fn to_delegate(self) -> IoDelegate<Self> {
+		let mut delegate = IoDelegate::new(Arc::new(self));
+		delegate.add_method("personal_listAccounts", Personal::accounts);
+		delegate.add_method("personal_newAccount", Personal::new_account);
+		delegate.add_method("personal_unlockAccount", Personal::unlock_account);
+		delegate
+	}
+}

rpc/src/v1/types/mod.rs

@@ -14,22 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-mod block;
-mod block_number;
-mod bytes;
-mod filter;
-mod index;
-mod log;
-mod optionals;
-mod sync;
-mod transaction;
+#[cfg(feature = "serde_macros")]
+include!("mod.rs.in");
 
-pub use self::block::{Block, BlockTransactions};
-pub use self::block_number::BlockNumber;
-pub use self::bytes::Bytes;
-pub use self::filter::Filter;
-pub use self::index::Index;
-pub use self::log::Log;
-pub use self::optionals::OptionalValue;
-pub use self::sync::{SyncStatus, SyncInfo};
-pub use self::transaction::Transaction;
+#[cfg(not(feature = "serde_macros"))]
+include!(concat!(env!("OUT_DIR"), "/mod.rs"));

rpc/src/v1/types/mod.rs.in

@@ -0,0 +1,35 @@
+// 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/>.
+
+mod block;
+mod block_number;
+mod bytes;
+mod filter;
+mod index;
+mod log;
+mod optionals;
+mod sync;
+mod transaction;
+
+pub use self::block::{Block, BlockTransactions};
+pub use self::block_number::BlockNumber;
+pub use self::bytes::Bytes;
+pub use self::filter::Filter;
+pub use self::index::Index;
+pub use self::log::Log;
+pub use self::optionals::OptionalValue;
+pub use self::sync::{SyncStatus, SyncInfo};
+pub use self::transaction::Transaction;