1.完成了Scheduler

2.完成任务执行器对缓存目录初始化的操作
3.环境变量初始化

.gitignore

@@ -9,4 +9,4 @@ Cargo.lock
 # These are backup files generated by rustfmt
 **/*.rs.bk
 
-/config/
+/run/

Cargo.toml

@@ -9,8 +9,9 @@ description = "DragonOS Application Development Kit\nDragonOS应用开发工具"
 
 [dependencies]
 clap = { version = "4.2.4", features = ["derive"] }
+lazy_static = "1.4.0"
 log = "0.4.17"
 reqwest = { version = "0.11", features = ["blocking", "json"] }
 serde = { version = "1.0.160", features = ["serde_derive"] }
 serde_json = "1.0.96"
-simple_logger = "4.1.0"
+simple_logger = "4.1.0"

src/console/mod.rs

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

src/executor/cache.rs

@@ -0,0 +1,177 @@
+use std::{path::PathBuf, rc::Rc};
+
+use log::{debug, info};
+
+use crate::{
+    parser::task::{CodeSource, DADKTask, TaskType},
+    scheduler::SchedEntity,
+    utils::lazy_init::Lazy,
+};
+
+use super::ExecutorError;
+
+pub static CACHE_ROOT: Lazy<PathBuf> = Lazy::new();
+
+/// # 初始化缓存根目录
+///
+/// ## 参数
+///
+/// - `path` 缓存根目录的路径
+pub fn cache_root_init(path: Option<PathBuf>) -> Result<(), ExecutorError> {
+    let cache_root: String;
+    if path.is_none() {
+        // 查询环境变量，是否有设置缓存根目录
+        let env = std::env::var("DADK_CACHE_ROOT");
+        if env.is_ok() {
+            cache_root = env.unwrap();
+        } else {
+            // 如果没有设置环境变量，则使用默认值
+            // 默认值为当前目录下的.cache目录
+            let cwd = std::env::current_dir().map_err(|e| ExecutorError::IoError(e))?;
+            let cwd = cwd.to_str();
+
+            if cwd.is_none() {
+                return Err(ExecutorError::IoError(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    "Current dir is not a valid unicode string",
+                )));
+            }
+            let cwd = cwd.unwrap();
+
+            cache_root = format!("{}/.cache", cwd);
+        }
+    } else {
+        // 如果有设置缓存根目录，则使用设置的值
+        let path = path.unwrap();
+        let x = path
+            .to_str()
+            .ok_or(ExecutorError::IoError(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "Cache root dir is not a valid unicode string",
+            )))?;
+        cache_root = x.to_string();
+    }
+
+    let cache_root = PathBuf::from(cache_root);
+
+    // 如果缓存根目录不存在，则创建
+    if !cache_root.exists() {
+        info!("Cache root dir not exists, create it: {:?}", cache_root);
+        std::fs::create_dir_all(&cache_root).map_err(|e| ExecutorError::IoError(e))?;
+    } else if !cache_root.is_dir() {
+        // 如果缓存根目录不是目录，则报错
+        return Err(ExecutorError::IoError(std::io::Error::new(
+            std::io::ErrorKind::NotADirectory,
+            format!("Cache root dir is not a directory: {:?}", cache_root),
+        )));
+    }
+
+    // 初始化缓存根目录
+    CACHE_ROOT.init(cache_root);
+
+    // 设置环境变量
+    std::env::set_var("DADK_CACHE_ROOT", CACHE_ROOT.get().to_str().unwrap());
+    info!("Cache root dir: {:?}", CACHE_ROOT.get());
+    return Ok(());
+}
+
+#[derive(Debug)]
+pub struct CacheDir {
+    entity: Rc<SchedEntity>,
+    pub path: PathBuf,
+    pub cache_type: CacheDirType,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum CacheDirType {
+    Build,
+    Source,
+}
+
+impl CacheDir {
+    pub fn new(entity: Rc<SchedEntity>, cache_type: CacheDirType) -> Result<Self, ExecutorError> {
+        let task = entity.task();
+        let path = Self::get_path(task, cache_type);
+
+        let result = Self {
+            entity,
+            path,
+            cache_type,
+        };
+
+        result.create()?;
+
+        return Ok(result);
+    }
+
+    fn get_path(task: &DADKTask, cache_type: CacheDirType) -> PathBuf {
+        let cache_root = CACHE_ROOT.get();
+        let name_version = task.name_version();
+        let cache_dir = match cache_type {
+            CacheDirType::Build => {
+                format!("{}/build/{}", cache_root.to_str().unwrap(), name_version)
+            }
+            CacheDirType::Source => {
+                format!("{}/source/{}", cache_root.to_str().unwrap(), name_version)
+            }
+        };
+
+        return PathBuf::from(cache_dir);
+    }
+
+    pub fn build_dir(entity: Rc<SchedEntity>) -> Result<PathBuf, ExecutorError> {
+        return Ok(Self::new(entity, CacheDirType::Build)?.path);
+    }
+
+    pub fn source_dir(entity: Rc<SchedEntity>) -> Result<PathBuf, ExecutorError> {
+        return Ok(Self::new(entity, CacheDirType::Source)?.path);
+    }
+
+    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> {
+        let name_version_env = entity.task().name_version_env();
+        return Ok(format!("DADK_SOURCE_CACHE_DIR_{}", name_version_env));
+    }
+
+    pub fn need_source_cache(entity: &Rc<SchedEntity>) -> bool {
+        let task_type = &entity.task().task_type;
+
+        if let TaskType::BuildFromSource(cs) = task_type {
+            match cs {
+                CodeSource::Git(_) | CodeSource::Archive(_) => {
+                    return true;
+                }
+                CodeSource::Local(_) => {
+                    return false;
+                }
+            }
+        } else if let TaskType::InstallFromPrebuilt(ps) = task_type {
+            match ps {
+                crate::parser::task::PrebuiltSource::Archive(_) => return true,
+                crate::parser::task::PrebuiltSource::Local(_) => return false,
+            }
+        }
+
+        unimplemented!("Not fully implemented task type: {:?}", task_type);
+    }
+
+    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))?;
+            debug!("Cache dir: [{:?}] created.", self.path);
+        } else if !self.path.is_dir() {
+            // 如果路径类别不是目录，则报错
+            return Err(ExecutorError::IoError(std::io::Error::new(
+                std::io::ErrorKind::NotADirectory,
+                format!("Cache dir is not a directory: {:?}", self.path),
+            )));
+        }
+        
+        return Ok(());
+    }
+}

src/executor/mod.rs

@@ -0,0 +1,160 @@
+use std::{collections::BTreeMap, env::Vars, rc::Rc, sync::RwLock};
+
+use log::{debug, info};
+
+use crate::{
+    executor::cache::CacheDir,
+    scheduler::{SchedEntities, SchedEntity},
+};
+
+use self::cache::CacheDirType;
+
+pub mod cache;
+
+lazy_static! {
+    // 全局环境变量的列表
+    pub static ref ENV_LIST: RwLock<EnvMap> = RwLock::new(EnvMap::new());
+}
+
+#[derive(Debug)]
+pub struct Executor {
+    entity: Rc<SchedEntity>,
+    local_envs: EnvMap,
+    build_dir: CacheDir,
+    source_dir: Option<CacheDir>,
+}
+
+impl Executor {
+    /// # 创建执行器
+    ///
+    /// 用于执行一个任务
+    ///
+    /// ## 参数
+    ///
+    /// * `entity` - 任务调度实体
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(Executor)` - 创建成功
+    /// * `Err(ExecutorError)` - 创建失败
+    pub fn new(entity: Rc<SchedEntity>) -> Result<Self, ExecutorError> {
+        let local_envs = EnvMap::new();
+        let build_dir = CacheDir::new(entity.clone(), CacheDirType::Build)?;
+
+        let source_dir = if CacheDir::need_source_cache(&entity) {
+            Some(CacheDir::new(entity.clone(), CacheDirType::Source)?)
+        } else {
+            None
+        };
+
+        let result: Executor = Self {
+            entity,
+            local_envs,
+            build_dir,
+            source_dir,
+        };
+
+        return Ok(result);
+    }
+
+    /// # 执行任务
+    /// 
+    /// 创建执行器后，调用此方法执行任务。
+    /// 该方法会执行以下步骤：
+    /// 
+    /// 1. 创建工作线程
+    /// 2. 准备环境变量
+    /// 3. 拉取数据（可选）
+    /// 4. 执行构建
+    pub fn execute(&self) -> Result<(), ExecutorError> {
+        // todo!("Execute task: {:?}", self.entity.task());
+        info!("Execute task: {}", self.entity.task().name_version());
+
+        return Ok(());
+    }
+}
+
+#[derive(Debug)]
+pub struct EnvMap {
+    pub envs: BTreeMap<String, EnvVar>,
+}
+
+impl EnvMap {
+    pub fn new() -> Self {
+        Self {
+            envs: BTreeMap::new(),
+        }
+    }
+
+    pub fn add(&mut self, env: EnvVar) {
+        self.envs.insert(env.key.clone(), env);
+    }
+
+    pub fn get(&self, key: &str) -> Option<&EnvVar> {
+        self.envs.get(key)
+    }
+
+    pub fn add_vars(&mut self, vars: Vars) {
+        for (key, value) in vars {
+            self.add(EnvVar::new(key, value));
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, PartialOrd, Eq, Ord)]
+pub struct EnvVar {
+    pub key: String,
+    pub value: String,
+}
+
+impl EnvVar {
+    pub fn new(key: String, value: String) -> Self {
+        Self { key, value }
+    }
+}
+
+#[derive(Debug)]
+pub enum ExecutorError {
+    /// # 准备环境变量错误
+    PrepareEnvError,
+    IoError(std::io::Error),
+}
+
+pub fn prepare_env(sched_entities: &SchedEntities) -> Result<(), ExecutorError> {
+    info!("Preparing environment variables...");
+    // 获取当前全局环境变量列表
+    let mut env_list = ENV_LIST.write().unwrap();
+    let envs: Vars = std::env::vars();
+    env_list.add_vars(envs);
+
+    // 为每个任务创建特定的环境变量
+    for entity in sched_entities.iter() {
+        // 导出任务的构建目录环境变量
+        let build_dir = CacheDir::build_dir(entity.clone())?;
+
+        let build_dir_key = CacheDir::build_dir_env_key(entity.clone())?;
+        env_list.add(EnvVar::new(
+            build_dir_key,
+            build_dir.to_str().unwrap().to_string(),
+        ));
+
+        // 如果需要源码缓存目录，则导出
+        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())?;
+            env_list.add(EnvVar::new(
+                source_dir_key,
+                source_dir.to_str().unwrap().to_string(),
+            ));
+        }
+    }
+
+    // 查看环境变量列表
+    // debug!("Environment variables:");
+
+    // for (key, value) in env_list.envs.iter() {
+    //     debug!("{}: {}", key, value.value);
+    // }
+
+    return Ok(());
+}

src/main.rs

@@ -21,6 +21,10 @@
 //!
 //! DADK is licensed under the [GPLv2 License](LICENSE).
 
+#![feature(io_error_more)]
+
+#[macro_use]
+extern crate lazy_static;
 extern crate log;
 extern crate serde;
 extern crate serde_json;
@@ -28,35 +32,38 @@ extern crate simple_logger;
 
 use std::{fs, path::PathBuf, process::exit};
 
-use clap::{Parser, Subcommand};
-use log::{error, info};
+use clap::Parser;
+use log::{info, error};
 use parser::task::{
-    ArchiveSource, BuildConfig, CodeSource, DADKTask, Dependency, GitSource, InstallConfig,
-    TaskType,
+    BuildConfig, CodeSource, DADKTask, Dependency, GitSource, InstallConfig, TaskType,
 };
 use simple_logger::SimpleLogger;
 
+use crate::{console::Action, scheduler::Scheduler, executor::cache::cache_root_init};
+
+mod console;
+mod executor;
 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,
-}
 
-/// @brief 要执行的操作
-#[derive(Debug, Subcommand)]
-enum Action {
-    Build,
-    Clean,
-    Install,
-    Uninstall,
+    /// DADK缓存根目录
+    #[arg(long, value_parser = parse_check_dir_exists)]
+    cache_dir: Option<PathBuf>,
 }
 
 /// @brief 检查目录是否存在
@@ -79,24 +86,41 @@ fn main() {
     let args = CommandLineArgs::parse();
 
     info!("DADK run with args: {:?}", &args);
+    // DragonOS sysroot在主机上的路径
     let dragonos_dir = args.dragonos_dir;
     let config_dir = args.config_dir;
     let action = args.action;
-    info!("DragonOS dir: {}", dragonos_dir.display());
+    info!("DragonOS sysroot dir: {}", dragonos_dir.display());
     info!("Config dir: {}", config_dir.display());
     info!("Action: {:?}", action);
 
+    // 初始化缓存目录
+    let r = cache_root_init(args.cache_dir);
+    if r.is_err() {
+        error!("Failed to init cache root: {:?}", r.unwrap_err());
+        exit(1);
+    }
+
     let mut parser = parser::Parser::new(config_dir);
     let r = parser.parse();
     if r.is_err() {
-        error!("{:?}", r.unwrap_err());
         exit(1);
     }
-    let tasks: Vec<DADKTask> = r.unwrap();
-    info!("Tasks: {:?}", tasks);
+    let tasks: Vec<(PathBuf, DADKTask)> = r.unwrap();
+    // info!("Parsed tasks: {:?}", tasks);
 
+    let scheduler = Scheduler::new(dragonos_dir, action, tasks);
+    if scheduler.is_err() {
+        exit(1);
+    }
+
+    let r = scheduler.unwrap().run();
+    if r.is_err() {
+        exit(1);
+    }
 }
 
+#[allow(dead_code)]
 fn generate_tmp_dadk() {
     let x = DADKTask {
         name: "test".to_string(),
@@ -121,6 +145,7 @@ fn generate_tmp_dadk() {
             "master".to_string(),
             None,
         ))),
+        envs: None,
     };
     let x = serde_json::to_string(&x).unwrap();
     fs::write("test.json", x).unwrap();

src/parser/mod.rs

@@ -22,14 +22,12 @@
 //!     "install": {安装配置（该部分详见InstallConfig的文档）}
 //! }
 use std::{
+    fmt::Debug,
     fs::{DirEntry, ReadDir},
-    path::PathBuf, fmt::Debug,
+    path::PathBuf,
 };
 
-use log::info;
-use serde::{Deserialize, Serialize};
-
-use crate::parser::task::TaskType;
+use log::{error, info};
 
 use self::task::DADKTask;
 pub mod task;
@@ -45,31 +43,45 @@ pub struct Parser {
     config_files: Vec<PathBuf>,
 }
 
-
 pub struct ParserError {
     pub config_file: Option<PathBuf>,
     pub error: InnerParserError,
 }
-impl Debug for ParserError{
+impl Debug for ParserError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self.error {
             InnerParserError::IoError(e) => {
                 if let Some(config_file) = &self.config_file {
-                    write!(f, "IO Error while parsing config file {}: {}", config_file.display(), e)
+                    write!(
+                        f,
+                        "IO Error while parsing config file {}: {}",
+                        config_file.display(),
+                        e
+                    )
                 } else {
                     write!(f, "IO Error while parsing config files: {}", e)
                 }
             }
             InnerParserError::JsonError(e) => {
                 if let Some(config_file) = &self.config_file {
-                    write!(f, "Json Error while parsing config file {}: {}", config_file.display(), e)
+                    write!(
+                        f,
+                        "Json Error while parsing config file {}: {}",
+                        config_file.display(),
+                        e
+                    )
                 } else {
                     write!(f, "Json Error while parsing config file: {}", e)
                 }
             }
             InnerParserError::TaskError(e) => {
                 if let Some(config_file) = &self.config_file {
-                    write!(f, "Error while parsing config file {}: {}", config_file.display(), e)
+                    write!(
+                        f,
+                        "Error while parsing config file {}: {}",
+                        config_file.display(),
+                        e
+                    )
                 } else {
                     write!(f, "Error while parsing config file: {}", e)
                 }
@@ -101,14 +113,16 @@ impl Parser {
     ///
     /// ## 返回值
     ///
-    /// * `Ok(Vec<DADKTask>)` - 任务列表
+    /// * `Ok(Vec<(PathBuf, DADKTask)>)` - 任务列表(配置文件路径, 任务)
     /// * `Err(ParserError)` - 解析错误
-    pub fn parse(&mut self) -> Result<Vec<DADKTask>, ParserError> {
-        info!("Parsing config files in {}", self.config_dir.display());
-
+    pub fn parse(&mut self) -> Result<Vec<(PathBuf, DADKTask)>, ParserError> {
         self.scan_config_files()?;
-        println!("Found {} config files", self.config_files.len());
-        return self.gen_tasks();
+        info!("Found {} config files", self.config_files.len());
+        let r: Result<Vec<(PathBuf, DADKTask)>, ParserError> = self.gen_tasks();
+        if r.is_err() {
+            error!("Error while parsing config files: {:?}", r);
+        }
+        return r;
     }
 
     /// # 扫描配置文件目录，找到所有配置文件
@@ -162,11 +176,11 @@ impl Parser {
     ///
     /// * `Ok(Vec<DADKTask>)` - 任务列表
     /// * `Err(ParserError)` - 解析错误
-    fn gen_tasks(&self) -> Result<Vec<DADKTask>, ParserError> {
+    fn gen_tasks(&self) -> Result<Vec<(PathBuf, DADKTask)>, ParserError> {
         let mut result_vec = Vec::new();
         for config_file in &self.config_files {
             let task: DADKTask = self.parse_config_file(config_file)?;
-            result_vec.push(task);
+            result_vec.push((config_file.clone(), task));
         }
 
         return Ok(result_vec);
@@ -189,11 +203,14 @@ impl Parser {
         })?;
 
         // 从json字符串中解析出DADKTask
-        let task: DADKTask = serde_json::from_str(&content).map_err(|e| ParserError {
+        let mut task: DADKTask = serde_json::from_str(&content).map_err(|e| ParserError {
             config_file: Some(config_file.clone()),
             error: InnerParserError::JsonError(e),
         })?;
 
+        // 去除字符串中的空白字符
+        task.trim();
+
         // 校验DADKTask的参数是否合法
         task.validate().map_err(|e| ParserError {
             config_file: Some(config_file.clone()),
@@ -202,5 +219,4 @@ impl Parser {
 
         return Ok(task);
     }
-
 }

src/parser/task.rs

@@ -3,6 +3,9 @@ use std::path::PathBuf;
 use reqwest::Url;
 use serde::{Deserialize, Serialize};
 
+// 对于生成的包名和版本号，需要进行替换的字符。
+pub static NAME_VERSION_REPLACE_TABLE: [(&str, &str); 3] = [(" ", "_"), ("\t", "_"), ("-", "_")];
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DADKTask {
     /// 包名
@@ -19,9 +22,12 @@ pub struct DADKTask {
     pub build: BuildConfig,
     /// 安装配置
     pub install: InstallConfig,
+    /// 环境变量
+    pub envs: Option<Vec<TaskEnv>>,
 }
 
 impl DADKTask {
+    #[allow(dead_code)]
     pub fn new(
         name: String,
         version: String,
@@ -30,6 +36,7 @@ impl DADKTask {
         depends: Vec<Dependency>,
         build: BuildConfig,
         install: InstallConfig,
+        envs: Option<Vec<TaskEnv>>,
     ) -> Self {
         Self {
             name,
@@ -39,6 +46,7 @@ impl DADKTask {
             depends,
             build,
             install,
+            envs,
         }
     }
 
@@ -52,9 +60,65 @@ impl DADKTask {
         self.task_type.validate()?;
         self.build.validate()?;
         self.install.validate()?;
+        self.validate_depends()?;
+        self.validate_envs()?;
 
         return Ok(());
     }
+
+    pub fn trim(&mut self) {
+        self.name = self.name.trim().to_string();
+        self.version = self.version.trim().to_string();
+        self.description = self.description.trim().to_string();
+        self.task_type.trim();
+        self.build.trim();
+        self.install.trim();
+        self.trim_depends();
+        self.trim_envs();
+    }
+
+    fn validate_depends(&self) -> Result<(), String> {
+        for depend in &self.depends {
+            depend.validate()?;
+        }
+        return Ok(());
+    }
+
+    fn trim_depends(&mut self) {
+        for depend in &mut self.depends {
+            depend.trim();
+        }
+    }
+
+    fn validate_envs(&self) -> Result<(), String> {
+        if let Some(envs) = &self.envs {
+            for env in envs {
+                env.validate()?;
+            }
+        }
+        return Ok(());
+    }
+
+    fn trim_envs(&mut self) {
+        if let Some(envs) = &mut self.envs {
+            for env in envs {
+                env.trim();
+            }
+        }
+    }
+
+    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();
+        for (src, dst) in &NAME_VERSION_REPLACE_TABLE {
+            name_version = name_version.replace(src, dst);
+        }
+        return name_version;
+    }
+
 }
 
 /// @brief 构建配置
@@ -65,6 +129,7 @@ pub struct BuildConfig {
 }
 
 impl BuildConfig {
+    #[allow(dead_code)]
     pub fn new(build_command: String) -> Self {
         Self { build_command }
     }
@@ -72,6 +137,10 @@ impl BuildConfig {
     pub fn validate(&self) -> Result<(), String> {
         return Ok(());
     }
+
+    pub fn trim(&mut self) {
+        self.build_command = self.build_command.trim().to_string();
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -83,6 +152,7 @@ pub struct InstallConfig {
 }
 
 impl InstallConfig {
+    #[allow(dead_code)]
     pub fn new(in_dragonos_path: PathBuf, install_command: String) -> Self {
         Self {
             in_dragonos_path,
@@ -93,6 +163,10 @@ impl InstallConfig {
     pub fn validate(&self) -> Result<(), String> {
         return Ok(());
     }
+
+    pub fn trim(&mut self) {
+        self.install_command = self.install_command.trim().to_string();
+    }
 }
 
 /// @brief 依赖项
@@ -102,6 +176,32 @@ pub struct Dependency {
     pub version: String,
 }
 
+impl Dependency {
+    #[allow(dead_code)]
+    pub fn new(name: String, version: String) -> Self {
+        Self { name, version }
+    }
+
+    pub fn validate(&self) -> Result<(), String> {
+        if self.name.is_empty() {
+            return Err("name is empty".to_string());
+        }
+        if self.version.is_empty() {
+            return Err("version is empty".to_string());
+        }
+        return Ok(());
+    }
+
+    pub fn trim(&mut self) {
+        self.name = self.name.trim().to_string();
+        self.version = self.version.trim().to_string();
+    }
+
+    pub fn name_version(&self) -> String {
+        return format!("{}-{}", self.name, self.version);
+    }
+}
+
 /// # 任务类型
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum TaskType {
@@ -118,6 +218,13 @@ impl TaskType {
             TaskType::InstallFromPrebuilt(source) => source.validate(),
         }
     }
+
+    pub fn trim(&mut self) {
+        match self {
+            TaskType::BuildFromSource(source) => source.trim(),
+            TaskType::InstallFromPrebuilt(source) => source.trim(),
+        }
+    }
 }
 
 /// # 代码源
@@ -139,6 +246,14 @@ impl CodeSource {
             CodeSource::Archive(source) => source.validate(),
         }
     }
+
+    pub fn trim(&mut self) {
+        match self {
+            CodeSource::Git(source) => source.trim(),
+            CodeSource::Local(source) => source.trim(),
+            CodeSource::Archive(source) => source.trim(),
+        }
+    }
 }
 
 /// # 预编译包源
@@ -157,6 +272,13 @@ impl PrebuiltSource {
             PrebuiltSource::Local(source) => source.validate(None),
         }
     }
+
+    pub fn trim(&mut self) {
+        match self {
+            PrebuiltSource::Archive(source) => source.trim(),
+            PrebuiltSource::Local(source) => source.trim(),
+        }
+    }
 }
 
 /// # Git源
@@ -193,6 +315,14 @@ impl GitSource {
         }
         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();
+        }
+    }
 }
 
 /// # 本地源
@@ -203,6 +333,7 @@ pub struct LocalSource {
 }
 
 impl LocalSource {
+    #[allow(dead_code)]
     pub fn new(path: PathBuf) -> Self {
         Self { path }
     }
@@ -224,6 +355,8 @@ impl LocalSource {
 
         return Ok(());
     }
+
+    pub fn trim(&mut self) {}
 }
 
 /// # 在线压缩包源
@@ -234,6 +367,7 @@ pub struct ArchiveSource {
 }
 
 impl ArchiveSource {
+    #[allow(dead_code)]
     pub fn new(url: String) -> Self {
         Self { url }
     }
@@ -253,4 +387,43 @@ impl ArchiveSource {
         }
         return Ok(());
     }
+
+    pub fn trim(&mut self) {
+        self.url = self.url.trim().to_string();
+    }
+}
+
+/// # 任务环境变量
+///
+/// 任务执行时的环境变量.这个环境变量是在当前任务执行时设置的，不会影响到其他任务
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TaskEnv {
+    pub key: String,
+    pub value: String,
+}
+
+impl TaskEnv {
+    pub fn new(key: String, value: String) -> Self {
+        Self { key, value }
+    }
+
+    pub fn key(&self) -> &str {
+        &self.key
+    }
+
+    pub fn value(&self) -> &str {
+        &self.value
+    }
+
+    pub fn trim(&mut self) {
+        self.key = self.key.trim().to_string();
+        self.value = self.value.trim().to_string();
+    }
+
+    pub fn validate(&self) -> Result<(), String> {
+        if self.key.is_empty() {
+            return Err("Env: key is empty".to_string());
+        }
+        return Ok(());
+    }
 }

src/scheduler/mod.rs

@@ -0,0 +1,397 @@
+use std::{
+    collections::BTreeMap,
+    fmt::Debug,
+    path::PathBuf,
+    rc::Rc,
+    sync::atomic::{AtomicI32, Ordering}, process::exit,
+};
+
+use log::{error, info};
+
+use crate::{console::Action, executor::Executor, parser::task::DADKTask};
+
+/// # 调度实体
+#[derive(Debug)]
+pub struct SchedEntity {
+    /// 任务ID
+    id: i32,
+    file_path: PathBuf,
+    /// 任务
+    task: DADKTask,
+}
+
+impl SchedEntity {
+    #[allow(dead_code)]
+    pub fn id(&self) -> i32 {
+        self.id
+    }
+
+    #[allow(dead_code)]
+    pub fn file_path(&self) -> &PathBuf {
+        &self.file_path
+    }
+
+    #[allow(dead_code)]
+    pub fn task(&self) -> &DADKTask {
+        &self.task
+    }
+
+    #[allow(dead_code)]
+    pub fn task_mut(&mut self) -> &mut DADKTask {
+        &mut self.task
+    }
+}
+
+/// # 调度实体列表
+///
+/// 用于存储所有的调度实体
+#[derive(Debug)]
+pub struct SchedEntities {
+    /// 调度实体列表
+    entities: Vec<Rc<SchedEntity>>,
+    /// 任务ID到调度实体的映射
+    id2entity: BTreeMap<i32, Rc<SchedEntity>>,
+    /// 任务名和版本到调度实体的映射
+    name_version_2_entity: BTreeMap<(String, String), Rc<SchedEntity>>,
+}
+
+impl SchedEntities {
+    pub fn new() -> Self {
+        Self {
+            entities: Vec::new(),
+            id2entity: BTreeMap::new(),
+            name_version_2_entity: BTreeMap::new(),
+        }
+    }
+
+    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,
+        );
+    }
+
+    #[allow(dead_code)]
+    pub fn get(&self, id: i32) -> Option<Rc<SchedEntity>> {
+        self.id2entity.get(&id).cloned()
+    }
+
+    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()))
+            .cloned()
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &Rc<SchedEntity>> {
+        self.entities.iter()
+    }
+
+    #[allow(dead_code)]
+    pub fn len(&self) -> usize {
+        self.entities.len()
+    }
+
+    #[allow(dead_code)]
+    pub fn is_empty(&self) -> bool {
+        self.entities.is_empty()
+    }
+
+    #[allow(dead_code)]
+    pub fn clear(&mut self) {
+        self.entities.clear();
+        self.id2entity.clear();
+        self.name_version_2_entity.clear();
+    }
+
+    pub fn topo_sort(&self) -> Vec<Rc<SchedEntity>> {
+        let mut result = Vec::new();
+        let mut visited = BTreeMap::new();
+        for entity in self.entities.iter() {
+            if !visited.contains_key(&entity.id) {
+                let r = self.dfs(entity, &mut visited, &mut result);
+                if r.is_err() {
+                    let err = r.unwrap_err();
+                    error!("{}", err.display());
+                    println!("Please fix the errors above and try again.");
+                    std::process::exit(1);
+                }
+            }
+        }
+        return result;
+    }
+
+    fn dfs(
+        &self,
+        entity: &Rc<SchedEntity>,
+        visited: &mut BTreeMap<i32, bool>,
+        result: &mut Vec<Rc<SchedEntity>>,
+    ) -> Result<(), DependencyCycleError> {
+        visited.insert(entity.id, false);
+        for dep in entity.task.depends.iter() {
+            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()
+                        ),
+                    );
+                    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()
+                            ),
+                        );
+                        return Err(err);
+                    }
+                }
+            } else {
+                error!(
+                    "Dependency not found: {} -> {}",
+                    entity.task.name_version(),
+                    dep.name_version()
+                );
+                std::process::exit(1);
+            }
+        }
+        visited.insert(entity.id, true);
+        result.push(entity.clone());
+        return Ok(());
+    }
+}
+
+/// # 任务调度器
+#[derive(Debug)]
+pub struct Scheduler {
+    /// DragonOS sysroot在主机上的路径
+    dragonos_dir: PathBuf,
+    /// 要执行的操作
+    action: Action,
+    /// 调度实体列表
+    target: SchedEntities,
+}
+
+pub enum SchedulerError {
+    TaskError(String),
+    DependencyNotFound(Rc<SchedEntity>, String),
+    RunError(String),
+}
+
+impl Debug for SchedulerError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::TaskError(arg0) => {
+                write!(f, "TaskError: {}", arg0)
+            }
+            SchedulerError::DependencyNotFound(current, msg) => {
+                write!(
+                    f,
+                    "For task {}, dependency not found: {}. Please check file: {}",
+                    current.task.name_version(),
+                    msg,
+                    current.file_path.display()
+                )
+            }
+            SchedulerError::RunError(msg) => {
+                write!(f, "RunError: {}", msg)
+            }
+        }
+    }
+}
+
+impl Scheduler {
+    pub fn new(
+        dragonos_dir: PathBuf,
+        action: Action,
+        tasks: Vec<(PathBuf, DADKTask)>,
+    ) -> Result<Self, SchedulerError> {
+        let entities = SchedEntities::new();
+
+        let mut scheduler = Scheduler {
+            dragonos_dir,
+            action,
+            target: entities,
+        };
+
+        let r = scheduler.add_tasks(tasks);
+        if r.is_err() {
+            error!("Error while adding tasks: {:?}", r);
+            return Err(r.err().unwrap());
+        }
+
+        return Ok(scheduler);
+    }
+
+    /// # 添加多个任务
+    ///
+    /// 添加任务到调度器中，如果任务已经存在，则返回错误
+    pub fn add_tasks(&mut self, tasks: Vec<(PathBuf, DADKTask)>) -> Result<(), SchedulerError> {
+        for task in tasks {
+            self.add_task(task.0, task.1)?;
+        }
+
+        return Ok(());
+    }
+
+    /// # 添加一个任务
+    ///
+    /// 添加任务到调度器中，如果任务已经存在，则返回错误
+    pub fn add_task(&mut self, path: PathBuf, task: DADKTask) -> Result<(), SchedulerError> {
+        let id: i32 = self.generate_task_id();
+        let entity = Rc::new(SchedEntity {
+            id,
+            task,
+            file_path: path.clone(),
+        });
+        let name_version = (entity.task.name.clone(), entity.task.version.clone());
+
+        if self
+            .target
+            .get_by_name_version(&name_version.0, &name_version.1)
+            .is_some()
+        {
+            return Err(SchedulerError::TaskError(format!(
+                "Task with name [{}] and version [{}] already exists. Config file: {}",
+                name_version.0,
+                name_version.1,
+                path.display()
+            )));
+        }
+
+        self.target.add(entity.clone());
+
+        info!("Task added: {}", entity.task.name_version());
+        return Ok(());
+    }
+
+    fn generate_task_id(&self) -> i32 {
+        static TASK_ID: AtomicI32 = AtomicI32::new(0);
+        return TASK_ID.fetch_add(1, Ordering::SeqCst);
+    }
+
+    /// # 执行调度器中的所有任务
+    pub fn run(&self) -> Result<(), SchedulerError> {
+        // 检查是否有不存在的依赖
+        let r = self.check_not_exists_dependency();
+        if r.is_err() {
+            error!("Error while checking tasks: {:?}", r);
+            return r;
+        }
+
+        // 对调度实体进行拓扑排序
+        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 executor = Executor::new(entity.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中的任务不存在，则返回错误
+    fn check_not_exists_dependency(&self) -> Result<(), SchedulerError> {
+        for entity in self.target.iter() {
+            for dependency in entity.task.depends.iter() {
+                let name_version = (dependency.name.clone(), dependency.version.clone());
+                if !self
+                    .target
+                    .get_by_name_version(&name_version.0, &name_version.1)
+                    .is_some()
+                {
+                    return Err(SchedulerError::DependencyNotFound(
+                        entity.clone(),
+                        format!("name:{}, version:{}", name_version.0, name_version.1,),
+                    ));
+                }
+            }
+        }
+
+        return Ok(());
+    }
+}
+
+/// # 环形依赖错误路径
+///
+/// 本结构体用于在回溯过程中记录环形依赖的路径。
+///
+/// 例如，假设有如下依赖关系：
+///
+/// ```text
+/// A -> B -> C -> D -> A
+/// ```
+///
+/// 则在DFS回溯过程中，会依次记录如下路径：
+///
+/// ```text
+/// D -> A
+/// C -> D
+/// B -> C
+/// A -> B
+pub struct DependencyCycleError {
+    dependencies: Vec<(PathBuf, String)>,
+}
+
+impl DependencyCycleError {
+    pub fn new() -> Self {
+        Self {
+            dependencies: Vec::new(),
+        }
+    }
+
+    pub fn add(&mut self, path: PathBuf, dependency: String) {
+        self.dependencies.push((path, dependency));
+    }
+
+    #[allow(dead_code)]
+    pub fn dependencies(&self) -> &Vec<(PathBuf, String)> {
+        &self.dependencies
+    }
+
+    pub fn display(&self) -> String {
+        let mut ret = format!("Dependency cycle detected: \nStart ->\n");
+        for entity in self.dependencies.iter() {
+            ret.push_str(&format!(
+                "->\t{}\t--depends-->\t{}\n",
+                entity.0.display(),
+                entity.1
+            ));
+        }
+        ret.push_str("-> End");
+        return ret;
+    }
+}

src/utils/lazy_init.rs

@@ -0,0 +1,158 @@
+// Copyright (C) DragonOS Community  longjin
+
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+// Or you can visit https://www.gnu.org/licenses/gpl-2.0.html
+#![allow(dead_code)]
+
+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};
+
+
+
+/// A wrapper around a value that is initialized lazily.
+pub struct Lazy<T> {
+    /// The lock that is used to ensure that only one thread calls the init function at the same time.
+    init_lock: Mutex<()>,
+    /// The value that is initialized lazily.
+    value: UnsafeCell<MaybeUninit<T>>,
+    /// Whether the value has been initialized.
+    initialized: AtomicBool,
+}
+
+impl<T> Lazy<T> {
+    /// Creates a new `Lazy` value that will be initialized with the
+    /// result of the closure `init`.
+    pub const fn new() -> Lazy<T> {
+        Lazy {
+            value: UnsafeCell::new(MaybeUninit::uninit()),
+            initialized: AtomicBool::new(false),
+            init_lock: Mutex::new(()),
+        }
+    }
+
+    /// Returns true if the value has been initialized.
+    #[inline(always)]
+    pub fn initialized(&self) -> bool {
+        let initialized = self.initialized.load(Ordering::Acquire);
+        if initialized {
+            return true;
+        }
+        return false;
+    }
+
+    /// Ensures that this lazy value is initialized. If the value has not
+    /// yet been initialized, this will raise a panic.
+    #[inline(always)]
+    pub fn ensure(&self) {
+        if self.initialized() {
+            return;
+        }
+        panic!("Lazy value was not initialized");
+    }
+
+    pub fn init(&self, value: T) {
+        assert!(!self.initialized());
+
+        // We need this lock to ensure that only one thread calls the init function at the same time.
+        let _init_guard = self.init_lock.lock();
+        // Check again, in case another thread initialized it while we were waiting for the lock.
+        let initialized = self.initialized();
+        if initialized {
+            return;
+        }
+        unsafe {
+            (*self.value.get()).as_mut_ptr().write(value);
+        }
+        self.initialized.store(true, Ordering::Release);
+    }
+    /// Forces the evaluation of this lazy value and returns a reference to
+    /// the result. This is equivalent to the `Deref` impl, but is explicit.
+    /// This will initialize the value if it has not yet been initialized.
+    pub fn get(&self) -> &T {
+        self.ensure();
+        return unsafe { self.get_unchecked() };
+    }
+
+    /// Returns a reference to the value if it has been initialized.
+    /// Otherwise, returns `None`.
+    pub fn try_get(&self) -> Option<&T> {
+        if self.initialized() {
+            return Some(unsafe { self.get_unchecked() });
+        }
+        return None;
+    }
+
+    /// Forces the evaluation of this lazy value and returns a mutable
+    /// reference to the result. This is equivalent to the `DerefMut` impl,
+    /// but is explicit. This will initialize the value if it has not yet
+    /// been initialized.
+    pub fn get_mut(&mut self) -> &mut T {
+        self.ensure();
+        return unsafe { self.get_mut_unchecked() };
+    }
+
+    #[inline(always)]
+    pub unsafe fn get_unchecked(&self) -> &T {
+        return &*(*self.value.get()).as_ptr();
+    }
+
+    #[inline(always)]
+    pub unsafe fn get_mut_unchecked(&mut self) -> &mut T {
+        return &mut *(*self.value.get()).as_mut_ptr();
+    }
+}
+
+impl<T> Deref for Lazy<T> {
+    type Target = T;
+
+    #[inline(always)]
+    fn deref(&self) -> &T {
+        return self.get();
+    }
+}
+
+impl<T> DerefMut for Lazy<T> {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut T {
+        return self.get_mut();
+    }
+}
+
+impl<T: Debug> Debug for Lazy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        if let Some(value) = self.try_get() {
+            return write!(f, "Lazy({:?})", value);
+        } else {
+            return write!(f, "Lazy(uninitialized)");
+        }
+    }
+}
+
+impl<T> Drop for Lazy<T> {
+    fn drop(&mut self) {
+        if self.initialized() {
+            unsafe {
+                (*self.value.get()).as_mut_ptr().drop_in_place();
+            }
+        }
+    }
+}
+
+unsafe impl<T: Send + Sync> Sync for Lazy<T> {}
+unsafe impl<T: Send> Send for Lazy<T> {}

src/utils/mod.rs

@@ -0,0 +1 @@
+pub mod lazy_init;