Add IPC support to JSON RPC

Author: kakao-jun-e

Cargo.lock

@@ -67,6 +67,12 @@ args:
  help: Listen for rpc connections on PORT.
  takes_value: true
  default_value: "8080"
+ - ipc-path:
+ long: ipc-path
+ value_name: path
+ help: Specify custom path for JSON-RPC over IPC service.
+ takes_value: true
+ default_value: "/tmp/jsonrpc.ipc"
  - no-jsonrpc:
  long: no-jsonrpc
  help: Do not run jsonrpc.

codechain/codechain.yml

@@ -22,7 +22,7 @@ use cdiscovery::{KademliaConfig, UnstructuredConfig};
 use clap;
 use cnetwork::{NetworkConfig, SocketAddr};
 use ctypes::{Address, Secret};
-use rpc::HttpConfiguration as RpcHttpConfig;
+use rpc::{HttpConfiguration as RpcHttpConfig, IpcConfiguration as RpcIpcConfig};
 use toml;
 
 #[derive(Debug, PartialEq, Deserialize)]
@@ -221,3 +221,15 @@ pub fn parse_rpc_config(matches: &clap::ArgMatches) -> Result<Option<RpcHttpConf
 
  Ok(Some(config))
 }
+
+pub fn parse_rpc_ipc_config(matches: &clap::ArgMatches) -> Result<Option<RpcIpcConfig>, String> {
+ if matches.is_present("no-jsonrpc") {
+ return Ok(None)
+ }
+
+ let socket_addr = value_t_or_exit!(matches, "ipc-path", String);
+
+ Ok(Some(RpcIpcConfig {
+ socket_addr,
+ }))
+}

codechain/config/mod.rs

@@ -63,12 +63,12 @@ use clap::ArgMatches;
 use clogger::LoggerConfig;
 use cnetwork::{NetworkConfig, NetworkService, SocketAddr};
 use creactor::EventLoop;
-use crpc::Server as RpcServer;
+use crpc::{HttpServer, IpcServer};
 use csync::{BlockSyncExtension, ParcelSyncExtension, SnapshotService};
 use ctrlc::CtrlC;
 use fdlimit::raise_fd_limit;
 use parking_lot::{Condvar, Mutex};
-use rpc::HttpConfiguration as RpcHttpConfig;
+use rpc::{HttpConfiguration as RpcHttpConfig, IpcConfiguration as RpcIpcConfig};
 
 #[cfg(feature = "stratum")]
 extern crate stratum;
@@ -80,11 +80,16 @@ pub const APP_INFO: AppInfo = AppInfo {
  author: "Kodebox",
 };
 
