moved to async http client and serde

1 files changed, 83 insertions, 84 deletions

diff --git a/src/client.rs b/src/client.rs
index 293ef2f..c323714 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,12 +1,14 @@
-use std::fs::File;
+use std::path::Path;
 
-use ureq::RequestBuilder;
+use reqwest::{Body, RequestBuilder};
+use tokio_util::codec::{BytesCodec, FramedRead};
 
 use crate::types::*;
 
 type Result<T> = std::result::Result<T, HydrusError>;
 
 pub struct HydrusClient {
+    client: reqwest::Client,
     apikey: Option<String>,
     sessionkey: Option<String>,
     url: String,
@@ -15,6 +17,7 @@ pub struct HydrusClient {
 impl HydrusClient {
     pub fn new(url: &str) -> HydrusClient {
         HydrusClient {
+            client: reqwest::Client::new(),
             apikey: None,
             sessionkey: None,
             url: url.to_string(),
@@ -29,65 +32,68 @@ impl HydrusClient {
         self.sessionkey = Some(key.to_owned())
     }
 
-    pub fn request_new_permissions(
+    pub async fn request_new_permissions(
         &self,
         name: &str,
         permissions: &[HydrusPermissions],
     ) -> Result<String> {
         let mut req_url = self.url.to_owned();
         req_url.push_str("request_new_permissions?name=");
-        req_url.push_str(&urlencoding::encode(name));
+
+        req_url.push_str(name);
 
         if permissions.is_empty() {
             req_url.push_str("&permit_everything=true");
         } else {
+            let json_string = &serde_json::to_string(&permissions)?;
             req_url.push_str("&basic_permissions=");
-            let json_string = musli::json::to_string(&permissions)?;
-            req_url.push_str(&urlencoding::encode(&json_string));
+            req_url.push_str(&urlencoding::encode(json_string));
         };
 
-        let response = ureq::get(req_url).call()?.body_mut().read_to_vec()?;
-
-        let key: AccessKey = musli::json::decode(response.as_slice())?;
-
-        Ok(key.access_key)
+        Ok(self
+            .client
+            .get(req_url)
+            .send()
+            .await?
+            .json::<AccessKey>()
+            .await?
+            .access_key)
     }
 
-    pub fn get_session_key(&self) -> Result<String> {
+    pub async fn get_session_key(&self) -> Result<String> {
         let mut req_url = self.url.to_owned();
         req_url.push_str("session_key");
 
-        let mut request = ureq::get(req_url);
+        let mut request = self.client.get(req_url);
 
         if let Some(key) = &self.apikey {
             request = request.header("Hydrus-Client-API-Access-Key", key);
         }
 
-        let response = request.call()?.body_mut().read_to_vec()?;
-
-        let key: SessionKey = musli::json::decode(response.as_slice())?;
-
-        Ok(key.session_key)
+        Ok(request
+            .send()
+            .await?
+            .json::<SessionKey>()
+            .await?
+            .session_key)
     }
 
-    pub fn verify_access_key(&self, key: &str) -> Result<KeyInfo> {
+    pub async fn verify_access_key(&self, key: &str) -> Result<KeyInfo> {
         let mut req_url = self.url.to_owned();
         req_url.push_str("verify_access_key");
-        let response = ureq::get(req_url)
-            .header("Hydrus-Client-API-Access-Key", key)
-            .call()?
-            .body_mut()
-            .read_to_vec()?;
 
-        let data: KeyInfo = musli::json::decode(response.as_slice())?;
-
-        Ok(data)
+        Ok(self
+            .client
+            .get(req_url)
+            .header("Hydrus-Client-API-Access-Key", key)
+            .send()
+            .await?
+            .json::<KeyInfo>()
+            .await?)
     }
 
-    fn set_get_api_key(
-        &self,
-        request: RequestBuilder<ureq::typestate::WithoutBody>,
-    ) -> Result<RequestBuilder<ureq::typestate::WithoutBody>> {
+    fn set_get_request_key(&self, url: &str) -> Result<RequestBuilder> {
+        let request = self.client.get(url);
         if let Some(key) = &self.sessionkey {
             Ok(request.header("Hydrus-Client-API-Access-Key", key))
         } else if let Some(key) = &self.apikey {
@@ -97,10 +103,8 @@ impl HydrusClient {
         }
     }
 
-    fn set_post_api_key(
-        &self,
-        request: RequestBuilder<ureq::typestate::WithBody>,
-    ) -> Result<RequestBuilder<ureq::typestate::WithBody>> {
+    fn set_post_request_key(&self, url: &str) -> Result<RequestBuilder> {
+        let request = self.client.post(url);
         if let Some(key) = &self.sessionkey {
             Ok(request.header("Hydrus-Client-API-Access-Key", key))
         } else if let Some(key) = &self.apikey {
@@ -110,52 +114,46 @@ impl HydrusClient {
         }
     }
 
-    pub fn get_service_name(&self, name: &str) -> Result<Service> {
+    pub async fn get_service_name(&self, name: &str) -> Result<Service> {
         let mut req_url = self.url.to_owned();
         req_url.push_str("get_service?service_name=");
         req_url.push_str(&urlencoding::encode(name));
 
-        let response = self
-            .set_get_api_key(ureq::get(req_url))?
-            .call()?
-            .body_mut()
-            .read_to_vec()?;
-
-        let service: Service = musli::json::decode(response.as_slice())?;
-        Ok(service)
+        Ok(self
+            .set_get_request_key(&req_url)?
+            .send()
+            .await?
+            .json::<Service>()
+            .await?)
     }
 
-    pub fn get_service_key(&self, key: &str) -> Result<Service> {
+    pub async fn get_service_key(&self, key: &str) -> Result<Service> {
         let mut req_url = self.url.to_owned();
         req_url.push_str("get_service?service_key=");
         req_url.push_str(&urlencoding::encode(key));
 
-        let response = self
-            .set_get_api_key(ureq::get(req_url))?
-            .call()?
-            .body_mut()
-            .read_to_vec()?;
-
-        let service: Service = musli::json::decode(response.as_slice())?;
-        Ok(service)
+        Ok(self
+            .set_get_request_key(&req_url)?
+            .send()
+            .await?
+            .json::<Service>()
+            .await?)
     }
 
-    pub fn get_services(&self) -> Result<Vec<Service>> {
+    pub async fn get_services(&self) -> Result<Vec<Service>> {
         let mut req_url = self.url.to_owned();
         req_url.push_str("get_services");
 
-        let response = self
-            .set_get_api_key(ureq::get(req_url))?
-            .call()?
-            .body_mut()
-            .read_to_vec()?;
-
-        let services: ServiceResponse = musli::json::decode(response.as_slice())?;
-
-        Ok(services.service_vec())
+        Ok(self
+            .set_get_request_key(&req_url)?
+            .send()
+            .await?
+            .json::<ServiceResponse>()
+            .await?
+            .service_vec())
     }
 
-    pub fn add_file_via_path(
+    pub async fn add_file_via_path(
         &self,
         path: &str,
         delete: Option<bool>,
@@ -178,34 +176,35 @@ impl HydrusClient {
             }
         }
 
-        let data = musli::json::to_vec(&form)?;
-
         let mut req_url = self.url.to_owned();
         req_url.push_str("add_files/add_file");
 
-        let response = self
-            .set_post_api_key(ureq::post(req_url))?
-            .content_type("application/json")
-            .send(data)?
-            .body_mut()
-            .read_to_vec()?;
-
-        let status: FileAddResponse = musli::json::decode(response.as_slice())?;
-        Ok(status)
+        Ok(self
+            .set_post_request_key(&req_url)?
+            .header("Content-Type", "application/json")
+            .json(&form)
+            .send()
+            .await?
+            .json::<FileAddResponse>()
+            .await?)
     }
 
-    pub fn add_file_via_file(&self, file: &File) -> Result<FileAddResponse> {
+    pub async fn add_file_via_file(&self, file: impl AsRef<Path>) -> Result<FileAddResponse> {
         let mut req_url = self.url.to_owned();
         req_url.push_str("add_files/add_file");
 
-        let response = self
-            .set_post_api_key(ureq::post(req_url))?
-            .content_type("application/octet-stream")
-            .send(file)?
-            .body_mut()
-            .read_to_vec()?;
+        let file = tokio::fs::File::open(file).await?;
+
+        let stream = FramedRead::new(file, BytesCodec::new());
+        let body = Body::wrap_stream(stream);
 
-        let status: FileAddResponse = musli::json::decode(response.as_slice())?;
-        Ok(status)
+        Ok(self
+            .set_post_request_key(&req_url)?
+            .header("Content-Type", "application/octet-stream")
+            .body(body)
+            .send()
+            .await?
+            .json::<FileAddResponse>()
+            .await?)
     }
 }