move async in services

src/commands/clone.rs

@@ -5,7 +5,7 @@ use regex::Regex;
 use crate::services::api::ApiError;
 use crate::services::req_props::{ReqProps, ObjProps};
 use crate::services::download_files::DownloadFiles;
-use crate::store::object;
+use crate::store::object::{self, add_blob, add_tree};
 use crate::commands;
 use crate::utils::api::ApiProps;
 use crate::global::global::{DIR_PATH, set_dir_path};
@@ -51,31 +51,28 @@ pub fn clone(remote: Values<'_>) {
         };
 
         // request folder content
-        let mut objs = vec![];
-        tokio::runtime::Runtime::new().unwrap().block_on(async {
-            let res = ReqProps::new()
-                .set_request(relative_s.as_str(), &api_props)
-                .gethref()
-                .getlastmodified()
-                .send_req_multiple()
-                .await;
-            objs = match res {
-                Ok(o) => o,
-                Err(ApiError::IncorrectRequest(err)) => {
-                    eprintln!("fatal: {}", err.status());
-                    std::process::exit(1);
-                },
-                Err(ApiError::EmptyError(_)) => {
-                    eprintln!("Failed to get body");
-                    vec![]
-                }
-                Err(ApiError::RequestError(err)) => {
-                    eprintln!("fatal: {}", err);
-                    std::process::exit(1);
-                },
-                Err(ApiError::Unexpected(_)) => todo!()
+        let res = ReqProps::new()
+            .set_request(relative_s.as_str(), &api_props)
+            .gethref()
+            .getlastmodified()
+            .send_req_multiple();
+
+        let mut objs = match res {
+            Ok(o) => o,
+            Err(ApiError::IncorrectRequest(err)) => {
+                eprintln!("fatal: {}", err.status());
+                std::process::exit(1);
+            },
+            Err(ApiError::EmptyError(_)) => {
+                eprintln!("Failed to get body");
+                vec![]
             }
-        });
+            Err(ApiError::RequestError(err)) => {
+                eprintln!("fatal: {}", err);
+                std::process::exit(1);
+            },
+            Err(ApiError::Unexpected(_)) => todo!()
+        };
 
         // create folder
         if first_iter {
@@ -90,14 +87,14 @@ pub fn clone(remote: Values<'_>) {
             // create folder
             let p = ref_path.clone().join(Path::new(&relative_s));
             if let Err(err) = DirBuilder::new().recursive(true).create(p.clone()) {
-                eprintln!("error: cannot create directory {}: {}", p.display(), err);
+                eprintln!("err: cannot create directory {}: {}", p.display(), err);
             }
 
             // add tree
             let path_folder = p.strip_prefix(ref_path.clone()).unwrap();
-            let last_modified = folder.lastmodified.unwrap().timestamp_millis();
-            if object::add_tree(&path_folder, &last_modified.to_string()).is_err() {
-                eprintln!("error: cannot store object {}", path_folder.display());
+            let lastmodified = folder.lastmodified.unwrap().timestamp_millis();
+            if let Err(err) = add_tree(&path_folder, &lastmodified.to_string()) {
+                eprintln!("err: saving ref of {}: {}", path_folder.display(), err);
             }
         }
 
@@ -119,34 +116,32 @@ pub fn clone(remote: Values<'_>) {
 
 fn download_files(ref_p: PathBuf, files: Vec<ObjProps>, api_props: &ApiProps) {
     for obj in files {
-        tokio::runtime::Runtime::new().unwrap().block_on(async {
-            let relative_s = &obj.clone().relative_s.unwrap();
-            let res = DownloadFiles::new()
-                .set_url(&relative_s, api_props)
-                .save(ref_p.clone()).await;
+        let relative_s = &obj.clone().relative_s.unwrap();
+        let res = DownloadFiles::new()
+            .set_url(&relative_s, api_props)
+            .save(ref_p.clone());
 
-            match res {
-                Ok(()) => {
-                    let relative_p = Path::new(&relative_s);
-                    let last_modified = obj.clone().lastmodified.unwrap().timestamp_millis();
-                    if let Err(_) = object::add_blob(relative_p, &last_modified.to_string()) {
-                        eprintln!("error saving reference of {}", relative_s.clone());
-                    }
-                },
-                Err(ApiError::Unexpected(_)) => {
-                    eprintln!("error writing {}", relative_s);
-                },
-                Err(ApiError::IncorrectRequest(err)) => {
-                    eprintln!("fatal: {}", err.status());
-                    std::process::exit(1);
-                },
-                Err(ApiError::EmptyError(_)) => eprintln!("Failed to get body"),
-                Err(ApiError::RequestError(err)) => {
-                    eprintln!("fatal: {}", err);
-                    std::process::exit(1);
+        match res {
+            Ok(()) => {
+                let relative_p = Path::new(&relative_s);
+                let lastmodified = obj.clone().lastmodified.unwrap().timestamp_millis();
+                if let Err(err) = add_blob(relative_p, &lastmodified.to_string()) {
+                    eprintln!("err: saving ref of {}: {}", relative_s.clone(), err);
                 }
+            },
+            Err(ApiError::Unexpected(_)) => {
+                eprintln!("err: writing {}", relative_s);
+            },
+            Err(ApiError::IncorrectRequest(err)) => {
+                eprintln!("fatal: {}", err.status());
+                std::process::exit(1);
+            },
+            Err(ApiError::EmptyError(_)) => eprintln!("Failed to get body"),
+            Err(ApiError::RequestError(err)) => {
+                eprintln!("fatal: {}", err);
+                std::process::exit(1);
             }
-        });
+        }
     }
 }
 

src/commands/push.rs

@@ -57,25 +57,22 @@ struct New {
 impl PushChange for New {
     fn can_push(&self) -> PushState {
         // check if exist on server
-        let file_infos = tokio::runtime::Runtime::new().unwrap().block_on(async {
-            let res = ReqProps::new()
-                .set_url(&self.obj.path.to_str().unwrap())
-                .getlastmodified()
-                .send_req_single()
-                .await;
+        let res = ReqProps::new()
+            .set_url(&self.obj.path.to_str().unwrap())
+            .getlastmodified()
+            .send_req_single();
 
-            match res {
-                Ok(obj) => Ok(Some(obj)),
-                Err(ApiError::IncorrectRequest(err)) => {
-                    if err.status() == 404 {
-                        Ok(None)
-                    } else {
-                        Err(())
-                    }
-                },
-                Err(_) => Err(()),
-            }
-        });
+        let file_infos = match res {
+            Ok(obj) => Ok(Some(obj)),
+            Err(ApiError::IncorrectRequest(err)) => {
+                if err.status() == 404 {
+                    Ok(None)
+                } else {
+                    Err(())
+                }
+            },
+            Err(_) => Err(()),
+        };
 
         if let Ok(infos) = file_infos {
             if let Some(info) = infos {
@@ -92,25 +89,22 @@ impl PushChange for New {
 
     fn push(&self) {
         let obj = &self.obj;
-        tokio::runtime::Runtime::new().unwrap().block_on(async {
-            let res = UploadFile::new()
-                .set_url(obj.path.to_str().unwrap())
-                .set_file(obj.path.clone())
-                .send_with_err()
-                .await;
+        let res = UploadFile::new()
+            .set_url(obj.path.to_str().unwrap())
+            .set_file(obj.path.clone())
+            .send_with_err();
 
-            match res {
-                Err(ApiError::IncorrectRequest(err)) => {
-                    eprintln!("fatal: error pushing file {}: {}", obj.name, err.status());
-                    std::process::exit(1);
-                },
-                Err(ApiError::RequestError(_)) => {
-                    eprintln!("fatal: request error pushing file {}", obj.name);
-                    std::process::exit(1);
-                }
-                _ => (),
+        match res {
+            Err(ApiError::IncorrectRequest(err)) => {
+                eprintln!("fatal: error pushing file {}: {}", obj.name, err.status());
+                std::process::exit(1);
+            },
+            Err(ApiError::RequestError(_)) => {
+                eprintln!("fatal: request error pushing file {}", obj.name);
+                std::process::exit(1);
             }
-        });
+            _ => (),
+        }
 
         // update tree
         add_blob(&obj.path.clone(), "todo_date");
@@ -128,25 +122,22 @@ struct Deleted {
 impl PushChange for Deleted {
     fn can_push(&self) -> PushState {
         // check if exist on server
-        let file_infos = tokio::runtime::Runtime::new().unwrap().block_on(async {
-            let res = ReqProps::new()
-                .set_url(&self.obj.path.to_str().unwrap())
-                .getlastmodified()
-                .send_with_err()
-                .await;
+        let res = ReqProps::new()
+            .set_url(&self.obj.path.to_str().unwrap())
+            .getlastmodified()
+            .send_with_err();
 
-            match res {
-                Ok(obj) => Ok(Some(obj)),
-                Err(ApiError::IncorrectRequest(err)) => {
-                    if err.status() == 404 {
-                        Ok(None)
-                    } else {
-                        Err(())
-                    }
-                },
-                Err(_) => Err(()),
-            }
-        });
+        let file_infos = match res {
+            Ok(obj) => Ok(Some(obj)),
+            Err(ApiError::IncorrectRequest(err)) => {
+                if err.status() == 404 {
+                    Ok(None)
+                } else {
+                    Err(())
+                }
+            },
+            Err(_) => Err(()),
+        };
 
         if let Ok(infos) = file_infos {
             if let Some(inf) = infos {
@@ -164,24 +155,21 @@ impl PushChange for Deleted {
 
     fn push(&self) {
         let obj = &self.obj;
-        tokio::runtime::Runtime::new().unwrap().block_on(async {
-            let res = DeletePath::new()
-                .set_url(obj.path.to_str().unwrap())
-                .send_with_err()
-                .await;
+        let res = DeletePath::new()
+            .set_url(obj.path.to_str().unwrap())
+            .send_with_err();
 
-            match res {
-                Err(ApiError::IncorrectRequest(err)) => {
-                    eprintln!("fatal: error deleting file {}: {}", obj.name, err.status());
-                    std::process::exit(1);
-                },
-                Err(ApiError::RequestError(_)) => {
-                    eprintln!("fatal: request error deleting file {}", obj.name);
-                    std::process::exit(1);
-                }
-                _ => (),
+        match res {
+            Err(ApiError::IncorrectRequest(err)) => {
+                eprintln!("fatal: error deleting file {}: {}", obj.name, err.status());
+                std::process::exit(1);
+            },
+            Err(ApiError::RequestError(_)) => {
+                eprintln!("fatal: request error deleting file {}", obj.name);
+                std::process::exit(1);
             }
-        });
+            _ => (),
+        }
 
         // update tree
         rm_blob(&obj.path.clone());