Extract client plumbing from derive, fix circular dependency (paritytech#417)

* Update core-client name in publish script

* Remove circular dependency for client-core test

* Use TypedClient in client derive macro

* Remove generate_client_method, inline the code

* Fix derive client compilation

* Don't panic

* Remove unused log dependency from derive

* Make RpcMessage fields private

* Remove redundant intos

Author: ascjones

_automate/publish.sh

@@ -2,7 +2,7 @@
 
 set -exu
 
-ORDER=(core client server-utils tcp ws ws/client http ipc stdio pubsub derive test)
+ORDER=(core core-client server-utils tcp ws ws/client http ipc stdio pubsub derive test)
 
 for crate in ${ORDER[@]}; do
 	cd $crate

core-client/Cargo.toml

@@ -23,11 +23,11 @@ failure = "0.1"
 futures = "~0.1.6"
 jsonrpc-core = { version = "11.0", path = "../core" }
 log = "0.4"
+serde = "1.0"
 serde_json = "1.0"
 
 [dev-dependencies]
 jsonrpc-derive = { version = "11.0", path = "../derive" }
-jsonrpc-core-client = { version = "11.0", path = "." }
 serde = "1.0"
 tokio = "0.1"
 

core-client/src/lib.rs

@@ -2,13 +2,15 @@
 #![deny(missing_docs)]
 
 use failure::{format_err, Fail};
-use futures::prelude::*;
+use futures::{future, prelude::*};
 use futures::sync::{mpsc, oneshot};
 use jsonrpc_core::{Call, Error, Id, MethodCall, Output, Params, Request, Response, Version};
 use log::debug;
 use serde_json::Value;
 use std::collections::HashMap;
 use std::collections::VecDeque;
+use serde::de::DeserializeOwned;
+use serde::Serialize;
 
 /// The errors returned by the client.
 #[derive(Debug, Fail)]
@@ -67,12 +69,12 @@ impl Future for RpcFuture {
 /// the derive crate can generate a client.
 pub struct RpcMessage {
 	/// The rpc method name.
-	pub method: String,
+	method: String,
 	/// The rpc method parameters.
-	pub params: Params,
+	params: Params,
 	/// The oneshot channel to send the result of the rpc
 	/// call to.
-	pub sender: oneshot::Sender<Result<Value, Error>>,
+	sender: oneshot::Sender<Result<Value, Error>>,
 }
 
 /// A channel to a `RpcClient`.
@@ -202,6 +204,83 @@ where
 	}
 }
 
