Merge branch 'master' into lightcli

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)
+	}
+}