feat(config): support multiple config format

Author: BobAnkh

Cargo.toml

@@ -20,3 +20,6 @@ serde = { version = "1.0", features = ["derive"] }
 futures = "0.3"
 pbr = "1.0.4"
 num_cpus = "1.13"
+ron = "0.8"
+serde_json = "1.0"
+serde_yaml = "0.9"

README.md

@@ -17,6 +17,8 @@ Examples see `examples/simple.rs`.
 
 To run the example, you can first execute the script `setup-ns3.sh` then execute `cargo run --example simple` in the root directory.
 
+Currently support 4 config file formats: toml, ron, json, yaml. Example config files can see `config.toml` and `config.ron` under root. **Welcome contributions for any new config format**.
+
 ## Maintainer
 
 [@BobAnkh](https://github.com/BobAnkh)

config.ron

@@ -0,0 +1,26 @@
+{
+    "exp-1": (
+        policy: [
+            1, 2
+        ],
+        app_name: "ns3-tcp-bbr",
+        sim_time: 5,
+    ),
+    "exp-2": (
+        policy: [
+            1, 2, 3, 4
+        ],
+        app_name: "ns3-tcp-cubic",
+        sim_time: 2,
+    ),
+    "exp-3": (
+        policy: [
+            1, 2, 3, 4
+        ],
+        app_name: "ns3-tcp-copa",
+    ),
+    "exp-4": (
+        app_name: "ns3-tcp-creno",
+        sim_time: 2,
+    )
+}

examples/simple.rs

@@ -1,4 +1,4 @@
-use ns3_parallel::{BuildCmd, BuildParam, Executor, ExecutorBuilder};
+use ns3_parallel::{executor::ConfigFormat, BuildCmd, BuildParam, Executor, ExecutorBuilder};
 use serde::{Deserialize, Serialize};
 
 // This is what you want to read from your configuration file.
@@ -62,9 +62,11 @@ impl BuildCmd for MyParam {
 
 #[tokio::main]
 async fn main() {
+    // ========== Use toml format as the config file ==========
     // Use ExecutorBuilder to build your executor.
     let mut exe: Executor<MyConfig, MyParam> = ExecutorBuilder::new()
         .config_path("config.toml")
+        .config_format(ConfigFormat::Toml)
         .ns3_path("ns-allinone-3.33/ns-3.33/")
         .build()
         .unwrap();
@@ -81,4 +83,28 @@ async fn main() {
             println!("{}", task.stderr);
         }
     }
+
+    // ========== Use ron format as the config file ==========
+    // Use ExecutorBuilder to build your executor.
+    let mut exe: Executor<MyConfig, MyParam> = ExecutorBuilder::new()
+        .config_path("config.ron")
+        .config_format(ConfigFormat::Ron)
+        .ns3_path("ns-allinone-3.33/ns-3.33/")
+        .task_concurrent(4)
+        .retry_limit(2)
+        .build()
+        .unwrap();
+
+    // Run your executor.
+    let _ = exe.execute().await.unwrap();
+
+    // Collect your results.
+    let outputs = exe.get_outputs().to_owned();
+
+    // Here I just print all the results, you can do whatever you want with them here.
+    for (_, output) in outputs {
+        for task in output {
+            println!("{}", task.stderr);
+        }
+    }
 }

src/error.rs

@@ -1,14 +1,51 @@
 //! Error
 
+use ron::error::SpannedError;
+use std::io;
+use tokio::task::JoinError;
+
 /// # Error
 ///
 /// Error type for NS3 executor.
 #[derive(Debug, Clone)]
 pub enum Error {
     InvalidConfig(String),
     FileNotFound(String),
-    InvalidTomlFormat(String),
+    InvalidConfigFormat(String),
     ExecuteFail(String),
     BuildFail(String),
+    IoError(String),
+    JoinError(String),
+    NotImplement(String),
     RetryLimitExceed,
 }
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self {
+        Error::IoError(format!("{:?}", e))
+    }
+}
+
+impl From<JoinError> for Error {
+    fn from(e: JoinError) -> Self {
+        Error::JoinError(format!("{:?}", e))
+    }
+}
+
+impl From<SpannedError> for Error {
+    fn from(e: SpannedError) -> Self {
+        Error::InvalidConfigFormat(format!("{:?}", e))
+    }
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(e: serde_json::Error) -> Self {
+        Error::InvalidConfigFormat(format!("{:?}", e))
+    }
+}
+
+impl From<serde_yaml::Error> for Error {
+    fn from(e: serde_yaml::Error) -> Self {
+        Error::InvalidConfigFormat(format!("{:?}", e))
+    }
+}

