Merge github.com:paritytech/parity into block_header_rpc

rpc/Cargo.toml

@@ -21,6 +21,7 @@ transient-hashmap = "0.4"
 
 jsonrpc-core = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.7" }
 jsonrpc-http-server = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.7" }
+jsonrpc-minihttp-server = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.7" }
 jsonrpc-ipc-server = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.7" }
 jsonrpc-macros = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.7" }
 

rpc/src/lib.rs

@@ -29,8 +29,9 @@ extern crate time;
 extern crate transient_hashmap;
 
 extern crate jsonrpc_core;
-pub extern crate jsonrpc_http_server as http;
-pub extern crate jsonrpc_ipc_server as ipc;
+extern crate jsonrpc_http_server as http;
+extern crate jsonrpc_minihttp_server as minihttp;
+extern crate jsonrpc_ipc_server as ipc;
 
 extern crate ethash;
 extern crate ethcore;
@@ -62,10 +63,15 @@ extern crate ethjson;
 #[cfg(test)]
 extern crate ethcore_devtools as devtools;
 
+mod metadata;
 pub mod v1;
 
 pub use ipc::{Server as IpcServer, MetaExtractor as IpcMetaExtractor, RequestContext as IpcRequestContext};
-pub use http::{HttpMetaExtractor, Server as HttpServer, Error as HttpServerError, AccessControlAllowOrigin, Host};
+pub use http::{
+	hyper,
+	RequestMiddleware, RequestMiddlewareAction,
+	AccessControlAllowOrigin, Host,
+};
 
 pub use v1::{SigningQueue, SignerService, ConfirmationsQueue, NetworkSettings, Metadata, Origin, informant, dispatch};
 pub use v1::block_import::is_major_importing;
@@ -73,26 +79,98 @@ pub use v1::block_import::is_major_importing;
 use std::net::SocketAddr;
 use http::tokio_core;
 
+/// RPC HTTP Server instance
+pub enum HttpServer {
+	/// Fast MiniHTTP variant
+	Mini(minihttp::Server),
+	/// Hyper variant
+	Hyper(http::Server),
+}
+
+/// RPC HTTP Server error
+#[derive(Debug)]
+pub enum HttpServerError {
+	/// IO error
+	Io(::std::io::Error),
+	/// Other hyper error
+	Hyper(hyper::Error),
+}
+
+impl From<http::Error> for HttpServerError {
+	fn from(e: http::Error) -> Self {
+		use self::HttpServerError::*;
+		match e {
+			http::Error::Io(io) => Io(io),
+			http::Error::Other(hyper) => Hyper(hyper),
+		}
+	}
+}
+
+impl From<minihttp::Error> for HttpServerError {
+	fn from(e: minihttp::Error) -> Self {
+		use self::HttpServerError::*;
+		match e {
+			minihttp::Error::Io(io) => Io(io),
+		}
+	}
+}
+
+/// HTTP RPC server impl-independent metadata extractor
+pub trait HttpMetaExtractor: Send + Sync + 'static {
+	/// Type of Metadata
+	type Metadata: jsonrpc_core::Metadata;
+	/// Extracts metadata from given params.
+	fn read_metadata(&self, origin: String, dapps_origin: Option<String>) -> Self::Metadata;
+}
+
+/// HTTP server implementation-specific settings.
+pub enum HttpSettings<R: RequestMiddleware> {
+	/// Enable fast minihttp server with given number of threads.
+	Threads(usize),
+	/// Enable standard server with optional dapps middleware.
+	Dapps(Option<R>),
+}
+
 /// Start http server asynchronously and returns result with `Server` handle on success or an error.
