Async reqwest (#597)

* update reqwest and tokio

* Make extract link working with new packages

* Make uniq working with new packages

* Update get.md

* Make rest-post working with new packages

* Make API resource exists working with new packages

* Make Query the GitHub API working with new packages

* Fix typos

* update to edition 2018

* Extending reqwest

* fix mime request

* fix post file

* Fix download basic

* Remove toml lines

* add error handling

* Fix partial

* Improve coding in unique

* Borken links fix

* Fix retain example

* merging master

* Completed updating for async

* https://docs.rs/reqwest/0.10.6/reqwest/ references clients and they provided 404 errors

* replace anyhow with error-chain

* spelling and links

Co-authored-by: pollosp <pollo.es.pollo@gmail.com>
Co-authored-by: Olopez <pollosp@users.noreply.github.com>

Author: AndyGauge

Cargo.toml

@@ -1,11 +1,10 @@
 [package]
 name = "rust-cookbook"
-version = "0.1.0"
-authors = ["Brian Anderson <banderson@mozilla.com>"]
+version = "1.0.0"
+authors = ["Brian Anderson <banderson@mozilla.com>", "Andrew Gauger <andygauge@gmail.com>"]
 edition = "2018"
 license = "MIT/Apache-2.0"
 publish = false
-
 build = "build.rs"
 
 [dependencies]
@@ -42,19 +41,20 @@ rand = "0.7.3"
 rand_distr = "0.2.2"
 rayon = "1.0"
 regex = "1.0"
-reqwest = "0.9"
+reqwest = { version = "0.10", features = ["blocking", "json", "stream"] }
 ring = "0.16.11"
 rusqlite = { version = "0.22", features = ["chrono"] }
 same-file = "1.0"
 select = "0.4"
 semver = "0.9"
-serde = "1.0"
+serde = { version = "1.0", features = ["derive"] }
 serde_derive = "1.0"
 serde_json = "1.0"
 tar = "0.4.12"
 tempfile = "3.1"
 threadpool = "1.6"
 toml = "0.4"
+tokio = { version = "0.2", features = ["full"] }
 unicode-segmentation = "1.2.1"
 url = "2.1"
 walkdir = "2.0"

src/development_tools/errors.md

@@ -6,7 +6,7 @@ The  [error-chain] crate makes [matching] on different error types returned by
 a function possible and relatively compact. [`ErrorKind`] determines the error
 type.
 
-Uses [reqwest] to query a random integer generator web service.  Converts
+Uses [reqwest]::[blocking] to query a random integer generator web service.  Converts
 the string response into an integer. The Rust standard library,
 [reqwest], and the web service can all generate errors. Well defined Rust errors
 use [`foreign_links`]. An additional [`ErrorKind`] variant for the web service
@@ -15,51 +15,46 @@ error uses `errors` block of the `error_chain!` macro.
 ```rust,edition2018
 use error_chain::error_chain;
 
-use std::io::Read;
-
 error_chain! {
     foreign_links {
         Io(std::io::Error);
         Reqwest(reqwest::Error);
         ParseIntError(std::num::ParseIntError);
     }
-
     errors { RandomResponseError(t: String) }
 }
 
-fn parse_response(mut response: reqwest::Response) -> Result<u32> {
-    let mut body = String::new();
-    response.read_to_string(&mut body)?;
-    body.pop();
-    body.parse::<u32>()
-        .chain_err(|| ErrorKind::RandomResponseError(body))
+fn parse_response(response: reqwest::blocking::Response) -> Result<u32> {
+  let mut body = response.text()?;
+  body.pop();
+  body
+    .parse::<u32>()
+    .chain_err(|| ErrorKind::RandomResponseError(body))
 }
 
 fn run() -> Result<()> {
-    let url =
-        format!("https://www.random.org/integers/?num=1&min=0&max=10&col=1&base=10&format=plain");
-    let response = reqwest::get(&url)?;
-    let random_value: u32 = parse_response(response)?;
-
-    println!("a random number between 0 and 10: {}", random_value);
-
-    Ok(())
+  let url =
+    format!("https://www.random.org/integers/?num=1&min=0&max=10&col=1&base=10&format=plain");
+  let response = reqwest::blocking::get(&url)?;
+  let random_value: u32 = parse_response(response)?;
+  println!("a random number between 0 and 10: {}", random_value);
+  Ok(())
 }
 
 fn main() {
-    if let Err(error) = run() {
-        match *error.kind() {
-            ErrorKind::Io(_) => println!("Standard IO error: {:?}", error),
-            ErrorKind::Reqwest(_) => println!("Reqwest error: {:?}", error),
-            ErrorKind::ParseIntError(_) => println!("Standard parse int error: {:?}", error),
-            ErrorKind::RandomResponseError(_) => println!("User defined error: {:?}", error),
-            _ => println!("Other error: {:?}", error),
-        }
+  if let Err(error) = run() {
+    match *error.kind() {
+      ErrorKind::Io(_) => println!("Standard IO error: {:?}", error),
+      ErrorKind::Reqwest(_) => println!("Reqwest error: {:?}", error),
+      ErrorKind::ParseIntError(_) => println!("Standard parse int error: {:?}", error),
+      ErrorKind::RandomResponseError(_) => println!("User defined error: {:?}", error),
+      _ => println!("Other error: {:?}", error),
     }
+  }
 }
 ```
 
 [`ErrorKind`]: https://docs.rs/error-chain/*/error_chain/example_generated/enum.ErrorKind.html
 [`foreign_links`]: https://docs.rs/error-chain/*/error_chain/#foreign-links
-
+[blocking]: https://docs.rs/reqwest/*/reqwest/blocking/index.html
 [Matching]:https://docs.rs/error-chain/*/error_chain/#matching-errors

src/errors/handle/retain.md

@@ -26,8 +26,18 @@
 | [Get MIME type from filename][ex-mime-from-filename] | [![mime-badge]][mime] | [![cat-encoding-badge]][cat-encoding] |
 | [Parse the MIME type of a HTTP response][ex-http-response-mime-type] | [![mime-badge]][mime] [![reqwest-badge]][reqwest] | [![cat-net-badge]][cat-net] [![cat-encoding-badge]][cat-encoding] |
 
+## Clients
 
-{{#include web/clients.md}}
+| Recipe | Crates | Categories |
+|--------|--------|------------|
+| [Make a HTTP GET request][ex-url-basic] | [![reqwest-badge]][reqwest] | [![cat-net-badge]][cat-net] |
+| [Query the GitHub API][ex-rest-get] | [![reqwest-badge]][reqwest] [![serde-badge]][serde] | [![cat-net-badge]][cat-net] [![cat-encoding-badge]][cat-encoding] |
+| [Check if an API resource exists][ex-rest-head] | [![reqwest-badge]][reqwest] | [![cat-net-badge]][cat-net] |
+| [Create and delete Gist with GitHub API][ex-rest-post] | [![reqwest-badge]][reqwest] [![serde-badge]][serde] | [![cat-net-badge]][cat-net] [![cat-encoding-badge]][cat-encoding] |
+| [Consume a paginated RESTful API][ex-paginated-api] | [![reqwest-badge]][reqwest] [![serde-badge]][serde] | [![cat-net-badge]][cat-net] [![cat-encoding-badge]][cat-encoding] |
+| [Download a file to a temporary directory][ex-url-download] | [![reqwest-badge]][reqwest] [![tempdir-badge]][tempdir] | [![cat-net-badge]][cat-net] [![cat-filesystem-badge]][cat-filesystem] |
+| [Make a partial download with HTTP range headers][ex-progress-with-range] | [![reqwest-badge]][reqwest] | [![cat-net-badge]][cat-net] |
+| [POST a file to paste-rs][ex-file-post] | [![reqwest-badge]][reqwest] | [![cat-net-badge]][cat-net] |
 
 [ex-extract-links-webpage]: web/scraping.html#extract-all-links-from-a-webpage-html
 [ex-check-broken-links]: web/scraping.html#check-a-webpage-for-broken-links
@@ -43,4 +53,15 @@
 [ex-mime-from-filename]: web/mime.html#get-mime-type-from-filename
 [ex-http-response-mime-type]: web/mime.html#parse-the-mime-type-of-a-http-response
 
+[ex-url-basic]: web/clients/requests.html#make-a-http-get-request
+[ex-rest-custom-params]: web/clients/requests.html#set-custom-headers-and-url-parameters-for-a-rest-request
+[ex-rest-get]: web/clients/apis.html#query-the-github-api
+[ex-rest-head]: web/clients/apis.html#check-if-an-api-resource-exists
+[ex-rest-post]: web/clients/apis.html#create-and-delete-gist-with-github-api
+[ex-paginated-api]: web/clients/apis.html#consume-a-paginated-restful-api
+[ex-handle-rate-limited-api]: web/clients/apis.html#handle-a-rate-limited-api
+[ex-url-download]: web/clients/download.html#download-a-file-to-a-temporary-directory
+[ex-progress-with-range]: web/clients/download.html#make-a-partial-download-with-http-range-headers
+[ex-file-post]: web/clients/download.html#post-a-file-to-paste-rs
+
 {{#include links.md}}

src/web.md

@@ -11,15 +11,15 @@
 | [Make a partial download with HTTP range headers][ex-progress-with-range] | [![reqwest-badge]][reqwest] | [![cat-net-badge]][cat-net] |
 | [POST a file to paste-rs][ex-file-post] | [![reqwest-badge]][reqwest] | [![cat-net-badge]][cat-net] |
 
-[ex-url-basic]: web/clients/requests.html#make-a-http-get-request
-[ex-rest-custom-params]: web/clients/requests.html#set-custom-headers-and-url-parameters-for-a-rest-request
-[ex-rest-get]: web/clients/apis.html#query-the-github-api
-[ex-rest-head]: web/clients/apis.html#check-if-an-api-resource-exists
-[ex-rest-post]: web/clients/apis.html#create-and-delete-gist-with-github-api
-[ex-paginated-api]: web/clients/apis.html#consume-a-paginated-restful-api
-[ex-handle-rate-limited-api]: web/clients/apis.html#handle-a-rate-limited-api
-[ex-url-download]: web/clients/download.html#download-a-file-to-a-temporary-directory
-[ex-progress-with-range]: web/clients/download.html#make-a-partial-download-with-http-range-headers
-[ex-file-post]: web/clients/download.html#post-a-file-to-paste-rs
+[ex-url-basic]: clients/requests.html#make-a-http-get-request
+[ex-rest-custom-params]: clients/requests.html#set-custom-headers-and-url-parameters-for-a-rest-request
+[ex-rest-get]: clients/apis.html#query-the-github-api
+[ex-rest-head]: clients/apis.html#check-if-an-api-resource-exists
+[ex-rest-post]: clients/apis.html#create-and-delete-gist-with-github-api
+[ex-paginated-api]: clients/apis.html#consume-a-paginated-restful-api
+[ex-handle-rate-limited-api]: clients/apis.html#handle-a-rate-limited-api
+[ex-url-download]: clients/download.html#download-a-file-to-a-temporary-directory
+[ex-progress-with-range]: clients/download.html#make-a-partial-download-with-http-range-headers
+[ex-file-post]: clients/download.html#post-a-file-to-paste-rs
 
 {{#include ../links.md}}

src/web/clients.md

@@ -7,8 +7,8 @@ fetches the next page of results from the remote server as it arrives at the end
 of each page.
 
 ```rust,edition2018,no_run
+use reqwest::Result;
 use serde::Deserialize;
-use reqwest::Error;
 
 #[derive(Deserialize)]
 struct ApiResponse {
@@ -29,25 +29,25 @@ struct Meta {
 struct ReverseDependencies {
     crate_id: String,
     dependencies: <Vec<Dependency> as IntoIterator>::IntoIter,
-    client: reqwest::Client,
+    client: reqwest::blocking::Client,
     page: u32,
     per_page: u32,
     total: u32,
 }
 
 impl ReverseDependencies {
-    fn of(crate_id: &str) -> Result<Self, Error> {
+    fn of(crate_id: &str) -> Result<Self> {
         Ok(ReverseDependencies {
                crate_id: crate_id.to_owned(),
                dependencies: vec![].into_iter(),
-               client: reqwest::Client::new(),
+               client: reqwest::blocking::Client::new(),
                page: 0,
                per_page: 100,
                total: 0,
            })
     }
 
-    fn try_next(&mut self) -> Result<Option<Dependency>, Error> {
+    fn try_next(&mut self) -> Result<Option<Dependency>> {
         if let Some(dep) = self.dependencies.next() {
             return Ok(Some(dep));
         }
@@ -70,7 +70,7 @@ impl ReverseDependencies {
 }
 
 impl Iterator for ReverseDependencies {
-    type Item = Result<Dependency, Error>;
+    type Item = Result<Dependency>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.try_next() {
@@ -81,7 +81,7 @@ impl Iterator for ReverseDependencies {
     }
 }
 
-fn main() -> Result<(), Error> {
+fn main() -> Result<()> {
     for dep in ReverseDependencies::of("serde")? {
         println!("reverse dependency: {}", dep?.crate_id);
     }

src/web/clients/api/paginated.md

@@ -3,7 +3,11 @@
 [![reqwest-badge]][reqwest] [![serde-badge]][serde] [![cat-net-badge]][cat-net] [![cat-encoding-badge]][cat-encoding]
 
 Queries GitHub [stargazers API v3](https://developer.github.com/v3/activity/starring/#list-stargazers)
-with [`reqwest::get`] to get list of all users who have marked a GitHub project with a star. [`reqwest::Response`] is deserialized with [`Response::json`] into `User` objects implementing [`serde::Deserialize`].
+with [`reqwest::get`] to get list of all users who have marked a GitHub project with a star. 
+[`reqwest::Response`] is deserialized with [`Response::json`] into `User` objects implementing [`serde::Deserialize`].
+
+[tokio::main] is used to set up the async executor and the process waits for [`reqwet::get`] to complete before
+processing the response into User instances.  
 
 ```rust,edition2018,no_run
 use serde::Deserialize;
@@ -15,14 +19,15 @@ struct User {
     id: u32,
 }
 
-fn main() -> Result<(), Error> {
+#[tokio::main]
+async fn main() -> Result<(), Error> {
     let request_url = format!("https://api.github.com/repos/{owner}/{repo}/stargazers",
                               owner = "rust-lang-nursery",
                               repo = "rust-cookbook");
     println!("{}", request_url);
-    let mut response = reqwest::get(&request_url)?;
+    let response = reqwest::get(&request_url).await?;
 
-    let users: Vec<User> = response.json()?;
+    let users: Vec<User> = response.json().await?;
     println!("{:?}", users);
     Ok(())
 }

src/web/clients/api/rest-get.md

@@ -8,21 +8,23 @@ success. This is a quick way to query a rest resource without needing to receive
 a body. [`reqwest::Client`] cofigured with [`ClientBuilder::timeout`] ensures
 a request will not last longer than a timeout.
 
-```rust,edition2018,no_run
+Due to both [`ClientBuilder::build`] and [`ReqwestBuilder::send`] returning [`reqwest::Error`]
+types, the shortcut [`reqwest::Result`] is used for the main function return type. 
 
-use reqwest::Error;
+```rust,edition2018,no_run
+use reqwest::Result;
 use std::time::Duration;
 use reqwest::ClientBuilder;
 
-
-fn main() -> Result<(), Error> {
+#[tokio::main]
+async fn main() -> Result<()> {
     let user = "ferris-the-crab";
     let request_url = format!("https://api.github.com/users/{}", user);
     println!("{}", request_url);
 
     let timeout = Duration::new(5, 0);
     let client = ClientBuilder::new().timeout(timeout).build()?;
-    let response = client.head(&request_url).send()?;
+    let response = client.head(&request_url).send().await?;
 
     if response.status().is_success() {
         println!("{} is a user!", user);
@@ -34,6 +36,10 @@ fn main() -> Result<(), Error> {
 }
 ```
 
+[`ClientBuilder::build`]: https://docs.rs/reqwest/*/reqwest/struct.ClientBuilder.html#method.build
 [`Client::head`]: https://docs.rs/reqwest/*/reqwest/struct.Client.html#method.head
 [`ClientBuilder::timeout`]: https://docs.rs/reqwest/*/reqwest/struct.ClientBuilder.html#method.timeout
+[`RequestBuilder::send`]: https://docs.rs/reqwest/*/reqwest/struct.RequestBuilder.html#method.send
 [`reqwest::Client`]: https://docs.rs/reqwest/*/reqwest/struct.Client.html
+[`reqwest::Error`]: https://docs.rs/reqwest/*/reqwest/struct.Error.html
+[`reqwest::Result`]:https://docs.rs/reqwest/*/reqwest/type.Result.html

src/web/clients/api/rest-head.md

@@ -12,27 +12,27 @@ body. [`RequestBuilder::basic_auth`] handles authentication. The call to
 [`RequestBuilder::send`] synchronously executes the requests.
 
 ```rust,edition2018,no_run
-# use error_chain::error_chain;
+use error_chain::error_chain;
 use serde::Deserialize;
- use serde_json::json;
-
+use serde_json::json;
 use std::env;
 use reqwest::Client;
-#
-# error_chain! {
-#     foreign_links {
-#         EnvVar(env::VarError);
-#         HttpRequest(reqwest::Error);
-#     }
-# }
+
+error_chain! {
+    foreign_links {
+        EnvVar(env::VarError);
+        HttpRequest(reqwest::Error);
+    }
+}
 
 #[derive(Deserialize, Debug)]
 struct Gist {
     id: String,
     html_url: String,
 }
 
-fn main() -> Result<()> {
+#[tokio::main]
+async fn main() ->  Result<()> {
     let gh_user = env::var("GH_USER")?;
     let gh_pass = env::var("GH_PASS")?;
 
@@ -46,20 +46,20 @@ fn main() -> Result<()> {
         }});
 
     let request_url = "https://api.github.com/gists";
-    let mut response = Client::new()
+    let response = Client::new()
         .post(request_url)
         .basic_auth(gh_user.clone(), Some(gh_pass.clone()))
         .json(&gist_body)
-        .send()?;
+        .send().await?;
 
-    let gist: Gist = response.json()?;
+    let gist: Gist = response.json().await?;
     println!("Created {:?}", gist);
 
     let request_url = format!("{}/{}",request_url, gist.id);
     let response = Client::new()
         .delete(&request_url)
         .basic_auth(gh_user, Some(gh_pass))
-        .send()?;
+        .send().await?;
 
     println!("Gist {} deleted! Status code: {}",gist.id, response.status());
     Ok(())