Merge branch 'use-jsonrpc-core-types-more'

Author: faern

core/src/lib.rs

@@ -63,6 +63,7 @@ extern crate serde;
 extern crate serde_json;
 
 use futures::future::Future;
+use jsonrpc_core::types::{Id, MethodCall, Params, Version};
 use serde_json::Value as JsonValue;
 
 /// Contains the main macro of this crate, `jsonrpc_client`.
@@ -146,24 +147,30 @@ pub trait Transport: Clone + Send + 'static {
 /// # Not intended for direct use
 /// This is being called from the client structs generated by the `jsonrpc_client` macro. This
 /// function is not intended to be used directly, only the generated structs should call this.
-pub fn call_method<T, P, R>(mut transport: T, method: &str, params: P) -> RpcRequest<R>
+pub fn call_method<T, P, R>(mut transport: T, method: String, params: P) -> RpcRequest<R>
 where
     T: Transport,
     P: serde::Serialize,
-    for<'de> R: serde::Deserialize<'de> + Send + 'static,
+    R: serde::de::DeserializeOwned + Send + 'static,
 {
-    let id = transport.get_next_id();
-    trace!("Serializing call to method \"{}\" with id {}", method, id);
-    let request = serialize_request(id, method, params).chain_err(|| ErrorKind::SerializeError);
-    let method_copy1 = method.to_owned();
-    let method_copy2 = method.to_owned();
+    let raw_id = transport.get_next_id();
+    let id = Id::Num(raw_id);
+    trace!(
+        "Serializing call to method \"{}\" with id {}",
+        method,
+        raw_id
+    );
+    let request = serialize_request(id.clone(), method.clone(), params)
+        .chain_err(|| ErrorKind::SerializeError);
+    let method_copy1 = method.clone();
+    let method_copy2 = method.clone();
 
     let future = futures::future::result(request)
         .and_then(move |request_raw| {
             trace!(
                 "Sending call to method \"{}\" with id {} to transport",
                 method_copy1,
-                id
+                raw_id
             );
             transport
                 .send(request_raw)
@@ -173,7 +180,7 @@ where
             trace!(
                 "Deserializing response to method \"{}\" with id {}",
                 method_copy2,
-                id
+                raw_id
             );
             response::parse::<R>(&response_raw, id)
         });
@@ -183,20 +190,26 @@ where
 
 /// Creates a JSON-RPC 2.0 request to the given method with the given parameters.
 fn serialize_request<P>(
-    id: u64,
-    method: &str,
+    id: Id,
+    method: String,
     params: P,
 ) -> ::std::result::Result<Vec<u8>, serde_json::error::Error>
 where
     P: serde::Serialize,
 {
-    let mut request_map = serde_json::Map::new();
-    request_map.insert(String::from("jsonrpc"), JsonValue::from("2.0"));
-    request_map.insert(String::from("id"), JsonValue::from(id));
-    request_map.insert(String::from("method"), JsonValue::from(method));
-    request_map.insert(String::from("params"), serde_json::to_value(params)?);
-
-    serde_json::to_vec(&JsonValue::Object(request_map))
+    let serialized_params = match serde_json::to_value(params)? {
+        JsonValue::Null => None,
+        JsonValue::Array(vec) => Some(Params::Array(vec)),
+        JsonValue::Object(obj) => Some(Params::Map(obj)),
+        value => Some(Params::Array(vec![value])),
+    };
+    let method_call = MethodCall {
+        jsonrpc: Some(Version::V2),
+        method: method.to_owned(),
+        params: serialized_params,
+        id,
+    };
+    serde_json::to_vec(&method_call)
 }
 
 

core/src/macros.rs

@@ -34,7 +34,7 @@ macro_rules! jsonrpc_client {
                 pub fn $method(&mut $selff $(, $arg_name: $arg_ty)*)
                     -> $crate::RpcRequest<$return_ty>
                 {
-                    let method = stringify!($method);
+                    let method = String::from(stringify!($method));
                     let params = expand_params!($($arg_name,)*);
                     $crate::call_method($selff.transport.clone(), method, params)
                 }

core/src/response.rs

@@ -6,48 +6,42 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use {Error, ErrorKind, Result, ResultExt};
-use jsonrpc_core;
+use {ErrorKind, Result, ResultExt};
+use jsonrpc_core::types::{Id, Output, Version};
 use serde;
-use serde_json::{self, Value as JsonValue};
+use serde_json;
 
 /// Parses a binary response into json, extracts the "result" field and tries to deserialize that
 /// to the desired type.
-pub fn parse<R>(response: &[u8], expected_id: u64) -> Result<R>
+pub fn parse<R>(response_raw: &[u8], expected_id: Id) -> Result<R>
 where
-    for<'de> R: serde::Deserialize<'de>,
+    R: serde::de::DeserializeOwned,
 {
-    let response_json = deserialize_response(response)?;
-    let result_json = check_response_and_get_result(response_json, expected_id)?;
-    debug!("Received json result: {}", result_json);
-    serde_json::from_value::<R>(result_json)
-        .chain_err(|| ErrorKind::ResponseError("Not valid for target type"))
-}
-
-fn deserialize_response(response: &[u8]) -> Result<JsonValue> {
-    serde_json::from_slice(response).chain_err(|| ErrorKind::ResponseError("Not valid json"))
+    let response: Output = serde_json::from_slice(response_raw)
+        .chain_err(|| ErrorKind::ResponseError("Not valid json"))?;
+    match response {
+        Output::Success(success) => {
+            check_response(success.jsonrpc, success.id, expected_id)?;
+            debug!("Received json result: {}", success.result);
+            serde_json::from_value::<R>(success.result)
+                .chain_err(|| ErrorKind::ResponseError("Not valid for target type"))
+        }
+        Output::Failure(failure) => {
+            check_response(failure.jsonrpc, failure.id, expected_id)?;
+            Err(ErrorKind::JsonRpcError(failure.error).into())
+        }
+    }
 }
 
-/// Validate if response is a valid JSON-RPC 2.0 response object. If it is, it returns the
-/// content of the "result" field of that object.
-fn check_response_and_get_result(mut response: JsonValue, expected_id: u64) -> Result<JsonValue> {
-    let response_map = response.as_object_mut().ok_or_else(|| {
-        Error::from_kind(ErrorKind::ResponseError("Not a json object"))
-    })?;
+/// Validate if response is a valid JSON-RPC 2.0 response object with the correct Id.
+fn check_response(version: Option<Version>, id: Id, expected_id: Id) -> Result<()> {
     ensure!(
-        response_map.get("jsonrpc") == Some(&JsonValue::from("2.0")),
+        version == Some(Version::V2),
         ErrorKind::ResponseError("Not JSON-RPC 2.0 compatible")
     );
     ensure!(
-        response_map.get("id") == Some(&JsonValue::from(expected_id)),
+        id == expected_id,
         ErrorKind::ResponseError("Response id not equal to request id")
     );
-    if let Some(error_json) = response_map.remove("error") {
-        let error: jsonrpc_core::Error = serde_json::from_value(error_json)
-            .chain_err(|| ErrorKind::ResponseError("Malformed error object"))?;
-        bail!(ErrorKind::JsonRpcError(error));
-    }
-    response_map
-        .remove("result")
-        .ok_or_else(|| ErrorKind::ResponseError("No \"result\" field").into())
+    Ok(())
 }