-pub fn start_http<M, S, H, T>(
+pub fn start_http<M, S, H, T, R>(
 	addr: &SocketAddr,
 	cors_domains: http::DomainsValidation<http::AccessControlAllowOrigin>,
 	allowed_hosts: http::DomainsValidation<http::Host>,
 	handler: H,
 	remote: tokio_core::reactor::Remote,
 	extractor: T,
+	settings: HttpSettings<R>,
 ) -> Result<HttpServer, HttpServerError> where
 	M: jsonrpc_core::Metadata,
 	S: jsonrpc_core::Middleware<M>,
 	H: Into<jsonrpc_core::MetaIoHandler<M, S>>,
-	T: HttpMetaExtractor<M>,
+	T: HttpMetaExtractor<Metadata=M>,
+	R: RequestMiddleware,
 {
-	http::ServerBuilder::new(handler)
-		.event_loop_remote(remote)
-		.meta_extractor(extractor)
-		.cors(cors_domains.into())
-		.allowed_hosts(allowed_hosts.into())
-		.start_http(addr)
+	Ok(match settings {
+		HttpSettings::Dapps(middleware) => {
+			let mut builder = http::ServerBuilder::new(handler)
+				.event_loop_remote(remote)
+				.meta_extractor(metadata::HyperMetaExtractor::new(extractor))
+				.cors(cors_domains.into())
+				.allowed_hosts(allowed_hosts.into());
+
+			if let Some(dapps) = middleware {
+				builder = builder.request_middleware(dapps)
+			}
+			builder.start_http(addr)
+				.map(HttpServer::Hyper)?
+		},
+		HttpSettings::Threads(threads) => {
+			minihttp::ServerBuilder::new(handler)
+				.threads(threads)
+				.meta_extractor(metadata::MiniMetaExtractor::new(extractor))
+				.cors(cors_domains.into())
+				.allowed_hosts(allowed_hosts.into())
+				.start_http(addr)
+				.map(HttpServer::Mini)?
+		},
+	})
 }
 
 /// Start ipc server asynchronously and returns result with `Server` handle on success or an error.

rpc/src/metadata.rs

@@ -0,0 +1,74 @@
+// Copyright 2015-2017 Parity Technologies (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/>.
+
+use jsonrpc_core;
+use http;
+use hyper;
+use minihttp;
+use HttpMetaExtractor;
+
+pub struct HyperMetaExtractor<T> {
+	extractor: T,
+}
+
+impl<T> HyperMetaExtractor<T> {
+	pub fn new(extractor: T) -> Self {
+		HyperMetaExtractor {
+			extractor: extractor,
+		}
+	}
+}
+
+impl<M, T> http::MetaExtractor<M> for HyperMetaExtractor<T> where
+	T: HttpMetaExtractor<Metadata = M>,
+	M: jsonrpc_core::Metadata,
+{
+	fn read_metadata(&self, req: &hyper::server::Request<hyper::net::HttpStream>) -> M {
+		let origin = req.headers().get::<hyper::header::Origin>()
+			.map(|origin| format!("{}://{}", origin.scheme, origin.host))
+			.unwrap_or_else(|| "unknown".into());
+		let dapps_origin = req.headers().get_raw("x-parity-origin")
+			.and_then(|raw| raw.one())
+			.map(|raw| String::from_utf8_lossy(raw).into_owned());
+		self.extractor.read_metadata(origin, dapps_origin)
+	}
+}
+
+pub struct MiniMetaExtractor<T> {
+	extractor: T,
+}
+
+impl<T> MiniMetaExtractor<T> {
+	pub fn new(extractor: T) -> Self {
+		MiniMetaExtractor {
+			extractor: extractor,
+		}
+	}
+}
+
+impl<M, T> minihttp::MetaExtractor<M> for MiniMetaExtractor<T> where
+	T: HttpMetaExtractor<Metadata = M>,
+	M: jsonrpc_core::Metadata,
+{
+	fn read_metadata(&self, req: &minihttp::Req) -> M {
+		let origin = req.header("origin")
+			.unwrap_or_else(|| "unknown")
+			.to_owned();
+		let dapps_origin = req.header("x-parity-origin").map(|h| h.to_owned());
+
+		self.extractor.read_metadata(origin, dapps_origin)
+	}
+}

rpc/src/v1/helpers/dispatch.rs

@@ -207,7 +207,6 @@ pub fn fetch_gas_price_corpus(
 }
 
 /// Dispatcher for light clients -- fetches default gas price, next nonce, etc. from network.
-/// Light client `ETH` RPC.
 #[derive(Clone)]
 pub struct LightDispatcher {
 	/// Sync service.

rpc/src/v1/impls/light/eth.rs

@@ -108,7 +108,22 @@ impl Eth for EthClient {
 	}
 
 	fn syncing(&self) -> Result<SyncStatus, Error> {
-		rpc_unimplemented!()
+		if self.sync.is_major_importing() {
+			let chain_info = self.client.chain_info();
+			let current_block = U256::from(chain_info.best_block_number);
+			let highest_block = self.sync.highest_block().map(U256::from)
+				.unwrap_or_else(|| current_block.clone());
+
+			Ok(SyncStatus::Info(SyncInfo {
+				starting_block: U256::from(self.sync.start_block()).into(),
+				current_block: current_block.into(),
+				highest_block: highest_block.into(),
+				warp_chunks_amount: None,
+				warp_chunks_processed: None,
+			}))
+		} else {
+			Ok(SyncStatus::None)
+		}
 	}
 
 	fn author(&self, _meta: Self::Metadata) -> BoxFuture<RpcH160, Error> {

rpc/src/v1/impls/light/mod.rs

@@ -23,7 +23,10 @@ pub mod eth;
 pub mod parity;
 pub mod parity_set;
 pub mod trace;
+pub mod net;
 
 pub use self::eth::EthClient;
 pub use self::parity::ParityClient;
 pub use self::parity_set::ParitySetClient;
+pub use self::net::NetClient;
+pub use self::trace::TracesClient;

rpc/src/v1/impls/light/net.rs

@@ -0,0 +1,49 @@
+// Copyright 2015-2017 Parity Technologies (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/>.
+
+//! Net rpc implementation.
+use std::sync::Arc;
+use jsonrpc_core::Error;
+use ethsync::LightSyncProvider;
+use v1::traits::Net;
+
+/// Net rpc implementation.
+pub struct NetClient<S: ?Sized> {
+	sync: Arc<S>
+}
+
+impl<S: ?Sized> NetClient<S> where S: LightSyncProvider {
+	/// Creates new NetClient.
+	pub fn new(sync: Arc<S>) -> Self {
+		NetClient {
+			sync: sync,
+		}
+	}
+}
+
+impl<S: ?Sized + Sync + Send + 'static> Net for NetClient<S> where S: LightSyncProvider {
+	fn version(&self) -> Result<String, Error> {
+		Ok(format!("{}", self.sync.network_id()).to_owned())
+	}
+
+	fn peer_count(&self) -> Result<String, Error> {
+		Ok(format!("0x{:x}", self.sync.peer_numbers().connected as u64).to_owned())
+	}
+
+	fn is_listening(&self) -> Result<bool, Error> {
+		Ok(true)
+	}
+}

rpc/src/v1/impls/net.rs

@@ -21,7 +21,7 @@ use ethsync::SyncProvider;
 use v1::traits::Net;
 
 /// Net rpc implementation.
-pub struct NetClient<S: ?Sized> where S: SyncProvider {
+pub struct NetClient<S: ?Sized> {
 	sync: Weak<S>
 }
 

rpc/src/v1/tests/helpers/sync_provider.rs

@@ -83,7 +83,7 @@ impl SyncProvider for TestSyncProvider {
 					difficulty: Some(40.into()),
 					head: 50.into(),
 				}),
-				les_info: None,
+				pip_info: None,
 			},
 			PeerInfo {
 				id: None,
@@ -96,7 +96,7 @@ impl SyncProvider for TestSyncProvider {
 					difficulty: None,
 					head: 60.into()
 				}),
-				les_info: None,
+				pip_info: None,
 			}
 		]
 	}

