Merge branch 'master' into rpc-shared-miner

Conflicts:
	parity/main.rs

rpc/src/v1/impls/ethcore.rs

@@ -16,8 +16,10 @@
 
 //! Ethcore-specific rpc implementation.
 use util::{U256, Address, RotatingLogger};
+use util::network_settings::NetworkSettings;
 use std::sync::{Arc, Weak};
 use std::ops::Deref;
+use std::collections::BTreeMap;
 use jsonrpc_core::*;
 use ethminer::{MinerService};
 use v1::traits::Ethcore;
@@ -28,14 +30,16 @@ pub struct EthcoreClient<M>
 	where M: MinerService {
 	miner: Weak<M>,
 	logger: Arc<RotatingLogger>,
+	settings: Arc<NetworkSettings>,
 }
 
 impl<M> EthcoreClient<M> where M: MinerService {
 	/// Creates new `EthcoreClient`.
-	pub fn new(miner: &Arc<M>, logger: Arc<RotatingLogger>) -> Self {
+	pub fn new(miner: &Arc<M>, logger: Arc<RotatingLogger>, settings: Arc<NetworkSettings>) -> Self {
 		EthcoreClient {
 			miner: Arc::downgrade(miner),
 			logger: logger,
+			settings: settings,
 		}
 	}
 }
@@ -102,4 +106,27 @@ impl<M> Ethcore for EthcoreClient<M> where M: MinerService + 'static {
 		to_value(&self.logger.levels())
 	}
 
+	fn net_chain(&self, _params: Params) -> Result<Value, Error> {
+		to_value(&self.settings.chain)
+	}
+
+	fn net_max_peers(&self, _params: Params) -> Result<Value, Error> {
+		to_value(&self.settings.max_peers)
+	}
+
+	fn net_port(&self, _params: Params) -> Result<Value, Error> {
+		to_value(&self.settings.network_port)
+	}
+
+	fn node_name(&self, _params: Params) -> Result<Value, Error> {
+		to_value(&self.settings.name)
+	}
+
+	fn rpc_settings(&self, _params: Params) -> Result<Value, Error> {
+		let mut map = BTreeMap::new();
+		map.insert("enabled".to_owned(), Value::Bool(self.settings.rpc_enabled));
+		map.insert("interface".to_owned(), Value::String(self.settings.rpc_interface.clone()));
+		map.insert("port".to_owned(), Value::U64(self.settings.rpc_port as u64));
+		Ok(Value::Object(map))
+	}
 }

rpc/src/v1/tests/ethcore.rs

@@ -23,6 +23,7 @@ use v1::tests::helpers::TestMinerService;
 use util::numbers::*;
 use rustc_serialize::hex::FromHex;
 use util::log::RotatingLogger;
