Merge branch 'dont-clone-transport'

Author: faern

core/src/lib.rs

@@ -126,7 +126,7 @@ impl<T> Future for RpcRequest<T> {
 
 /// Trait for types acting as a transport layer for the JSON-RPC 2.0 clients generated by the
 /// `jsonrpc_client` macro.
-pub trait Transport: Clone + Send + 'static {
+pub trait Transport {
     /// The type of error that this transport emits if it fails.
     type Error: ::std::error::Error + Send + 'static;
 
@@ -147,7 +147,7 @@ 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: String, params: P) -> RpcRequest<R>
+pub fn call_method<T, P, R>(transport: &mut T, method: String, params: P) -> RpcRequest<R>
 where
     T: Transport,
     P: serde::Serialize,
@@ -160,31 +160,30 @@ where
         method,
         raw_id
     );
-    let request = serialize_request(id.clone(), method.clone(), params)
+    let request_serialization_result = 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| {
+    match request_serialization_result {
+        Err(e) => RpcRequest(Box::new(futures::future::err(e))),
+        Ok(request_raw) => {
             trace!(
                 "Sending call to method \"{}\" with id {} to transport",
-                method_copy1,
+                method,
                 raw_id
             );
-            transport
+            let future = transport
                 .send(request_raw)
                 .map_err(|e| Error::with_chain(e, ErrorKind::TransportError))
-        })
-        .and_then(move |response_raw: Vec<u8>| {
-            trace!(
-                "Deserializing response to method \"{}\" with id {}",
-                method_copy2,
-                raw_id
-            );
-            response::parse::<R>(&response_raw, id)
-        });
-    RpcRequest(Box::new(future))
+                .and_then(move |response_raw: Vec<u8>| {
+                    trace!(
+                        "Deserializing response to method \"{}\" with id {}",
+                        method,
+                        raw_id
+                    );
+                    response::parse::<R>(&response_raw, id)
+                });
+            RpcRequest(Box::new(future))
+        }
+    }
 }
 
 
@@ -205,7 +204,7 @@ where
     };
     let method_call = MethodCall {
         jsonrpc: Some(Version::V2),
-        method: method.to_owned(),
+        method,
         params: serialized_params,
         id,
     };

core/src/macros.rs

@@ -36,7 +36,7 @@ macro_rules! jsonrpc_client {
                 {
                     let method = String::from(stringify!($method));
                     let params = expand_params!($($arg_name,)*);
-                    $crate::call_method($selff.transport.clone(), method, params)
+                    $crate::call_method(&mut $selff.transport, method, params)
                 }
             )*
         }

http/src/lib.rs

@@ -80,16 +80,12 @@ extern crate native_tls;
 
 use futures::{future, Future, Stream};
 use futures::sync::{mpsc, oneshot};
-
 use hyper::{Client, Request, StatusCode, Uri};
-
 use jsonrpc_client_core::{BoxFuture, Transport};
-
 use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::thread;
-
 use tokio_core::reactor::Core;
 pub use tokio_core::reactor::Handle;
 
@@ -221,19 +217,17 @@ impl HttpTransport {
 
     fn standalone_internal<C: ClientCreator>(client_creator: C) -> Result<HttpTransport> {
         let (tx, rx) = ::std::sync::mpsc::channel();
-        thread::spawn(move || {
-            match create_standalone_core(client_creator) {
-                Err(e) => {
-                    tx.send(Err(e)).unwrap();
-                }
-                Ok((mut core, request_tx, future)) => {
-                    tx.send(Ok(HttpTransport::new_internal(request_tx)))
-                        .unwrap();
-                    if let Err(_) = core.run(future) {
-                        error!("JSON-RPC processing thread had an error");
-                    }
-                    debug!("Standalone HttpTransport thread exiting");
+        thread::spawn(move || match create_standalone_core(client_creator) {
+            Err(e) => {
+                tx.send(Err(e)).unwrap();
+            }
+            Ok((mut core, request_tx, future)) => {
+                tx.send(Ok(HttpTransport::new_internal(request_tx)))
+                    .unwrap();
+                if let Err(_) = core.run(future) {
+                    error!("JSON-RPC processing thread had an error");
                 }
+                debug!("Standalone HttpTransport thread exiting");
             }
         });
 
@@ -398,8 +392,8 @@ mod tests {
     #[test]
     fn failing_client_creator() {
         let error = HttpTransport::with_client(|_: &Handle| {
-            Err(io::Error::new(io::ErrorKind::Other, "Dummy error")) as
-                ::std::result::Result<Client<HttpConnector, hyper::Body>, io::Error>
+            Err(io::Error::new(io::ErrorKind::Other, "Dummy error"))
+                as ::std::result::Result<Client<HttpConnector, hyper::Body>, io::Error>
         }).unwrap_err();
         match error.kind() {
             &ErrorKind::ClientCreatorError => (),