rpc/src/v1/tests/mocked/parity.rs

@@ -304,7 +304,7 @@ fn rpc_parity_net_peers() {
 	let io = deps.default_client();
 
 	let request = r#"{"jsonrpc": "2.0", "method": "parity_netPeers", "params":[], "id": 1}"#;
-	let response = r#"{"jsonrpc":"2.0","result":{"active":0,"connected":120,"max":50,"peers":[{"caps":["eth/62","eth/63"],"id":"node1","name":"Parity/1","network":{"localAddress":"127.0.0.1:8888","remoteAddress":"127.0.0.1:7777"},"protocols":{"eth":{"difficulty":"0x28","head":"0000000000000000000000000000000000000000000000000000000000000032","version":62},"les":null}},{"caps":["eth/63","eth/64"],"id":null,"name":"Parity/2","network":{"localAddress":"127.0.0.1:3333","remoteAddress":"Handshake"},"protocols":{"eth":{"difficulty":null,"head":"000000000000000000000000000000000000000000000000000000000000003c","version":64},"les":null}}]},"id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":{"active":0,"connected":120,"max":50,"peers":[{"caps":["eth/62","eth/63"],"id":"node1","name":"Parity/1","network":{"localAddress":"127.0.0.1:8888","remoteAddress":"127.0.0.1:7777"},"protocols":{"eth":{"difficulty":"0x28","head":"0000000000000000000000000000000000000000000000000000000000000032","version":62},"pip":null}},{"caps":["eth/63","eth/64"],"id":null,"name":"Parity/2","network":{"localAddress":"127.0.0.1:3333","remoteAddress":"Handshake"},"protocols":{"eth":{"difficulty":null,"head":"000000000000000000000000000000000000000000000000000000000000003c","version":64},"pip":null}}]},"id":1}"#;
 
 	assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
 }

