添加配置解析器

添加配置解析器

.gitignore

@@ -8,3 +8,5 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+
+/config/

Cargo.toml

@@ -3,7 +3,14 @@ name = "dadk"
 authors = ["longjin <longjin@DragonOS.org>"]
 version = "0.1.0"
 edition = "2021"
+description = "DragonOS Application Development Kit\nDragonOS应用开发工具"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+clap = { version = "4.2.4", features = ["derive"] }
+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"

README.md

@@ -2,7 +2,7 @@
 
 DragonOS 应用开发工具包
 
-DragonOS Application Development Kits
+DragonOS Application Development Kit
 
 ## 简介
 

src/console/README.md

@@ -0,0 +1,11 @@
+# 命令行交互模块
+
+## 介绍
+
+命令行交互模块，使得用户能交互式的进行以下操作：
+
+- 创建dadk task配置文件
+- 查看当前所有的task配置文件
+- 删除task配置文件
+- 查询dadk更新
+

src/executor/README.md

@@ -0,0 +1,10 @@
+# 任务执行器
+
+## 简介
+
+任务执行器是一个独立的进程，用于执行任务，任务执行器的主要功能是：
+
+- 为具体任务设置环境变量
+- 处理构建缓存
+- 执行任务
+- 任务执行完成后，将任务的执行结果发送给任务调度器

src/main.rs

@@ -1,3 +1,127 @@
+//! # DADK - DragonOS Application Development Kit
+//! # DragonOS 应用开发工具
+//!
+//! ## 简介
+//!
+//! DADK是一个用于开发DragonOS应用的工具包，设计目的是为了让开发者能够更加方便的开发DragonOS应用。
+//!
+//! ### DADK做什么？
+//!
+//! - 自动配置libc等编译用户程序所需的环境
+//! - 自动处理软件库的依赖关系
+//! - 自动处理软件库的编译
+//! - 一键将软件库安装到DragonOS系统中
+//!
+//! ### DADK不做什么？
+//!
+//! - DADK不会帮助开发者编写代码
+//! - DADK不提供任何开发DragonOS应用所需的API。这部分工作由libc等库来完成
+//!
+//! ## License
+//!
+//! DADK is licensed under the [GPLv2 License](LICENSE).
+
+extern crate log;
+extern crate serde;
+extern crate serde_json;
+extern crate simple_logger;
+
+use std::{fs, path::PathBuf, process::exit};
+
+use clap::{Parser, Subcommand};
+use log::{error, info};
+use parser::task::{
+    ArchiveSource, BuildConfig, CodeSource, DADKTask, Dependency, GitSource, InstallConfig,
+    TaskType,
+};
+use simple_logger::SimpleLogger;
+
+mod parser;
+
+#[derive(Debug, Parser)]
+#[command(author, version, about)]
+struct CommandLineArgs {
+    #[arg(short, long, value_parser = parse_check_dir_exists)]
+    pub dragonos_dir: PathBuf,
+    #[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,
+}
+
+/// @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() {
-    println!("Hello, world!");
+    SimpleLogger::new().init().unwrap();
+    // generate_tmp_dadk();
+    info!("DADK Starting...");
+    let args = CommandLineArgs::parse();
+
+    info!("DADK run with args: {:?}", &args);
+    let dragonos_dir = args.dragonos_dir;
+    let config_dir = args.config_dir;
+    let action = args.action;
+    info!("DragonOS dir: {}", dragonos_dir.display());
+    info!("Config dir: {}", config_dir.display());
+    info!("Action: {:?}", action);
+
+    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);
+
+}
+
+fn generate_tmp_dadk() {
+    let x = DADKTask {
+        name: "test".to_string(),
+        version: "0.1.0".to_string(),
+        build: BuildConfig {
+            build_command: "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(),
+            version: "0.1.0".to_string(),
+        }],
+        description: "test".to_string(),
+        // task_type: TaskType::BuildFromSource(CodeSource::Archive(ArchiveSource::new(
+        //     "123".to_string(),
+        // ))),
+        task_type: TaskType::BuildFromSource(CodeSource::Git(GitSource::new(
+            "123".to_string(),
+            "master".to_string(),
+            None,
+        ))),
+    };
+    let x = serde_json::to_string(&x).unwrap();
+    fs::write("test.json", x).unwrap();
 }

src/parser/README.md

@@ -0,0 +1,5 @@
+# 配置解析器
+
+## 介绍
+
+配置解析器是一个用于解析配置文件的工具，它可以将DADK任务配置文件解析成DADKTask对象，并进行一些简单的参数验证。

src/parser/mod.rs

