添加任务执行器，并能够执行构建、安装动作 (#3)

* 1.任务执行器能够执行以下任务:
	a.本地构建
	b.自动克隆git仓库并构建
	c.安装构建结果到DragonOS内
2.修改代码结构,把一些结构体从parser移动到executor

src/console/mod.rs

@@ -1,10 +1,10 @@
 use clap::Subcommand;
 
 /// @brief 要执行的操作
-#[derive(Debug, Subcommand)]
+#[derive(Debug, Subcommand, Clone, Copy)]
 pub enum Action {
     Build,
     Clean,
     Install,
     Uninstall,
-}
+}

src/executor/cache.rs

@@ -75,8 +75,9 @@ pub fn cache_root_init(path: Option<PathBuf>) -> Result<(), ExecutorError> {
     return Ok(());
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct CacheDir {
+    #[allow(dead_code)]
     entity: Rc<SchedEntity>,
     pub path: PathBuf,
     pub cache_type: CacheDirType,
@@ -127,12 +128,12 @@ impl CacheDir {
         return Ok(Self::new(entity, CacheDirType::Source)?.path);
     }
 
-    pub fn build_dir_env_key(entity: Rc<SchedEntity>) -> Result<String, ExecutorError> {
+    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));
     }
 
-    pub fn source_dir_env_key(entity: Rc<SchedEntity>) -> Result<String, ExecutorError> {
+    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));
     }
@@ -159,7 +160,7 @@ impl CacheDir {
         unimplemented!("Not fully implemented task type: {:?}", task_type);
     }
 
-    fn create(&self) -> Result<(), ExecutorError> {
+    pub fn create(&self) -> Result<(), ExecutorError> {
         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))?;
@@ -171,7 +172,20 @@ impl CacheDir {
                 format!("Cache dir is not a directory: {:?}", self.path),
             )));
         }
-        
+
         return Ok(());
     }
+
+    /// 判断缓存目录是否为空
+    pub fn is_empty(&self) -> Result<bool, ExecutorError> {
+        let x = self
+            .path
+            .read_dir()
+            .map_err(|e| ExecutorError::IoError(e))?;
+        for _ in x {
+            return Ok(false);
+        }
+
+        return Ok(true);
+    }
 }

src/executor/mod.rs

@@ -1,27 +1,43 @@
-use std::{collections::BTreeMap, env::Vars, rc::Rc, sync::RwLock};
+use std::{
+    collections::BTreeMap,
+    env::Vars,
+    path::PathBuf,
+    process::{Command, Stdio},
+    rc::Rc,
+    sync::RwLock,
+};
 
-use log::{debug, info};
+use log::{error, info, warn};
 
 use crate::{
+    console::Action,
     executor::cache::CacheDir,
+    parser::task::{CodeSource, PrebuiltSource, TaskEnv, TaskType},
     scheduler::{SchedEntities, SchedEntity},
+    utils::stdio::StdioUtils,
 };
 
 use self::cache::CacheDirType;
 
 pub mod cache;