-pub fn rpc_start(cfg: RpcHttpConfig, deps: Arc<rpc_apis::ApiDependencies>) -> Result<RpcServer, String> {
+pub fn rpc_start(cfg: RpcHttpConfig, deps: Arc<rpc_apis::ApiDependencies>) -> Result<HttpServer, String> {
  info!("RPC Listening on {}", cfg.port);
  rpc::new_http(cfg, deps)
 }
 
+pub fn rpc_ipc_start(cfg: RpcIpcConfig, deps: Arc<rpc_apis::ApiDependencies>) -> Result<IpcServer, String> {
+ info!("IPC Listening on {}", cfg.socket_addr);
+ rpc::new_ipc(cfg, deps)
+}
+
 pub fn network_start(cfg: &NetworkConfig) -> Result<NetworkService, String> {
  info!("Handshake Listening on {}", cfg.port);
  let address = SocketAddr::v4(127, 0, 0, 1, cfg.port);
@@ -182,6 +187,14 @@ fn run_node(matches: ArgMatches) -> Result<(), String> {
  }
  };
 
+ let _ipc_server = {
+ if let Some(rpc_ipcconfig) = config::parse_rpc_ipc_config(&matches)? {
+ Some(rpc_ipc_start(rpc_ipcconfig, rpc_apis_deps.clone())?)
+ } else {
+ None
+ }
+ };
+
  let _network_service = {
  if let Some(network_config) = config::parse_network_config(&matches)? {
  let service = network_start(&network_config)?;

codechain/main.rs

@@ -18,7 +18,8 @@ use std::io;
 use std::net::SocketAddr;
 use std::sync::Arc;
 
-use crpc::{start_http, Compatibility, MetaIoHandler, Server};
+use crpc::{start_http, start_ipc, HttpServer, IpcServer};
+use crpc::{Compatibility, MetaIoHandler};
 use rpc_apis;
 
 #[derive(Debug, PartialEq)]
@@ -40,7 +41,7 @@ impl HttpConfiguration {
  }
 }
 
-pub fn new_http(cfg: HttpConfiguration, deps: Arc<rpc_apis::ApiDependencies>) -> Result<Server, String> {
+pub fn new_http(cfg: HttpConfiguration, deps: Arc<rpc_apis::ApiDependencies>) -> Result<HttpServer, String> {
  let url = format!("{}:{}", cfg.interface, cfg.port);
  let addr = url.parse().map_err(|_| format!("Invalid JSONRPC listen host/port given: {}", url))?;
  let server = setup_http_rpc_server(&addr, cfg.cors, cfg.hosts, deps)?;
@@ -52,7 +53,7 @@ pub fn setup_http_rpc_server(
  cors_domains: Option<Vec<String>>,
  allowed_hosts: Option<Vec<String>>,
  deps: Arc<rpc_apis::ApiDependencies>,
-) -> Result<Server, String> {
+) -> Result<HttpServer, String> {
  let server = setup_rpc_server(deps);
  let start_result = start_http(url, cors_domains, allowed_hosts, server);
  match start_result {
@@ -64,6 +65,23 @@ pub fn setup_http_rpc_server(
  }
 }
 
+#[derive(Debug, PartialEq)]
+pub struct IpcConfiguration {
+ pub socket_addr: String,
+}
+
+pub fn new_ipc(cfg: IpcConfiguration, deps: Arc<rpc_apis::ApiDependencies>) -> Result<IpcServer, String> {
+ let server = setup_rpc_server(deps);
+ let start_result = start_ipc(&cfg.socket_addr, server);
+ match start_result {
+ Err(ref err) if err.kind() == io::ErrorKind::AddrInUse => {
+ Err(format!("IPC address {} is already in use, make sure that another instance of a Codechain node is not running or change the address using the --ipc-path options.", cfg.socket_addr))
+ },
+ Err(e) => Err(format!("IPC error: {:?}", e)),
+ Ok(server) => Ok(server),
+ }
+}
+
 fn setup_rpc_server(deps: Arc<rpc_apis::ApiDependencies>) -> MetaIoHandler<()> {
  let mut handler = MetaIoHandler::with_compatibility(Compatibility::Both);
  deps.extend_api(&mut handler);

codechain/rpc.rs

@@ -21,4 +21,5 @@ tokio-core = "0.1.1"
 jsonrpc-core = { git = "https://github.com/ethcore/jsonrpc.git" }
 jsonrpc-macros = { git = "https://github.com/ethcore/jsonrpc.git" }
 jsonrpc-http-server = { git = "https://github.com/ethcore/jsonrpc.git" }
+jsonrpc-ipc-server = { git = "https://github.com/ethcore/jsonrpc.git" }
 

rpc/Cargo.toml

@@ -18,6 +18,7 @@ extern crate codechain_core as ccore;
 extern crate codechain_types as ctypes;
 extern crate jsonrpc_core;
 extern crate jsonrpc_http_server;
+extern crate jsonrpc_ipc_server;
 extern crate kvdb;
 extern crate kvdb_rocksdb as rocksdb;
 extern crate log;
@@ -41,5 +42,8 @@ pub use rustc_serialize::hex;
 pub use jsonrpc_core::{Compatibility, Error, MetaIoHandler, Params, Value};
 pub use jsonrpc_http_server::tokio_core::reactor::Remote;
 
-pub use jsonrpc_http_server::Server;
+pub use jsonrpc_http_server::Server as HttpServer;
 pub use rpc_server::start_http;
+
+pub use jsonrpc_ipc_server::Server as IpcServer;
+pub use rpc_server::start_ipc;

rpc/src/lib.rs

@@ -16,7 +16,8 @@
 
 // TODO: panic handler
 use jsonrpc_core;
-use jsonrpc_http_server::{self, Host, Server, ServerBuilder};
+use jsonrpc_http_server::{self, Host, Server as HttpServer, ServerBuilder as HttpServerBuilder};
+use jsonrpc_ipc_server::{Server as IpcServer, ServerBuilder as IpcServerBuilder};
 use std::default::Default;
 use std::io;
 use std::net::SocketAddr;
@@ -27,7 +28,7 @@ pub fn start_http<M: jsonrpc_core::Metadata>(
  cors_domains: Option<Vec<String>>,
  allowed_hosts: Option<Vec<String>>,
  handler: jsonrpc_core::MetaIoHandler<M>,
-) -> Result<Server, io::Error>
+) -> Result<HttpServer, io::Error>
 where
  M: Default, {
  let cors_domains = cors_domains.map(|domains| {
@@ -41,8 +42,18 @@ where
  .collect()
  });
 
- ServerBuilder::new(handler)
+ HttpServerBuilder::new(handler)
  .cors(cors_domains.into())
  .allowed_hosts(allowed_hosts.map(|hosts| hosts.into_iter().map(Host::from).collect()).into())
  .start_http(addr)
 }
+
+/// Start ipc server asynchronously and returns result with `Server` handle on success or an error.
+pub fn start_ipc<M: jsonrpc_core::Metadata>(
+ addr: &str,
+ handler: jsonrpc_core::MetaIoHandler<M>,
+) -> Result<IpcServer, io::Error>
+where
+ M: Default, {
+ IpcServerBuilder::new(handler).start(addr)
+}