JSON-RPC over IPC (#1039)

* moving namespaces for http/rpc

* cli options for ipc

* jsonrpc exposed fully

* updating json-ipc-server & removing non-standart traces api from defaults

* spelling & format

parity/cli.rs

@@ -84,6 +84,12 @@ API and Console Options:
   --webapp-pass PASSWORD   Specify password for WebApps server. Use only in
                            conjunction with --webapp-user.
 
+  --ipc-disable            Disable JSON-RPC over IPC service
+  --ipc-path PATH          Specify custom path for IPC service
+                           [default: $HOME/.parity/jsonrpc.ipc]
+  --ipc-api APIS           Specify custom API set available via IPC service
+                           [default: web3,eth,net,personal,ethcore]
+
 Sealing/Mining Options:
   --force-sealing          Force the node to author new blocks as if it were
                            always sealing/mining.
@@ -197,6 +203,9 @@ pub struct Args {
 	pub flag_tx_limit: usize,
 	pub flag_logging: Option<String>,
 	pub flag_version: bool,
+	pub flag_ipc_disable: bool,
+	pub flag_ipc_path: String,
+	pub flag_ipc_api: String,
 	// geth-compatibility...
 	pub flag_nodekey: Option<String>,
 	pub flag_nodiscover: bool,

parity/configuration.rs

@@ -31,6 +31,7 @@ use ethcore::ethereum;
 use ethcore::spec::Spec;
 use ethsync::SyncConfig;
 use price_info::PriceInfo;
+use rpc::IpcConfiguration;
 
 pub struct Configuration {
 	pub args: Args
@@ -266,6 +267,15 @@ impl Configuration {
 		self.args.flag_jsonrpc_cors.clone().or(self.args.flag_rpccorsdomain.clone())
 	}
 
+	pub fn ipc_settings(&self) -> IpcConfiguration {
+		IpcConfiguration {
+			enabled: !self.args.flag_ipc_disable,
+			socket_addr: self.args.flag_ipc_path.clone()
+				.replace("$HOME", env::home_dir().unwrap().to_str().unwrap()),
+			apis: self.args.flag_ipc_api.clone(),
+		}
+	}
+
 	pub fn network_settings(&self) -> NetworkSettings {
 		NetworkSettings {
 			name: self.args.flag_identity.clone(),

parity/main.rs

@@ -44,6 +44,7 @@ extern crate serde;
 extern crate bincode;
 #[macro_use]
 extern crate hyper; // for price_info.rs
+extern crate json_ipc_server as jsonipc;
 
 #[cfg(feature = "rpc")]
 extern crate ethcore_rpc;
@@ -159,14 +160,7 @@ fn execute_client(conf: Configuration) {
 	// Sync
 	let sync = EthSync::register(service.network(), sync_config, client.clone(), miner.clone());
 
-	// Setup rpc
-	let rpc_server = rpc::new(rpc::Configuration {
-		enabled: network_settings.rpc_enabled,
-		interface: network_settings.rpc_interface.clone(),
-		port: network_settings.rpc_port,
-		apis: conf.rpc_apis(),
-		cors: conf.rpc_cors(),
-	}, rpc::Dependencies {
+	let dependencies = Arc::new(rpc::Dependencies {
 		panic_handler: panic_handler.clone(),
 		client: client.clone(),
 		sync: sync.clone(),
@@ -177,6 +171,18 @@ fn execute_client(conf: Configuration) {
 		settings: network_settings.clone(),
 	});
 
+	// Setup http rpc
+	let rpc_server = rpc::new_http(rpc::HttpConfiguration {
+		enabled: network_settings.rpc_enabled,
+		interface: network_settings.rpc_interface.clone(),
+		port: network_settings.rpc_port,
+		apis: conf.rpc_apis(),
+		cors: conf.rpc_cors(),
+	}, &dependencies);
+
+	// setup ipc rpc
+	let ipc_server = rpc::new_ipc(conf.ipc_settings(), &dependencies);
+
 	let webapp_server = webapp::new(webapp::Configuration {
 		enabled: conf.args.flag_webapp,
 		interface: conf.args.flag_webapp_interface.clone(),

parity/rpc.rs

@@ -27,6 +27,7 @@ use util::panics::PanicHandler;
 use util::keys::store::{AccountService};
 use util::network_settings::NetworkSettings;
 use die::*;
+use jsonipc;
 
 #[cfg(feature = "rpc")]
 pub use ethcore_rpc::Server as RpcServer;
@@ -35,7 +36,7 @@ use ethcore_rpc::{RpcServerError, RpcServer as Server};
 #[cfg(not(feature = "rpc"))]
 pub struct RpcServer;
 
-pub struct Configuration {
+pub struct HttpConfiguration {
 	pub enabled: bool,
 	pub interface: String,
 	pub port: u16,
@@ -43,6 +44,12 @@ pub struct Configuration {
 	pub cors: Option<String>,
 }
 
+pub struct IpcConfiguration {
+	pub enabled: bool,
+	pub socket_addr: String,
+	pub apis: String,
+}
+
 pub struct Dependencies {
 	pub panic_handler: Arc<PanicHandler>,
 	pub client: Arc<Client>,
@@ -54,7 +61,7 @@ pub struct Dependencies {
 	pub settings: Arc<NetworkSettings>,
 }
 
-pub fn new(conf: Configuration, deps: Dependencies) -> Option<RpcServer> {
+pub fn new_http(conf: HttpConfiguration, deps: &Arc<Dependencies>) -> Option<RpcServer> {
 	if !conf.enabled {
 		return None;
 	}
@@ -68,26 +75,16 @@ pub fn new(conf: Configuration, deps: Dependencies) -> Option<RpcServer> {
 	let url = format!("{}:{}", interface, conf.port);
 	let addr = SocketAddr::from_str(&url).unwrap_or_else(|_| die!("{}: Invalid JSONRPC listen host/port given.", url));
 
-	Some(setup_rpc_server(deps, &addr, conf.cors, apis))
+	Some(setup_http_rpc_server(deps, &addr, conf.cors, apis))
 }
 
-#[cfg(not(feature = "rpc"))]
-pub fn setup_rpc_server(
-	_deps: Dependencies,
-	_url: &SocketAddr,
-	_cors_domain: Option<String>,
-	_apis: Vec<&str>,
-) -> ! {
-	die!("Your Parity version has been compiled without JSON-RPC support.")
+pub fn new_ipc(conf: IpcConfiguration, deps: &Arc<Dependencies>) -> Option<jsonipc::Server> {
+	if !conf.enabled { return None; }
+	let apis = conf.apis.split(',').collect();
+	Some(setup_ipc_rpc_server(deps, &conf.socket_addr, apis))
 }
 
-#[cfg(feature = "rpc")]
-pub fn setup_rpc_server(
-	deps: Dependencies,
-	url: &SocketAddr,
-	cors_domain: Option<String>,
-	apis: Vec<&str>,
-) -> RpcServer {
+fn setup_rpc_server(apis: Vec<&str>, deps: &Arc<Dependencies>) -> Server {
 	use ethcore_rpc::v1::*;
 
 	let server = Server::new();
@@ -125,7 +122,29 @@ pub fn setup_rpc_server(
 		}
 	}
 	server.add_delegate(RpcClient::new(modules).to_delegate());
+	server
+}
+
+#[cfg(not(feature = "rpc"))]
+pub fn setup_http_rpc_server(
+	_deps: Dependencies,
+	_url: &SocketAddr,
+	_cors_domain: Option<String>,
+	_apis: Vec<&str>,
+) -> ! {
+	die!("Your Parity version has been compiled without JSON-RPC support.")
+}
+
+#[cfg(feature = "rpc")]
+pub fn setup_http_rpc_server(
+	dependencies: &Arc<Dependencies>,
+	url: &SocketAddr,
+	cors_domain: Option<String>,
+	apis: Vec<&str>,
+) -> RpcServer {
+	let server = setup_rpc_server(apis, dependencies);
 	let start_result = server.start_http(url, cors_domain);
+	let deps = dependencies.clone();
 	match start_result {
 		Err(RpcServerError::IoError(err)) => die_with_io_error("RPC", err),
 		Err(e) => die!("RPC: {:?}", e),
@@ -138,3 +157,11 @@ pub fn setup_rpc_server(
 	}
 }
 
+pub fn setup_ipc_rpc_server(dependencies: &Arc<Dependencies>, addr: &str, apis: Vec<&str>) -> jsonipc::Server {
+	let server = setup_rpc_server(apis, dependencies);
+	match server.start_ipc(addr) {
+		Err(jsonipc::Error::Io(io_error)) => die_with_io_error("RPC", io_error),
+		Err(any_error) => die!("RPC: {:?}", any_error),
+		Ok(server) => server
+	}
+}