@@ -0,0 +1,206 @@
+//! # 配置解析器
+//!
+//! 用于解析配置文件，生成任务列表
+//!
+//! 您需要指定一个配置文件目录，解析器会自动解析该目录下的所有配置文件。
+//! 软件包的配置文件必须以`.dadk`作为后缀名，内容格式为json。
+//!
+//! ## 简介
+//!
+//! 在每个配置文件中，您需要指定软件包的名称、版本、描述、任务类型、依赖、构建配置和安装配置。DADK会根据这些信息生成任务列表。
+//!
+//! ## 配置文件格式
+//!
+//! ```json
+//! {
+//!     "name": "软件包名称",
+//!     "version": "软件包版本",
+//!     "description": "软件包描述",
+//!     "task_type": {任务类型（该部分详见`TaskType`的文档）},
+//!     "depends": [{依赖项（该部分详见Dependency的文档）}],
+//!     "build": {构建配置（该部分详见BuildConfig的文档）},
+//!     "install": {安装配置（该部分详见InstallConfig的文档）}
+//! }
+use std::{
+    fs::{DirEntry, ReadDir},
+    path::PathBuf, fmt::Debug,
+};
+
+use log::info;
+use serde::{Deserialize, Serialize};
+
+use crate::parser::task::TaskType;
+
+use self::task::DADKTask;
+pub mod task;
+
+/// # 配置解析器
+///
+/// 用于解析配置文件，生成任务列表
+#[derive(Debug)]
+pub struct Parser {
+    /// 配置文件目录
+    config_dir: PathBuf,
+    /// 扫描到的配置文件列表
+    config_files: Vec<PathBuf>,
+}
+
+
+pub struct ParserError {
+    pub config_file: Option<PathBuf>,
+    pub error: InnerParserError,
+}
+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)
+                } 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)
+                } 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)
+                } else {
+                    write!(f, "Error while parsing config file: {}", e)
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum InnerParserError {
+    IoError(std::io::Error),
+    JsonError(serde_json::Error),
+    TaskError(String),
+}
+
+impl Parser {
+    pub fn new(config_dir: PathBuf) -> Self {
+        Self {
+            config_dir,
+            config_files: Vec::new(),
+        }
+    }
+
+    /// # 解析所有配置文件，生成任务列表
+    ///
+    /// ## 参数
+    ///
+    /// * `config_dir` - 配置文件所在目录
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(Vec<DADKTask>)` - 任务列表
+    /// * `Err(ParserError)` - 解析错误
+    pub fn parse(&mut self) -> Result<Vec<DADKTask>, ParserError> {
+        info!("Parsing config files in {}", self.config_dir.display());
+
+        self.scan_config_files()?;
+        println!("Found {} config files", self.config_files.len());
+        return self.gen_tasks();
+    }
+
+    /// # 扫描配置文件目录，找到所有配置文件
+    fn scan_config_files(&mut self) -> Result<(), ParserError> {
+        info!("Scanning config files in {}", self.config_dir.display());
+
+        let mut dir_queue: Vec<PathBuf> = Vec::new();
+        // 将config目录加入队列
+        dir_queue.push(self.config_dir.clone());
+
+        while !dir_queue.is_empty() {
+            // 扫描目录，找到所有*.dadk文件
+            let dir = dir_queue.pop().unwrap();
+            let entries: ReadDir = std::fs::read_dir(&dir).map_err(|e| ParserError {
+                config_file: None,
+                error: InnerParserError::IoError(e),
+            })?;
+
+            for entry in entries {
+                let entry: DirEntry = entry.map_err(|e| ParserError {
+                    config_file: None,
+                    error: InnerParserError::IoError(e),
+                })?;
+
+                let path: PathBuf = entry.path();
+                if path.is_dir() {
+                    dir_queue.push(path);
+                } else if path.is_file() {
+                    let extension: Option<&std::ffi::OsStr> = path.extension();
+                    if extension.is_none() {
+                        continue;
+                    }
+                    let extension: &std::ffi::OsStr = extension.unwrap();
+                    if extension.to_ascii_lowercase() != "dadk" {
+                        continue;
+                    }
+                    // 找到一个配置文件, 加入列表
+                    self.config_files.push(path);
+                }
+            }
+        }
+
+        return Ok(());
+    }
+
+    /// # 解析所有配置文件，生成任务列表
+    ///
+    /// 一旦发生错误，立即返回
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(Vec<DADKTask>)` - 任务列表
+    /// * `Err(ParserError)` - 解析错误
+    fn gen_tasks(&self) -> Result<Vec<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);
+        }
+
+        return Ok(result_vec);
+    }
+
+    /// # 解析单个配置文件，生成任务
+    ///
+    /// ## 参数
+    ///
+    /// * `config_file` - 配置文件路径
+    ///
+    /// ## 返回值
+    ///
+    /// * `Ok(DADKTask)` - 生成好的任务
+    /// * `Err(ParserError)` - 解析错误
+    fn parse_config_file(&self, config_file: &PathBuf) -> Result<DADKTask, ParserError> {
+        let content = std::fs::read_to_string(config_file).map_err(|e| ParserError {
+            config_file: Some(config_file.clone()),
+            error: InnerParserError::IoError(e),
+        })?;
+
+        // 从json字符串中解析出DADKTask
+        let task: DADKTask = serde_json::from_str(&content).map_err(|e| ParserError {
+            config_file: Some(config_file.clone()),
+            error: InnerParserError::JsonError(e),
+        })?;
+
+        // 校验DADKTask的参数是否合法
+        task.validate().map_err(|e| ParserError {
+            config_file: Some(config_file.clone()),
+            error: InnerParserError::TaskError(e),
+        })?;
+
+        return Ok(task);
+    }
+
+}