src/executor.rs

@@ -1,8 +1,9 @@
 use futures::stream::FuturesUnordered;
 use futures::StreamExt;
 use pbr::MultiBar;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Output;
 use tokio::process::Command;
 use tokio::task::spawn_blocking;
@@ -12,9 +13,21 @@ use crate::error::Error;
 
 const DEFAULT_RETRY_LIMIT: i32 = 5;
 
+/// Used for ExecutorBuilder.
+///
+/// Specify the format of your config file. Default to `ConfigFormat::Toml`
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub enum ConfigFormat {
+    Ron,
+    Json,
+    Toml,
+    Yaml,
+}
+
 #[derive(Debug, Clone)]
 pub struct Executor<T: Default + BuildParam<P>, P: BuildCmd> {
     config_path: String,
+    config_format: ConfigFormat,
     ns3_path: String,
     task_concurrent: usize,
     retry_limit: u32,
@@ -25,6 +38,7 @@ pub struct Executor<T: Default + BuildParam<P>, P: BuildCmd> {
 #[derive(Debug, Clone)]
 pub struct ExecutorBuilder {
     pub config_path: Option<String>,
+    pub config_format: Option<ConfigFormat>,
     pub ns3_path: Option<String>,
     pub task_concurrent: Option<usize>,
     pub retry_limit: Option<u32>,
@@ -43,6 +57,10 @@ impl<T: Default + BuildParam<P>, P: BuildCmd> Executor<T, P> {
         &self.config_path
     }
 
+    pub fn get_config_format(&self) -> &ConfigFormat {
+        &self.config_format
+    }
+
     pub fn get_ns3_path(&self) -> &str {
         &self.ns3_path
     }
@@ -121,6 +139,56 @@ impl<T: Default + BuildParam<P>, P: BuildCmd> Executor<T, P> {
     }
 }
 
+fn check_config_file(config_path: &String, ext: &ConfigFormat) -> Result<PathBuf, Error> {
+    let config_file_path = match Path::new(&config_path).canonicalize() {
+        Ok(path) => path,
+        Err(e) => {
+            return Err(Error::FileNotFound(format!(
+                "Can not locate config file: {:?}.",
+                e
+            )));
+        }
+    };
+    match config_file_path.extension() {
+        Some(t) => match ext {
+            ConfigFormat::Ron => {
+                if t != "ron" {
+                    return Err(Error::InvalidConfig(
+                        "Config file must be a ron file.".to_string(),
+                    ));
+                }
+            }
+            ConfigFormat::Json => {
+                if t != "json" {
+                    return Err(Error::InvalidConfig(
+                        "Config file must be a json file.".to_string(),
+                    ));
+                }
+            }
+            ConfigFormat::Toml => {
+                if t != "toml" {
+                    return Err(Error::InvalidConfig(
+                        "Config file must be a toml file.".to_string(),
+                    ));
+                }
+            }
+            ConfigFormat::Yaml => {
+                if t != "yaml" {
+                    return Err(Error::InvalidConfig(
+                        "Config file must be a yaml file.".to_string(),
+                    ));
+                }
+            }
+        },
+        None => {
+            return Err(Error::InvalidConfig(
+                "Config file must have a valid file extension.".to_string(),
+            ));
+        }
+    }
+    Ok(config_file_path)
+}
+
 impl Default for ExecutorBuilder {
     fn default() -> Self {
         Self::new()
@@ -131,6 +199,7 @@ impl ExecutorBuilder {
     pub fn new() -> Self {
         Self {
             config_path: None,
+            config_format: None,
             ns3_path: None,
             task_concurrent: None,
             retry_limit: None,
@@ -142,6 +211,11 @@ impl ExecutorBuilder {
         self
     }
 
+    pub fn config_format(mut self, config_format: ConfigFormat) -> Self {
+        self.config_format = Some(config_format);
+        self
+    }
+
     pub fn ns3_path(mut self, ns3_path: &str) -> Self {
         self.ns3_path = Some(ns3_path.to_string());
         self
@@ -157,41 +231,21 @@ impl ExecutorBuilder {
         self
     }
 
-    pub fn build<'de, T: Default + BuildParam<P> + serde::de::Deserialize<'de>, P: BuildCmd>(
+    pub fn build<T: Default + BuildParam<P> + serde::de::DeserializeOwned, P: BuildCmd>(
         self,
     ) -> Result<Executor<T, P>, Error> {
-        let mut config_path = self
-            .config_path
-            .unwrap_or_else(|| "config.toml".to_string());
+        let config_format = self.config_format.unwrap_or(ConfigFormat::Toml);
+        let mut config_path = self.config_path.unwrap_or_else(|| match &config_format {
+            ConfigFormat::Ron => "config.ron".to_string(),
+            ConfigFormat::Toml => "config.toml".to_string(),
+            ConfigFormat::Json => "config.json".to_string(),
+            ConfigFormat::Yaml => "config.yaml".to_string(),
+        });
         let mut ns3_path = self.ns3_path.unwrap_or_else(|| "/".to_string());
         let task_concurrent = self.task_concurrent.unwrap_or_else(num_cpus::get);
-        let retry_limit = self
-            .retry_limit
-            .unwrap_or_else(|| DEFAULT_RETRY_LIMIT as u32);
+        let retry_limit = self.retry_limit.unwrap_or(DEFAULT_RETRY_LIMIT as u32);
         // Check config file
-        let config_file_path = match Path::new(&config_path).canonicalize() {
-            Ok(path) => path,
-            Err(e) => {
-                return Err(Error::FileNotFound(format!(
-                    "Can not locate config file: {:?}.",
-                    e
-                )));
-            }
-        };
-        match config_file_path.extension() {
-            Some(t) => {
-                if t != "toml" {
-                    return Err(Error::InvalidConfig(
-                        "Config file must be a toml file.".to_string(),
-                    ));
-                }
-            }
-            None => {
-                return Err(Error::InvalidConfig(
-                    "Config file must have a valid file extension.".to_string(),
-                ));
-            }
-        }
+        let config_file_path = check_config_file(&config_path, &config_format)?;
         config_path = config_file_path.display().to_string();
         // check ns3 directory
         let ns3_dir_path = match Path::new(&ns3_path).join("waf").canonicalize() {
@@ -204,36 +258,44 @@ impl ExecutorBuilder {
             }
         };
         ns3_path = ns3_dir_path.parent().unwrap().display().to_string();
-        let configuration = match std::fs::read_to_string(config_file_path) {
-            Ok(c) => c,
-            Err(e) => {
-                return Err(Error::InvalidConfig(format!(
-                    "Config file cannot be opened at {}. Err: {:?}.",
-                    &config_path, e
-                )))
+        let configs: HashMap<String, T> = match config_format {
+            ConfigFormat::Ron => {
+                let f = std::fs::File::open(config_file_path)?;
+                ron::de::from_reader(f)?
             }
-        };
-        let configs: toml::value::Table = match toml::from_str(&configuration) {
-            Ok(t) => t,
-            Err(e) => {
-                return Err(Error::InvalidTomlFormat(format!(
-                    "Config file is not a valid toml file. Err: {:?}.",
-                    e
-                )));
+            ConfigFormat::Json => {
+                let f = std::fs::File::open(config_file_path)?;
+                serde_json::from_reader(f)?
+            }
+            ConfigFormat::Yaml => {
+                let f = std::fs::File::open(config_file_path)?;
+                serde_yaml::from_reader(f)?
+            }
+            ConfigFormat::Toml => {
+                let configuration = std::fs::read_to_string(config_file_path)?;
+                let configs: toml::value::Table = match toml::from_str(&configuration) {
+                    Ok(t) => t,
+                    Err(e) => {
+                        return Err(Error::InvalidConfigFormat(format!(
+                            "Config file is not a valid toml file. Err: {:?}.",
+                            e
+                        )));
+                    }
+                };
+                configs
+                    .iter()
+                    .map(|(k, v)| (k.to_owned(), v.to_owned().try_into().unwrap()))
+                    .collect()
             }
         };
-
-        let configs: HashMap<String, T> = configs
-            .iter()
-            .map(|(k, v)| (k.to_owned(), v.to_owned().try_into().unwrap()))
-            .collect();
         let outputs: HashMap<String, Vec<Task<P>>> = configs
             .iter()
             .map(|(k, _)| (k.to_owned(), vec![]))
             .collect();
 
         Ok(Executor {
             config_path,
+            config_format,
             ns3_path,
             task_concurrent,
             retry_limit,