+pub mod source;
 
 lazy_static! {
     // 全局环境变量的列表
     pub static ref ENV_LIST: RwLock<EnvMap> = RwLock::new(EnvMap::new());
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Executor {
     entity: Rc<SchedEntity>,
+    action: Action,
     local_envs: EnvMap,
+    /// 任务构建结果输出到的目录
     build_dir: CacheDir,
+    /// 如果任务需要源文件缓存，则此字段为 Some(CacheDir)，否则为 None（使用本地源文件路径）
     source_dir: Option<CacheDir>,
+    /// DragonOS sysroot的路径
+    dragonos_sysroot: PathBuf,
 }
 
 impl Executor {
@@ -37,7 +53,11 @@ impl Executor {
     ///
     /// * `Ok(Executor)` - 创建成功
     /// * `Err(ExecutorError)` - 创建失败
-    pub fn new(entity: Rc<SchedEntity>) -> Result<Self, ExecutorError> {
+    pub fn new(
+        entity: Rc<SchedEntity>,
+        action: Action,
+        dragonos_sysroot: PathBuf,
+    ) -> Result<Self, ExecutorError> {
         let local_envs = EnvMap::new();
         let build_dir = CacheDir::new(entity.clone(), CacheDirType::Build)?;
 
@@ -48,33 +68,281 @@ impl Executor {
         };
 
         let result: Executor = Self {
+            action,
             entity,
             local_envs,
             build_dir,
             source_dir,
+            dragonos_sysroot,
         };
 
         return Ok(result);
     }
 
     /// # 执行任务
-    /// 
+    ///
     /// 创建执行器后，调用此方法执行任务。
     /// 该方法会执行以下步骤：
-    /// 
+    ///
     /// 1. 创建工作线程
     /// 2. 准备环境变量
     /// 3. 拉取数据（可选）
     /// 4. 执行构建
-    pub fn execute(&self) -> Result<(), ExecutorError> {
-        // todo!("Execute task: {:?}", self.entity.task());
+    pub fn execute(&mut self) -> Result<(), ExecutorError> {
         info!("Execute task: {}", self.entity.task().name_version());
 
+        // 准备本地环境变量
+        self.prepare_local_env()?;
+
+        match self.action {
+            Action::Build => {
+                // 构建任务
+                self.build()?;
+            }
+            Action::Install => {
+                // 把构建结果安装到DragonOS
+                self.install()?;
+            }
+            _ => {
+                error!("Unsupported action: {:?}", self.action);
+            }
+        }
+        info!("Task {} finished", self.entity.task().name_version());
+        return Ok(());
+    }
+
+    /// # 执行build操作
+    fn build(&mut self) -> Result<(), ExecutorError> {
+        // 确认源文件就绪
+        self.prepare_input()?;
+
+        let command: Option<Command> = self.create_command()?;
+        if let Some(cmd) = command {
+            self.run_command(cmd)?;
+        }
+
+        // 检查构建结果，如果为空，则抛出警告
+        if self.build_dir.is_empty()? {
+            warn!(
+                "Task {}: build result is empty, do you forget to copy the result to [${}]?",
+                self.entity.task().name_version(),
+                CacheDir::build_dir_env_key(&self.entity)?
+            );
+        }
         return Ok(());
     }
+
+    /// # 执行安装操作，把构建结果安装到DragonOS
+    fn install(&self) -> Result<(), ExecutorError> {
+        info!("Installing task: {}", self.entity.task().name_version());
+
+        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();
+            in_dragonos_path = in_dragonos_path[count_leading_slashes..].to_string();
+        }
+        // 拼接最终的安装路径
+        let install_path = self.dragonos_sysroot.join(in_dragonos_path);
+        // debug!("install_path: {:?}", install_path);
+        // 创建安装路径
+        std::fs::create_dir_all(&install_path).map_err(|e| {
+            ExecutorError::InstallError(format!("Failed to create install path: {}", e.to_string()))
+        })?;
+
+        // 拷贝构建结果到安装路径
+        let build_dir: PathBuf = self.build_dir.path.clone();
+
+        let cmd = Command::new("cp")
+            .arg("-r")
+            .arg(build_dir.to_string_lossy().to_string() + "/.")
+            .arg(install_path)
+            .stdout(Stdio::null())
+            .stderr(Stdio::piped())
+            .spawn()
+            .map_err(|e| {
+                ExecutorError::InstallError(format!(
+                    "Failed to install, error message: {}",
+                    e.to_string()
+                ))
+            })?;
+
+        let output = cmd.wait_with_output().map_err(|e| {
+            ExecutorError::InstallError(format!(
+                "Failed to install, error message: {}",
+                e.to_string()
+            ))
+        })?;
+
+        if !output.status.success() {
+            let err_msg = StdioUtils::tail_n_str(StdioUtils::stderr_to_lines(&output.stderr), 10);
+            return Err(ExecutorError::InstallError(format!(
+                "Failed to install, error message: {}",
+                err_msg
+            )));
+        }
+
+        info!("Task {} installed.", self.entity.task().name_version());
+
+        return Ok(());
+    }
+
+    /// 获取源文件的工作目录
+    fn src_work_dir(&self) -> PathBuf {
+        if let Some(local_path) = self.entity.task().source_path() {
+            return local_path;
+        }
+
+        return self.source_dir.as_ref().unwrap().path.clone();
+    }
+
+    /// 为任务创建命令
+    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(),
+            _ => None,
+        };
+
+        if raw_cmd.is_none() {
+            return Ok(None);
+        }
+
+        let raw_cmd = raw_cmd.unwrap();
+
+        let mut command = Command::new("bash");
+        command.current_dir(self.src_work_dir());
+
+        // 设置参数
+        command.arg("-c");
+        command.arg(raw_cmd);
+
+        // 设置环境变量
+        let env_list = ENV_LIST.read().unwrap();
+        for (key, value) in env_list.envs.iter() {
+            // if key.starts_with("DADK") {
+            //     debug!("DADK env found: {}={}", key, value.value);
+            // }
+            command.env(key, value.value.clone());
+        }
+        drop(env_list);
+        for (key, value) in self.local_envs.envs.iter() {
+            command.env(key, value.value.clone());
+        }
+
+        return Ok(Some(command));
+    }
+
+    /// # 准备工作线程本地环境变量
+    fn prepare_local_env(&mut self) -> Result<(), ExecutorError> {
+        // 设置本地环境变量
+        let task_envs: Option<&Vec<TaskEnv>> = self.entity.task().envs.as_ref();
+        if task_envs.is_none() {
+            return Ok(());
+        }
+
+        let task_envs = task_envs.unwrap();
+        for tv in task_envs.iter() {
+            self.local_envs
+                .add(EnvVar::new(tv.key().to_string(), tv.value().to_string()));
+        }
+
+        return Ok(());
+    }
+
+    fn prepare_input(&self) -> Result<(), ExecutorError> {
+        // 拉取源文件
+        if self.source_dir.is_none() {
+            return Ok(());
+        }
+        let task = self.entity.task();
+        let source_dir = self.source_dir.as_ref().unwrap();
+
+        match &task.task_type {
+            TaskType::BuildFromSource(cs) => {
+                match cs {
+                    CodeSource::Git(git) => {
+                        git.prepare(source_dir)
+                            .map_err(|e| ExecutorError::PrepareEnvError(e))?;
+                    }
+                    // 本地源文件，不需要拉取
+                    CodeSource::Local(_) => return Ok(()),
+                    // 在线压缩包，需要下载
+                    CodeSource::Archive(_) => todo!(),
+                }
+            }
+            TaskType::InstallFromPrebuilt(pb) => {
+                match pb {
+                    // 本地源文件，不需要拉取
+                    PrebuiltSource::Local(_) => return Ok(()),
+                    // 在线压缩包，需要下载
+                    PrebuiltSource::Archive(_) => todo!(),
+                }
+            }
+        }
+
+        return Ok(());
+    }
+
+    fn run_command(&self, mut command: Command) -> Result<(), ExecutorError> {
+        let mut child = command
+            .stdin(Stdio::inherit())
+            .spawn()
+            .map_err(|e| ExecutorError::IoError(e))?;
+
+        // 等待子进程结束
+        let r = child.wait().map_err(|e| ExecutorError::IoError(e));
+        if r.is_ok() {
+            let r = r.unwrap();
+            if r.success() {
+                return Ok(());
+            } else {
+                // 执行失败，获取最后100行stderr输出
+                let errmsg = format!(
+                    "Task {} failed, exit code = {}",
+                    self.entity.task().name_version(),
+                    r.code().unwrap()
+                );
+                error!("{errmsg}");
+                let command_opt = command.output();
+                if command_opt.is_err() {
+                    return Err(ExecutorError::TaskFailed(
+                        "Failed to get command output".to_string(),
+                    ));
+                }
+                let command_opt = command_opt.unwrap();
+                let command_output = String::from_utf8_lossy(&command_opt.stderr);
+                let mut last_100_outputs = command_output
+                    .lines()
+                    .rev()
+                    .take(100)
+                    .collect::<Vec<&str>>();
+                last_100_outputs.reverse();
+                error!("Last 100 lines msg of stderr:");
+                for line in last_100_outputs {
+                    error!("{}", line);
+                }
+                return Err(ExecutorError::TaskFailed(errmsg));
+            }
+        } else {
+            let errmsg = format!(
+                "Task {} failed, msg = {:?}",
+                self.entity.task().name_version(),
+                r.err().unwrap()
+            );
+            error!("{errmsg}");
+            return Err(ExecutorError::TaskFailed(errmsg));
+        }
+    }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct EnvMap {
     pub envs: BTreeMap<String, EnvVar>,
 }
@@ -90,6 +358,7 @@ impl EnvMap {
         self.envs.insert(env.key.clone(), env);
     }
 
+    #[allow(dead_code)]
     pub fn get(&self, key: &str) -> Option<&EnvVar> {
         self.envs.get(key)
     }
@@ -101,7 +370,8 @@ impl EnvMap {
     }
 }
 
-#[derive(Debug, PartialEq, PartialOrd, Eq, Ord)]
+/// # 环境变量
+#[derive(Debug, PartialEq, PartialOrd, Eq, Ord, Clone)]
 pub struct EnvVar {
     pub key: String,
     pub value: String,
@@ -113,13 +383,19 @@ impl EnvVar {
     }
 }
 
+/// # 任务执行器错误枚举
 #[derive(Debug)]
 pub enum ExecutorError {
-    /// # 准备环境变量错误
-    PrepareEnvError,
+    /// 准备执行环境错误
+    PrepareEnvError(String),
     IoError(std::io::Error),
+    /// 构建执行错误
+    TaskFailed(String),
+    /// 安装错误
+    InstallError(String),
 }
 
+/// # 准备全局环境变量
 pub fn prepare_env(sched_entities: &SchedEntities) -> Result<(), ExecutorError> {
     info!("Preparing environment variables...");
     // 获取当前全局环境变量列表
@@ -132,7 +408,7 @@ pub fn prepare_env(sched_entities: &SchedEntities) -> Result<(), ExecutorError>
         // 导出任务的构建目录环境变量
         let build_dir = CacheDir::build_dir(entity.clone())?;
 
-        let build_dir_key = CacheDir::build_dir_env_key(entity.clone())?;
+        let build_dir_key = CacheDir::build_dir_env_key(&entity)?;
         env_list.add(EnvVar::new(
             build_dir_key,
             build_dir.to_str().unwrap().to_string(),
@@ -141,7 +417,7 @@ pub fn prepare_env(sched_entities: &SchedEntities) -> Result<(), ExecutorError>
         // 如果需要源码缓存目录，则导出
         if CacheDir::need_source_cache(entity) {
             let source_dir = CacheDir::source_dir(entity.clone())?;
-            let source_dir_key = CacheDir::source_dir_env_key(entity.clone())?;
+            let source_dir_key = CacheDir::source_dir_env_key(&entity)?;
             env_list.add(EnvVar::new(
                 source_dir_key,
                 source_dir.to_str().unwrap().to_string(),

src/executor/source.rs

@@ -0,0 +1,379 @@
+use std::{
+    path::PathBuf,
+    process::{Command, Stdio},
+};
+
+use log::{debug, info};
+use reqwest::Url;
+use serde::{Deserialize, Serialize};
+
+use crate::utils::stdio::StdioUtils;
+
+use super::cache::CacheDir;
+
+/// # Git源
+///
+/// 从Git仓库获取源码
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitSource {
+    /// Git仓库地址
+    url: String,
+    /// 分支（可选，如果为空，则拉取master）branch和revision只能同时指定一个
+    branch: Option<String>,
+    /// 特定的提交的hash值（可选，如果为空，则拉取branch的最新提交）
+    revision: Option<String>,
+}
+
+impl GitSource {
+    pub fn new(url: String, branch: Option<String>, revision: Option<String>) -> Self {
+        Self {
+            url,
+            branch,
+            revision,
+        }
+    }
+
+    /// # 验证参数合法性
+    ///
+    /// 仅进行形式校验，不会检查Git仓库是否存在，以及分支是否存在、是否有权限访问等
+    pub fn validate(&mut self) -> Result<(), String> {
+        if self.url.is_empty() {
+            return Err("url is empty".to_string());
+        }
+        // branch和revision不能同时为空
+        if self.branch.is_none() && self.revision.is_none() {
+            self.branch = Some("master".to_string());
+        }
+        // branch和revision只能同时指定一个
+        if self.branch.is_some() && self.revision.is_some() {
+            return Err("branch and revision are both specified".to_string());
+        }
+
+        if self.branch.is_some() {
+            if self.branch.as_ref().unwrap().is_empty() {
+                return Err("branch is empty".to_string());
+            }
+        }
+        if self.revision.is_some() {
+            if self.revision.as_ref().unwrap().is_empty() {
+                return Err("revision is empty".to_string());
+            }
+        }
+        return Ok(());
+    }
+
+    pub fn trim(&mut self) {
+        self.url = self.url.trim().to_string();
+        if let Some(branch) = &mut self.branch {
+            *branch = branch.trim().to_string();
+        }
+
+        if let Some(revision) = &mut self.revision {
+            *revision = revision.trim().to_string();
+        }
+    }
+
+    /// # 确保Git仓库已经克隆到指定目录，并且切换到指定分支/Revision
+    ///
+    /// 如果目录不存在，则会自动创建
+    ///
+    /// ## 参数
+    ///
+    /// * `target_dir` - 目标目录
+    ///
+    /// ## 返回
+    ///
+    /// * `Ok(())` - 成功
+    /// * `Err(String)` - 失败，错误信息
+    pub fn prepare(&self, target_dir: &CacheDir) -> Result<(), String> {
+        info!(
+            "Preparing git repo: {}, branch: {:?}, revision: {:?}",
+            self.url, self.branch, self.revision
+        );
+
+        target_dir.create().map_err(|e| {
+            format!(
+                "Failed to create target dir: {}, message: {e:?}",
+                target_dir.path.display()
+            )
+        })?;
+
+        if target_dir.is_empty().map_err(|e| {
+            format!(
+                "Failed to check if target dir is empty: {}, message: {e:?}",
+                target_dir.path.display()
+            )
+        })? {
+            debug!("Target dir is empty, cloning repo");
+            self.clone_repo(target_dir)?;
+        }
+
+        self.checkout(target_dir)?;
+
+        self.pull(target_dir)?;
+
+        return Ok(());
+    }
+
+    fn checkout(&self, target_dir: &CacheDir) -> Result<(), String> {
+        let do_checkout = || -> Result<(), String> {
+            let mut cmd = Command::new("git");
+            cmd.current_dir(&target_dir.path);
+            cmd.arg("checkout");
+
+            if let Some(branch) = &self.branch {
+                cmd.arg(branch);
+            }
+            if let Some(revision) = &self.revision {
+                cmd.arg(revision);
+            }
+
+            // 强制切换分支，且安静模式
+            cmd.arg("-f").arg("-q");
+
+            // 创建子进程，执行命令
+            let proc: std::process::Child = cmd
+                .stderr(Stdio::piped())
+                .spawn()
+                .map_err(|e| e.to_string())?;
+            let output = proc.wait_with_output().map_err(|e| e.to_string())?;
+
+            if !output.status.success() {
+                return Err(format!(
+                    "Failed to checkout {}, message: {}",
+                    target_dir.path.display(),
+                    String::from_utf8_lossy(&output.stdout)
+                ));
+            }
+            return Ok(());
+        };
+
+        if let Err(_) = do_checkout() {
+            // 如果切换分支失败，则尝试重新fetch
+            if self.revision.is_some() {
+                self.set_fetch_config(target_dir)?;
+                self.unshallow(target_dir)?
+            };
+
+            self.fetch_all(target_dir).ok();
+            do_checkout()?;
+        }
+
+        return Ok(());
+    }
+
+    pub fn clone_repo(&self, cache_dir: &CacheDir) -> Result<(), String> {
+        let path: &PathBuf = &cache_dir.path;
+        let mut cmd = Command::new("git");
+        cmd.arg("clone").arg(&self.url).arg(".").arg("--recursive");
+
+        if let Some(branch) = &self.branch {
+            cmd.arg("--branch").arg(branch).arg("--depth").arg("1");
+        }
+
+        // 对于克隆，如果指定了revision，则直接克隆整个仓库，稍后再切换到指定的revision
+
+        // 设置工作目录
+        cmd.current_dir(path);
+
+        // 创建子进程，执行命令
+        let proc: std::process::Child = cmd
+            .stderr(Stdio::piped())
+            .stdout(Stdio::inherit())
+            .spawn()
+            .map_err(|e| e.to_string())?;
+        let output = proc.wait_with_output().map_err(|e| e.to_string())?;
+
+        if !output.status.success() {
+            return Err(format!(
+                "clone git repo failed, status: {:?},  stderr: {:?}",
+                output.status,
+                StdioUtils::tail_n_str(StdioUtils::stderr_to_lines(&output.stderr), 5)
+            ));
+        }
+        return Ok(());
+    }
+
+    /// 设置fetch所有分支
+    fn set_fetch_config(&self, target_dir: &CacheDir) -> Result<(), String> {
+        let mut cmd = Command::new("git");
+        cmd.current_dir(&target_dir.path);
+        cmd.arg("config")
+            .arg("remote.origin.fetch")
+            .arg("+refs/heads/*:refs/remotes/origin/*");
+
+        // 创建子进程，执行命令
+        let proc: std::process::Child = cmd
+            .stderr(Stdio::piped())
+            .spawn()
+            .map_err(|e| e.to_string())?;
+        let output = proc.wait_with_output().map_err(|e| e.to_string())?;
+
+        if !output.status.success() {
+            return Err(format!(
+                "Failed to set fetch config {}, message: {}",
+                target_dir.path.display(),
+                StdioUtils::tail_n_str(StdioUtils::stderr_to_lines(&output.stderr), 5)
+            ));
+        }
+        return Ok(());
+    }
+
+    /// # 把浅克隆的仓库变成深克隆
+    fn unshallow(&self, target_dir: &CacheDir) -> Result<(), String> {
+        let mut cmd = Command::new("git");
+        cmd.current_dir(&target_dir.path);
+        cmd.arg("fetch").arg("--unshallow");
+
+        // 安静模式
+        cmd.arg("-f").arg("-q");
+
+        // 创建子进程，执行命令
+        let proc: std::process::Child = cmd
+            .stderr(Stdio::piped())
+            .spawn()
+            .map_err(|e| e.to_string())?;
+        let output = proc.wait_with_output().map_err(|e| e.to_string())?;
+
+        if !output.status.success() {
+            return Err(format!(
+                "Failed to unshallow {}, message: {}",
+                target_dir.path.display(),
+                StdioUtils::tail_n_str(StdioUtils::stderr_to_lines(&output.stderr), 5)
+            ));
+        }
+        return Ok(());
+    }
+
+    fn fetch_all(&self, target_dir: &CacheDir) -> Result<(), String> {
+        self.set_fetch_config(target_dir)?;
+        let mut cmd = Command::new("git");
+        cmd.current_dir(&target_dir.path);
+        cmd.arg("fetch").arg("--all");
+
+        // 安静模式
+        cmd.arg("-f").arg("-q");
+
+        // 创建子进程，执行命令
+        let proc: std::process::Child = cmd
+            .stderr(Stdio::piped())
+            .spawn()
+            .map_err(|e| e.to_string())?;
+        let output = proc.wait_with_output().map_err(|e| e.to_string())?;
+
+        if !output.status.success() {
+            return Err(format!(
+                "Failed to fetch all {}, message: {}",
+                target_dir.path.display(),
+                StdioUtils::tail_n_str(StdioUtils::stderr_to_lines(&output.stderr), 5)
+            ));
+        }
+
+        return Ok(());
+    }
+
+    fn pull(&self, target_dir: &CacheDir) -> Result<(), String> {
+        // 如果没有指定branch，则不执行pull
+        if !self.branch.is_some() {
+            return Ok(());
+        }
+        info!("git pulling: {}", target_dir.path.display());
+
+        let mut cmd = Command::new("git");
+        cmd.current_dir(&target_dir.path);
+        cmd.arg("pull");
+
+        // 安静模式
+        cmd.arg("-f").arg("-q");
+
+        // 创建子进程，执行命令
+        let proc: std::process::Child = cmd
+            .stderr(Stdio::piped())
+            .spawn()
+            .map_err(|e| e.to_string())?;
+        let output = proc.wait_with_output().map_err(|e| e.to_string())?;
+
+        // 如果pull失败，且指定了branch，则报错
+        if !output.status.success() {
+            return Err(format!(
+                "Failed to pull {}, message: {}",
+                target_dir.path.display(),
+                StdioUtils::tail_n_str(StdioUtils::stderr_to_lines(&output.stderr), 5)
+            ));
+        }
+
+        return Ok(());
+    }
+}
+
+/// # 本地源
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LocalSource {
+    /// 本地目录/文件的路径
+    path: PathBuf,
+}
+
+impl LocalSource {
+    #[allow(dead_code)]
+    pub fn new(path: PathBuf) -> Self {
+        Self { path }
+    }
+
+    pub fn validate(&self, expect_file: Option<bool>) -> Result<(), String> {
+        if !self.path.exists() {
+            return Err(format!("path {:?} not exists", self.path));
+        }
+
+        if let Some(expect_file) = expect_file {
+            if expect_file && !self.path.is_file() {
+                return Err(format!("path {:?} is not a file", self.path));
+            }
+
+            if !expect_file && !self.path.is_dir() {
+                return Err(format!("path {:?} is not a directory", self.path));
+            }
+        }
+
+        return Ok(());
+    }
+
+    pub fn trim(&mut self) {}
+
+    pub fn path(&self) -> &PathBuf {
+        &self.path
+    }
+}
+
+/// # 在线压缩包源
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ArchiveSource {
+    /// 压缩包的URL
+    url: String,
+}
+
+impl ArchiveSource {
+    #[allow(dead_code)]
+    pub fn new(url: String) -> Self {
+        Self { url }
+    }
+
+    pub fn validate(&self) -> Result<(), String> {
+        if self.url.is_empty() {
+            return Err("url is empty".to_string());
+        }
+
+        // 判断是一个网址
+        if let Ok(url) = Url::parse(&self.url) {
+            if url.scheme() != "http" && url.scheme() != "https" {
+                return Err(format!("url {:?} is not a http/https url", self.url));
+            }
+        } else {
+            return Err(format!("url {:?} is not a valid url", self.url));
+        }
+        return Ok(());
+    }
+
+    pub fn trim(&mut self) {
+        self.url = self.url.trim().to_string();
+    }
+}

src/main.rs

@@ -33,13 +33,12 @@ extern crate simple_logger;
 use std::{fs, path::PathBuf, process::exit};
 
 use clap::Parser;
-use log::{info, error};
-use parser::task::{
-    BuildConfig, CodeSource, DADKTask, Dependency, GitSource, InstallConfig, TaskType,
-};
+use executor::source::GitSource;
+use log::{error, info};
+use parser::task::{BuildConfig, CodeSource, DADKTask, Dependency, InstallConfig, TaskType};
 use simple_logger::SimpleLogger;
 
-use crate::{console::Action, scheduler::Scheduler, executor::cache::cache_root_init};
+use crate::{console::Action, executor::cache::cache_root_init, scheduler::Scheduler};
 
 mod console;
 mod executor;
@@ -126,11 +125,10 @@ fn generate_tmp_dadk() {
         name: "test".to_string(),
         version: "0.1.0".to_string(),
         build: BuildConfig {
-            build_command: "echo test".to_string(),
+            build_command: Some("echo test".to_string()),
         },
         install: InstallConfig {
             in_dragonos_path: PathBuf::from("/bin"),
-            install_command: "echo test".to_string(),
         },
         depends: vec![Dependency {
             name: "test".to_string(),
@@ -142,7 +140,7 @@ fn generate_tmp_dadk() {
         // ))),
         task_type: TaskType::BuildFromSource(CodeSource::Git(GitSource::new(
             "123".to_string(),
-            "master".to_string(),
+            Some("master".to_string()),
             None,
         ))),
         envs: None,

src/parser/mod.rs

@@ -19,7 +19,8 @@
 //!     "task_type": {任务类型（该部分详见`TaskType`的文档）},
 //!     "depends": [{依赖项（该部分详见Dependency的文档）}],
 //!     "build": {构建配置（该部分详见BuildConfig的文档）},
-//!     "install": {安装配置（该部分详见InstallConfig的文档）}
+//!     "install": {安装配置（该部分详见InstallConfig的文档）},
+//!     "envs" : [{ "key": "环境变量名", "value": "环境变量值" }]
 //! }
 use std::{
     fmt::Debug,

src/parser/task.rs

@@ -1,10 +1,12 @@
 use std::path::PathBuf;
 
-use reqwest::Url;
 use serde::{Deserialize, Serialize};
 
+use crate::executor::source::{ArchiveSource, GitSource, LocalSource};
+
 // 对于生成的包名和版本号，需要进行替换的字符。
-pub static NAME_VERSION_REPLACE_TABLE: [(&str, &str); 3] = [(" ", "_"), ("\t", "_"), ("-", "_")];
+pub static NAME_VERSION_REPLACE_TABLE: [(&str, &str); 4] =
+    [(" ", "_"), ("\t", "_"), ("-", "_"), (".", "_")];
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DADKTask {
@@ -50,7 +52,7 @@ impl DADKTask {
         }
     }
 
-    pub fn validate(&self) -> Result<(), String> {
+    pub fn validate(&mut self) -> Result<(), String> {
         if self.name.is_empty() {
             return Err("name is empty".to_string());
         }
@@ -59,6 +61,7 @@ impl DADKTask {
         }
         self.task_type.validate()?;
         self.build.validate()?;
+        self.validate_build_type()?;
         self.install.validate()?;
         self.validate_depends()?;
         self.validate_envs()?;
@@ -107,30 +110,76 @@ impl DADKTask {
         }
     }
 
+    /// 验证任务类型与构建配置是否匹配
+    fn validate_build_type(&self) -> Result<(), String> {
+        match &self.task_type {
+            TaskType::BuildFromSource(_) => {
+                if self.build.build_command.is_none() {
+                    return Err("build command is empty".to_string());
+                }
+            }
+            TaskType::InstallFromPrebuilt(_) => {
+                if self.build.build_command.is_some() {
+                    return Err(
+                        "build command should be empty when install from prebuilt".to_string()
+                    );
+                }
+            }
+        }
+        return Ok(());
+    }
+
     pub fn name_version(&self) -> String {
         return format!("{}-{}", self.name, self.version);
     }
 
     pub fn name_version_env(&self) -> String {
-        let mut name_version = self.name_version();
+        return Self::name_version_uppercase(&self.name, &self.version);
+    }
+
+    pub fn name_version_uppercase(name: &str, version: &str) -> String {
+        let mut name_version = format!("{}-{}", name, version).to_ascii_uppercase();
         for (src, dst) in &NAME_VERSION_REPLACE_TABLE {
             name_version = name_version.replace(src, dst);
         }
         return name_version;
     }
 
+    /// # 获取源码目录
+    ///
+    /// 如果从本地路径构建，则返回本地路径。否则返回None。
+    pub fn source_path(&self) -> Option<PathBuf> {
+        match &self.task_type {
+            TaskType::BuildFromSource(cs) => match cs {
+                CodeSource::Local(lc) => {
+                    return Some(lc.path().clone());
+                }
+                _ => {
+                    return None;
+                }
+            },
+            TaskType::InstallFromPrebuilt(ps) => match ps {
+                PrebuiltSource::Local(lc) => {
+                    return Some(lc.path().clone());
+                }
+                _ => {
+                    return None;
+                }
+            },
+        }
+    }
 }
 
 /// @brief 构建配置
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BuildConfig {
     /// 构建命令
-    pub build_command: String,
+    pub build_command: Option<String>,
 }
 
 impl BuildConfig {
     #[allow(dead_code)]
-    pub fn new(build_command: String) -> Self {
+    pub fn new(build_command: Option<String>) -> Self {
         Self { build_command }
     }
 
@@ -139,7 +188,9 @@ impl BuildConfig {
     }
 
     pub fn trim(&mut self) {
-        self.build_command = self.build_command.trim().to_string();
+        if let Some(build_command) = &mut self.build_command {
+            *build_command = build_command.trim().to_string();
+        }
     }
 }
 
@@ -147,26 +198,22 @@ impl BuildConfig {
 pub struct InstallConfig {
     /// 安装到DragonOS内的目录
     pub in_dragonos_path: PathBuf,
-    /// 安装命令
-    pub install_command: String,
 }
 
 impl InstallConfig {
     #[allow(dead_code)]
-    pub fn new(in_dragonos_path: PathBuf, install_command: String) -> Self {
-        Self {
-            in_dragonos_path,
-            install_command,
-        }
+    pub fn new(in_dragonos_path: PathBuf) -> Self {
+        Self { in_dragonos_path }
     }
 
     pub fn validate(&self) -> Result<(), String> {
+        if self.in_dragonos_path.is_relative() {
+            return Err("InstallConfig: in_dragonos_path should be an Absolute path".to_string());
+        }
         return Ok(());
     }
 
-    pub fn trim(&mut self) {
-        self.install_command = self.install_command.trim().to_string();
-    }
+    pub fn trim(&mut self) {}
 }
 
 /// @brief 依赖项
@@ -212,7 +259,7 @@ pub enum TaskType {
 }
 
 impl TaskType {
-    pub fn validate(&self) -> Result<(), String> {
+    pub fn validate(&mut self) -> Result<(), String> {
         match self {
             TaskType::BuildFromSource(source) => source.validate(),
             TaskType::InstallFromPrebuilt(source) => source.validate(),
@@ -239,7 +286,7 @@ pub enum CodeSource {
 }
 
 impl CodeSource {
-    pub fn validate(&self) -> Result<(), String> {
+    pub fn validate(&mut self) -> Result<(), String> {
         match self {
             CodeSource::Git(source) => source.validate(),
             CodeSource::Local(source) => source.validate(Some(false)),
@@ -281,118 +328,6 @@ impl PrebuiltSource {
     }
 }
 
-/// # Git源
-///
-/// 从Git仓库获取源码
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct GitSource {
-    /// Git仓库地址
-    url: String,
-    /// 分支
-    branch: String,
-    /// 特定的提交的hash值（可选，如果为空，则拉取最新提交）
-    revision: Option<String>,
-}
-
-impl GitSource {
-    pub fn new(url: String, branch: String, revision: Option<String>) -> Self {
-        Self {
-            url,
-            branch,
-            revision,
-        }
-    }
-
-    /// # 验证参数合法性
-    ///
-    /// 仅进行形式校验，不会检查Git仓库是否存在，以及分支是否存在、是否有权限访问等
-    pub fn validate(&self) -> Result<(), String> {
-        if self.url.is_empty() {
-            return Err("url is empty".to_string());
-        }
-        if self.branch.is_empty() {
-            return Err("branch is empty".to_string());
-        }
-        return Ok(());
-    }
-
-    pub fn trim(&mut self) {
-        self.url = self.url.trim().to_string();
-        self.branch = self.branch.trim().to_string();
-        if let Some(revision) = &mut self.revision {
-            *revision = revision.trim().to_string();
-        }
-    }
-}
-
-/// # 本地源
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LocalSource {
-    /// 本地目录/文件的路径
-    path: PathBuf,
-}
-
-impl LocalSource {
-    #[allow(dead_code)]
-    pub fn new(path: PathBuf) -> Self {
-        Self { path }
-    }
-
-    pub fn validate(&self, expect_file: Option<bool>) -> Result<(), String> {
-        if !self.path.exists() {
-            return Err(format!("path {:?} not exists", self.path));
-        }
-
-        if let Some(expect_file) = expect_file {
-            if expect_file && !self.path.is_file() {
-                return Err(format!("path {:?} is not a file", self.path));
-            }
-
-            if !expect_file && !self.path.is_dir() {
-                return Err(format!("path {:?} is not a directory", self.path));
-            }
-        }
-
-        return Ok(());
-    }
-
-    pub fn trim(&mut self) {}
-}
-
-/// # 在线压缩包源
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ArchiveSource {
-    /// 压缩包的URL
-    url: String,
-}
-
-impl ArchiveSource {
-    #[allow(dead_code)]
-    pub fn new(url: String) -> Self {
-        Self { url }
-    }
-
-    pub fn validate(&self) -> Result<(), String> {
-        if self.url.is_empty() {
-            return Err("url is empty".to_string());
-        }
-
-        // 判断是一个网址
-        if let Ok(url) = Url::parse(&self.url) {
-            if url.scheme() != "http" && url.scheme() != "https" {
-                return Err(format!("url {:?} is not a http/https url", self.url));
-            }
-        } else {
-            return Err(format!("url {:?} is not a valid url", self.url));
-        }
-        return Ok(());
-    }
-
-    pub fn trim(&mut self) {
-        self.url = self.url.trim().to_string();
-    }
-}
-
 /// # 任务环境变量
 ///
 /// 任务执行时的环境变量.这个环境变量是在当前任务执行时设置的，不会影响到其他任务
@@ -403,6 +338,7 @@ pub struct TaskEnv {
 }
 
 impl TaskEnv {
+    #[allow(dead_code)]
     pub fn new(key: String, value: String) -> Self {
         Self { key, value }
     }

src/scheduler/mod.rs

@@ -2,8 +2,9 @@ use std::{
     collections::BTreeMap,
     fmt::Debug,
     path::PathBuf,
+    process::exit,
     rc::Rc,
-    sync::atomic::{AtomicI32, Ordering}, process::exit,
+    sync::atomic::{AtomicI32, Ordering},
 };
 
 use log::{error, info};
@@ -11,7 +12,7 @@ use log::{error, info};
 use crate::{console::Action, executor::Executor, parser::task::DADKTask};
 
 /// # 调度实体
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct SchedEntity {
     /// 任务ID
     id: i32,
@@ -20,6 +21,12 @@ pub struct SchedEntity {
     task: DADKTask,
 }
 
+impl PartialEq for SchedEntity {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
 impl SchedEntity {
     #[allow(dead_code)]
     pub fn id(&self) -> i32 {
@@ -52,7 +59,7 @@ pub struct SchedEntities {
     /// 任务ID到调度实体的映射
     id2entity: BTreeMap<i32, Rc<SchedEntity>>,
     /// 任务名和版本到调度实体的映射
-    name_version_2_entity: BTreeMap<(String, String), Rc<SchedEntity>>,
+    name_version_2_entity: BTreeMap<String, Rc<SchedEntity>>,
 }
 
 impl SchedEntities {
@@ -67,10 +74,8 @@ impl SchedEntities {
     pub fn add(&mut self, entity: Rc<SchedEntity>) {
         self.entities.push(entity.clone());
         self.id2entity.insert(entity.id, entity.clone());
-        self.name_version_2_entity.insert(
-            (entity.task.name.clone(), entity.task.version.clone()),
-            entity,
-        );
+        self.name_version_2_entity
+            .insert(entity.task.name_version_env(), entity);
     }
 
     #[allow(dead_code)]
@@ -80,7 +85,7 @@ impl SchedEntities {
 
     pub fn get_by_name_version(&self, name: &str, version: &str) -> Option<Rc<SchedEntity>> {
         self.name_version_2_entity
-            .get(&(name.to_string(), version.to_string()))
+            .get(&DADKTask::name_version_uppercase(name, version))
             .cloned()
     }
 
@@ -133,30 +138,24 @@ impl SchedEntities {
             if let Some(dep_entity) = self.get_by_name_version(&dep.name, &dep.version) {
                 if let Some(&false) = visited.get(&dep_entity.id) {
                     // 输出完整环形依赖
-                    let mut err = DependencyCycleError::new();
-
-                    err.add(
-                        entity.file_path.clone(),
-                        format!(
-                            "{} ({})",
-                            dep_entity.task.name_version(),
-                            dep_entity.file_path.display()
-                        ),
-                    );
+                    let mut err = DependencyCycleError::new(dep_entity.clone());
+
+                    err.add(entity.clone(), dep_entity);
                     return Err(err);
                 }
                 if !visited.contains_key(&dep_entity.id) {
                     let r = self.dfs(&dep_entity, visited, result);
                     if r.is_err() {
-                        let mut err = r.unwrap_err();
-                        err.add(
-                            entity.file_path.clone(),
-                            format!(
-                                "{} ({})",
-                                dep_entity.task.name_version(),
-                                dep_entity.file_path.display()
-                            ),
-                        );
+                        let mut err: DependencyCycleError = r.unwrap_err();
+                        // 如果错误已经停止传播，则直接返回
+                        if err.stop_propagation {
+                            return Err(err);
+                        }
+                        // 如果当前实体是错误的起始实体，则停止传播
+                        if entity == &err.head_entity {
+                            err.stop_propagation();
+                        }
+                        err.add(entity.clone(), dep_entity);
                         return Err(err);
                     }
                 }
@@ -300,23 +299,32 @@ impl Scheduler {
             .map_err(|e| SchedulerError::RunError(format!("{:?}", e)))?;
 
         for entity in r.iter() {
-            let executor = Executor::new(entity.clone()).map_err(|e| {
+            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();
+            })
+            .unwrap();
+
+            executor
+                .execute()
+                .map_err(|e| {
+                    error!(
+                        "Error while executing task {} : {:?}",
+                        entity.task().name_version(),
+                        e
+                    );
+                    exit(-1);
+                })
+                .unwrap();
         }
         return Ok(());
     }
@@ -363,32 +371,49 @@ impl Scheduler {
 /// B -> C
 /// A -> B
 pub struct DependencyCycleError {
-    dependencies: Vec<(PathBuf, String)>,
+    /// # 起始实体
+    /// 本错误的起始实体，即环形依赖的起点
+    head_entity: Rc<SchedEntity>,
+    /// 是否停止传播
+    stop_propagation: bool,
+    /// 依赖关系
+    dependencies: Vec<(Rc<SchedEntity>, Rc<SchedEntity>)>,
 }
 
 impl DependencyCycleError {
-    pub fn new() -> Self {
+    pub fn new(head_entity: Rc<SchedEntity>) -> Self {
         Self {
+            head_entity,
+            stop_propagation: false,
             dependencies: Vec::new(),
         }
     }
 
-    pub fn add(&mut self, path: PathBuf, dependency: String) {
-        self.dependencies.push((path, dependency));
+    pub fn add(&mut self, current: Rc<SchedEntity>, dependency: Rc<SchedEntity>) {
+        self.dependencies.push((current, dependency));
+    }
+
+    pub fn stop_propagation(&mut self) {
+        self.stop_propagation = true;
     }
 
     #[allow(dead_code)]
-    pub fn dependencies(&self) -> &Vec<(PathBuf, String)> {
+    pub fn dependencies(&self) -> &Vec<(Rc<SchedEntity>, Rc<SchedEntity>)> {
         &self.dependencies
     }
 
     pub fn display(&self) -> String {
+        let mut tmp = self.dependencies.clone();
+        tmp.reverse();
+
         let mut ret = format!("Dependency cycle detected: \nStart ->\n");
-        for entity in self.dependencies.iter() {
+        for (current, dep) in tmp.iter() {
             ret.push_str(&format!(
-                "->\t{}\t--depends-->\t{}\n",
-                entity.0.display(),
-                entity.1
+                "->\t{} ({})\t--depends-->\t{} ({})\n",
+                current.task.name_version(),
+                current.file_path.display(),
+                dep.task.name_version(),
+                dep.file_path.display()
             ));
         }
         ret.push_str("-> End");

src/utils/lazy_init.rs

@@ -20,10 +20,8 @@ use std::cell::UnsafeCell;
 use std::fmt::Debug;
 use std::mem::MaybeUninit;
 use std::ops::{Deref, DerefMut};
-use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, Ordering};
-
-
+use std::sync::Mutex;
 
 /// A wrapper around a value that is initialized lazily.
 pub struct Lazy<T> {
@@ -155,4 +153,4 @@ impl<T> Drop for Lazy<T> {
 }
 
 unsafe impl<T: Send + Sync> Sync for Lazy<T> {}
-unsafe impl<T: Send> Send for Lazy<T> {}
+unsafe impl<T: Send> Send for Lazy<T> {}

src/utils/mod.rs

@@ -1 +1,2 @@
-pub mod lazy_init;
+pub mod lazy_init;
+pub mod stdio;

src/utils/stdio.rs

@@ -0,0 +1,21 @@
+pub struct StdioUtils;
+
+impl StdioUtils {
+    /// # 将标准错误输出转换为行列表
+    pub fn stderr_to_lines(stderr: &[u8]) -> Vec<String> {
+        let stderr = String::from_utf8_lossy(stderr);
+        return stderr.lines().map(|s| s.to_string()).collect();
+    }
+
+    /// 获取标准错误输出的最后n行, 以字符串形式返回.
+    /// 如果标准错误输出的行数小于n, 则返回所有行.
+    pub fn tail_n_str(lines: Vec<String>, n: usize) -> String {
+        let mut result = String::new();
+        let start = if lines.len() > n { lines.len() - n } else { 0 };
+        for line in lines.iter().skip(start) {
+            result.push_str(line);
+            result.push_str("\n");
+        }
+        return result;
+    }
+}