新增支持交互式控制台创建配置文件。完善dadk文档 (#5)

* 新增支持交互式控制台创建配置文件。完善dadk文档

* fix gpl licene link

Cargo.toml

@@ -4,6 +4,9 @@ authors = ["longjin <longjin@DragonOS.org>"]
 version = "0.1.0"
 edition = "2021"
 description = "DragonOS Application Development Kit\nDragonOS应用开发工具"
+license = "GPLv2"
+repository = "https://github.com/DragonOS-Community/DADK.git"
+readme = "README.md"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

README.md

@@ -1,8 +1,5 @@
-# DADK
-
-DragonOS 应用开发工具包
-
-DragonOS Application Development Kit
+# DADK - DragonOS Application Development Kit
+# DragonOS 应用开发工具
 
 ## 简介
 
@@ -23,3 +20,65 @@ DADK是一个用于开发DragonOS应用的工具包，设计目的是为了让
 ## License
 
 DADK is licensed under the [GPLv2 License](LICENSE).
+
+## 快速开始
+
+### 安装DADK
+
+DADK是一个Rust程序，您可以通过Cargo来安装DADK。
+
+```shell
+# 从GitHub安装最新版
+cargo install --git https://github.com/DragonOS-Community/DADK.git
+
+# 从crates.io下载
+cargo install dadk
+
+```
+
+## DADK的工作原理
+
+DADK使用(任务名，任务版本）来标识每个构建目标。当使用DADK构建DragonOS应用时，DADK会根据用户的配置文件，自动完成以下工作：
+
+- 解析配置文件，生成DADK任务列表
+- 根据DADK任务列表，进行拓扑排序。这一步会自动处理软件库的依赖关系。
+- 收集环境变量信息，并根据DADK任务列表，设置全局环境变量、任务环境变量。
+- 根据拓扑排序后的DADK任务列表，自动执行任务。
+
+### DADK与环境变量
+
+环境变量的设置是DADK能正常工作的关键因素之一，您可以在您的编译脚本中，通过引用环境变量，来获得其他软件库的编译信息。
+这是使得您的应用能够自动依赖其他软件库的关键一步。
+
+只要您的编译脚本能够正确地引用环境变量，DADK就能够自动处理软件库的依赖关系。
+
+DADK会设置以下全局环境变量：
+
+- `DADK_CACHE_ROOT`：DADK的缓存根目录。您可以在编译脚本中，通过引用该环境变量，来获得DADK的缓存根目录。
+- `DADK_BUILD_CACHE_DIR_任务名_任务版本`：DADK的任务构建结果缓存目录。当您要引用其他软件库的构建结果时，可以通过该环境变量来获得。
+同时，您也要在构建您的app时，把构建结果放到您的软件库的构建结果缓存目录（通过对应的环境变量获得）中。
+- `DADK_SOURCE_CACHE_DIR_任务名_任务版本`：DADK的某个任务的源码目录。当您要引用其他软件库的源码目录时，可以通过该环境变量来获得。
+
+同时，DADK会为每个任务设置其自身在配置文件中指定的环境变量。
+
+#### 全局环境变量命名格式
+
+全局环境变量中的任务名和任务版本，都会被转换为大写字母，并对特殊字符进行替换。替换表如下：
+
+| 原字符 | 替换字符 |
+| ------ | -------- |
+| `.`    | `_`      |
+| `-`    | `_`      |
+| `\t`   | `_`      |
+| 空格   | `_`      |
+| `+`    | `_`      |
+| `*`    | `_`      |
+
+**举例**：对于任务`libc-0.1.0`，其构建结果的全局环境变量名为`DADK_BUILD_CACHE_DIR_LIBC_0_1_0`。
+
+
+## TODO
+
+- 支持从在线归档文件下载源码、构建好的软件库
+- 支持自动更新
+- 完善clean命令的逻辑

src/console/elements.rs

@@ -0,0 +1,375 @@
+use std::{
+    cell::RefCell,
+    fmt::Debug,
+    io::{self, Write},
+    rc::Rc,
+};
+
+use log::error;
+
+use super::{interactive::InputFunc, ConsoleError};
+
+#[derive(Debug, Clone)]
+pub struct Input {
+    /// 在输入箭头前面的提示 (e.g. "Please input your name: >> ")
+    pre_tips: Option<String>,
+    /// 在输入箭头后面的提示 (e.g. ">> (y/n)")
+    post_tips: Option<String>,
+}
+
+impl Input {
+    pub fn new(pre_tips: Option<String>, post_tips: Option<String>) -> Self {
+        Self {
+            pre_tips,
+            post_tips,
+        }
+    }
+
+    /// # 输出提示语，并从标准输入读取一行
+    pub fn input(&self) -> Result<String, ConsoleError> {
+        let mut input = String::new();
+
+        if let Some(pre_tips) = &self.pre_tips {
+            print!("{}", pre_tips);
+        }
+
+        print!(" >> ");
+
+        if let Some(post_tips) = &self.post_tips {
+            print!("{} ", post_tips);
+        }
+
+        io::stdout().flush().map_err(|e| ConsoleError::IOError(e))?;
+
+        io::stdin()
+            .read_line(&mut input)
+            .map_err(|e| ConsoleError::IOError(e))?;
+
+        return Ok(input.trim().to_string());
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct OptionalChoice {
+    /// 选项的提示语
+    first_line_tips: Option<String>,
+    /// 选项列表
+    items: Vec<OptionalChoiceItem>,
+}
+
+#[derive(Debug, Clone)]
+pub struct OptionalChoiceItem {
+    id: String,
+    description: String,
+}
+
+/// # 列表选择器
+///
+/// 展示一个列表，用户可以通过输入选项序号的方式，选择其中的一个选项
+///
+/// ## 效果
+///
+/// ```text
+/// Please choose an item:
+///
+///     1. Item 1
+///     2. Item 2
+///
+/// Please input: >> (1-2)
+/// ```
+impl OptionalChoice {
+    pub fn new(first_line_tips: Option<String>) -> Self {
+        Self {
+            first_line_tips,
+            items: Vec::new(),
+        }
+    }
+
+    /// # 增加一个选项
+    ///
+    /// ## 参数
+    ///
+    /// * `id` - 选项的 ID （当用户选择了该选项时，会返回该 ID）
+    /// * `description` - 选项的描述（会在选项里面显示）
+    pub fn add_choice(&mut self, id: String, description: String) {
+        self.items.push(OptionalChoiceItem { id, description });
+    }
+
+    /// # 读取用户的选择
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(String)` - 用户选择的选项的 ID
+    /// * `Err(ConsoleError)` - 用户输入的不是一个数字，或者数字不在选项列表的范围内
+    pub fn choose(&self) -> Result<String, ConsoleError> {
+        println!("");
+        if let Some(first_line_tips) = &self.first_line_tips {
+            println!("{}", first_line_tips);
+        }
+
+        for item in self.items.iter().enumerate() {
+            println!("\t{}. {}", item.0 + 1, item.1.description);
+        }
+
+        println!("");
+        let input_tips = format!("Please input your choice:");
+        let post_tips = format!("(1-{})", self.items.len());
+        let input: String = Input::new(Some(input_tips), Some(post_tips)).input()?;
+        return self.parse_input(input);
+    }
+
+    /// 读取用户的选择，直到用户输入的是一个有效的选项.
+    /// 如果用户输入的是无效的选项，则会重新输入.
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(String)` - 用户选择的选项的 ID
+    /// * `Err(ConsoleError)` - 产生了除InvalidInput之外的错误
+    pub fn choose_until_valid(&self) -> Result<String, ConsoleError> {
+        loop {
+            let choice = self.choose();
+            if choice.is_err() {
+                // 如果用户输入的是无效的选项，则重新输入
+                if let Err(ConsoleError::InvalidInput(e)) = choice {
+                    error!("Invalid choice: {}", e);
+                    continue;
+                } else {
+                    return Err(choice.unwrap_err());
+                }
+            }
+            return choice;
+        }
+    }
+
+    /// 读取用户的选择，直到用户输入的是一个有效的选项.
+    /// 如果用户输入的是无效的选项，则会重新输入.
+    /// 如果用户输入的是无效的选项超过了指定的次数，则会返回错误.
+    ///
+    /// ## 参数
+    ///
+    /// * `retry` - 允许用户输入无效选项的次数
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(String)` - 用户选择的选项的 ID
+    /// * `Err(ConsoleError::RetryLimitExceeded)` - 用户输入的无效选项超过了指定的次数
+    /// * `Err(ConsoleError)` - 产生了除InvalidInput之外的错误
+    #[allow(dead_code)]
+    pub fn choose_with_retry(&self, retry: u32) -> Result<String, ConsoleError> {
+        for _ in 0..retry {
+            let choice = self.choose();
+            if choice.is_err() {
+                // 如果用户输入的是无效的选项，则重新输入
+                if let Err(ConsoleError::InvalidInput(e)) = choice {
+                    error!("Invalid choice: {}", e);
+                    continue;
+                } else {
+                    return Err(choice.unwrap_err());
+                }
+            }
+            return choice;
+        }
+        return Err(ConsoleError::RetryLimitExceeded(format!(
+            "Invalid choice: please input a number between 1 and {}",
+            self.items.len()
+        )));
+    }
+
+    /// # 解析用户的输入
+    ///
+    /// 用户的输入必须是一个数字，且在选项列表的范围内.
+    ///
+    /// ## 参数
+    ///
+    /// * `input` - 用户的输入
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(String)` - 用户选择的选项的 ID
+    /// * `Err(ConsoleError::InvalidInput(e))` - 用户的输入不合法
+    fn parse_input(&self, input: String) -> Result<String, ConsoleError> {
+        let input = input.trim().to_string();
+        let input = input.parse::<usize>().map_err(|e| {
+            ConsoleError::InvalidInput(format!("Invalid choice: {}", e.to_string()))
+        })?;
+
+        if input < 1 || input > self.items.len() {
+            return Err(ConsoleError::InvalidInput(format!(
+                "Invalid input: {}, please input a number between 1 and {}",
+                input,
+                self.items.len()
+            )));
+        }
+        Ok(self.items[input - 1].id.clone())
+    }
+}
+
+/// # 选择是或者否
+#[derive(Debug)]
+pub struct ChooseYesOrNo {
+    tips: String,
+}
+
+impl ChooseYesOrNo {
+    pub fn new(tips: String) -> Self {
+        Self { tips }
+    }
+
+    /// # 读取用户的选择
+    /// 读取用户的选择，如果用户输入的是 yes，则返回 true，否则返回 false.
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(bool)` - 用户的选择
+    /// * `Err(ConsoleError::InvalidInput)` - 用户输入的不是 yes 或者 no
+    /// * `Err(ConsoleError)` - 产生了除InvalidInput之外的错误
+    pub fn choose(&self) -> Result<bool, ConsoleError> {
+        let choice = Input::new(Some(self.tips.clone()), Some("(yes/no)".to_string()))
+            .input()?
+            .to_ascii_lowercase();
+
+        if choice == "yes" || choice == "y" {
+            return Ok(true);
+        } else if choice == "no" || choice == "n" {
+            return Ok(false);
+        } else {
+            return Err(ConsoleError::InvalidInput(format!(
+                "Invalid choice: {}",
+                choice
+            )));
+        }
+    }
+
+    /// 读取用户的选择，直到用户输入的是一个有效的选项.
+    ///
+    /// 如果用户输入的是无效的选项，则会重新输入.
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(bool)` - 用户的选择
+    /// * `Err(ConsoleError)` - 产生了除InvalidInput之外的错误
+    pub fn choose_until_valid(&self) -> Result<bool, ConsoleError> {
+        loop {
+            let choice = self.choose();
+            if choice.is_err() {
+                // 如果用户输入的是无效的选项，则重新输入
+                if let Err(ConsoleError::InvalidInput(e)) = choice {
+                    error!("{}", e);
+                    continue;
+                } else {
+                    return Err(choice.unwrap_err());
+                }
+            }
+            return choice;
+        }
+    }
+
+    /// 读取用户的选择，直到用户输入的是一个有效的选项或者超过了指定的次数.
+    ///
+    /// 如果用户输入的是无效的选项，则会重新输入.
+    /// 如果用户输入的是无效的选项超过了指定的次数，则会返回错误.
+    ///
+    /// ## 参数
+    ///
+    /// * `retry` - 允许用户输入无效选项的次数
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(bool)` - 用户的选择
+    ///
+    /// * `Err(ConsoleError::RetryLimitExceeded)` - 用户输入的无效选项超过了指定的次数
+    /// * `Err(ConsoleError)` - 产生了除InvalidInput之外的错误
+    #[allow(dead_code)]
+    pub fn choose_with_retry(&self, retry: u32) -> Result<bool, ConsoleError> {
+        for _ in 0..retry {
+            let choice = self.choose();
+            if choice.is_err() {
+                // 如果用户输入的是无效的选项，则重新输入
+                if let Err(ConsoleError::InvalidInput(e)) = choice {
+                    error!("Invalid choice: {}", e);
+                    continue;
+                } else {
+                    return Err(choice.unwrap_err());
+                }
+            }
+            return choice;
+        }
+        return Err(ConsoleError::RetryLimitExceeded(format!(
+            "Retry limit exceeded."
+        )));
+    }
+}
+
+/// # 读入多个元素到一个列表
+pub struct VecInput<T: Debug> {
+    /// 每次读入元素的提示信息
+    tips: Option<String>,
+    /// 读入的元素列表
+    results: Vec<T>,
+    /// 元素读取器
+    element_input_func: Rc<RefCell<dyn InputFunc<T>>>,
+}
+
+impl<T: Debug> Debug for VecInput<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VecInput")
+            .field("tips", &self.tips)
+            .field("results", &self.results)
+            .finish()
+    }
+}
+
+impl<T: Debug> VecInput<T> {
+    /// # 创建一个新的 VecInput
+    ///
+    /// ## 参数
+    ///
+    /// * `tips` - 每次读入元素的提示信息
+    /// * `element_input_func` - 元素读取器
+    pub fn new(tips: Option<String>, element_input_func: Rc<RefCell<dyn InputFunc<T>>>) -> Self {
+        Self {
+            tips,
+            results: Vec::new(),
+            element_input_func,
+        }
+    }
+
+    /// # 读入一组元素
+    pub fn input(&mut self) -> Result<(), ConsoleError> {
+        println!("\nPlease one or more items.");
+        while !self.should_exit()? {
+            self.input_one()?;
+        }
+        return Ok(());
+    }
+
+    /// # 读入指定数量的元素
+    #[allow(dead_code)]
+    pub fn input_n(&mut self, count: usize) -> Result<(), ConsoleError> {
+        println!("\nPlease input {} items.", count);
+        for _ in 0..count {
+            self.input_one()?;
+        }
+        return Ok(());
+    }
+
+    pub fn input_one(&mut self) -> Result<(), ConsoleError> {
+        println!();
+        if let Some(tips) = self.tips.as_ref() {
+            println!("{}", tips);
+        }
+        let elem = self.element_input_func.borrow_mut().input_until_valid()?;
+        self.results.push(elem);
+        return Ok(());
+    }
+
+    fn should_exit(&self) -> Result<bool, ConsoleError> {
+        let input_more = ChooseYesOrNo::new("Input more?".to_string()).choose_until_valid()?;
+        Ok(!input_more)
+    }
+
+    /// # 获取读入的元素列表的引用
+    pub fn results(&self) -> Result<&Vec<T>, ConsoleError> {
+        return Ok(&self.results);
+    }
+}

src/console/interactive.rs

@@ -0,0 +1,93 @@
+use std::{fmt::Debug, path::PathBuf};
+
+use log::error;
+
+use crate::console::new_config::NewConfigCommand;
+
+use super::{Action, ConsoleError};
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub struct InteractiveConsole {
+    /// DragonOS sysroot在主机上的路径
+    dragonos_dir: Option<PathBuf>,
+    /// DADK任务配置文件所在目录
+    config_dir: Option<PathBuf>,
+    /// 要执行的操作
+    action: Action,
+}
+
+pub trait InteractiveCommand {
+    fn run(&mut self) -> Result<(), ConsoleError>;
+}
+
+impl InteractiveConsole {
+    pub fn new(dragonos_dir: Option<PathBuf>, config_dir: Option<PathBuf>, action: Action) -> Self {
+        Self {
+            dragonos_dir,
+            config_dir,
+            action,
+        }
+    }
+
+    pub fn run(&self) -> Result<(), ConsoleError> {
+        println!("\nWelcome to DADK interactive console!\n");
+        match self.action {
+            Action::New => {
+                let mut cmd = NewConfigCommand::new(self.config_dir.clone());
+                cmd.run()
+            }
+            _ => {
+                let msg = format!(
+                    "Action '{:?}' not supported in interactive console",
+                    self.action
+                );
+                error!("{msg}");
+                return Err(ConsoleError::CommandError(msg));
+            }
+        }
+    }
+}
+
+pub trait InputFunc<T: Debug + Sized> {
+    /// # 读取用户输入
+    fn input(&mut self) -> Result<T, ConsoleError>;
+    /// # 读取用户输入，直到返回值合法
+    fn input_until_valid(&mut self) -> Result<T, ConsoleError> {
+        loop {
+            let task_type = self.input();
+            if task_type.is_ok() {
+                return task_type;
+            } else {
+                if let Err(ConsoleError::InvalidInput(e)) = task_type {
+                    error!("{}", e);
+                    continue;
+                } else {
+                    return task_type;
+                }
+            }
+        }
+    }
+
+    /// # 读取用户输入，最多重试指定次数
+    ///
+    /// 如果重试次数超过指定次数，则返回错误Err(ConsoleError::RetryLimitExceeded)
+    fn input_with_retry(&mut self, retry: usize) -> Result<T, ConsoleError> {
+        for _ in 0..retry {
+            let task_type = self.input();
+            if task_type.is_ok() {
+                return task_type;
+            } else {
+                if let Err(ConsoleError::InvalidInput(e)) = task_type {
+                    error!("{}", e);
+                    continue;
+                } else {
+                    return task_type;
+                }
+            }
+        }
+        return Err(ConsoleError::RetryLimitExceeded(format!(
+            "Retry limit exceeded."
+        )));
+    }
+}

src/console/mod.rs

@@ -1,4 +1,20 @@
+//! # DADK控制台
+//! 
+//! DADK控制台能够让用户通过命令行交互的方式使用DADK。
+//! 
+//! ## 创建配置文件
+//! 
+//! DADK控制台提供了一个命令，用于创建一个配置文件。您可以通过以下命令创建一个配置文件：
+//! 
+//! ```bash
+//! dadk new
+//! ```
+//! 
+
 pub mod clean;
+pub mod elements;
+pub mod interactive;
+pub mod new_config;
 
 use std::path::PathBuf;
 
@@ -49,7 +65,16 @@ pub enum Action {
     Install,
     /// 尚不支持
     Uninstall,
+    /// 使用交互式命令行创建dadk任务配置文件
+    New,
 }
 
-#[derive(Debug, Clone)]
-pub enum ConsoleError {}
+#[derive(Debug)]
+pub enum ConsoleError {
+    CommandError(String),
+    IOError(std::io::Error),
+    /// 错误次数超过限制
+    RetryLimitExceeded(String),
+    /// 无效的输入
+    InvalidInput(String),
+}

src/console/new_config.rs

@@ -0,0 +1,718 @@
+use std::{cell::RefCell, fmt::Debug, path::PathBuf, rc::Rc};
+
+use log::{debug, error, info};
+
+use crate::{
+    console::elements::{OptionalChoice, VecInput},
+    executor::{
+        cache::CacheDir,
+        source::{ArchiveSource, GitSource, LocalSource},
+    },
+    parser::task::{
+        BuildConfig, CleanConfig, CodeSource, DADKTask, Dependency, InstallConfig, PrebuiltSource,
+        TaskEnv, TaskType,
+    },
+};
+
+use super::{
+    elements::Input,
+    interactive::{InputFunc, InteractiveCommand},
+    ConsoleError,
+};
+
+#[derive(Debug)]
+pub struct NewConfigCommand {
+    /// DADK任务配置文件所在目录
+    config_dir: Option<PathBuf>,
+}
+
+impl InteractiveCommand for NewConfigCommand {
+    fn run(&mut self) -> Result<(), ConsoleError> {
+        // 如果没有指定配置文件输出的目录，则使用当前目录
+        if self.config_dir.is_none() {
+            self.config_dir = Some(PathBuf::from("./"));
+        }
+
+        println!("To create a new DADK task config, please follow the guidance below... \n");
+
+        let mut dadk_task = self.build_dadk_task()?;
+        debug!("dadk_task: {:?}", dadk_task);
+
+        // 校验
+        let check: Result<(), ConsoleError> = dadk_task.validate().map_err(|e| {
+            let msg = format!("Failed to validate DADKTask: {:?}", e);
+            ConsoleError::InvalidInput(msg)
+        });
+
+        if check.is_err() {
+            error!("{:?}", check.unwrap_err());
+        }
+        // 不管校验是否通过，都写入文件
+        let config_file_path = self.write_dadk_config_file(&dadk_task)?;
+
+        info!(
+            "DADK task config file created successfully! File:{}",
+            config_file_path.display()
+        );
+        return Ok(());
+    }
+}
+
+impl NewConfigCommand {
+    pub fn new(config_dir: Option<PathBuf>) -> Self {
+        Self { config_dir }
+    }
+
+    fn write_dadk_config_file(&self, dadk_task: &DADKTask) -> Result<PathBuf, ConsoleError> {
+        let json = serde_json::to_string_pretty(&dadk_task).map_err(|e| {
+            let msg = format!("Failed to serialize DADKTask to json: {:?}", e);
+            error!("{}", msg);
+            ConsoleError::InvalidInput(msg)
+        })?;
+        info!("Complete DADK task config file:\n {}", json);
+
+        // 创建路径
+        let config_dir = self.config_dir.as_ref().unwrap();
+        let filename = format!("{}.dadk", dadk_task.name_version());
+        let config_path = config_dir.join(filename);
+
+        // 写入文件
+        std::fs::write(&config_path, json).map_err(|e| {
+            let msg = format!(
+                "Failed to write config file to {}, error: {:?}",
+                config_path.display(),
+                e
+            );
+            error!("{}", msg);
+            ConsoleError::InvalidInput(msg)
+        })?;
+
+        return Ok(config_path);
+    }
+
+    fn build_dadk_task(&self) -> Result<DADKTask, ConsoleError> {
+        let name = self.input_name()?;
+        let version = self.input_version()?;
+        let description = self.input_description()?;
+        debug!(
+            "name: {}, version: {}, description: {}",
+            name, version, description
+        );
+
+        let task_type: TaskType = TaskTypeInput::new().input()?;
+        debug!("task_type: {:?}", task_type);
+
+        let dep: Vec<Dependency> = DependencyInput::new().input()?;
+        debug!("dep: {:?}", dep);
+        let build_config: BuildConfig = BuildConfigInput::new().input()?;
+        debug!("build_config: {:?}", build_config);
+        let install_config: InstallConfig = InstallConfigInput::new().input()?;
+        debug!("install_config: {:?}", install_config);
+        let clean_config: CleanConfig = CleanConfigInput::new().input()?;
+        debug!("clean_config: {:?}", clean_config);
+
+        let task_env: Option<Vec<TaskEnv>> = TaskEnvInput::new().input()?;
+        debug!("task_env: {:?}", task_env);
+
+        let mut dadk: DADKTask = DADKTask::new(
+            name,
+            version,
+            description,
+            task_type,
+            dep,
+            build_config,
+            install_config,
+            clean_config,
+            task_env,
+        );
+
+        dadk.trim();
+
+        return Ok(dadk);
+    }
+
+    // 输入任务名称
+    fn input_name(&self) -> Result<String, ConsoleError> {
+        let name = Input::new(
+            Some("Please input the [name] of the task:".to_string()),
+            None,
+        )
+        .input()?;
+        Ok(name)
+    }
+
+    // 输入任务版本
+    fn input_version(&self) -> Result<String, ConsoleError> {
+        let version = Input::new(
+            Some("Please input the [version] of the task:".to_string()),
+            None,
+        )
+        .input()?;
+
+        return Ok(version);
+    }
+
+    // 输入任务描述
+    fn input_description(&self) -> Result<String, ConsoleError> {
+        let description = Input::new(
+            Some("Please input the [description] of the task:".to_string()),
+            None,
+        )
+        .input()?;
+
+        return Ok(description);
+    }
+}
+
+#[derive(Debug)]
+struct TaskTypeInput;
+
+impl TaskTypeInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl InputFunc<TaskType> for TaskTypeInput {
+    /// # 输入任务类型
+    fn input(&mut self) -> Result<TaskType, ConsoleError> {
+        const TASK_TYPE_BUILD_FROM_SOURCE: &str = "src";
+        const TASK_TYPE_INSTALL_FROM_PREBUILT: &str = "prebuilt";
+
+        let mut task_type_choose =
+            OptionalChoice::new(Some("Please choose the [type] of the task:".to_string()));
+        task_type_choose.add_choice(
+            TASK_TYPE_BUILD_FROM_SOURCE.to_string(),
+            "Build from source".to_string(),
+        );
+        task_type_choose.add_choice(
+            TASK_TYPE_INSTALL_FROM_PREBUILT.to_string(),
+            "Install from prebuilt".to_string(),
+        );
+
+        // 读取用户输入
+        let task_type = task_type_choose.choose_until_valid()?;
+
+        // debug!("task type: {}", task_type);
+
+        let mut task_type = match task_type.as_str() {
+            TASK_TYPE_BUILD_FROM_SOURCE => {
+                TaskType::BuildFromSource(CodeSourceInput::new().input()?)
+            }
+            TASK_TYPE_INSTALL_FROM_PREBUILT => {
+                TaskType::InstallFromPrebuilt(PrebuiltSourceInput::new().input()?)
+            }
+            _ => {
+                let msg = format!("Invalid task type: {}", task_type);
+                return Err(ConsoleError::InvalidInput(msg));
+            }
+        };
+
+        // 验证输入
+        task_type.validate().map_err(|e| {
+            ConsoleError::InvalidInput(format!("Invalid task type: {}", e.to_string()))
+        })?;
+
+        return Ok(task_type);
+    }
+}
+/// # 代码源输入
+#[derive(Debug)]
+struct CodeSourceInput;
+
+impl CodeSourceInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    pub fn input(&self) -> Result<CodeSource, ConsoleError> {
+        const CODE_SOURCE_GIT: &str = "git";
+        const CODE_SOURCE_LOCAL: &str = "local";
+        const CODE_SOURCE_ARCHIVE: &str = "archive";
+
+        let mut code_source_choose = OptionalChoice::new(Some(
+            "Please choose the [code source] of the task:".to_string(),
+        ));
+        code_source_choose.add_choice(
+            CODE_SOURCE_GIT.to_string(),
+            "Build from git repository".to_string(),
+        );
+        code_source_choose.add_choice(
+            CODE_SOURCE_LOCAL.to_string(),
+            "Build from local directory".to_string(),
+        );
+        code_source_choose.add_choice(
+            CODE_SOURCE_ARCHIVE.to_string(),
+            "Build from archive file".to_string(),
+        );
+
+        // 读取用户输入
+        let code_source: String = code_source_choose.choose_until_valid()?;
+        // debug!("code source: {}", code_source);
+
+        let mut code_source: CodeSource = match code_source.as_str() {
+            CODE_SOURCE_GIT => CodeSource::Git(GitSourceInput::new().input_until_valid()?),
+            CODE_SOURCE_LOCAL => CodeSource::Local(LocalSourceInput::new().input_until_valid()?),
+            CODE_SOURCE_ARCHIVE => {
+                CodeSource::Archive(ArchiveSourceInput::new().input_until_valid()?)
+            }
+            _ => {
+                let msg = format!("Invalid code source: {}", code_source);
+                return Err(ConsoleError::InvalidInput(msg));
+            }
+        };
+        code_source.trim();
+        code_source.validate().map_err(|e| {
+            ConsoleError::InvalidInput(format!("Invalid code source: {}", e.to_string()))
+        })?;
+
+        return Ok(code_source);
+    }
+}
+
+#[derive(Debug)]
+struct PrebuiltSourceInput;
+
+impl PrebuiltSourceInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl InputFunc<PrebuiltSource> for PrebuiltSourceInput {
+    fn input(&mut self) -> Result<PrebuiltSource, ConsoleError> {
+        const PREBUILT_SOURCE_LOCAL: &str = "local";
+        const PREBUILT_SOURCE_ARCHIVE: &str = "archive";
+
+        let mut prebuilt_source_choose = OptionalChoice::new(Some(
+            "Please choose the [prebuilt source] of the task:".to_string(),
+        ));
+
+        prebuilt_source_choose.add_choice(
+            PREBUILT_SOURCE_LOCAL.to_string(),
+            "Install from local directory".to_string(),
+        );
+        prebuilt_source_choose.add_choice(
+            PREBUILT_SOURCE_ARCHIVE.to_string(),
+            "Install from archive file".to_string(),
+        );
+
+        // 读取用户输入
+        let prebuilt_source: String = prebuilt_source_choose.choose_until_valid()?;
+        // debug!("prebuilt source: {}", prebuilt_source);
+
+        let mut prebuilt_source: PrebuiltSource = match prebuilt_source.as_str() {
+            PREBUILT_SOURCE_LOCAL => {
+                PrebuiltSource::Local(LocalSourceInput::new().input_until_valid()?)
+            }
+            PREBUILT_SOURCE_ARCHIVE => {
+                PrebuiltSource::Archive(ArchiveSourceInput::new().input_until_valid()?)
+            }
+            _ => {
+                let msg = format!("Invalid prebuilt source: {}", prebuilt_source);
+                return Err(ConsoleError::InvalidInput(msg));
+            }
+        };
+        prebuilt_source.trim();
+        prebuilt_source.validate().map_err(|e| {
+            ConsoleError::InvalidInput(format!("Invalid prebuilt source: {}", e.to_string()))
+        })?;
+
+        return Ok(prebuilt_source);
+    }
+}
+
+#[derive(Debug)]
+struct GitSourceInput;
+
+impl InputFunc<GitSource> for GitSourceInput {
+    fn input(&mut self) -> Result<GitSource, ConsoleError> {
+        let url = self.input_url()?;
+
+        // 选择分支还是指定的commit
+        const GIT_SOURCE_BRANCH: &str = "branch";
+        const GIT_SOURCE_REVISION: &str = "revision";
+
+        let mut git_source_choose = OptionalChoice::new(Some(
+            "Please choose the [git source] of the task:".to_string(),
+        ));
+        git_source_choose.add_choice(GIT_SOURCE_BRANCH.to_string(), "branch name".to_string());
+        git_source_choose.add_choice(GIT_SOURCE_REVISION.to_string(), "revision hash".to_string());
+
+        // 读取用户输入
+        let git_source = git_source_choose.choose_until_valid()?;
+        // debug!("git source: {}", git_source);
+
+        let mut git_source: GitSource = match git_source.as_str() {
+            GIT_SOURCE_BRANCH => {
+                let branch = self.input_branch()?;
+                GitSource::new(url, Some(branch), None)
+            }
+            GIT_SOURCE_REVISION => {
+                let revision = self.input_revision()?;
+                GitSource::new(url, None, Some(revision))
+            }
+            _ => {
+                let msg = format!("Invalid git source: {}", git_source);
+                return Err(ConsoleError::InvalidInput(msg));
+            }
+        };
+        git_source.trim();
+        // 验证输入
+        git_source.validate().map_err(|e| {
+            ConsoleError::InvalidInput(format!("Invalid git source: {}", e.to_string()))
+        })?;
+
+        return Ok(git_source);
+    }
+}
+
+impl GitSourceInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn input_url(&self) -> Result<String, ConsoleError> {
+        let url = Input::new(
+            Some("Please input the [url] of the git repository:".to_string()),
+            None,
+        )
+        .input()?;
+        return Ok(url);
+    }
+
+    fn input_branch(&self) -> Result<String, ConsoleError> {
+        let branch = Input::new(
+            Some("Please input the [branch name] of the git repository:".to_string()),
+            None,
+        )
+        .input()?;
+        return Ok(branch);
+    }
+
+    fn input_revision(&self) -> Result<String, ConsoleError> {
+        let revision = Input::new(
+            Some("Please input the [revision hash] of the git repository:".to_string()),
+            None,
+        )
+        .input()?;
+        return Ok(revision);
+    }
+}
+
+#[derive(Debug)]
+struct LocalSourceInput;
+
+impl LocalSourceInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn input_path(&self) -> Result<String, ConsoleError> {
+        let path = Input::new(
+            Some("Please input the [path] of the local directory:".to_string()),
+            None,
+        )
+        .input()?;
+        return Ok(path);
+    }
+}
+impl InputFunc<LocalSource> for LocalSourceInput {
+    fn input(&mut self) -> Result<LocalSource, ConsoleError> {
+        let path = self.input_path()?;
+        let path = PathBuf::from(path);
+        let mut local_source = LocalSource::new(path);
+
+        local_source.trim();
+        // 验证输入
+        local_source.validate(None).map_err(|e| {
+            ConsoleError::InvalidInput(format!("Invalid local source: {}", e.to_string()))
+        })?;
+
+        return Ok(local_source);
+    }
+}
+
+#[derive(Debug)]
+struct ArchiveSourceInput;
+
+impl ArchiveSourceInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn input_url(&self) -> Result<String, ConsoleError> {
+        let url = Input::new(
+            Some("Please input the [url] of the archive file:".to_string()),
+            None,
+        )
+        .input()?;
+        return Ok(url);
+    }
+}
+
+impl InputFunc<ArchiveSource> for ArchiveSourceInput {
+    fn input(&mut self) -> Result<ArchiveSource, ConsoleError> {
+        let url = self.input_url()?;
+        let mut archive_source = ArchiveSource::new(url);
+
+        archive_source.trim();
+        // 验证输入
+        archive_source.validate().map_err(|e| {
+            ConsoleError::InvalidInput(format!("Invalid archive source: {}", e.to_string()))
+        })?;
+
+        return Ok(archive_source);
+    }
+}
+
+#[derive(Debug)]
+struct DependencyInput;
+
+impl DependencyInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl InputFunc<Vec<Dependency>> for DependencyInput {
+    fn input(&mut self) -> Result<Vec<Dependency>, ConsoleError> {
+        const TIPS: &str = "Please input the [dependencies] of the task:";
+        println!();
+        println!("Please input the [dependencies] of the task:");
+        let dependency_reader: Rc<RefCell<DependencyInputOne>> =
+            Rc::new(RefCell::new(DependencyInputOne::new()));
+        let mut vecinput = VecInput::new(Some(TIPS.to_string()), dependency_reader);
+        vecinput.input()?;
+        return Ok(vecinput.results()?.clone());
+    }
+}
+
+/// 读取一个dependency的读取器
+#[derive(Debug)]
+struct DependencyInputOne;
+
+impl InputFunc<Dependency> for DependencyInputOne {
+    fn input(&mut self) -> Result<Dependency, ConsoleError> {
+        return self.input_one();
+    }
+}
+
+impl DependencyInputOne {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn input_name(&self) -> Result<String, ConsoleError> {
+        let name = Input::new(
+            Some("Please input the [name] of the dependency:".to_string()),
+            None,
+        )
+        .input()?;
+        return Ok(name);
+    }
+
+    fn input_version(&self) -> Result<String, ConsoleError> {
+        let version = Input::new(
+            Some("Please input the [version] of the dependency:".to_string()),
+            None,
+        )
+        .input()?;
+        return Ok(version);
+    }
+
+    fn input_one(&self) -> Result<Dependency, ConsoleError> {
+        let name = self.input_name()?;
+        let version = self.input_version()?;
+        let mut dependency = Dependency::new(name, version);
+
+        dependency.trim();
+        // 验证输入
+        dependency.validate().map_err(|e| {
+            ConsoleError::InvalidInput(format!("Invalid dependency: {}", e.to_string()))
+        })?;
+
+        return Ok(dependency);
+    }
+}
+
+#[derive(Debug)]
+pub struct BuildConfigInput;
+
+impl BuildConfigInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn input_command(&self) -> Result<String, ConsoleError> {
+        println!("Please input the [build command] of the task:");
+        let tips = format!("\nNote:
+\t1. The command will be executed in the root directory of the source code.
+\t2. After the command is executed, all files need to install to DragonOS should be placed in: [{}_TASKNAME_VERSION]\n",
+ CacheDir::DADK_BUILD_CACHE_DIR_ENV_KEY_PREFIX);
+        println!("{}", tips);
+        let mut command = Input::new(Some("Build Command:".to_string()), None).input()?;
+        command = command.trim().to_string();
+
+        return Ok(command);
+    }
+}
+
+impl InputFunc<BuildConfig> for BuildConfigInput {
+    fn input(&mut self) -> Result<BuildConfig, ConsoleError> {
+        println!("\nPlease input the [build_config] of the task:");
+
+        // 读取build_config
+        let command = self.input_command()?;
+        let command = if command.is_empty() {
+            None
+        } else {
+            Some(command)
+        };
+        let build_config = BuildConfig::new(command);
+        return Ok(build_config);
+    }
+}
+
+#[derive(Debug)]
+struct InstallConfigInput;
+
+impl InstallConfigInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn input_install_dir(&self) -> Result<Option<PathBuf>, ConsoleError> {
+        let install_dir = Input::new(
+            Some("Please input the [dir to install in DragonOS] of the task:".to_string()),
+            None,
+        )
+        .input()?;
+        let install_dir = install_dir.trim().to_string();
+        let install_dir = if install_dir.is_empty() {
+            None
+        } else {
+            Some(PathBuf::from(install_dir))
+        };
+        return Ok(install_dir);
+    }
+}
+
+impl InputFunc<InstallConfig> for InstallConfigInput {
+    fn input(&mut self) -> Result<InstallConfig, ConsoleError> {
+        println!("\nPlease input the [install_config] of the task:");
+
+        // 读取install dir
+        let install_dir = self.input_install_dir()?;
+        let mut install_config = InstallConfig::new(install_dir);
+        install_config.trim();
+        return Ok(install_config);
+    }
+}
+
+#[derive(Debug)]
+struct CleanConfigInput;
+
+impl CleanConfigInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn input_clean_command(&self) -> Result<Option<String>, ConsoleError> {
+        let clean_command = Input::new(
+            Some("Please input the [clean command] of the task:".to_string()),
+            None,
+        )
+        .input()?;
+        let clean_command = clean_command.trim().to_string();
+        let clean_command = if clean_command.is_empty() {
+            None
+        } else {
+            Some(clean_command)
+        };
+        return Ok(clean_command);
+    }
+}
+
+impl InputFunc<CleanConfig> for CleanConfigInput {
+    fn input(&mut self) -> Result<CleanConfig, ConsoleError> {
+        println!("\nPlease configure the [clean_config] of the task:");
+
+        // 读取clean command
+        let clean_command = self.input_clean_command()?;
+        let mut clean_config = CleanConfig::new(clean_command);
+        clean_config.trim();
+        return Ok(clean_config);
+    }
+}
+
+#[derive(Debug)]
+struct TaskEnvInput;
+
+impl TaskEnvInput {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl InputFunc<Option<Vec<TaskEnv>>> for TaskEnvInput {
+    fn input(&mut self) -> Result<Option<Vec<TaskEnv>>, ConsoleError> {
+        const TIPS: &str = "Please configure the [ environment variables ] of the task:";
+        println!();
+        println!("{TIPS}");
+        let env_reader: Rc<RefCell<TaskEnvInputOne>> =
+            Rc::new(RefCell::new(TaskEnvInputOne::new()));
+        let mut vecinput: VecInput<TaskEnv> = VecInput::new(Some(TIPS.to_string()), env_reader);
+        vecinput.input()?;
+        let result = vecinput.results()?.clone();
+        // 不管是否有输入，都返回Some
+        return Ok(Some(result));
+    }
+}
+
+#[derive(Debug)]
+struct TaskEnvInputOne;
+
+impl TaskEnvInputOne {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn input_name(&self) -> Result<String, ConsoleError> {
+        let name = Input::new(
+            Some("Please input the [name] of the env:".to_string()),
+            None,
+        )
+        .input()?;
+        return Ok(name);
+    }
+
+    fn input_value(&self) -> Result<String, ConsoleError> {
+        let value = Input::new(
+            Some("Please input the [value] of the env:".to_string()),
+            None,
+        )
+        .input()?;
+        return Ok(value);
+    }
+
+    fn input_one(&self) -> Result<TaskEnv, ConsoleError> {
+        let name = self.input_name()?;
+        let value = self.input_value()?;
+        let mut env = TaskEnv::new(name, value);
+
+        env.trim();
+        // 验证输入
+        env.validate()
+            .map_err(|e| ConsoleError::InvalidInput(format!("Invalid env: {}", e.to_string())))?;
+
+        return Ok(env);
+    }
+}
+
+impl InputFunc<TaskEnv> for TaskEnvInputOne {
+    fn input(&mut self) -> Result<TaskEnv, ConsoleError> {
+        let env = self.input_one()?;
+        return Ok(env);
+    }
+}

src/executor/cache.rs

@@ -90,6 +90,8 @@ pub enum CacheDirType {
 }
 
 impl CacheDir {
+    pub const DADK_BUILD_CACHE_DIR_ENV_KEY_PREFIX: &'static str = "DADK_BUILD_CACHE_DIR";
+    pub const DADK_SOURCE_CACHE_DIR_ENV_KEY_PREFIX: &'static str = "DADK_SOURCE_CACHE_DIR";
     pub fn new(entity: Rc<SchedEntity>, cache_type: CacheDirType) -> Result<Self, ExecutorError> {
         let task = entity.task();
         let path = Self::get_path(task, cache_type);
@@ -130,12 +132,12 @@ impl CacheDir {
 
     pub fn build_dir_env_key(entity: &Rc<SchedEntity>) -> Result<String, ExecutorError> {
         let name_version_env = entity.task().name_version_env();
-        return Ok(format!("DADK_BUILD_CACHE_DIR_{}", name_version_env));
+        return Ok(format!("{}_{}", Self::DADK_BUILD_CACHE_DIR_ENV_KEY_PREFIX,name_version_env));
     }
 
     pub fn source_dir_env_key(entity: &Rc<SchedEntity>) -> Result<String, ExecutorError> {
         let name_version_env = entity.task().name_version_env();
-        return Ok(format!("DADK_SOURCE_CACHE_DIR_{}", name_version_env));
+        return Ok(format!("{}_{}", Self::DADK_SOURCE_CACHE_DIR_ENV_KEY_PREFIX,name_version_env));
     }
 
     pub fn need_source_cache(entity: &Rc<SchedEntity>) -> bool {

src/executor/mod.rs

@@ -105,7 +105,10 @@ impl Executor {
             }
             Action::Clean(_) => {
                 // 清理构建结果
-                self.clean()?;
+                let r = self.clean();
+                if let Err(e) = r {
+                    error!("Failed to clean task {}: {:?}", self.entity.task().name_version(), e);
+                }
             }
             _ => {
                 error!("Unsupported action: {:?}", self.action);
@@ -138,15 +141,14 @@ impl Executor {
 
     /// # 执行安装操作，把构建结果安装到DragonOS
     fn install(&self) -> Result<(), ExecutorError> {
+        let in_dragonos_path = self.entity.task().install.in_dragonos_path.as_ref();
+        // 如果没有指定安装路径，则不执行安装
+        if in_dragonos_path.is_none() {
+            return Ok(());
+        }
         info!("Installing task: {}", self.entity.task().name_version());
+        let mut in_dragonos_path = in_dragonos_path.unwrap().to_string_lossy().to_string();
 
-        let mut in_dragonos_path = self
-            .entity
-            .task()
-            .install
-            .in_dragonos_path
-            .to_string_lossy()
-            .to_string();
         // 去除开头的斜杠
         {
             let count_leading_slashes = in_dragonos_path.chars().take_while(|c| *c == '/').count();

src/main.rs

@@ -19,7 +19,69 @@
 //!
 //! ## License
 //!
-//! DADK is licensed under the [GPLv2 License](LICENSE).
+//! DADK is licensed under the [GPLv2 License](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html).
+//! 
+//! ## 快速开始
+//! 
+//! ### 安装DADK
+//! 
+//! DADK是一个Rust程序，您可以通过Cargo来安装DADK。
+//! 
+//! ```shell
+//! # 从GitHub安装最新版
+//! cargo install --git https://github.com/DragonOS-Community/DADK.git
+//! 
+//! # 从crates.io下载
+//! cargo install dadk
+//! 
+//! ```
+//! 
+//! ## DADK的工作原理
+//! 
+//! DADK使用(任务名，任务版本）来标识每个构建目标。当使用DADK构建DragonOS应用时，DADK会根据用户的配置文件，自动完成以下工作：
+//! 
+//! - 解析配置文件，生成DADK任务列表
+//! - 根据DADK任务列表，进行拓扑排序。这一步会自动处理软件库的依赖关系。
+//! - 收集环境变量信息，并根据DADK任务列表，设置全局环境变量、任务环境变量。
+//! - 根据拓扑排序后的DADK任务列表，自动执行任务。
+//! 
+//! ### DADK与环境变量
+//! 
+//! 环境变量的设置是DADK能正常工作的关键因素之一，您可以在您的编译脚本中，通过引用环境变量，来获得其他软件库的编译信息。
+//! 这是使得您的应用能够自动依赖其他软件库的关键一步。
+//! 
+//! 只要您的编译脚本能够正确地引用环境变量，DADK就能够自动处理软件库的依赖关系。
+//! 
+//! DADK会设置以下全局环境变量：
+//! 
+//! - `DADK_CACHE_ROOT`：DADK的缓存根目录。您可以在编译脚本中，通过引用该环境变量，来获得DADK的缓存根目录。
+//! - `DADK_BUILD_CACHE_DIR_任务名_任务版本`：DADK的任务构建结果缓存目录。当您要引用其他软件库的构建结果时，可以通过该环境变量来获得。
+//! 同时，您也要在构建您的app时，把构建结果放到您的软件库的构建结果缓存目录（通过对应的环境变量获得）中。
+//! - `DADK_SOURCE_CACHE_DIR_任务名_任务版本`：DADK的某个任务的源码目录。当您要引用其他软件库的源码目录时，可以通过该环境变量来获得。
+//! 
+//! 同时，DADK会为每个任务设置其自身在配置文件中指定的环境变量。
+//! 
+//! #### 全局环境变量命名格式
+//! 
+//! 全局环境变量中的任务名和任务版本，都会被转换为大写字母，并对特殊字符进行替换。替换表如下：
+//! 
+//! | 原字符 | 替换字符 |
+//! | ------ | -------- |
+//! | `.`    | `_`      |
+//! | `-`    | `_`      |
+//! | `\t`   | `_`      |
+//! | 空格   | `_`      |
+//! | `+`    | `_`      |
+//! | `*`    | `_`      |
+//! 
+//! **举例**：对于任务`libc-0.1.0`，其构建结果的全局环境变量名为`DADK_BUILD_CACHE_DIR_LIBC_0_1_0`。
+//! 
+//! 
+//! ## TODO
+//! 
+//! - 支持从在线归档文件下载源码、构建好的软件库
+//! - 支持自动更新
+//! - 完善clean命令的逻辑
 
 #![feature(io_error_more)]
 
@@ -30,17 +92,19 @@ extern crate serde;
 extern crate serde_json;
 extern crate simple_logger;
 
-use std::{fs, path::PathBuf, process::exit};
+use std::{path::PathBuf, process::exit};
 
 use clap::Parser;
-use executor::source::GitSource;
+
 use log::{error, info};
-use parser::task::{
-    BuildConfig, CleanConfig, CodeSource, DADKTask, Dependency, InstallConfig, TaskType,
-};
+use parser::task::DADKTask;
 use simple_logger::SimpleLogger;
 
-use crate::{console::CommandLineArgs, executor::cache::cache_root_init, scheduler::Scheduler};
+use crate::{
+    console::{interactive::InteractiveConsole, CommandLineArgs},
+    executor::cache::cache_root_init,
+    scheduler::Scheduler,
+};
 
 mod console;
 mod executor;
@@ -49,15 +113,15 @@ mod scheduler;
 mod utils;
 
 fn main() {
-    SimpleLogger::new().init().unwrap();
+    logger_init();
     // generate_tmp_dadk();
     info!("DADK Starting...");
     let args = CommandLineArgs::parse();
 
     info!("DADK run with args: {:?}", &args);
     // DragonOS sysroot在主机上的路径
-    let dragonos_dir = args.dragonos_dir.as_ref();
-    let config_dir = args.config_dir.as_ref();
+    let dragonos_dir = args.dragonos_dir.clone();
+    let config_dir = args.config_dir.clone();
     let action = args.action;
     info!(
         "DragonOS sysroot dir: {}",
@@ -73,6 +137,18 @@ fn main() {
     );
     info!("Action: {:?}", action);
 
+    match action {
+        console::Action::New => {
+            let r = InteractiveConsole::new(dragonos_dir.clone(), config_dir.clone(), action).run();
+            if r.is_err() {
+                error!("Failed to run interactive console: {:?}", r.unwrap_err());
+                exit(1);
+            }
+            exit(0);
+        }
+        _ => {}
+    }
+
     // 初始化缓存目录
     let r = cache_root_init(args.cache_dir);
     if r.is_err() {
@@ -109,33 +185,11 @@ fn main() {
     }
 }
 
-#[allow(dead_code)]
-fn generate_tmp_dadk() {
-    let x = DADKTask {
-        name: "test".to_string(),
-        version: "0.1.0".to_string(),
-        build: BuildConfig {
-            build_command: Some("echo test".to_string()),
-        },
-        install: InstallConfig {
-            in_dragonos_path: PathBuf::from("/bin"),
-        },
-        clean: CleanConfig::new(None),
-        depends: vec![Dependency {
-            name: "test".to_string(),
-            version: "0.1.0".to_string(),
-        }],
-        description: "test".to_string(),
-        // task_type: TaskType::BuildFromSource(CodeSource::Archive(ArchiveSource::new(
-        //     "123".to_string(),
-        // ))),
-        task_type: TaskType::BuildFromSource(CodeSource::Git(GitSource::new(
-            "123".to_string(),
-            Some("master".to_string()),
-            None,
-        ))),
-        envs: None,
-    };
-    let x = serde_json::to_string(&x).unwrap();
-    fs::write("test.json", x).unwrap();
+/// 初始化日志系统
+fn logger_init() {
+    // 初始化日志系统，日志级别为Info
+    // 如果需要调试，可以将日志级别设置为Debug
+    let logger = SimpleLogger::new().with_level(log::LevelFilter::Info);
+
+    logger.init().unwrap();
 }

src/parser/task.rs

@@ -5,8 +5,14 @@ use serde::{Deserialize, Serialize};
 use crate::executor::source::{ArchiveSource, GitSource, LocalSource};
 
 // 对于生成的包名和版本号，需要进行替换的字符。
-pub static NAME_VERSION_REPLACE_TABLE: [(&str, &str); 4] =
-    [(" ", "_"), ("\t", "_"), ("-", "_"), (".", "_")];
+pub static NAME_VERSION_REPLACE_TABLE: [(&str, &str); 6] = [
+    (" ", "_"),
+    ("\t", "_"),
+    ("-", "_"),
+    (".", "_"),
+    ("+", "_"),
+    ("*", "_"),
+];
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DADKTask {
@@ -203,23 +209,30 @@ impl BuildConfig {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct InstallConfig {
     /// 安装到DragonOS内的目录
-    pub in_dragonos_path: PathBuf,
+    pub in_dragonos_path: Option<PathBuf>,
 }
 
 impl InstallConfig {
     #[allow(dead_code)]
-    pub fn new(in_dragonos_path: PathBuf) -> Self {
+    pub fn new(in_dragonos_path: Option<PathBuf>) -> Self {
         Self { in_dragonos_path }
     }
 
     pub fn validate(&self) -> Result<(), String> {
-        if self.in_dragonos_path.is_relative() {
+        if self.in_dragonos_path.is_none() {
+            return Ok(());
+        }
+        if self.in_dragonos_path.as_ref().unwrap().is_relative() {
             return Err("InstallConfig: in_dragonos_path should be an Absolute path".to_string());
         }
         return Ok(());
     }
 
-    pub fn trim(&mut self) {}
+    pub fn trim(&mut self) {
+        if let Some(in_dragonos_path) = &mut self.in_dragonos_path {
+            *in_dragonos_path = in_dragonos_path.canonicalize().unwrap();
+        }
+    }
 }
 
 /// # 清理配置

src/scheduler/mod.rs

@@ -294,7 +294,7 @@ impl Scheduler {
                 self.run_with_topo_sort()?;
             }
             Action::Clean(_) => self.run_without_topo_sort()?,
-            Action::Uninstall => todo!(),
+            _ => unimplemented!(),            
         }
 
         return Ok(());