async

Author: Tosainu

Cargo.toml

@@ -6,7 +6,8 @@ edition = "2018"
 
 [dependencies]
 dirs = "3.0"
-reqwest = { version = "0.10", features = ["blocking", "json"] }
+reqwest = { version = "0.10", features = ["json"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 structopt = "0.3"
+tokio = { version = "0.2", features = ["macros", "time"] }

src/api.rs

@@ -15,7 +15,7 @@ trait RequestBuilder {
     fn auth(self, login: &Login) -> Self;
 }
 
-impl RequestBuilder for reqwest::blocking::RequestBuilder {
+impl RequestBuilder for reqwest::RequestBuilder {
     fn auth(self, login: &Login) -> Self {
         match login {
             Login::OAuth(token) => self.header(AUTHORIZATION, format!("token {}", token)),
@@ -83,16 +83,16 @@ enum AccessTokenResponse {
 }
 
 pub struct Client {
-    client: reqwest::blocking::Client,
+    client: reqwest::Client,
 }
 
 impl Client {
     pub fn build() -> Result<Self> {
-        let b = reqwest::blocking::Client::builder().user_agent("reqwest");
+        let b = reqwest::Client::builder().user_agent("reqwest");
         Ok(Client { client: b.build()? })
     }
 
-    pub fn user(&self, login: &Login) -> Result<UserResponse> {
+    pub async fn user(&self, login: &Login) -> Result<UserResponse> {
         let res = self
             .client
             .get("https://api.github.com/user")
@@ -101,18 +101,19 @@ impl Client {
                 HeaderValue::from_static("application/vnd.github.v3+json"),
             )
             .auth(&login)
-            .send()?;
+            .send()
+            .await?;
         if res.status().is_success() {
-            Ok(res.json()?)
+            Ok(res.json().await?)
         } else {
             Err(Error::new(ErrorKind::ApiWithStatus {
                 status: res.status(),
-                message: res.text()?,
+                message: res.text().await?,
             }))
         }
     }
 
-    pub fn upload(
+    pub async fn upload(
         &self,
         login: &Login,
         public: bool,
@@ -142,18 +143,23 @@ impl Client {
             .post("https://api.github.com/gists")
             .auth(&login)
             .json(&req)
-            .send()?;
+            .send()
+            .await?;
         if res.status().is_success() {
-            Ok(res.json::<GistResponse>()?)
+            Ok(res.json::<GistResponse>().await?)
         } else {
             Err(Error::new(ErrorKind::ApiWithStatus {
                 status: res.status(),
-                message: res.text()?,
+                message: res.text().await?,
             }))
         }
     }
 
-    pub fn list(&self, login: Option<&Login>, username: Option<&str>) -> Result<ListResponse> {
+    pub async fn list(
+        &self,
+        login: Option<&Login>,
+        username: Option<&str>,
+    ) -> Result<ListResponse> {
         let mut builder = if let Some(username) = username {
             self.client
                 .get(&format!("https://api.github.com/users/{}/gists", username))
@@ -165,50 +171,52 @@ impl Client {
             builder = builder.auth(&login);
         }
 
-        let res = builder.send()?;
+        let res = builder.send().await?;
         if res.status().is_success() {
-            Ok(res.json::<ListResponse>()?)
+            Ok(res.json::<ListResponse>().await?)
         } else {
             Err(Error::new(ErrorKind::ApiWithStatus {
                 status: res.status(),
-                message: res.text()?,
+                message: res.text().await?,
             }))
         }
     }
 
-    pub fn list_starred(&self, login: &Login) -> Result<ListResponse> {
+    pub async fn list_starred(&self, login: &Login) -> Result<ListResponse> {
         let res = self
             .client
             .get("https://api.github.com/gists/starred")
             .auth(&login)
-            .send()?;
+            .send()
+            .await?;
         if res.status().is_success() {
-            Ok(res.json::<ListResponse>()?)
+            Ok(res.json::<ListResponse>().await?)
         } else {
             Err(Error::new(ErrorKind::ApiWithStatus {
                 status: res.status(),
-                message: res.text()?,
+                message: res.text().await?,
             }))
         }
     }
 
-    pub fn delete(&self, login: &Login, id: &str) -> Result<()> {
+    pub async fn delete(&self, login: &Login, id: &str) -> Result<()> {
         let res = self
             .client
             .delete(&format!("https://api.github.com/gists/{}", id))
             .auth(&login)
-            .send()?;
+            .send()
+            .await?;
         if res.status().is_success() {
             Ok(())
         } else {
             Err(Error::new(ErrorKind::ApiWithStatus {
                 status: res.status(),
-                message: res.text()?,
+                message: res.text().await?,
             }))
         }
     }
 
-    pub fn request_verification_code(
+    pub async fn request_verification_code(
         &self,
         client_id: &str,
         scope: &str,
@@ -222,18 +230,19 @@ impl Client {
             .post("https://github.com/login/device/code")
             .header(ACCEPT, HeaderValue::from_static("application/json"))
             .json(&req)
-            .send()?;
+            .send()
+            .await?;
         if res.status().is_success() {
-            Ok(res.json()?)
+            Ok(res.json().await?)
         } else {
             Err(Error::new(ErrorKind::ApiWithStatus {
                 status: res.status(),
-                message: res.text()?,
+                message: res.text().await?,
             }))
         }
     }
 
-    pub fn request_access_token(
+    pub async fn request_access_token(
         &self,
         client_id: &str,
         device_code: &str,
@@ -245,17 +254,18 @@ impl Client {
             grant_type: "urn:ietf:params:oauth:grant-type:device_code".to_owned(),
         };
         loop {
-            std::thread::sleep(Duration::from_secs(interval));
+            tokio::time::delay_for(Duration::from_secs(interval)).await;
 
             let res = self
                 .client
                 .post("https://github.com/login/oauth/access_token")
                 .header(ACCEPT, HeaderValue::from_static("application/json"))
                 .json(&req)
-                .send()?;
+                .send()
+                .await?;
 
             if res.status().is_success() {
-                match res.json::<AccessTokenResponse>()? {
+                match res.json::<AccessTokenResponse>().await? {
                     AccessTokenResponse::AccessToken { access_token } => {
                         return Ok(Login::OAuth(access_token))
                     }
@@ -267,7 +277,7 @@ impl Client {
             } else {
                 return Err(Error::new(ErrorKind::ApiWithStatus {
                     status: res.status(),
-                    message: res.text()?,
+                    message: res.text().await?,
                 }));
             }
         }

src/app.rs

@@ -4,30 +4,30 @@ use crate::api;
 use crate::config;
 use crate::error::Result;
 
-pub fn upload(
+pub async fn upload(
     login: &config::Login,
     secret: bool,
     description: Option<&str>,
     files: &[PathBuf],
 ) -> Result<()> {
     let client = api::Client::build()?;
-    let res = client.upload(&login, !secret, description, files)?;
+    let res = client.upload(&login, !secret, description, files).await?;
 
     println!("{}", res.html_url);
 
     Ok(())
 }
 
-pub fn list(login: Option<&config::Login>, username: Option<&str>) -> Result<()> {
+pub async fn list(login: Option<&config::Login>, username: Option<&str>) -> Result<()> {
     let client = api::Client::build()?;
-    let r = client.list(login, username)?;
+    let r = client.list(login, username).await?;
     list_gists(&r);
     Ok(())
 }
 
-pub fn list_starred(login: &config::Login) -> Result<()> {
+pub async fn list_starred(login: &config::Login) -> Result<()> {
     let client = api::Client::build()?;
-    let r = client.list_starred(login)?;
+    let r = client.list_starred(login).await?;
     list_gists(&r);
     Ok(())
 }
@@ -42,28 +42,30 @@ fn list_gists(gists: &[api::GistResponse]) {
     }
 }
 
-pub fn delete(login: &config::Login, id: &[String]) -> Result<()> {
+pub async fn delete(login: &config::Login, id: &[String]) -> Result<()> {
     let client = api::Client::build()?;
     for i in id.into_iter() {
-        client.delete(login, &i)?;
+        client.delete(login, &i).await?;
         println!("{}", i);
     }
     println!("Success!");
     Ok(())
 }
 
-pub fn login(client_id: &str) -> Result<()> {
+pub async fn login(client_id: &str) -> Result<()> {
     let client = api::Client::build()?;
 
-    let vc = client.request_verification_code(client_id, "gist")?;
+    let vc = client.request_verification_code(client_id, "gist").await?;
 
     println!("open {} and enter '{}'", vc.verification_uri, vc.user_code);
 
-    let login = client.request_access_token(client_id, &vc.device_code, vc.interval)?;
+    let login = client
+        .request_access_token(client_id, &vc.device_code, vc.interval)
+        .await?;
 
     println!("{:#?}", login);
 
-    let u = client.user(&login)?;
+    let u = client.user(&login).await?;
     println!("{:#?}", u);
 
     let mut cfg = config::load_config()?;

src/bin/gist.rs

@@ -81,28 +81,31 @@ struct Delete {
     id: Vec<String>,
 }
 
-fn main() -> Result<()> {
+#[tokio::main]
+async fn main() -> Result<()> {
     let args = Args::from_args();
 
     match args.command {
-        Subcommand::Login(opt) => gist::app::login(&opt.client_id),
+        Subcommand::Login(opt) => gist::app::login(&opt.client_id).await?,
         Subcommand::Upload(u) => {
             let l = select_account(args.account)?;
-            gist::app::upload(&l, u.secret, u.description.as_deref(), &u.files)
+            gist::app::upload(&l, u.secret, u.description.as_deref(), &u.files).await?;
         }
         Subcommand::List(opt) => {
             let l = select_account(args.account);
             if opt.starred {
-                gist::app::list_starred(&l?)
+                gist::app::list_starred(&l?).await?;
             } else {
-                gist::app::list(l.ok().as_ref(), opt.username.as_deref())
+                gist::app::list(l.ok().as_ref(), opt.username.as_deref()).await?;
             }
         }
         Subcommand::Delete(opt) => {
             let l = select_account(args.account)?;
-            gist::app::delete(&l, &opt.id)
+            gist::app::delete(&l, &opt.id).await?;
         }
     }
+
+    Ok(())
 }
 
 fn select_account(account: Account) -> Result<gist::config::Login> {