新增支持clean命令 (#4)

* 新增支持clean命令。

src/console/clean.rs

@@ -0,0 +1,57 @@
+use std::{fmt::Display, str::FromStr};
+
+use clap::{Args, Subcommand};
+
+/// 清理缓存的级别
+#[derive(Debug, Args, Clone, Copy)]
+pub struct CleanArg {
+    #[arg(default_value = "src")]
+    /// 清理缓存的级别
+    ///
+    /// all：清理所有缓存
+    ///
+    /// src：在源码目录内运行clean命令
+    ///
+    /// target：清理DADK输出目录
+    ///
+    /// cache：清理DADK缓存目录（下载的源码、编译好的库等）
+    pub level: CleanLevel,
+}
+
+#[derive(Debug, Subcommand, Clone, Copy)]
+pub enum CleanLevel {
+    /// 清理所有缓存
+    All,
+    /// 在源码目录内运行clean命令
+    Src,
+    /// 清理DADK输出目录
+    Target,
+    /// 清理DADK缓存目录（下载的源码、编译好的库等）
+    Cache,
+}
+
+impl FromStr for CleanLevel {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_ascii_lowercase();
+        match s.as_str() {
+            "all" => Ok(CleanLevel::All),
+            "src" => Ok(CleanLevel::Src),
+            "target" => Ok(CleanLevel::Target),
+            "cache" => Ok(CleanLevel::Cache),
+            _ => Err(format!("Unknown clean level: {}", s)),
+        }
+    }
+}
+
+impl Display for CleanLevel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CleanLevel::All => write!(f, "all"),
+            CleanLevel::Src => write!(f, "src"),
+            CleanLevel::Target => write!(f, "target"),
+            CleanLevel::Cache => write!(f, "cache"),
+        }
+    }
+}

src/console/mod.rs

@@ -1,10 +1,55 @@
-use clap::Subcommand;
+pub mod clean;
+
+use std::path::PathBuf;
+
+use clap::{Parser, Subcommand};
+
+use self::clean::CleanArg;
+
+#[derive(Debug, Parser, Clone)]
+#[command(author, version, about)]
+pub struct CommandLineArgs {
+    /// DragonOS sysroot在主机上的路径
+    #[arg(short, long, value_parser = parse_check_dir_exists)]
+    pub dragonos_dir: Option<PathBuf>,
+    /// DADK任务配置文件所在目录
+    #[arg(short, long, value_parser = parse_check_dir_exists)]
+    pub config_dir: Option<PathBuf>,
+
+    /// 要执行的操作
+    #[command(subcommand)]
+    pub action: Action,
+
+    /// DADK缓存根目录
+    #[arg(long, value_parser = parse_check_dir_exists)]
+    pub cache_dir: Option<PathBuf>,
+}
+
+/// @brief 检查目录是否存在
+fn parse_check_dir_exists(path: &str) -> Result<PathBuf, String> {
+    let path = PathBuf::from(path);
+    if !path.exists() {
+        return Err(format!("Path '{}' not exists", path.display()));
+    }
+    if !path.is_dir() {
+        return Err(format!("Path '{}' is not a directory", path.display()));
+    }
+
+    return Ok(path);
+}
 
 /// @brief 要执行的操作
 #[derive(Debug, Subcommand, Clone, Copy)]
 pub enum Action {
+    /// 构建所有项目
     Build,
-    Clean,
+    /// 清理缓存
+    Clean(CleanArg),
+    /// 安装到DragonOS sysroot
     Install,
+    /// 尚不支持
     Uninstall,
 }
+
+#[derive(Debug, Clone)]
+pub enum ConsoleError {}

src/executor/cache.rs

@@ -1,6 +1,6 @@
 use std::{path::PathBuf, rc::Rc};
 