+/// Client for raw JSON RPC requests
+#[derive(Clone)]
+pub struct RawClient(RpcChannel);
+
+impl From<RpcChannel> for RawClient {
+	fn from(channel: RpcChannel) -> Self {
+		RawClient(channel)
+	}
+}
+
+impl RawClient {
+	/// Call RPC with raw JSON
+	pub fn call_method(&self, method: &str, params: Params) -> impl Future<Item=Value, Error=RpcError> {
+		let (sender, receiver) = oneshot::channel();
+		let msg = RpcMessage {
+			method: method.into(),
+			params,
+			sender,
+		};
+		self.0
+			.to_owned()
+			.send(msg)
+			.map_err(|error| RpcError::Other(error.into()))
+			.and_then(|_| RpcFuture::new(receiver))
+	}
+}
+
+/// Client for typed JSON RPC requests
+#[derive(Clone)]
+pub struct TypedClient(RawClient);
+
+impl From<RpcChannel> for TypedClient {
+	fn from(channel: RpcChannel) -> Self {
+		TypedClient(channel.into())
+	}
+}
+
+impl TypedClient {
+	/// Create new TypedClient
+	pub fn new(raw_cli: RawClient) -> Self {
+		TypedClient(raw_cli)
+	}
+
+	/// Call RPC with serialization of request and deserialization of response
+	pub fn call_method<T: Serialize, R: DeserializeOwned + 'static>(
+		&self,
+		method: &str,
+		returns: &'static str,
+		args: T,
+	) -> impl Future<Item=R, Error=RpcError> {
+		let args = serde_json::to_value(args)
+			.expect("Only types with infallible serialisation can be used for JSON-RPC");
+		let params = match args {
+			Value::Array(vec) => Params::Array(vec),
+			Value::Null => Params::None,
+			_ => return future::Either::A(future::err(RpcError::Other(
+				format_err!("RPC params should serialize to a JSON array, or null")))),
+		};
+
+		future::Either::B(
+			self.0
+				.call_method(method, params)
+				.and_then(move |value: Value| {
+					log::debug!("response: {:?}", value);
+					let result = serde_json::from_value::<R>(value)
+						.map_err(|error| {
+							RpcError::ParseError(
+								returns.into(),
+								error.into(),
+							)
+						});
+					future::done(result)
+				})
+		)
+	}
+}
+
 /// Rpc client implementation for `Deref<Target=MetaIoHandler<Metadata + Default>>`.
 pub mod local {
 	use super::*;
@@ -284,12 +363,12 @@ pub mod local {
 
 #[cfg(test)]
 mod tests {
-	use futures::prelude::*;
-	use jsonrpc_core_client::local;
+	use super::*;
 	use jsonrpc_core::{IoHandler, Result};
 	use jsonrpc_derive::rpc;
+	use crate::{TypedClient, RpcError, RpcChannel};
 
-	#[rpc]
+	#[rpc(server)]
 	pub trait Rpc {
 		#[rpc(name = "add")]
 		fn add(&self, a: u64, b: u64) -> Result<u64>;
@@ -303,11 +382,26 @@ mod tests {
 		}
 	}
 
+	#[derive(Clone)]
+	struct AddClient(TypedClient);
+
+	impl From<RpcChannel> for AddClient {
+		fn from(channel: RpcChannel) -> Self {
+			AddClient(channel.into())
+		}
+	}
+
+	impl AddClient {
+		fn add(&self, a: u64, b: u64) -> impl Future<Item=u64, Error=RpcError> {
+			self.0.call_method("add", "u64", (a, b))
+		}
+	}
+
 	#[test]
 	fn test_client_terminates() {
 		let mut handler = IoHandler::new();
 		handler.extend_with(RpcServer.to_delegate());
-		let (client, rpc_client) = local::connect::<gen_client::Client, _, _>(handler);
+		let (client, rpc_client) = local::connect::<AddClient, _, _>(handler);
 		let fut = client
 			.clone()
 			.add(3, 4)

derive/Cargo.toml

@@ -23,7 +23,6 @@ jsonrpc-core = { version = "11.0", path = "../core" }
 jsonrpc-core-client = { version = "11.0", path = "../core-client" }
 jsonrpc-pubsub = { version = "11.0", path = "../pubsub" }
 jsonrpc-tcp-server = { version = "11.0", path = "../tcp" }
-log = "0.4"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"

derive/src/to_client.rs

@@ -49,12 +49,12 @@ pub fn generate_client_module(methods: &[MethodRegistration], item_trait: &syn::
 			use _jsonrpc_core::futures::{future, Future, Sink};
 			use _jsonrpc_core::futures::sync::oneshot;
 			use _jsonrpc_core::serde_json::{self, Value};
-			use _jsonrpc_core_client::{RpcChannel, RpcError, RpcFuture, RpcMessage};
+			use _jsonrpc_core_client::{RpcChannel, RpcError, RpcFuture, RpcMessage, TypedClient};
 
 			/// The Client.
 			#[derive(Clone)]
 			pub struct Client#generics {
-				sender: RpcChannel,
+				inner: TypedClient,
 				#(#markers_decl),*
 			}
 
@@ -65,38 +65,20 @@ pub fn generate_client_module(methods: &[MethodRegistration], item_trait: &syn::
 				/// Creates a new `Client`.
 				pub fn new(sender: RpcChannel) -> Self {
 					Client {
-						sender,
+						inner: sender.into(),
 						#(#markers_impl),*
 					}
 				}
 
 				#(#client_methods)*
-
-				fn call_method(
-					&self,
-					method: String,
-					params: Params,
-				) -> impl Future<Item=Value, Error=RpcError> {
-					let (sender, receiver) = oneshot::channel();
-					let msg = RpcMessage {
-						method,
-						params,
-						sender,
-					};
-					self.sender
-						.to_owned()
-						.send(msg)
-						.map_err(|error| RpcError::Other(error.into()))
-						.and_then(|_| RpcFuture::new(receiver))
-				}
 			}
 
 			impl#generics From<RpcChannel> for Client#generics
 			where
 				#(#where_clause2),*
 			{
 				fn from(channel: RpcChannel) -> Self {
-					Client::new(channel)
+					Client::new(channel.into())
 				}
 			}
 		}
@@ -119,7 +101,14 @@ fn generate_client_methods(methods: &[MethodRegistration]) -> Result<Vec<syn::Im
 						continue;
 					}
 				};
-				let client_method = generate_client_method(&attrs, rpc_name, name, &args, &arg_names, &returns);
+				let returns_str = quote!(#returns).to_string();
+				let client_method = syn::parse_quote! {
+					#(#attrs)*
+					pub fn #name(&self, #args) -> impl Future<Item=#returns, Error=RpcError> {
+						let args_tuple = (#(#arg_names,)*);
+						self.inner.call_method(#rpc_name, #returns_str, args_tuple)
+					}
+				};
 				client_methods.push(client_method);
 			}
 			MethodRegistration::PubSub { .. } => {
@@ -130,43 +119,6 @@ fn generate_client_methods(methods: &[MethodRegistration]) -> Result<Vec<syn::Im
 	Ok(client_methods)
 }
 
-fn generate_client_method(
-	attrs: &[syn::Attribute],
-	rpc_name: &str,
-	name: &syn::Ident,
-	args: &Punctuated<syn::FnArg, syn::token::Comma>,
-	arg_names: &[&syn::Ident],
-	returns: &syn::Type,
-) -> syn::ImplItem {
-	let returns_str = quote!(#returns).to_string();
-	syn::parse_quote! {
-		#(#attrs)*
-		pub fn #name(&self, #args) -> impl Future<Item=#returns, Error=RpcError> {
-			let args_tuple = (#(#arg_names,)*);
-			let args = serde_json::to_value(args_tuple)
-				.expect("Only types with infallible serialisation can be used for JSON-RPC");
-			let method = #rpc_name.to_owned();
-			let params = match args {
-				Value::Array(vec) => Some(Params::Array(vec)),
-				Value::Null => Some(Params::None),
-				_ => None,
-			}.expect("should never happen");
-			self.call_method(method, params)
-				.and_then(|value: Value| {
-					log::debug!("response: {:?}", value);
-					let result = serde_json::from_value::<#returns>(value)
-						.map_err(|error| {
-							RpcError::ParseError(
-								#returns_str.to_string(),
-								error.into(),
-							)
-						});
-					future::done(result)
-				})
-		}
-	}
-}
-
 fn get_doc_comments(attrs: &[syn::Attribute]) -> Vec<syn::Attribute> {
 	let mut doc_comments = vec![];
 	for attr in attrs {

derive/tests/run-pass/client_only.rs

@@ -3,7 +3,6 @@ extern crate jsonrpc_core;
 extern crate jsonrpc_core_client;
 #[macro_use]
 extern crate jsonrpc_derive;
-extern crate log;
 
 use jsonrpc_core::futures::future::Future;
 use jsonrpc_core::futures::sync::mpsc;