+use util::network_settings::NetworkSettings;
 
 
 fn miner_service() -> Arc<TestMinerService> {
@@ -32,10 +33,26 @@ fn logger() -> Arc<RotatingLogger> {
 	Arc::new(RotatingLogger::new("rpc=trace".to_owned()))
 }
 
+fn settings() -> Arc<NetworkSettings> {
+	Arc::new(NetworkSettings {
+		name: "mynode".to_owned(),
+		chain: "testchain".to_owned(),
+		max_peers: 25,
+		network_port: 30303,
+		rpc_enabled: true,
+		rpc_interface: "all".to_owned(),
+		rpc_port: 8545,
+	})
+}
+
+fn ethcore_client(miner: &Arc<TestMinerService>) -> EthcoreClient<TestMinerService> {
+	EthcoreClient::new(&miner, logger(), settings())
+}
+
 #[test]
 fn rpc_ethcore_extra_data() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -49,7 +66,7 @@ fn rpc_ethcore_extra_data() {
 #[test]
 fn rpc_ethcore_gas_floor_target() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -62,7 +79,7 @@ fn rpc_ethcore_gas_floor_target() {
 #[test]
 fn rpc_ethcore_min_gas_price() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -75,7 +92,7 @@ fn rpc_ethcore_min_gas_price() {
 #[test]
 fn rpc_ethcore_set_min_gas_price() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -89,7 +106,7 @@ fn rpc_ethcore_set_min_gas_price() {
 #[test]
 fn rpc_ethcore_set_gas_floor_target() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -103,7 +120,7 @@ fn rpc_ethcore_set_gas_floor_target() {
 #[test]
 fn rpc_ethcore_set_extra_data() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -117,7 +134,7 @@ fn rpc_ethcore_set_extra_data() {
 #[test]
 fn rpc_ethcore_set_author() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -134,7 +151,7 @@ fn rpc_ethcore_dev_logs() {
 	let logger = logger();
 	logger.append("a".to_owned());
 	logger.append("b".to_owned());
-	let ethcore = EthcoreClient::new(&miner, logger.clone()).to_delegate();
+	let ethcore = EthcoreClient::new(&miner, logger.clone(), settings()).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -147,7 +164,7 @@ fn rpc_ethcore_dev_logs() {
 #[test]
 fn rpc_ethcore_dev_logs_levels() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -159,7 +176,7 @@ fn rpc_ethcore_dev_logs_levels() {
 #[test]
 fn rpc_ethcore_set_transactions_limit() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -170,11 +187,10 @@ fn rpc_ethcore_set_transactions_limit() {
 	assert_eq!(miner.transactions_limit(), 10_240_240);
 }
 
-
 #[test]
 fn rpc_ethcore_transactions_limit() {
 	let miner = miner_service();
-	let ethcore = EthcoreClient::new(&miner, logger()).to_delegate();
+	let ethcore = ethcore_client(&miner).to_delegate();
 	let io = IoHandler::new();
 	io.add_delegate(ethcore);
 
@@ -183,3 +199,68 @@ fn rpc_ethcore_transactions_limit() {
 
 	assert_eq!(io.handle_request(request), Some(response.to_owned()));
 }
+
+#[test]
+fn rpc_ethcore_net_chain() {
+	let miner = miner_service();
+	let ethcore = ethcore_client(&miner).to_delegate();
+	let io = IoHandler::new();
+	io.add_delegate(ethcore);
+
+	let request = r#"{"jsonrpc": "2.0", "method": "ethcore_netChain", "params":[], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"testchain","id":1}"#;
+
+	assert_eq!(io.handle_request(request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_ethcore_net_max_peers() {
+	let miner = miner_service();
+	let ethcore = ethcore_client(&miner).to_delegate();
+	let io = IoHandler::new();
+	io.add_delegate(ethcore);
+
+	let request = r#"{"jsonrpc": "2.0", "method": "ethcore_netMaxPeers", "params":[], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":25,"id":1}"#;
+
+	assert_eq!(io.handle_request(request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_ethcore_net_port() {
+	let miner = miner_service();
+	let ethcore = ethcore_client(&miner).to_delegate();
+	let io = IoHandler::new();
+	io.add_delegate(ethcore);
+
+	let request = r#"{"jsonrpc": "2.0", "method": "ethcore_netPort", "params":[], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":30303,"id":1}"#;
+
+	assert_eq!(io.handle_request(request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_ethcore_rpc_settings() {
+	let miner = miner_service();
+	let ethcore = ethcore_client(&miner).to_delegate();
+	let io = IoHandler::new();
+	io.add_delegate(ethcore);
+
+	let request = r#"{"jsonrpc": "2.0", "method": "ethcore_rpcSettings", "params":[], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":{"enabled":true,"interface":"all","port":8545},"id":1}"#;
+
+	assert_eq!(io.handle_request(request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_ethcore_node_name() {
+	let miner = miner_service();
+	let ethcore = ethcore_client(&miner).to_delegate();
+	let io = IoHandler::new();
+	io.add_delegate(ethcore);
+
+	let request = r#"{"jsonrpc": "2.0", "method": "ethcore_nodeName", "params":[], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"mynode","id":1}"#;
+
+	assert_eq!(io.handle_request(request), Some(response.to_owned()));
+}

rpc/src/v1/traits/ethcore.rs

@@ -54,6 +54,21 @@ pub trait Ethcore: Sized + Send + Sync + 'static {
 	/// Returns logs levels
 	fn dev_logs_levels(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 
+	/// Returns chain name
+	fn net_chain(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns max peers
+	fn net_max_peers(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns network port
+	fn net_port(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns rpc settings
+	fn rpc_settings(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns node name
+	fn node_name(&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));
@@ -69,6 +84,11 @@ pub trait Ethcore: Sized + Send + Sync + 'static {
 		delegate.add_method("ethcore_transactionsLimit", Ethcore::transactions_limit);
 		delegate.add_method("ethcore_devLogs", Ethcore::dev_logs);
 		delegate.add_method("ethcore_devLogsLevels", Ethcore::dev_logs_levels);
+		delegate.add_method("ethcore_netChain", Ethcore::net_chain);
+		delegate.add_method("ethcore_netMaxPeers", Ethcore::net_max_peers);
+		delegate.add_method("ethcore_netPort", Ethcore::net_port);
+		delegate.add_method("ethcore_rpcSettings", Ethcore::rpc_settings);
+		delegate.add_method("ethcore_nodeName", Ethcore::node_name);
 
 		delegate
 	}