-use log::{debug, info};
+use log::info;
 
 use crate::{
     parser::task::{CodeSource, DADKTask, TaskType},
@@ -164,7 +164,7 @@ impl CacheDir {
         if !self.path.exists() {
             info!("Cache dir not exists, create it: {:?}", self.path);
             std::fs::create_dir_all(&self.path).map_err(|e| ExecutorError::IoError(e))?;
-            debug!("Cache dir: [{:?}] created.", self.path);
+            info!("Cache dir: [{:?}] created.", self.path);
         } else if !self.path.is_dir() {
             // 如果路径类别不是目录，则报错
             return Err(ExecutorError::IoError(std::io::Error::new(
@@ -188,4 +188,16 @@ impl CacheDir {
 
         return Ok(true);
     }
+
+    /// # 递归删除自身目录
+    /// 递归删除自身目录，如果目录不存在，则忽略
+    ///
+    /// 请注意，这会删除整个目录，包括目录下的所有文件和子目录
+    pub fn remove_self_recursive(&self) -> Result<(), ExecutorError> {
+        let path = &self.path;
+        if path.exists() {
+            std::fs::remove_dir_all(path).map_err(|e| ExecutorError::IoError(e))?;
+        }
+        return Ok(());
+    }
 }

src/executor/mod.rs

@@ -10,7 +10,7 @@ use std::{
 use log::{error, info, warn};
 
 use crate::{
-    console::Action,
+    console::{clean::CleanLevel, Action},
     executor::cache::CacheDir,
     parser::task::{CodeSource, PrebuiltSource, TaskEnv, TaskType},
     scheduler::{SchedEntities, SchedEntity},
@@ -103,6 +103,10 @@ impl Executor {
                 // 把构建结果安装到DragonOS
                 self.install()?;
             }
+            Action::Clean(_) => {
+                // 清理构建结果
+                self.clean()?;
+            }
             _ => {
                 error!("Unsupported action: {:?}", self.action);
             }
@@ -193,6 +197,93 @@ impl Executor {
         return Ok(());
     }
 
+    fn clean(&self) -> Result<(), ExecutorError> {
+        let level = if let Action::Clean(l) = self.action {
+            l.level
+        } else {
+            panic!(
+                "BUG: clean() called with non-clean action. executor details: {:?}",
+                self
+            );
+        };
+        info!(
+            "Cleaning task: {}, level={level}",
+            self.entity.task().name_version()
+        );
+
+        let r: Result<(), ExecutorError> = match level {
+            CleanLevel::All => self.clean_all(),
+            CleanLevel::Src => self.clean_src(),
+            CleanLevel::Target => self.clean_target(),
+            CleanLevel::Cache => self.clean_cache(),
+        };
+
+        if let Err(e) = r {
+            error!(
+                "Failed to clean task: {}, error message: {:?}",
+                self.entity.task().name_version(),
+                e
+            );
+            return Err(e);
+        }
+
+        return Ok(());
+    }
+
+    fn clean_all(&self) -> Result<(), ExecutorError> {
+        // 在源文件目录执行清理
+        self.clean_src()?;
+        // 清理构建结果
+        self.clean_target()?;
+        // 清理缓存
+        self.clean_cache()?;
+        return Ok(());
+    }
+
+    /// 在源文件目录执行清理
+    fn clean_src(&self) -> Result<(), ExecutorError> {
+        let cmd: Option<Command> = self.create_command()?;
+        if cmd.is_none() {
+            // 如果这里没有命令，则认为用户不需要在源文件目录执行清理
+            return Ok(());
+        }
+        info!(
+            "{}: Cleaning in source directory: {:?}",
+            self.entity.task().name_version(),
+            self.src_work_dir()
+        );
+
+        let cmd = cmd.unwrap();
+        self.run_command(cmd)?;
+        return Ok(());
+    }
+
+    /// 清理构建输出目录
+    fn clean_target(&self) -> Result<(), ExecutorError> {
+        info!(
+            "{}: Cleaning build target directory: {:?}",
+            self.entity.task().name_version(),
+            self.build_dir.path
+        );
+        return self.build_dir.remove_self_recursive();
+    }
+
+    /// 清理下载缓存
+    fn clean_cache(&self) -> Result<(), ExecutorError> {
+        let cache_dir = self.source_dir.as_ref();
+        if cache_dir.is_none() {
+            // 如果没有缓存目录，则认为用户不需要清理缓存
+            return Ok(());
+        }
+        info!(
+            "{}: Cleaning cache directory: {}",
+            self.entity.task().name_version(),
+            self.src_work_dir().display()
+        );
+
+        return cache_dir.unwrap().remove_self_recursive();
+    }
+
     /// 获取源文件的工作目录
     fn src_work_dir(&self) -> PathBuf {
         if let Some(local_path) = self.entity.task().source_path() {
@@ -206,7 +297,14 @@ impl Executor {
     fn create_command(&self) -> Result<Option<Command>, ExecutorError> {
         // 获取命令
         let raw_cmd = match self.entity.task().task_type {
-            TaskType::BuildFromSource(_) => self.entity.task().build.build_command.clone(),
+            TaskType::BuildFromSource(_) => match self.action {
+                Action::Build => self.entity.task().build.build_command.clone(),
+                Action::Clean(_) => self.entity.task().clean.clean_command.clone(),
+                _ => unimplemented!(
+                    "create_command: Action {:?} not supported yet.",
+                    self.action
+                ),
+            },
             _ => None,
         };
 
@@ -384,6 +482,7 @@ impl EnvVar {
 }
 
 /// # 任务执行器错误枚举
+#[allow(dead_code)]
 #[derive(Debug)]
 pub enum ExecutorError {
     /// 准备执行环境错误
@@ -393,6 +492,8 @@ pub enum ExecutorError {
     TaskFailed(String),
     /// 安装错误
     InstallError(String),
+    /// 清理错误
+    CleanError(String),
 }
 
 /// # 准备全局环境变量

src/executor/source.rs

@@ -3,7 +3,7 @@ use std::{
     process::{Command, Stdio},
 };
 
-use log::{debug, info};
+use log::info;
 use reqwest::Url;
 use serde::{Deserialize, Serialize};
 
@@ -104,7 +104,7 @@ impl GitSource {
                 target_dir.path.display()
             )
         })? {
-            debug!("Target dir is empty, cloning repo");
+            info!("Target dir is empty, cloning repo");
             self.clone_repo(target_dir)?;
         }
 

src/main.rs

@@ -35,10 +35,12 @@ use std::{fs, path::PathBuf, process::exit};
 use clap::Parser;
 use executor::source::GitSource;
 use log::{error, info};
-use parser::task::{BuildConfig, CodeSource, DADKTask, Dependency, InstallConfig, TaskType};
+use parser::task::{
+    BuildConfig, CleanConfig, CodeSource, DADKTask, Dependency, InstallConfig, TaskType,
+};
 use simple_logger::SimpleLogger;
 
-use crate::{console::Action, executor::cache::cache_root_init, scheduler::Scheduler};
+use crate::{console::CommandLineArgs, executor::cache::cache_root_init, scheduler::Scheduler};
 
 mod console;
 mod executor;
@@ -46,38 +48,6 @@ mod parser;
 mod scheduler;
 mod utils;
 
-#[derive(Debug, Parser)]
-#[command(author, version, about)]
-struct CommandLineArgs {
-    /// DragonOS sysroot在主机上的路径
-    #[arg(short, long, value_parser = parse_check_dir_exists)]
-    pub dragonos_dir: PathBuf,
-    /// DADK任务配置文件所在目录
-    #[arg(short, long, value_parser = parse_check_dir_exists)]
-    config_dir: PathBuf,
-
-    /// 要执行的操作
-    #[command(subcommand)]
-    action: Action,
-
-    /// DADK缓存根目录
-    #[arg(long, value_parser = parse_check_dir_exists)]
-    cache_dir: Option<PathBuf>,
-}
-
-/// @brief 检查目录是否存在
-fn parse_check_dir_exists(path: &str) -> Result<PathBuf, String> {
-    let path = PathBuf::from(path);
-    if !path.exists() {
-        return Err(format!("Path '{}' not exists", path.display()));
-    }
-    if !path.is_dir() {
-        return Err(format!("Path '{}' is not a directory", path.display()));
-    }
-
-    return Ok(path);
-}
-
 fn main() {
     SimpleLogger::new().init().unwrap();
     // generate_tmp_dadk();
@@ -86,11 +56,21 @@ fn main() {
 
     info!("DADK run with args: {:?}", &args);
     // DragonOS sysroot在主机上的路径
-    let dragonos_dir = args.dragonos_dir;
-    let config_dir = args.config_dir;
+    let dragonos_dir = args.dragonos_dir.as_ref();
+    let config_dir = args.config_dir.as_ref();
     let action = args.action;
-    info!("DragonOS sysroot dir: {}", dragonos_dir.display());
-    info!("Config dir: {}", config_dir.display());
+    info!(
+        "DragonOS sysroot dir: {}",
+        dragonos_dir
+            .as_ref()
+            .map_or_else(|| "None".to_string(), |d| d.display().to_string())
+    );
+    info!(
+        "Config dir: {}",
+        config_dir
+            .as_ref()
+            .map_or_else(|| "None".to_string(), |d| d.display().to_string())
+    );
     info!("Action: {:?}", action);
 
     // 初始化缓存目录
@@ -100,6 +80,16 @@ fn main() {
         exit(1);
     }
 
+    let config_dir = args.config_dir.unwrap_or_else(|| {
+        error!("Config dir not specified");
+        exit(1);
+    });
+
+    let dragonos_dir = args.dragonos_dir.unwrap_or_else(|| {
+        error!("DragonOS sysroot dir not specified");
+        exit(1);
+    });
+
     let mut parser = parser::Parser::new(config_dir);
     let r = parser.parse();
     if r.is_err() {
@@ -130,6 +120,7 @@ fn generate_tmp_dadk() {
         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(),

src/parser/task.rs

@@ -24,6 +24,8 @@ pub struct DADKTask {
     pub build: BuildConfig,
     /// 安装配置
     pub install: InstallConfig,
+    /// 清理配置
+    pub clean: CleanConfig,
     /// 环境变量
     pub envs: Option<Vec<TaskEnv>>,
 }
@@ -38,6 +40,7 @@ impl DADKTask {
         depends: Vec<Dependency>,
         build: BuildConfig,
         install: InstallConfig,
+        clean: CleanConfig,
         envs: Option<Vec<TaskEnv>>,
     ) -> Self {
         Self {
@@ -48,6 +51,7 @@ impl DADKTask {
             depends,
             build,
             install,
+            clean,
             envs,
         }
     }
@@ -63,6 +67,7 @@ impl DADKTask {
         self.build.validate()?;
         self.validate_build_type()?;
         self.install.validate()?;
+        self.clean.validate()?;
         self.validate_depends()?;
         self.validate_envs()?;
 
@@ -76,6 +81,7 @@ impl DADKTask {
         self.task_type.trim();
         self.build.trim();
         self.install.trim();
+        self.clean.trim();
         self.trim_depends();
         self.trim_envs();
     }
@@ -216,6 +222,30 @@ impl InstallConfig {
     pub fn trim(&mut self) {}
 }
 
+/// # 清理配置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CleanConfig {
+    /// 清理命令
+    pub clean_command: Option<String>,
+}
+
+impl CleanConfig {
+    #[allow(dead_code)]
+    pub fn new(clean_command: Option<String>) -> Self {
+        Self { clean_command }
+    }
+
+    pub fn validate(&self) -> Result<(), String> {
+        return Ok(());
+    }
+
+    pub fn trim(&mut self) {
+        if let Some(clean_command) = &mut self.clean_command {
+            *clean_command = clean_command.trim().to_string();
+        }
+    }
+}
+
 /// @brief 依赖项
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Dependency {

src/scheduler/mod.rs

@@ -285,6 +285,25 @@ impl Scheduler {
 
     /// # 执行调度器中的所有任务
     pub fn run(&self) -> Result<(), SchedulerError> {
+        // 准备全局环境变量
+        crate::executor::prepare_env(&self.target)
+            .map_err(|e| SchedulerError::RunError(format!("{:?}", e)))?;
+
+        match self.action {
+            Action::Build | Action::Install => {
+                self.run_with_topo_sort()?;
+            }
+            Action::Clean(_) => self.run_without_topo_sort()?,
+            Action::Uninstall => todo!(),
+        }
+
+        return Ok(());
+    }
+
+    /// Action需要按照拓扑序执行
+    ///
+    /// Action::Build | Action::Install
+    fn run_with_topo_sort(&self) -> Result<(), SchedulerError> {
         // 检查是否有不存在的依赖
         let r = self.check_not_exists_dependency();
         if r.is_err() {
@@ -295,9 +314,6 @@ impl Scheduler {
         // 对调度实体进行拓扑排序
         let r: Vec<Rc<SchedEntity>> = self.target.topo_sort();
 
-        crate::executor::prepare_env(&self.target)
-            .map_err(|e| SchedulerError::RunError(format!("{:?}", e)))?;
-
         for entity in r.iter() {
             let mut executor = Executor::new(
                 entity.clone(),
@@ -329,6 +345,39 @@ impl Scheduler {
         return Ok(());
     }
 
+    /// Action不需要按照拓扑序执行
+    fn run_without_topo_sort(&self) -> Result<(), SchedulerError> {
+        for entity in self.target.iter() {
+            let mut executor = Executor::new(
+                entity.clone(),
+                self.action.clone(),
+                self.dragonos_dir.clone(),
+            )
+            .map_err(|e| {
+                error!(
+                    "Error while creating executor for task {} : {:?}",
+                    entity.task().name_version(),
+                    e
+                );
+                exit(-1);
+            })
+            .unwrap();
+
+            executor
+                .execute()
+                .map_err(|e| {
+                    error!(
+                        "Error while executing task {} : {:?}",
+                        entity.task().name_version(),
+                        e
+                    );
+                    exit(-1);
+                })
+                .unwrap();
+        }
+        return Ok(());
+    }
+
     /// # 检查是否有不存在的依赖
     ///
     /// 如果某个任务的dependency中的任务不存在，则返回错误