Introduce error_chain (#215)

* Use error-chain for ws server.

* Error chain for http.

* Get rid of error wrapper for minihttp.

* Add jsonrpc_core::Result.

* Fix crate use.

* Add comments.

* Make ws error more abstract.

* Remove explicit message type.

Author: tomusdrw

README.md

@@ -71,19 +71,19 @@ extern crate jsonrpc_core;
 #[macro_use]
 extern crate jsonrpc_macros;
 
-use jsonrpc_core::Error;
+use jsonrpc_core::Result;
 
 build_rpc_trait! {
 	pub trait Rpc {
 		/// Adds two numbers and returns a result
 		#[rpc(name = "add")]
-		fn add(&self, u64, u64) -> Result<u64, Error>;
+		fn add(&self, u64, u64) -> Result<u64>;
 	}
 }
 
 pub struct RpcImpl;
 impl Rpc for RpcImpl {
-	fn add(&self, a: u64, b: u64) -> Result<u64, Error> {
+	fn add(&self, a: u64, b: u64) -> Result<u64> {
 		Ok(a + b)
 	}
 }

core/src/calls.rs

@@ -18,7 +18,7 @@ pub trait RpcMethodSimple: Send + Sync + 'static {
 /// Asynchronous Method with Metadata
 pub trait RpcMethod<T: Metadata>: Send + Sync + 'static {
 	/// Call method
-	fn call(&self, params: Params, meta: T) -> BoxFuture<Value, Error>;
+	fn call(&self, params: Params, meta: T) -> BoxFuture<Value>;
 }
 
 /// Notification
@@ -69,7 +69,7 @@ impl<F: Send + Sync + 'static, X: Send + 'static, T, I> RpcMethod<T> for F where
 	I: IntoFuture<Item = Value, Error = Error, Future = X>,
 	X: Future<Item = Value, Error = Error>,
 {
-	fn call(&self, params: Params, meta: T) -> BoxFuture<Value, Error> {
+	fn call(&self, params: Params, meta: T) -> BoxFuture<Value> {
 		Box::new(self(params, meta).into_future())
 	}
 }

core/src/io.rs

@@ -9,10 +9,9 @@ use calls::{RemoteProcedure, Metadata, RpcMethodSimple, RpcMethod, RpcNotificati
 use middleware::{self, Middleware};
 use types::{Params, Error, ErrorCode, Version};
 use types::{Request, Response, Call, Output};
-use BoxFuture;
 
 /// A type representing middleware or RPC response before serialization.
-pub type FutureResponse = BoxFuture<Option<Response>, ()>;
+pub type FutureResponse = Box<Future<Item=Option<Response>, Error=()> + Send>;
 
 /// A type representing future string response.
 pub type FutureResult<F> = future::Map<
@@ -22,7 +21,7 @@ pub type FutureResult<F> = future::Map<
 
 /// A type representing a result of a single method call.
 pub type FutureOutput = future::Either<
-	BoxFuture<Option<Output>, ()>,
+	Box<Future<Item=Option<Output>, Error=()> + Send>,
 	future::FutureResult<Option<Output>, ()>,
 >;
 

core/src/lib.rs

@@ -39,7 +39,10 @@ mod middleware;
 pub mod types;
 
 /// A `Future` trait object.
-pub type BoxFuture<T, E> = Box<futures::Future<Item = T, Error = E> + Send>;
+pub type BoxFuture<T> = Box<futures::Future<Item = T, Error = Error> + Send>;
+
+/// A Result type.
+pub type Result<T> = ::std::result::Result<T, Error>;
 
 pub use calls::{RemoteProcedure, Metadata, RpcMethodSimple, RpcMethod, RpcNotificationSimple, RpcNotification};
 pub use io::{Compatibility, IoHandler, MetaIoHandler, FutureResponse, FutureResult};

core/src/middleware.rs

@@ -3,7 +3,6 @@
 use calls::Metadata;
 use types::{Request, Response};
 use futures::Future;
-use BoxFuture;
 
 /// RPC middleware
 pub trait Middleware<M: Metadata>: Send + Sync + 'static {
@@ -22,7 +21,7 @@ pub trait Middleware<M: Metadata>: Send + Sync + 'static {
 #[derive(Default)]
 pub struct Noop;
 impl<M: Metadata> Middleware<M> for Noop {
-	type Future = BoxFuture<Option<Response>, ()>;
+	type Future = Box<Future<Item=Option<Response>, Error=()> + Send>;
 
 	fn on_request<F, X>(&self, request: Request, meta: M, process: F) -> Self::Future where
 		F: FnOnce(Request, M) -> X + Send,

core/src/types/response.rs

@@ -3,6 +3,7 @@ use serde::de::{Deserialize, Deserializer, Error as DeError};
 use serde::ser::{Serialize, Serializer};
 use serde_json::value::from_value;
 use super::{Id, Value, Error, ErrorCode, Version};
+use {Result as CoreResult};
 
 /// Successful response
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -39,7 +40,7 @@ pub enum Output {
 
 impl Output {
 	/// Creates new output given `Result`, `Id` and `Version`.
-	pub fn from(result: Result<Value, Error>, id: Id, jsonrpc: Option<Version>) -> Self {
+	pub fn from(result: CoreResult<Value>, id: Id, jsonrpc: Option<Version>) -> Self {
 		match result {
 			Ok(result) => Output::Success(Success {
 				id: id,
@@ -80,9 +81,9 @@ impl Output {
 	}
 }
 
-impl From<Output> for Result<Value, Error> {
+impl From<Output> for CoreResult<Value> {
 	/// Convert into a result. Will be `Ok` if it is a `Success` and `Err` if `Failure`.
-	fn from(output: Output) -> Result<Value, Error> {
+	fn from(output: Output) -> CoreResult<Value> {
 		match output {
 			Output::Success(s) => Ok(s.result),
 			Output::Failure(f) => Err(f.error),

http/Cargo.toml

@@ -10,11 +10,11 @@ keywords = ["jsonrpc", "json-rpc", "json", "rpc", "server"]
 documentation = "https://paritytech.github.io/jsonrpc/jsonrpc_http_server/index.html"
 
 [dependencies]
-log = "0.3"
-net2 = "0.2"
+hyper = "0.11"
 jsonrpc-core = { version = "8.0", path = "../core" }
 jsonrpc-server-utils = { version = "8.0", path = "../server-utils" }
-hyper = "0.11"
+log = "0.3"
+net2 = "0.2"
 unicase = "2.0"
 
 [badges]

http/src/handler.rs

@@ -7,7 +7,7 @@ use hyper::{self, mime, server, Method};
 use hyper::header::{self, Headers};
 use unicase::Ascii;
 
-use jsonrpc::{self as core, FutureResult, BoxFuture, Metadata, Middleware, NoopMiddleware};
+use jsonrpc::{self as core, FutureResult, Metadata, Middleware, NoopMiddleware};
 use jsonrpc::futures::{Future, Poll, Async, Stream, future};
 use jsonrpc::serde_json;
 use response::Response;
@@ -90,7 +90,7 @@ impl<M: Metadata, S: Middleware<M>> server::Service for ServerHandler<M, S> {
 pub enum Handler<M: Metadata, S: Middleware<M>> {
 	Rpc(RpcHandler<M, S>),
 	Error(Option<Response>),
-	Middleware(BoxFuture<server::Response, hyper::Error>),
+	Middleware(Box<Future<Item=server::Response, Error=hyper::Error> + Send>),
 }
 
 impl<M: Metadata, S: Middleware<M>> Future for Handler<M, S> {

http/src/lib.rs

@@ -19,26 +19,28 @@
 
 #![warn(missing_docs)]
 
-#[macro_use] extern crate log;
 extern crate unicase;
 extern crate jsonrpc_core as jsonrpc;
 extern crate jsonrpc_server_utils as server_utils;
 extern crate net2;
 
 pub extern crate hyper;
 
-mod response;
+#[macro_use]
+extern crate log;
+
 mod handler;
+mod response;
 mod utils;
 #[cfg(test)]
 mod tests;
 
-use std::{fmt, io};
+use std::io;
 use std::sync::{mpsc, Arc};
 use std::net::SocketAddr;
 
 use hyper::server;
-use jsonrpc::{BoxFuture, MetaIoHandler};
+use jsonrpc::MetaIoHandler;
 use jsonrpc::futures::{self, Future, Stream};
 use jsonrpc::futures::sync::oneshot;
 use server_utils::reactor::{Remote, UninitializedRemote};
@@ -50,55 +52,6 @@ pub use handler::ServerHandler;
 pub use utils::{is_host_allowed, cors_header, CorsHeader};
 pub use response::Response;
 
-/// Result of starting the Server.
-pub type ServerResult = Result<Server, Error>;
-
-/// RPC Server startup error.
-#[derive(Debug)]
-pub enum Error {
-	/// IO Error
-	Io(std::io::Error),
-	/// Other Error (hyper)
-	Other(hyper::error::Error),
-}
-
-impl From<std::io::Error> for Error {
-	fn from(err: std::io::Error) -> Self {
-		Error::Io(err)
-	}
-}
-
-impl From<hyper::error::Error> for Error {
-	fn from(err: hyper::error::Error) -> Self {
-		match err {
-			hyper::error::Error::Io(e) => Error::Io(e),
-			e => Error::Other(e)
-		}
-	}
-}
-
-impl fmt::Display for Error {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		match *self {
-			Error::Io(ref e) => e.fmt(f),
-			Error::Other(ref e) => e.fmt(f),
-		}
-	}
-}
-
-impl ::std::error::Error for Error {
-	fn description(&self) -> &str {
-		"Starting the JSON-RPC HTTP server failed"
-	}
-
-	fn cause(&self) -> Option<&::std::error::Error> {
-		Some(match *self {
-			Error::Io(ref e) => e,
-			Error::Other(ref e) => e,
-		})
-	}
-}
-
 /// Action undertaken by a middleware.
 pub enum RequestMiddlewareAction {
 	/// Proceed with standard RPC handling
@@ -114,7 +67,7 @@ pub enum RequestMiddlewareAction {
 		/// Should standard hosts validation be performed?
 		should_validate_hosts: bool,
 		/// a future for server response
-		response: BoxFuture<server::Response, hyper::Error>,
+		response: Box<Future<Item=server::Response, Error=hyper::Error> + Send>,
 	}
 }
 
@@ -338,7 +291,7 @@ impl<M: jsonrpc::Metadata, S: jsonrpc::Middleware<M>> ServerBuilder<M, S> {
 	}
 
 	/// Start this JSON-RPC HTTP server trying to bind to specified `SocketAddr`.
-	pub fn start_http(self, addr: &SocketAddr) -> ServerResult {
+	pub fn start_http(self, addr: &SocketAddr) -> io::Result<Server> {
 		let cors_domains = self.cors_domains;
 		let request_middleware = self.request_middleware;
 		let allowed_hosts = self.allowed_hosts;

macros/examples/meta-macros.rs

@@ -5,7 +5,7 @@ extern crate jsonrpc_tcp_server;
 
 use std::collections::BTreeMap;
 
-use jsonrpc_core::{futures, MetaIoHandler, Metadata, Error, Value};
+use jsonrpc_core::{futures, MetaIoHandler, Metadata, Error, Value, Result};
 use jsonrpc_core::futures::future::FutureResult;
 
 #[derive(Clone, Default)]
@@ -18,11 +18,11 @@ build_rpc_trait! {
 
 		/// Adds two numbers and returns a result
 		#[rpc(name = "add")]
-		fn add(&self, u64, u64) -> Result<u64, Error>;
+		fn add(&self, u64, u64) -> Result<u64>;
 
 		/// Multiplies two numbers. Second number is optional.
 		#[rpc(name = "mul")]
-		fn mul(&self, u64, jsonrpc_macros::Trailing<u64>) -> Result<u64, Error>;
+		fn mul(&self, u64, jsonrpc_macros::Trailing<u64>) -> Result<u64>;
 
 		/// Performs asynchronous operation
 		#[rpc(name = "callAsync")]
@@ -38,11 +38,11 @@ struct RpcImpl;
 impl Rpc for RpcImpl {
 	type Metadata = Meta;
 
-	fn add(&self, a: u64, b: u64) -> Result<u64, Error> {
+	fn add(&self, a: u64, b: u64) -> Result<u64> {
 		Ok(a + b)
 	}
 
-	fn mul(&self, a: u64, b: jsonrpc_macros::Trailing<u64>) -> Result<u64, Error> {
+	fn mul(&self, a: u64, b: jsonrpc_macros::Trailing<u64>) -> Result<u64> {
 		Ok(a * b.unwrap_or(1))
 	}