rpc/src/v1/types/mod.rs

@@ -65,7 +65,7 @@ pub use self::receipt::Receipt;
 pub use self::rpc_settings::RpcSettings;
 pub use self::sync::{
 	SyncStatus, SyncInfo, Peers, PeerInfo, PeerNetworkInfo, PeerProtocolsInfo,
-	TransactionStats, ChainStatus, EthProtocolInfo, LesProtocolInfo,
+	TransactionStats, ChainStatus, EthProtocolInfo, PipProtocolInfo,
 };
 pub use self::trace::{LocalizedTrace, TraceResults};
 pub use self::trace_filter::TraceFilter;

rpc/src/v1/types/sync.rs

@@ -83,8 +83,8 @@ pub struct PeerNetworkInfo {
 pub struct PeerProtocolsInfo {
 	/// Ethereum protocol information
 	pub eth: Option<EthProtocolInfo>,
-	/// LES protocol information.
-	pub les: Option<LesProtocolInfo>,
+	/// PIP protocol information.
+	pub pip: Option<PipProtocolInfo>,
 }
 
 /// Peer Ethereum protocol information
@@ -108,10 +108,10 @@ impl From<ethsync::EthProtocolInfo> for EthProtocolInfo {
 	}
 }
 
-/// Peer LES protocol information
+/// Peer PIP protocol information
 #[derive(Default, Debug, Serialize)]
-pub struct LesProtocolInfo {
-	/// Negotiated LES protocol version
+pub struct PipProtocolInfo {
+	/// Negotiated PIP protocol version
 	pub version: u32,
 	/// Peer total difficulty
 	pub difficulty: U256,
@@ -119,9 +119,9 @@ pub struct LesProtocolInfo {
 	pub head: String,
 }
 
-impl From<ethsync::LesProtocolInfo> for LesProtocolInfo {
-	fn from(info: ethsync::LesProtocolInfo) -> Self {
-		LesProtocolInfo {
+impl From<ethsync::PipProtocolInfo> for PipProtocolInfo {
+	fn from(info: ethsync::PipProtocolInfo) -> Self {
+		PipProtocolInfo {
 			version: info.version,
 			difficulty: info.difficulty.into(),
 			head: info.head.hex(),
@@ -171,7 +171,7 @@ impl From<SyncPeerInfo> for PeerInfo {
 			},
 			protocols: PeerProtocolsInfo {
 				eth: p.eth_info.map(Into::into),
-				les: p.les_info.map(Into::into),
+				pip: p.pip_info.map(Into::into),
 			},
 		}
 	}