src/parser/task.rs

@@ -0,0 +1,256 @@
+use std::path::PathBuf;
+
+use reqwest::Url;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DADKTask {
+    /// 包名
+    pub name: String,
+    /// 版本
+    pub version: String,
+    /// 包的描述
+    pub description: String,
+    /// 任务类型
+    pub task_type: TaskType,
+    /// 依赖的包
+    pub depends: Vec<Dependency>,
+    /// 构建配置
+    pub build: BuildConfig,
+    /// 安装配置
+    pub install: InstallConfig,
+}
+
+impl DADKTask {
+    pub fn new(
+        name: String,
+        version: String,
+        description: String,
+        task_type: TaskType,
+        depends: Vec<Dependency>,
+        build: BuildConfig,
+        install: InstallConfig,
+    ) -> Self {
+        Self {
+            name,
+            version,
+            description,
+            task_type,
+            depends,
+            build,
+            install,
+        }
+    }
+
+    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());
+        }
+        self.task_type.validate()?;
+        self.build.validate()?;
+        self.install.validate()?;
+
+        return Ok(());
+    }
+}
+
+/// @brief 构建配置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BuildConfig {
+    /// 构建命令
+    pub build_command: String,
+}
+
+impl BuildConfig {
+    pub fn new(build_command: String) -> Self {
+        Self { build_command }
+    }
+
+    pub fn validate(&self) -> Result<(), String> {
+        return Ok(());
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InstallConfig {
+    /// 安装到DragonOS内的目录
+    pub in_dragonos_path: PathBuf,
+    /// 安装命令
+    pub install_command: String,
+}
+
+impl InstallConfig {
+    pub fn new(in_dragonos_path: PathBuf, install_command: String) -> Self {
+        Self {
+            in_dragonos_path,
+            install_command,
+        }
+    }
+
+    pub fn validate(&self) -> Result<(), String> {
+        return Ok(());
+    }
+}
+
+/// @brief 依赖项
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Dependency {
+    pub name: String,
+    pub version: String,
+}
+
+/// # 任务类型
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum TaskType {
+    /// 从源码构建
+    BuildFromSource(CodeSource),
+    /// 从预编译包安装
+    InstallFromPrebuilt(PrebuiltSource),
+}
+
+impl TaskType {
+    pub fn validate(&self) -> Result<(), String> {
+        match self {
+            TaskType::BuildFromSource(source) => source.validate(),
+            TaskType::InstallFromPrebuilt(source) => source.validate(),
+        }
+    }
+}
+
+/// # 代码源
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum CodeSource {
+    /// 从Git仓库获取
+    Git(GitSource),
+    /// 从本地目录获取
+    Local(LocalSource),
+    /// 从在线压缩包获取
+    Archive(ArchiveSource),
+}
+
+impl CodeSource {
+    pub fn validate(&self) -> Result<(), String> {
+        match self {
+            CodeSource::Git(source) => source.validate(),
+            CodeSource::Local(source) => source.validate(Some(false)),
+            CodeSource::Archive(source) => source.validate(),
+        }
+    }
+}
+
+/// # 预编译包源
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum PrebuiltSource {
+    /// 从在线压缩包获取
+    Archive(ArchiveSource),
+    /// 从本地目录/文件获取
+    Local(LocalSource),
+}
+
+impl PrebuiltSource {
+    pub fn validate(&self) -> Result<(), String> {
+        match self {
+            PrebuiltSource::Archive(source) => source.validate(),
+            PrebuiltSource::Local(source) => source.validate(None),
+        }
+    }
+}
+
+/// # 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(());
+    }
+}
+
+/// # 本地源
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LocalSource {
+    /// 本地目录/文件的路径
+    path: PathBuf,
+}
+
+impl LocalSource {
+    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(());
+    }
+}
+
+/// # 在线压缩包源
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ArchiveSource {
+    /// 压缩包的URL
+    url: String,
+}
+
+impl ArchiveSource {
+    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(());
+    }
+}

src/scheduler/README.md

@@ -0,0 +1,10 @@
+# 任务调度器
+
+## 简介
+
+任务调度器用于对要执行的任务进行调度，任务调度器的主要功能包括：
+
+- 检查任务间的依赖关系，确保依赖关系满足后才能执行任务。
+- 对任务进行拓扑排序，确保构建任务能够按照正确的顺序执行。
+- 当具有相同依赖关系的任务同时被提交时，只执行一次任务。
+- 当任务存在环形依赖关系时，为用户提供友好的错误提示：找到环形依赖关系并打印出来，以便用户进行修复。