change create dir's to fs::create_dir_all

Author: ThePhoenixPixel

src/cloud.rs

@@ -1,3 +1,12 @@
+use std::error::Error;
+use bx::network::url::Url;
+use colored::{ColoredString, Colorize};
+use std::{env, fs};
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::RwLock;
+
 use crate::core::services_all::AllServices;
 use crate::core::services_local::LocalServices;
 use crate::core::services_network::NetworkServices;
@@ -7,14 +16,7 @@ use crate::sys_config::software_config::SoftwareConfig;
 use crate::terminal::cmd::Cmd;
 use crate::utils::logger::Logger;
 use crate::{log_error, log_info, log_warning};
-use bx::network::url::Url;
-use bx::path::Directory;
-use colored::{ColoredString, Colorize};
-use std::env;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::RwLock;
+
 
 #[cfg(feature = "rest-api")]
 use crate::rest_api::restapi_main::ApiMain;
@@ -72,13 +74,13 @@ impl Cloud {
         CloudConfig::check(&url).await;
 
         // check folder
-        Cloud::check_folder();
+        Cloud::check_folder().expect("Checking Folder failed");
 
         // check software config file
         SoftwareConfig::check(&url).await;
 
         // check the software files
-        Cloud::check_software().await;
+        Cloud::check_software().await.expect("Checking Software failed");
 
         // NodeServer
         {
@@ -252,46 +254,48 @@ impl Cloud {
         }
     }
 
-    pub fn check_folder() {
+    pub fn check_folder() -> Result<(), Box<dyn Error>> {
         let config_path = CloudConfig::get().get_cloud_path();
 
         // create task folder
-        Directory::create_path(&config_path.get_task_folder_path());
+        fs::create_dir_all(&config_path.get_task_folder_path())?;
 
         // create template folder
-        Directory::create_path(&config_path.get_template_folder_path());
+        fs::create_dir_all(&config_path.get_template_folder_path())?;
 
         // create service temp folder
-        Directory::create_path(&config_path.get_service_folder().get_temp_folder_path());
+        fs::create_dir_all(&config_path.get_service_folder().get_temp_folder_path())?;
 
         // create service static folder
-        Directory::create_path(&config_path.get_service_folder().get_static_folder_path());
+        fs::create_dir_all(&config_path.get_service_folder().get_static_folder_path())?;
 
         // create system_plugins_folder
-        Directory::create_path(
+        fs::create_dir_all(
             &config_path
                 .get_system_folder()
                 .get_system_plugins_folder_path(),
-        );
+        )?;
 
         // create software_files_folder
-        Directory::create_path(
+        fs::create_dir_all(
             &config_path
                 .get_system_folder()
                 .get_software_files_folder_path(),
-        );
+        )?;
 
         // create software_lib_folder
-        Directory::create_path(
+        fs::create_dir_all(
             &config_path
                 .get_system_folder()
                 .get_software_lib_folder_path(),
-        );
+        )?;
         log_info!("All Folders are safe :=)");
+        Ok(())
     }
 
     // check software && system plugins
-    pub async fn check_software() {
+    pub async fn check_software() -> Result<(), Box<dyn Error>> {
+        // Todo: refactoren 'check_software()'
         let software_types = SoftwareConfig::get().get_software_types();
         let cloud_config_system = CloudConfig::get().get_cloud_path().get_system_folder();
 
@@ -309,9 +313,9 @@ impl Cloud {
                 .join(&software_type_name);
 
             // create the software types folder
-            Directory::create_path(&software_path);
-            Directory::create_path(&system_plugins_path);
-            Directory::create_path(&software_lib_path);
+            fs::create_dir_all(&software_path)?;
+            fs::create_dir_all(&system_plugins_path)?;
+            fs::create_dir_all(&software_lib_path)?;
 
             // iter to software names
             for software in software_type.get_software_names() {
@@ -344,7 +348,7 @@ impl Cloud {
                         }
                         Err(e) => {
                             log_error!("{}", e.to_string());
-                            panic!("Can not download the software {}", software_file_url);
+                            return Err(e);
                         }
                     }
                 }
@@ -369,10 +373,7 @@ impl Cloud {
                         }
                         Err(e) => {
                             log_error!("{}", e.to_string());
-                            panic!(
-                                "Can not download the Software System Plugin {}",
-                                software.get_system_plugin().get_download()
-                            );
+                            return Err(e);
                         }
                     }
                 }
@@ -387,7 +388,7 @@ impl Cloud {
                     {
                         let mut path = software_lib_path.clone();
                         path.pop();
-                        Directory::create_path(&path);
+                        fs::create_dir_all(&path)?;
 
                         match Url::download_file(&url_str, &software_lib_path).await {
                             Ok(_) => log_info!(
@@ -405,6 +406,7 @@ impl Cloud {
                 }
             }
         }
+        Ok(())
     }
 }
 

src/core/service.rs

@@ -422,7 +422,7 @@ impl Service {
 
     pub fn save_to_file(&self) {
         let path = self.get_path_with_service_config();
-        Directory::create_path(&path);
+        fs::create_dir_all(&path).expect("Cant create Service File in 'save_to_file'");
         if File::create(self.get_path_with_service_file()).is_err() {
             log_error!("Error by create to service config file");
             return;
@@ -637,7 +637,7 @@ impl Service {
             .join(&software.get_system_plugin().get_path());
 
         if !target_path.exists() {
-            Directory::create_path(&target_path);
+            fs::create_dir_all(&target_path)?;
         }
 
         target_path.push(self.get_task().get_software().get_system_plugin_name());

src/core/services_local.rs

@@ -1,11 +1,13 @@
-use crate::core::service::Service;
-use crate::core::task::Task;
-use crate::sys_config::cloud_config::CloudConfig;
 use bx::path::Directory;
 use std::io::Error;
 use std::path::PathBuf;
 use uuid::Uuid;
 
+use crate::core::service::Service;
+use crate::core::task::Task;
+use crate::sys_config::cloud_config::CloudConfig;
+
+
 pub struct LocalServices {
     services: Vec<Service>,
 }
@@ -117,7 +119,7 @@ impl LocalServices {
     }
 
     pub async fn stop_all(&mut self, shutdown_msg: &str) {
-        let ids: Vec<Uuid> = self.get_started_services()
+        let ids: Vec<Uuid> = self.get_all()
             .iter()
             .map(|s| s.get_id())
             .collect();

src/core/task.rs

@@ -2,7 +2,7 @@ use bx::path::Directory;
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 use std::fs::File;
-use std::io::{Read, Write};
+use std::io::{Error, Read, Write};
 use std::path::PathBuf;
 use std::{fs, io};
 
@@ -423,7 +423,7 @@ impl Task {
 
     pub fn prepared_to_service(&self) -> Result<PathBuf, String> {
         // create the next free service folder with the template
-        let target_path = &self.create_next_free_service_folder();
+        let target_path = &self.create_next_free_service_folder().map_err(|e| e.to_string())?;
         let templates = &self.get_templates();
         let template = match select_template_with_priority(&templates) {
             Some(template) => template,
@@ -442,7 +442,7 @@ impl Task {
     }
 
     // create the next not exist service folder
-    fn create_next_free_service_folder(&self) -> PathBuf {
+    fn create_next_free_service_folder(&self) -> Result<PathBuf, Error> {
         let mut folder_index: u32 = 1;
         let target_base_path = self.get_service_path();
         let mut target_service_folder_path =
@@ -454,8 +454,8 @@ impl Task {
                 target_base_path.join(format!("{}-{}", &self.get_name(), folder_index));
         }
 
-        Directory::create_path(&target_service_folder_path);
-        target_service_folder_path
+        fs::create_dir_all(&target_service_folder_path)?;
+        Ok(target_service_folder_path)
     }
 
     //get temp or static for the service

src/core/template.rs

@@ -1,6 +1,6 @@
+use std::fs;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
-use bx::path::Directory;
 
 use crate::core::task::Task;
 use crate::sys_config::cloud_config::CloudConfig;
@@ -83,12 +83,12 @@ impl Template {
         template_path.push("default");
 
         if !template_path.exists() {
-            Directory::create_path(&template_path);
+            fs::create_dir_all(template_path).expect("Cant create Template Path in 'create_by_task'");
         }
     }
 
     pub fn create(&self) {
-        Directory::create_path(&self.get_path());
+        fs::create_dir_all(&self.get_path()).expect("Cant create Template Path in 'create'");
     }
 
     pub fn exists(&self) -> bool {

src/utils/logger.rs

@@ -1,13 +1,13 @@
 use chrono::Local;
 use colored::{ColoredString, Colorize};
-use std::env;
+use std::{env, fs};
 use std::fs::OpenOptions;
 use std::io::Write;
-use bx::path::Directory;
 
 use crate::sys_config::cloud_config::CloudConfig;
 use crate::utils::log::Log;
 
+
 pub struct Logger;
 
 impl Logger {
@@ -47,7 +47,7 @@ impl Logger {
             env::current_exe().expect("Cloud Error can not get the exe path of the cloud system");
         log_path.pop();
         log_path.push("log");
-        Directory::create_path(&log_path);
+        fs::create_dir_all(&log_path).expect("Cant create Log File path in 'write_in_file'");
 
         let file_name = format!("log_{}.log", Local::now().format("%Y-%m-%d"));
         log_path.push(&file_name);