replace hyper v0.10 with reqwest

`hyper` v0.10 is extremely outdated, the current release is v1.6. this
old version pulls in vulnerable dependencies (incl. `hyper` v0.10
itself).

rather than upgrading to `hyper` v1.6 i opted to replace it with
`reqwest` since this crate here is not `async` and `hyper` v1 is
completely `async`. due to the very limited amount of features needed
from `hyper` (just executing HTTP POST requests) it can instead be
replaced with the much simpler `reqwest` crate. while it hasn't hit v1.0
yet it is very widely used (nearly 200 million downloads on crates.io).

this is a breaking change for consumers since the URLs can now just be
passed as strings rather than having to call `.parse()?` on the string.

note that this is similar to, but not the same as, adnanademovic#8.

fixes adnanademovic#9

Author: rursprung

Cargo.toml

@@ -10,7 +10,7 @@ version = "0.1.0"
 [dependencies]
 base64 = "0.22.1"
 error-chain = "0.12.4"
-hyper = "0.10.15"
+reqwest = { version = "0.12", features = ["blocking"] }
 lazy_static = "1.5.0"
 regex = "1.11.1"
 serde = { version = "1.0.217", features = ["derive"] }

src/bin/echo.rs

@@ -39,7 +39,7 @@ pub fn main() {
         bar: "baz".into(),
     };
     println!("Sending: {:?}", req);
-    let uri = "http://localhost:8080/".parse().unwrap();
+    let uri = "http://localhost:8080/";
     let res: Result<Result<TestStruct, _>, _> = client.call(&uri, "echo", req.clone());
     println!("Echo Received: {:?}", res);
     let res: Result<Result<TestStruct, _>, _> = client.call(&uri, "double", req.clone());

src/bin/threadcheck.rs

@@ -32,25 +32,25 @@ fn main() {
     std::thread::sleep(Duration::from_secs(1));
 
     let t1 = std::thread::spawn(|| {
-        call::<_, _, ()>(&"http://127.0.0.1:5000".parse().unwrap(), "foo", ())
+        call::<_, _, _, ()>(&"http://127.0.0.1:5000", "foo", ())
             .unwrap()
             .unwrap();
     });
 
     let t2 = std::thread::spawn(|| {
-        call::<_, _, ()>(&"http://127.0.0.1:5000".parse().unwrap(), "bar", ())
+        call::<_, _, _, ()>(&"http://127.0.0.1:5000", "bar", ())
             .unwrap()
             .unwrap();
     });
 
     let t3 = std::thread::spawn(|| {
-        call::<_, _, ()>(&"http://127.0.0.1:5000".parse().unwrap(), "foo", ())
+        call::<_, _, _, ()>(&"http://127.0.0.1:5000", "foo", ())
             .unwrap()
             .unwrap();
     });
 
     let t4 = std::thread::spawn(|| {
-        call::<_, _, ()>(&"http://127.0.0.1:5000".parse().unwrap(), "bar", ())
+        call::<_, _, _, ()>(&"http://127.0.0.1:5000", "bar", ())
             .unwrap()
             .unwrap();
     });

src/client.rs

@@ -1,26 +1,24 @@
 use super::error::{Result, ResultExt};
 use super::xmlfmt::{from_params, into_params, parse, Call, Fault, Params, Response};
-use hyper::{self, Client as HyperClient};
 use serde::{Deserialize, Serialize};
 use std;
-use Url;
+use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
 
-use hyper::header::Headers;
-header! { (ContentType, "ContentType") => [String] }
-
-pub fn call_value<Tkey>(uri: &Url, name: Tkey, params: Params) -> Result<Response>
+pub fn call_value<URL, Tkey>(uri: &URL, name: Tkey, params: Params) -> Result<Response>
 where
+    URL: reqwest::IntoUrl + Clone,
     Tkey: Into<String>,
 {
     Client::new()?.call_value(uri, name, params)
 }
 
-pub fn call<'a, Tkey, Treq, Tres>(
-    uri: &Url,
+pub fn call<'a, URL, Tkey, Treq, Tres>(
+    uri: &URL,
     name: Tkey,
     req: Treq,
 ) -> Result<std::result::Result<Tres, Fault>>
 where
+    URL: reqwest::IntoUrl + Clone,
     Tkey: Into<String>,
     Treq: Serialize,
     Tres: Deserialize<'a>,
@@ -29,34 +27,33 @@ where
 }
 
 pub struct Client {
-    client: HyperClient,
+    client: reqwest::blocking::Client,
 }
 
 impl Client {
     pub fn new() -> Result<Client> {
-        let client = HyperClient::new();
+        let client = reqwest::blocking::Client::new();
         Ok(Client { client })
     }
 
-    pub fn call_value<Tkey>(&mut self, uri: &Url, name: Tkey, params: Params) -> Result<Response>
+    pub fn call_value<URL, Tkey>(&mut self, uri: &URL, name: Tkey, params: Params) -> Result<Response>
     where
+        URL: reqwest::IntoUrl + Clone,
         Tkey: Into<String>,
     {
         use super::xmlfmt::value::ToXml;
-        let body_str = Call {
+        let body = Call {
             name: name.into(),
             params,
         }
         .to_xml();
-        let bytes: &[u8] = body_str.as_bytes();
-        let body = hyper::client::Body::BufBody(bytes, bytes.len());
 
-        let mut headers = Headers::new();
-        headers.set(ContentType("xml".to_owned()));
+        let mut headers = HeaderMap::new();
+        headers.insert(CONTENT_TYPE, HeaderValue::from_static("text/xml"));
 
         let response = self
             .client
-            .post(uri.as_ref())
+            .post(uri.clone())
             .headers(headers)
             .body(body)
             .send()
@@ -65,13 +62,14 @@ impl Client {
         parse::response(response).map_err(Into::into)
     }
 
-    pub fn call<'a, Tkey, Treq, Tres>(
+    pub fn call<'a, URL, Tkey, Treq, Tres>(
         &mut self,
-        uri: &Url,
+        uri: &URL,
         name: Tkey,
         req: Treq,
     ) -> Result<std::result::Result<Tres, Fault>>
     where
+        URL: reqwest::IntoUrl + Clone,
         Tkey: Into<String>,
         Treq: Serialize,
         Tres: Deserialize<'a>,

src/lib.rs

@@ -4,8 +4,6 @@ extern crate base64;
 #[macro_use]
 extern crate error_chain;
 #[macro_use]
-extern crate hyper;
-#[macro_use]
 extern crate lazy_static;
 extern crate regex;
 #[macro_use]
@@ -15,13 +13,13 @@ pub extern crate rouille;
 extern crate serde_bytes;
 extern crate serde_xml_rs;
 extern crate xml;
+extern crate reqwest;
 
 pub mod client;
 pub mod error;
 pub mod server;
 mod xmlfmt;
 
 pub use client::{call, call_value, Client};
-pub use hyper::Url;
 pub use server::Server;
 pub use xmlfmt::{from_params, into_params, Call, Fault, Params, Response, Value};

src/server.rs

@@ -135,7 +135,6 @@ where
     F: Send + Sync + 'static + Fn(&rouille::Request) -> rouille::Response,
 {
     server: rouille::Server<F>,
-    // server: hyper::Server<NewService, hyper::Body>,
 }
 
 impl<F> BoundServer<F>