完成整体Unit文件的解析框架，完成对Service文件的解析 (#2)

.cargo/config.toml

@@ -0,0 +1,8 @@
+#[build]
+#target = "x86_64-unknown-dragonos"
+
+[target.'cfg(target_os = "dragonos")']
+rustflags = [
+  "-C", "target-feature=+crt-static",
+  "-C", "link-arg=-no-pie",
+]

.vscode/launch.json

@@ -0,0 +1,7 @@
+{
+    // 使用 IntelliSense 了解相关属性。 
+    // 悬停以查看现有属性的描述。
+    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": []
+}

Cargo.toml

@@ -10,7 +10,10 @@ path = "src/main.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-drstd = {path = "/home/heyicong/DrogonOS-work/dragonos-rs-std"}
+#drstd = {git = "https://git.mirrors.dragonos.org/DragonOS-Community/drstd.git", revision = "a4d693c682"}
+#lazy_static = { version = "1.4.0", default-features = false, features = ["spin_no_std"] }
+lazy_static = {version = "1.4.0"}
+hashbrown = "0.11"
 
 [profile.release]
 panic = 'abort'

DragonReach/.crates.toml

@@ -0,0 +1,2 @@
+[v1]
+"DragonReach 0.1.0 (path+file:///home/heyicong/DragonReach)" = ["DragonReach"]

DragonReach/.crates2.json

@@ -0,0 +1 @@
+{"installs":{"DragonReach 0.1.0 (path+file:///home/heyicong/DragonReach)":{"version_req":null,"bins":["DragonReach"],"features":[],"all_features":false,"no_default_features":false,"profile":"release","target":"target","rustc":"rustc 1.74.0-nightly (20999de3a 2023-09-15)\nbinary: rustc\ncommit-hash: 20999de3a2f866a6006169c9bc188017aba79fcc\ncommit-date: 2023-09-15\nhost: x86_64-unknown-linux-gnu\nrelease: 1.74.0-nightly\nLLVM version: 17.0.0\n"}}}

Makefile

@@ -0,0 +1,8 @@
+build:
+	cargo -Z build-std=core,alloc,compiler_builtins build --target x86_64-unknown-dragonos
+
+install:
+	cargo -Z build-std=core,alloc,compiler_builtins install --target ./target.json --path .  --root ./DragonReach
+
+build-linux:
+	cargo -Z build-std=core,alloc,compiler_builtins build --target x86_64-unknown-linux-gnu

parse_test/test.service

@@ -0,0 +1,8 @@
+[Unit]
+Description=test
+
+[Service]
+ExecStart=/path/to/my-service run docker /path/to/my-service run / make
+Restart=always
+
+[Install]

src/contants.rs

@@ -5,4 +5,4 @@ pub const IPV4_MIN_MTU: u32 = 68;
 pub const IPV6_MIN_MTU: u32 = 1280;
 
 pub const PRIO_MIN: i8 = -20;
-pub const PRIO_MAX: i8 = 20;
+pub const PRIO_MAX: i8 = 20;

src/error/mod.rs

@@ -1,75 +1,21 @@
-
 #[repr(i32)]
 #[derive(Debug, PartialEq, Eq, Clone)]
 #[allow(dead_code, non_camel_case_types)]
-pub enum SystemError {
-    EPERM = 1,
-    /// 没有指定的文件或目录 No such file or directory.
-    ENOENT = 2,
-    /// 没有这样的进程 No such process.
-    ESRCH = 3,
-    /// 被中断的函数 Interrupted function.
-    EINTR = 4,
-    /// I/O错误 I/O error.
-    EIO = 5,
-    /// 没有这样的设备或地址 No such device or address.
-    ENXIO = 6,
-    /// 参数列表过长，或者在输出buffer中缺少空间 或者参数比系统内建的最大值要大 Argument list too long.
-    E2BIG = 7,
-    /// 可执行文件格式错误 Executable file format error
-    ENOEXEC = 8,
-    /// 错误的文件描述符 Bad file descriptor.
-    EBADF = 9,
-    /// 没有子进程 No child processes.
-    ECHILD = 10,
-    /// 资源不可用，请重试。 Resource unavailable, try again.(may be the same value as [EWOULDBLOCK])
-    ///
-    /// 操作将被禁止 Operation would block.(may be the same value as [EAGAIN]).
-    EAGAIN_OR_EWOULDBLOCK = 11,
-    /// 没有足够的空间 Not enough space.
-    ENOMEM = 12,
-    /// 访问被拒绝 Permission denied
-    EACCES = 13,
-    /// 错误的地址 Bad address
-    EFAULT = 14,
-    /// 需要块设备 Block device required
-    ENOTBLK = 15,
-    /// 设备或资源忙 Device or resource busy.
-    EBUSY = 16,
-    /// 文件已存在 File exists.
-    EEXIST = 17,
-    /// 跨设备连接 Cross-device link.
-    EXDEV = 18,
-    /// 没有指定的设备 No such device.
-    ENODEV = 19,
-    /// 不是目录 Not a directory.
-    ENOTDIR = 20,
-    /// 是一个目录 Is a directory
-    EISDIR = 21,
-    /// 不可用的参数 Invalid argument.
-    EINVAL = 22,
-    /// 系统中打开的文件过多 Too many files open in system.
-    ENFILE = 23,
-    /// 文件描述符的值过大 File descriptor value too large.
-    EMFILE = 24,
-    /// 不正确的I/O控制操作 Inappropriate I/O control operation.
-    ENOTTY = 25,
-    /// 文本文件忙 Text file busy.
-    ETXTBSY = 26,
-    /// 文件太大 File too large.
-    EFBIG = 27,
-    /// 设备上没有空间 No space left on device.
-    ENOSPC = 28,
-    /// 错误的寻道.当前文件是pipe，不允许seek请求  Invalid seek.
-    ESPIPE = 29,
-    /// 只读的文件系统 Read-only file system.
-    EROFS = 30,
-    /// 链接数过多 Too many links.
-    EMLINK = 31,
-    /// 断开的管道 Broken pipe.
-    EPIPE = 32,
-    /// 数学参数超出作用域 Mathematics argument out of domain of function.
-    EDOM = 33,
+pub enum ParseError {
+    /// 不合法参数
+    EINVAL,
     /// 结果过大 Result too large.
-    ERANGE = 34,
-}
+    ERANGE,
+    /// 重复定义
+    EREDEF,
+    /// 未预料到的空值
+    EUnexpectedEmpty,
+    /// 语法错误
+    ESyntaxError,
+    /// 非法文件描述符
+    EBADF,
+    /// 非法文件
+    EFILE,
+    /// 不是目录
+    ENODIR,
+}

src/main.rs

@@ -1,16 +1,34 @@
-#![no_std]
-#![no_main]
+// #![no_std]
+// #![no_main]
 
-extern crate drstd;
-use drstd::std as std;
+//extern crate drstd;
+extern crate hashbrown;
+
+//use drstd as std;
+use std::print;
+use std::println;
+use std::rc::Rc;
+use unit::service::ServiceUnit;
 
-mod parse;
-mod error;
-mod types;
 mod contants;
+mod error;
+mod parse;
+mod task;
 mod unit;
 
-#[no_mangle]
+use crate::unit::service;
+
+use self::unit::Unit;
+
+pub struct FileDescriptor(usize);
+
+//#[no_mangle]
 fn main() {
-    
+    let service =
+        ServiceUnit::from_path("/home/heyicong/DragonReach/parse_test/test.service").unwrap();
+    let service = service.as_ref();
+    let cmds = &service.service_part.exec_start;
+    for cmd in cmds{
+        println!("{},{}",cmd.path,cmd.cmd);
+    }
 }

src/parse/mod.rs

@@ -1,3 +1,294 @@
+use crate::unit::{BaseUnit, Unit};
+use crate::{
+    error::ParseError,
+    unit::{service::ServiceUnitAttr, BaseUnitAttr, InstallUnitAttr, UnitType},
+};
+use core::cell::RefCell;
+//use drstd as std;
+use hashbrown::HashMap;
+use lazy_static::lazy_static;
+use std::boxed::Box;
+use std::format;
+use std::fs::File;
+use std::io::{self, BufRead};
+use std::rc::Rc;
+use std::string::String;
+use std::vec::Vec;
+
+use self::parse_base_unit::BaseUnitParser;
+
+pub mod parse_base_unit;
+pub mod parse_service;
 mod parse_util;
 
-struct UnitParser;
+pub trait AttrParse<T> {
+    fn parse_and_set_attribute(unit: &mut T, attr: &str, val: &str) -> Result<(), ParseError>;
+}
+
+//对应Unit段类型
+#[derive(PartialEq, Clone, Copy)]
+pub enum Segment {
+    None,
+    Unit,
+    Install,
+    Service,
+}
+
+lazy_static! {
+    static ref UNIT_SUFFIX: HashMap<&'static str, UnitType> = {
+        let mut table = HashMap::new();
+        table.insert("automount", UnitType::Automount);
+        table.insert("device", UnitType::Device);
+        table.insert("mount", UnitType::Mount);
+        table.insert("path", UnitType::Path);
+        table.insert("scope", UnitType::Scope);
+        table.insert("service", UnitType::Service);
+        table.insert("slice", UnitType::Automount);
+        table.insert("automount", UnitType::Slice);
+        table.insert("socket", UnitType::Socket);
+        table.insert("swap", UnitType::Swap);
+        table.insert("target", UnitType::Target);
+        table.insert("timer", UnitType::Timer);
+        table
+    };
+    static ref SEGMENT_TABLE: HashMap<&'static str, Segment> = {
+        let mut table = HashMap::new();
+        table.insert("[Unit]", Segment::Unit);
+        table.insert("[Install]", Segment::Install);
+        table.insert("[Service]", Segment::Service);
+        table
+    };
+    static ref INSTALL_UNIT_ATTR_TABLE: HashMap<&'static str, InstallUnitAttr> = {
+        let mut unit_attr_table = HashMap::new();
+        unit_attr_table.insert("WantedBy", InstallUnitAttr::WantedBy);
+        unit_attr_table.insert("RequiredBy", InstallUnitAttr::RequiredBy);
+        unit_attr_table.insert("Also", InstallUnitAttr::Also);
+        unit_attr_table.insert("Alias", InstallUnitAttr::Alias);
+        unit_attr_table
+    };
+    static ref SERVICE_UNIT_ATTR_TABLE: HashMap<&'static str, ServiceUnitAttr> = {
+        let mut unit_attr_table = HashMap::new();
+        unit_attr_table.insert("Type", ServiceUnitAttr::Type);
+        unit_attr_table.insert("RemainAfterExit", ServiceUnitAttr::RemainAfterExit);
+        unit_attr_table.insert("ExecStart", ServiceUnitAttr::ExecStart);
+        unit_attr_table.insert("ExecStartPre", ServiceUnitAttr::ExecStartPre);
+        unit_attr_table.insert("ExecStartPos", ServiceUnitAttr::ExecStartPos);
+        unit_attr_table.insert("ExecReload", ServiceUnitAttr::ExecReload);
+        unit_attr_table.insert("ExecStop", ServiceUnitAttr::ExecStop);
+        unit_attr_table.insert("ExecStopPost", ServiceUnitAttr::ExecStopPost);
+        unit_attr_table.insert("RestartSec", ServiceUnitAttr::RestartSec);
+        unit_attr_table.insert("Restart", ServiceUnitAttr::Restart);
+        unit_attr_table.insert("TimeoutStartSec", ServiceUnitAttr::TimeoutStartSec);
+        unit_attr_table.insert("TimeoutStopSec", ServiceUnitAttr::TimeoutStopSec);
+        unit_attr_table.insert("Environment", ServiceUnitAttr::Environment);
+        unit_attr_table.insert("EnvironmentFile", ServiceUnitAttr::EnvironmentFile);
+        unit_attr_table.insert("Nice", ServiceUnitAttr::Nice);
+        unit_attr_table.insert("WorkingDirectory", ServiceUnitAttr::WorkingDirectory);
+        unit_attr_table.insert("RootDirectory", ServiceUnitAttr::RootDirectory);
+        unit_attr_table.insert("User", ServiceUnitAttr::User);
+        unit_attr_table.insert("Group", ServiceUnitAttr::Group);
+        unit_attr_table.insert("MountFlags", ServiceUnitAttr::MountFlags);
+        unit_attr_table
+    };
+    static ref BASE_UNIT_ATTR_TABLE: HashMap<&'static str, BaseUnitAttr> = {
+        let mut unit_attr_table = HashMap::new();
+        unit_attr_table.insert("Description", BaseUnitAttr::Description);
+        unit_attr_table.insert("Documentation", BaseUnitAttr::Documentation);
+        unit_attr_table.insert("Requires", BaseUnitAttr::Requires);
+        unit_attr_table.insert("Wants", BaseUnitAttr::Wants);
+        unit_attr_table.insert("After", BaseUnitAttr::After);
+        unit_attr_table.insert("Before", BaseUnitAttr::Before);
+        unit_attr_table.insert("Binds To", BaseUnitAttr::BindsTo);
+        unit_attr_table.insert("Part Of", BaseUnitAttr::PartOf);
+        unit_attr_table.insert("OnFailure", BaseUnitAttr::OnFailure);
+        unit_attr_table.insert("Conflicts", BaseUnitAttr::Conflicts);
+        unit_attr_table
+    };
+    static ref BASE_IEC: HashMap<&'static str, u64> = {
+        let mut table = HashMap::new();
+        table.insert(
+            "E",
+            1024u64 * 1024u64 * 1024u64 * 1024u64 * 1024u64 * 1024u64,
+        );
+        table.insert("P", 1024u64 * 1024u64 * 1024u64 * 1024u64 * 1024u64);
+        table.insert("T", 1024u64 * 1024u64 * 1024u64 * 1024u64);
+        table.insert("G", 1024u64 * 1024u64 * 1024u64);
+        table.insert("M", 1024u64 * 1024u64);
+        table.insert("K", 1024u64);
+        table.insert("B", 1u64);
+        table.insert("", 1u64);
+        table
+    };
+    static ref BASE_SI: HashMap<&'static str, u64> = {
+        let mut table = HashMap::new();
+        table.insert(
+            "E",
+            1000u64 * 1000u64 * 1000u64 * 1000u64 * 1000u64 * 1000u64,
+        );
+        table.insert("P", 1000u64 * 1000u64 * 1000u64 * 1000u64 * 1000u64);
+        table.insert("T", 1000u64 * 1000u64 * 1000u64 * 1000u64);
+        table.insert("G", 1000u64 * 1000u64 * 1000u64);
+        table.insert("M", 1000u64 * 1000u64);
+        table.insert("K", 1000u64);
+        table.insert("B", 1u64);
+        table.insert("", 1u64);
+        table
+    };
+    static ref SEC_UNIT_TABLE: HashMap<&'static str, u64> = {
+        let mut table = HashMap::new();
+        table.insert("h", 60 * 60 * 1000 * 1000 * 1000);
+        table.insert("min", 60 * 1000 * 1000 * 1000);
+        table.insert("m", 60 * 1000 * 1000 * 1000);
+        table.insert("s", 1000 * 1000 * 1000);
+        table.insert("", 1000 * 1000 * 1000);
+        table.insert("ms", 1000 * 1000);
+        table.insert("us", 1000);
+        table.insert("ns", 1);
+        table
+    };
+}
+
+//用于解析Unit共有段的方法
+pub struct UnitParser;
+
+impl UnitParser {
+    /// @brief 从path获取到BufReader,此方法将会检验文件类型
+    ///
+    /// 从path获取到BufReader,此方法将会检验文件类型
+    ///
+    /// @param path 需解析的文件路径
+    /// 
+    /// @param unit_type 指定Unit类型
+    ///
+    /// @return 成功则返回对应BufReader，否则返回Err
+    fn get_unit_reader(path: &str, unit_type: UnitType) -> Result<io::BufReader<File>, ParseError> {
+        let suffix = match path.rfind('.') {
+            Some(idx) => &path[idx + 1..],
+            None => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+        let u_type = UNIT_SUFFIX.get(suffix);
+        if u_type.is_none() {
+            return Err(ParseError::EFILE);
+        }
+        if *(u_type.unwrap()) != unit_type {
+            return Err(ParseError::EFILE);
+        }
+
+        let file = match File::open(path) {
+            Ok(file) => file,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+        return Ok(io::BufReader::new(file));
+    }
+
+    /// @brief 将path路径的文件解析为unit_type类型的Unit
+    ///
+    /// 该方法解析每个Unit共有的段(Unit,Install),其余独有的段属性将会交付T类型的Unit去解析
+    /// TODO:该方法多态性做得不是很优雅，后期可以重构一下
+    ///
+    /// @param path 需解析的文件路径
+    /// 
+    /// @param unit_type 指定Unit类型
+    /// 
+    /// @param unit 需要的unit对象,解析结果会放置在里面,将会调用unit的set_attr方法设置独有属性
+    /// 
+    /// @param unit_base 共有段的解析结果将会放置在unit_base中
+    ///
+    /// @return 解析成功则返回Ok(())，否则返回Err
+    pub fn parse<T: Unit>(
+        path: &str,
+        unit_type: UnitType,
+        unit: &mut T,
+        unit_base: &mut BaseUnit,
+    ) -> Result<(), ParseError> {
+        unit_base.unit_type = unit_type;
+        let reader = UnitParser::get_unit_reader(path, unit_type)?;
+
+        //用于记录当前段的类型
+        let mut segment = Segment::None;
+        //用于处理多行对应一个属性的情况
+        let mut last_attr = ServiceUnitAttr::None;
+
+        //一行一行向下解析
+        let lines = reader
+            .lines()
+            .map(|line| line.unwrap())
+            .collect::<Vec<String>>();
+        let mut i = 0;
+        while i < lines.len() {
+            let line = &lines[i];
+            //空行跳过
+            if line.chars().all(char::is_whitespace) {
+                i += 1;
+                continue;
+            }
+            //注释跳过
+            if line.starts_with('#') {
+                i += 1;
+                continue;
+            }
+            let mut line = line.trim();
+            let segment_flag = SEGMENT_TABLE.get(&line);
+            if !segment_flag.is_none() {
+                //如果当前行匹配到的为段名，则切换段类型继续匹配下一行
+                segment = *segment_flag.unwrap();
+                i += 1;
+                continue;
+            }
+            if segment == Segment::None {
+                //未找到段名则不能继续匹配
+                return Err(ParseError::ESyntaxError);
+            }
+
+            //下面进行属性匹配
+            //合并多行为一个属性的情况
+            //最后一个字符为\，代表换行，将多行转换为一行统一解析
+            if lines[i].ends_with('\\') {
+                let mut templine = String::new();
+                while lines[i].ends_with('\\') {
+                    let temp = &lines[i][..lines[i].len() - 1];
+                    templine = format!("{} {}", templine, temp);
+                    i += 1;
+                }
+                templine = format!("{} {}", templine, lines[i]);
+                line = templine.as_str();
+                i += 1;
+                break;
+            }
+            //=号分割后第一个元素为属性，后面的均为值，若一行出现两个等号则是语法错误
+            let attr_val_map = line.split('=').collect::<Vec<&str>>();
+            if attr_val_map.len() != 2 {
+                return Err(ParseError::ESyntaxError);
+            }
+
+            //首先匹配所有unit文件都有的unit段和install段
+            if BASE_UNIT_ATTR_TABLE.get(attr_val_map[0]).is_some() {
+                if segment != Segment::Unit {
+                    return Err(ParseError::EINVAL);
+                }
+                BaseUnitParser::parse_and_set_base_unit_attribute(
+                    &mut unit_base.unit_part,
+                    BASE_UNIT_ATTR_TABLE.get(attr_val_map[0]).unwrap(),
+                    attr_val_map[1],
+                )?
+            } else if INSTALL_UNIT_ATTR_TABLE.get(attr_val_map[0]).is_some() {
+                if segment != Segment::Install {
+                    return Err(ParseError::EINVAL);
+                }
+                BaseUnitParser::parse_and_set_base_install_attribute(
+                    &mut unit_base.install_part,
+                    INSTALL_UNIT_ATTR_TABLE.get(attr_val_map[0]).unwrap(),
+                    attr_val_map[1],
+                )?
+            } else {
+                unit.set_attr(segment, attr_val_map[0], attr_val_map[1])?;
+            }
+            i += 1;
+        }
+        return Ok(());
+    }
+}

src/parse/parse_base_unit/mod.rs

@@ -0,0 +1,165 @@
+use crate::{
+    error::ParseError,
+    unit::{target::TargetUnit, BaseUnitAttr, InstallPart, UnitPart},
+};
+//use drstd as std;
+use std::rc::Rc;
+use std::string::String;
+use std::vec::Vec;
+
+use super::{parse_util::UnitParseUtil, InstallUnitAttr};
+
+//Unit同有部分的解析器
+pub struct BaseUnitParser;
+
+impl BaseUnitParser {
+    /// @brief 为Unit解析Unit段属性并添加
+    ///
+    /// 为Unit解析Unit段属性并添加
+    ///
+    /// @param unit_part UnitPart(Unit段结构体)，解析结果将存在该结构体
+    /// 
+    /// @param attr BaseUnitAttr,Unit段的属性抽象
+    /// 
+    /// @param val 属性值
+    ///
+    /// @return 成功则返回Ok(())，否则返回Err
+    pub fn parse_and_set_base_unit_attribute(
+        unit_part: &mut UnitPart,
+        attr: &BaseUnitAttr,
+        val: &str,
+    ) -> Result<(), ParseError> {
+        match attr {
+            BaseUnitAttr::None => {
+                return Err(ParseError::ESyntaxError);
+            }
+            BaseUnitAttr::Description => unit_part.description = String::from(val),
+            BaseUnitAttr::Documentation => unit_part
+                .documentation
+                .extend(UnitParseUtil::parse_url(val)?),
+            BaseUnitAttr::Requires => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入requires列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    unit_part
+                        .requires
+                        .push(UnitParseUtil::parse_unit_no_type(unit_path)?);
+                }
+            }
+            BaseUnitAttr::Wants => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    unit_part
+                        .wants
+                        .push(UnitParseUtil::parse_unit_no_type(unit_path)?);
+                }
+            }
+            BaseUnitAttr::After => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    unit_part
+                        .after
+                        .push(UnitParseUtil::parse_unit_no_type(unit_path)?);
+                }
+            }
+            BaseUnitAttr::Before => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    unit_part
+                        .before
+                        .push(UnitParseUtil::parse_unit_no_type(unit_path)?);
+                }
+            }
+            BaseUnitAttr::BindsTo => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    unit_part
+                        .binds_to
+                        .push(UnitParseUtil::parse_unit_no_type(unit_path)?);
+                }
+            }
+            BaseUnitAttr::PartOf => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    unit_part
+                        .part_of
+                        .push(UnitParseUtil::parse_unit_no_type(unit_path)?);
+                }
+            }
+            BaseUnitAttr::OnFailure => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    unit_part
+                        .on_failure
+                        .push(UnitParseUtil::parse_unit_no_type(unit_path)?);
+                }
+            }
+            BaseUnitAttr::Conflicts => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    let unit = UnitParseUtil::parse_unit_no_type(unit_path)?;
+                    unit_part.conflicts.push(unit);
+                }
+            }
+        }
+        return Ok(());
+    }
+
+    /// @brief 为Unit解析Install段属性并添加
+    ///
+    /// 为Unit解析Install段属性并添加
+    ///
+    /// @param install_part InstallPart(Install段结构体)，解析结果将存在该结构体
+    /// 
+    /// @param attr BaseUnitAttr,Unit段的属性抽象
+    /// 
+    /// @param val 属性值
+    ///
+    /// @return 成功则返回Ok(())，否则返回Err
+    pub fn parse_and_set_base_install_attribute(
+        install_part: &mut InstallPart,
+        attr: &InstallUnitAttr,
+        val: &str,
+    ) -> Result<(), ParseError> {
+        match attr {
+            InstallUnitAttr::RequiredBy => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    let unit = UnitParseUtil::parse_unit::<TargetUnit>(unit_path)?;
+                    install_part.requires_by.push(unit);
+                }
+            }
+            InstallUnitAttr::Also => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    let unit = UnitParseUtil::parse_unit_no_type(unit_path)?;
+                    install_part.also.push(unit);
+                }
+            }
+            InstallUnitAttr::WantedBy => {
+                let units = val.split_whitespace().collect::<Vec<&str>>();
+                //TODO:目前先加入列表，可能会出现循环依赖问题，后续应解决循环依赖问题
+                for unit_path in units {
+                    let unit = UnitParseUtil::parse_unit::<TargetUnit>(unit_path)?;
+                    install_part.wanted_by.push(unit);
+                }
+            }
+            InstallUnitAttr::Alias => {
+                install_part.alias = String::from(val);
+            }
+            InstallUnitAttr::None => {
+                return Err(ParseError::EINVAL);
+            }
+        }
+        return Ok(());
+    }
+}

src/parse/parse_service/mod.rs

@@ -0,0 +1,179 @@
+use super::{AttrParse, ServiceUnitAttr, UnitParser, SERVICE_UNIT_ATTR_TABLE};
+use crate::error::ParseError;
+use crate::parse::parse_util::UnitParseUtil;
+use crate::unit::service::{MountFlag, RestartOption, ServiceType, ServiceUnit};
+use crate::unit::{BaseUnit, Unit};
+use core::borrow::BorrowMut;
+use core::cell::RefCell;
+//use drstd as std;
+use std::boxed::Box;
+use std::fs;
+use std::rc::Rc;
+use std::string::String;
+pub struct ServiceParser;
+
+impl ServiceParser {
+    /// @brief 解析Service类型Unit的
+    ///
+    /// 从path解析Service类型Unit
+    ///
+    /// @param path 需解析的文件路径
+    ///
+    /// @return 成功则返回Ok(Rc<ServiceUnit>)，否则返回Err
+    pub fn parse(path: &str) -> Result<Rc<ServiceUnit>, ParseError> {
+        let mut service = ServiceUnit::default();
+        let mut unit_base = BaseUnit::default();
+
+        //交付总解析器
+        UnitParser::parse::<ServiceUnit>(
+            path,
+            crate::unit::UnitType::Service,
+            &mut service,
+            &mut unit_base,
+        )?;
+
+        //设置
+        service.unit_base = unit_base;
+        let mut service = Rc::new(service);
+        return Ok(service);
+    }
+}
+
+impl AttrParse<ServiceUnit> for ServiceParser {
+    /// @brief 为Service类型Unit解析并添加属性
+    ///
+    /// 为Service类型Unit解析并添加属性
+    ///
+    /// @param service ServiceUnit对象
+    /// 
+    /// @param attr_str 属性名
+    /// 
+    /// @param val 属性值
+    ///
+    /// @return 成功则返回Ok(())，否则返回Err
+    fn parse_and_set_attribute(
+        service: &mut ServiceUnit,
+        attr_str: &str,
+        val: &str,
+    ) -> Result<(), ParseError> {
+        //let mut service = *unit;
+
+        let attr = match SERVICE_UNIT_ATTR_TABLE.get(attr_str) {
+            Some(val) => val,
+            None => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+        match attr {
+            ServiceUnitAttr::Type => match val {
+                "simple" => service.service_part.service_type = ServiceType::Simple,
+                "forking" => service.service_part.service_type = ServiceType::Forking,
+                "oneshot" => service.service_part.service_type = ServiceType::OneShot,
+                "dbus" => service.service_part.service_type = ServiceType::Dbus,
+                "notify" => service.service_part.service_type = ServiceType::Notify,
+                "idle" => service.service_part.service_type = ServiceType::Idle,
+                _ => {
+                    return Err(ParseError::EINVAL);
+                }
+            },
+            ServiceUnitAttr::RemainAfterExit => {
+                service.service_part.remain_after_exit = UnitParseUtil::parse_boolean(val)?
+            }
+            ServiceUnitAttr::ExecStart => {
+                service
+                    .service_part
+                    .exec_start
+                    .extend(UnitParseUtil::parse_cmd_task(val)?);
+            }
+            ServiceUnitAttr::ExecStartPre => {
+                service
+                    .service_part
+                    .exec_start_pre
+                    .extend(UnitParseUtil::parse_cmd_task(val)?);
+            }
+            ServiceUnitAttr::ExecStartPos => {
+                service
+                    .service_part
+                    .exec_start_pos
+                    .extend(UnitParseUtil::parse_cmd_task(val)?);
+            }
+            ServiceUnitAttr::ExecReload => {
+                service
+                    .service_part
+                    .exec_reload
+                    .extend(UnitParseUtil::parse_cmd_task(val)?);
+            }
+            ServiceUnitAttr::ExecStopPost => {
+                service
+                    .service_part
+                    .exec_stop_post
+                    .extend(UnitParseUtil::parse_cmd_task(val)?);
+            }
+            ServiceUnitAttr::ExecStop => {
+                service
+                    .service_part
+                    .exec_stop
+                    .extend(UnitParseUtil::parse_cmd_task(val)?);
+            }
+            ServiceUnitAttr::RestartSec => {
+                service.service_part.restart_sec = UnitParseUtil::parse_sec(val)?
+            }
+            ServiceUnitAttr::Restart => match val {
+                "always" => service.service_part.restart = RestartOption::AlwaysRestart,
+                "on-success" => service.service_part.restart = RestartOption::OnSuccess,
+                "on-failure" => service.service_part.restart = RestartOption::OnFailure,
+                "on-abnormal" => service.service_part.restart = RestartOption::OnAbnormal,
+                "on-abort" => service.service_part.restart = RestartOption::OnAbort,
+                "on-watchdog" => service.service_part.restart = RestartOption::OnWatchdog,
+                _ => {
+                    return Err(ParseError::EINVAL);
+                }
+            },
+            ServiceUnitAttr::TimeoutStartSec => {
+                service.service_part.timeout_start_sec = UnitParseUtil::parse_sec(val)?
+            }
+            ServiceUnitAttr::TimeoutStopSec => {
+                service.service_part.timeout_stop_sec = UnitParseUtil::parse_sec(val)?
+            }
+            ServiceUnitAttr::Environment => {
+                service.service_part.environment = String::from(val);
+            }
+            ServiceUnitAttr::EnvironmentFile => {
+                if !UnitParseUtil::is_absolute_path(val) {
+                    return Err(ParseError::EFILE);
+                }
+                service.service_part.environment_file = String::from(val);
+            }
+            ServiceUnitAttr::Nice => {
+                service.service_part.nice = UnitParseUtil::parse_nice(val)?;
+            }
+            ServiceUnitAttr::WorkingDirectory => {
+                if !UnitParseUtil::is_dir(val) {
+                    return Err(ParseError::ENODIR);
+                }
+                service.service_part.working_directory = String::from(val);
+            }
+            ServiceUnitAttr::User => {
+                //TODO: 检查系统是否存在这个用户
+                service.service_part.user = String::from(val);
+            }
+            ServiceUnitAttr::Group => {
+                //TODO: 检查系统是否存在该用户组
+                service.service_part.group = String::from(val);
+            }
+            ServiceUnitAttr::MountFlags => match val {
+                "shared" => service.service_part.mount_flags = MountFlag::Shared,
+                "slave" => service.service_part.mount_flags = MountFlag::Slave,
+                "private" => service.service_part.mount_flags = MountFlag::Private,
+                _ => {
+                    return Err(ParseError::EINVAL);
+                }
+            },
+            _ => {
+                return Err(ParseError::EINVAL);
+            }
+        }
+
+        return Ok(());
+    }
+}

src/parse/parse_util/mod.rs

@@ -1,420 +1,613 @@
-use drstd::std as std;
-use std::{
-    num,
-    vec,
-    vec::Vec,
-    string::ToString
+use crate::{
+    contants::{AF_INET, AF_INET6, IPV4_MIN_MTU, IPV6_MIN_MTU, PRIO_MAX, PRIO_MIN},
+    error::ParseError,
+    task::cmdtask::CmdTask,
+    unit::{Unit, Url},
+    FileDescriptor,
 };
-use crate::{error::SystemError, types::{pid_t, mode_t}, contants::{AF_INET6, IPV6_MIN_MTU, AF_INET, IPV4_MIN_MTU, PRIO_MAX, PRIO_MIN}};
-
-/// @brief 解析布尔值
-/// 
-/// 将传入的字符串解析为布尔值
-/// "yes","y","1","true","t","on"均可表示true
-/// "no","n","0","false","f","off"均可表示false
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_boolean(s: &str) -> Result<bool,SystemError> {
-    let t_table: Vec<&str> = vec!["yes","y","1","true","t","on"];
-    let f_table: Vec<&str> = vec!["no","n","0","false","f","off"];
-
-    if t_table.contains(&s) {
-        return Ok(true);
-    }else if f_table.contains(&s) {
-        return Ok(false);
-    }
-    
-    return Err(SystemError::EINVAL);
+//use drstd::std;
+use std::{format, fs, path::Path, rc::Rc, string::String, string::ToString, vec, vec::Vec};
+
+use super::{parse_service::ServiceParser, BASE_IEC, BASE_SI, SEC_UNIT_TABLE};
+
+#[derive(PartialEq)]
+pub enum SizeBase {
+    IEC,
+    Si,
 }
 
-/// @brief 解析pid
-/// 
-/// 将传入的字符串解析为pid
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_pid(s: &str) -> Result<pid_t,SystemError>{
-    let s = s.trim();
-    //先使用u64变换
-    let pid_ul = match s.parse::<u64>() {
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+pub struct UnitParseUtil;
+
+impl UnitParseUtil {
+    /// @brief 解析布尔值
+    ///
+    /// 将传入的字符串解析为布尔值
+    /// "yes","y","1","true","t","on"均可表示true
+    /// "no","n","0","false","f","off"均可表示false
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_boolean(s: &str) -> Result<bool, ParseError> {
+        let t_table: Vec<&str> = vec!["yes", "y", "1", "true", "t", "on"];
+        let f_table: Vec<&str> = vec!["no", "n", "0", "false", "f", "off"];
+
+        if t_table.contains(&s) {
+            return Ok(true);
+        } else if f_table.contains(&s) {
+            return Ok(false);
         }
-    };
-    let pid: pid_t = pid_ul as pid_t;
 
-    if (pid as u64) != pid_ul {
-        //如果在从pid_t转换为u64之后与之前不等，则说明发生了截断，返回错误
-        return Err(SystemError::ERANGE);
+        return Err(ParseError::EINVAL);
     }
 
-    if pid < 0 {
-        //pid小于0不合法
-        return Err(SystemError::EINVAL);
-    }
+    /// @brief 解析pid
+    ///
+    /// 将传入的字符串解析为pid
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_pid(s: &str) -> Result<i32, ParseError> {
+        let s = s.trim();
+        //先使用u64变换
+        let pid_ul = match s.parse::<u64>() {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+        let pid: i32 = pid_ul as i32;
 
-    return Ok(pid);
-}
+        if (pid as u64) != pid_ul {
+            //如果在从pid_t转换为u64之后与之前不等，则说明发生了截断，返回错误
+            return Err(ParseError::ERANGE);
+        }
 
-/// @brief 解析pid
-/// 
-/// 将传入的字符串解析为mode_t
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_mode(s: &str) -> Result<mode_t,SystemError> {
-    let s = s.trim();
-    let m = match u32::from_str_radix(s, 8) {
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+        if pid < 0 {
+            //pid小于0不合法
+            return Err(ParseError::EINVAL);
         }
-    };
 
-    //如果模式大于权限的最大值则为非法权限，返回错误
-    if m > 0o7777 {
-        return Err(SystemError::ERANGE);
+        return Ok(pid);
     }
 
-    return Ok(m);
-}
+    /// @brief 解析pid
+    ///
+    /// 将传入的字符串解析为mode_t
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_mode(s: &str) -> Result<u32, ParseError> {
+        let s = s.trim();
+        let m = match u32::from_str_radix(s, 8) {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
 
-/// @brief 解析网络接口索引
-/// 
-/// 将传入的字符串解析为网络接口索引具体值
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_ifindex(s: &str) -> Result<i32,SystemError> {
-    let s = s.trim();
-    let ret: i32 = match s.parse::<i32>(){
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+        //如果模式大于权限的最大值则为非法权限，返回错误
+        if m > 0o7777 {
+            return Err(ParseError::ERANGE);
         }
-    };
 
-    if ret <= 0 {
-        return Err(SystemError::EINVAL);
+        return Ok(m);
     }
 
-    return Ok(ret);
-}
+    /// @brief 解析网络接口索引
+    ///
+    /// 将传入的字符串解析为网络接口索引具体值
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_ifindex(s: &str) -> Result<i32, ParseError> {
+        let s = s.trim();
+        let ret: i32 = match s.parse::<i32>() {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
 
-/// @brief 解析最大传输单元(MTU)
-/// 
-/// 将传入的字符串解析为具体值
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @param family 网络地址族
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_mtu(s: &str,family: i32) -> Result<u32,SystemError> {
-    let s = s.trim();
-    let mtu = match s.parse::<u64>() {
-        Ok(val) => val,
-        Err(_) => {
-            //针对非法字符出错时
-            return Err(SystemError::EINVAL);
+        if ret <= 0 {
+            return Err(ParseError::EINVAL);
         }
-    };
-    
-    //针对数据溢出时的报错
-    if mtu > u32::MAX as u64 {
-        return Err(SystemError::ERANGE);
+
+        return Ok(ret);
     }
 
-    let mtu: u32 = mtu as u32;
+    /// @brief 解析最大传输单元(MTU)
+    ///
+    /// 将传入的字符串解析为具体值
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @param family 网络地址族
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_mtu(s: &str, family: i32) -> Result<u32, ParseError> {
+        let s = s.trim();
+        let mtu = match s.parse::<u64>() {
+            Ok(val) => val,
+            Err(_) => {
+                //针对非法字符出错时
+                return Err(ParseError::EINVAL);
+            }
+        };
 
-    let mut min_mtu: u32 = 0;
-    //判断mtu是否合法
-    if family == AF_INET6 {
-        min_mtu = IPV6_MIN_MTU;
-    }else if family == AF_INET {
-        min_mtu = IPV4_MIN_MTU;
-    }else {
-        return Err(SystemError::EINVAL);
-    }
+        //针对数据溢出时的报错
+        if mtu > u32::MAX as u64 {
+            return Err(ParseError::ERANGE);
+        }
 
-    return Ok(mtu);
-}
+        let mtu: u32 = mtu as u32;
 
-#[derive(PartialEq)]
-pub enum SizeBase {
-    IEC,
-    Si
-}
+        let mut min_mtu: u32 = 0;
+        //判断mtu是否合法
+        if family == AF_INET6 {
+            min_mtu = IPV6_MIN_MTU;
+        } else if family == AF_INET {
+            min_mtu = IPV4_MIN_MTU;
+        } else {
+            return Err(ParseError::EINVAL);
+        }
 
-struct BaseMapper<'a> {
-    suffix: &'a str,
-    factor: u64
-}
+        return Ok(mtu);
+    }
 
-// IEC表
-const BASE_IEC:[BaseMapper;8] = [
-    BaseMapper{ suffix: "E", factor: 1024u64*1024u64*1024u64*1024u64*1024u64*1024u64 },
-    BaseMapper{ suffix: "P", factor: 1024u64*1024u64*1024u64*1024u64*1024u64 },
-    BaseMapper{ suffix: "T", factor: 1024u64*1024u64*1024u64*1024u64 },
-    BaseMapper{ suffix: "G", factor: 1024u64*1024u64*1024u64 },
-    BaseMapper{ suffix: "M", factor: 1024u64*1024u64 },
-    BaseMapper{ suffix: "K", factor: 1024u64 },
-    BaseMapper{ suffix: "B", factor: 1u64 },
-    BaseMapper{ suffix: "",  factor: 1u64 },
-];
-
-// SI表
-const BASE_SI:[BaseMapper;8] = [
-    BaseMapper{ suffix: "E", factor: 1000u64*1000u64*1000u64*1000u64*1000u64*1000u64 },
-    BaseMapper{ suffix: "P", factor: 1000u64*1000u64*1000u64*1000u64*1000u64 },
-    BaseMapper{ suffix: "T", factor: 1000u64*1000u64*1000u64*1000u64 },
-    BaseMapper{ suffix: "G", factor: 1000u64*1000u64*1000u64 },
-    BaseMapper{ suffix: "M", factor: 1000u64*1000u64 },
-    BaseMapper{ suffix: "K", factor: 1000u64 },
-    BaseMapper{ suffix: "B", factor: 1u64 },
-    BaseMapper{ suffix: "",  factor: 1u64 },
-];
-
-/// @brief 解析Size
-/// 
-/// 将传入的字符串解析为具体的字节数
-/// 可支持IEC二进制后缀，也可支持SI十进制后缀
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @param base 设置为IEC二进制后缀或者SI十进制后缀
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_size(s: &str, base: SizeBase) -> Result<u64, SystemError> {
-    let s = s.trim();
-    //将s分解为数字和后缀部分
-    let (number_str,suffix) = match s.find(|c: char| !c.is_digit(10) && c != '.'){
-        Some(mid) => s.split_at(mid),
-        None => (s,"")
-    };
-
-    //获得数字部分的整数和小数部分
-    let (integer, fraction) = match number_str.find(".") {
-        Some(mid) => {
-            let (integer, fraction) = number_str.split_at(mid);
-            let integer = integer.parse::<u64>().unwrap();
-            let fraction = match fraction[1..].parse::<u64>() {
-                Ok(val) => val,
-                Err(_) => {
-                    return Err(SystemError::EINVAL);
+    /// @brief 解析Size
+    ///
+    /// 将传入的字符串解析为具体的字节数
+    /// 可支持IEC二进制后缀，也可支持SI十进制后缀
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @param base 设置为IEC二进制后缀或者SI十进制后缀
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_size(s: &str, base: SizeBase) -> Result<u64, ParseError> {
+        let s = s.trim();
+        //将s分解为数字和后缀部分
+        let (number_str, suffix) = match s.find(|c: char| !c.is_digit(10) && c != '.') {
+            Some(mid) => s.split_at(mid),
+            None => (s, ""),
+        };
+
+        //获得数字部分的整数和小数部分
+        let (integer, fraction) = match number_str.find(".") {
+            Some(mid) => {
+                let (integer, fraction) = number_str.split_at(mid);
+                let integer = integer.parse::<u64>().unwrap();
+                let fraction = match fraction[1..].parse::<u64>() {
+                    Ok(val) => val,
+                    Err(_) => {
+                        return Err(ParseError::EINVAL);
+                    }
+                };
+                (integer, fraction)
+            }
+            None => (number_str.parse::<u64>().unwrap(), 0),
+        };
+
+        //从表中查找到后缀所对应的字节倍数
+        let mut factor: u64 = 0;
+        if base == SizeBase::IEC {
+            factor = match BASE_IEC.get(suffix) {
+                Some(val) => *val,
+                None => {
+                    return Err(ParseError::EINVAL);
                 }
-            };
-            (integer,fraction)
-        }
-        None => (number_str.parse::<u64>().unwrap(),0)
-    };
-
-    //从表中查找到后缀所对应的字节倍数
-    let mut factor: u64 = 0;
-    if base == SizeBase::IEC {
-        factor = match BASE_IEC.iter().find(|mapper|mapper.suffix == suffix) {
-            Some(val) => val.factor,
-            None => {
-                return Err(SystemError::EINVAL);
             }
-        } 
-    } else if base == SizeBase::Si {
-        factor = match BASE_SI.iter().find(|mapper|mapper.suffix == suffix) {
-            Some(val) => val.factor,
-            None => {
-                return Err(SystemError::EINVAL);
+        } else if base == SizeBase::Si {
+            factor = match BASE_SI.get(suffix) {
+                Some(val) => *val,
+                None => {
+                    return Err(ParseError::EINVAL);
+                }
             }
-        } 
+        }
+
+        Ok(integer * factor + (fraction * factor) / (10u64.pow(fraction.to_string().len() as u32)))
     }
-    
-    Ok(integer*factor + (fraction*factor)/(10u64.pow(fraction.to_string().len() as u32)))
-}
 
-/// @brief 解析扇区大小
-/// 
-/// 将传入的字符串解析为具体的扇区大小
-/// 若扇区大小小于512或者大于4096,将会返回错误，若扇区大小不为2的幂，返回错误。
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_sector_size(s: &str) -> Result<u64,SystemError> {
-    let s = s.trim();
-    let size: u64 = match s.parse::<u64>(){
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+    /// @brief 解析扇区大小
+    ///
+    /// 将传入的字符串解析为具体的扇区大小
+    /// 若扇区大小小于512或者大于4096,将会返回错误，若扇区大小不为2的幂，返回错误。
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_sector_size(s: &str) -> Result<u64, ParseError> {
+        let s = s.trim();
+        let size: u64 = match s.parse::<u64>() {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+
+        if size < 512 || size > 4096 {
+            return Err(ParseError::ERANGE);
+        }
+
+        //判断是否为2的幂，如果不是则报错
+        if (size & (size - 1)) != 0 {
+            return Err(ParseError::EINVAL);
         }
-    };
 
-    if size < 512 || size > 4096 {
-        return Err(SystemError::ERANGE);
+        return Ok(size);
     }
 
-    //判断是否为2的幂，如果不是则报错
-    if (size & (size - 1)) != 0 {
-        return Err(SystemError::EINVAL);
-    }  
+    /// @brief 解析范围
+    ///
+    /// 将传入的字符串解析为具体的范围
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_range(s: &str) -> Result<(u32, u32), ParseError> {
+        let mid = match s.find('-') {
+            Some(val) => val,
+            None => {
+                //如果字符串中没有'-'符号，则表示一个值，所以范围两端都为该值
+                let s = s.trim();
+                let ret = match s.parse::<u32>() {
+                    Ok(val) => val,
+                    Err(_) => {
+                        return Err(ParseError::EINVAL);
+                    }
+                };
+                return Ok((ret, ret));
+            }
+        };
 
-    return Ok(size);
-}
+        //若字符串中存在'-'，则分别解析为u32，解析失败则报错
+        let (l, r) = s.split_at(mid);
 
-/// @brief 解析范围
-/// 
-/// 将传入的字符串解析为具体的范围
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_range(s: &str) -> Result<(u32,u32),SystemError> {
-    let mid = match s.find('-') {
-        Some(val) => val,
-        None =>{
-            //如果字符串中没有'-'符号，则表示一个值，所以范围两端都为该值
-            let s = s.trim();
-            let ret = match s.parse::<u32>() {
-                Ok(val) => val,
-                Err(_) => {
-                    return Err(SystemError::EINVAL);
-                }
-            };
-            return Ok((ret,ret));
+        let l = l.trim();
+        let l = match l.parse::<u32>() {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+        let r = r.trim();
+        let r = match r.parse::<u32>() {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+
+        return Ok((l, r));
+    }
+
+    /// @brief 解析文件描述符
+    ///
+    /// 将传入的字符串解析为文件描述符fd
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_fd(s: &str) -> Result<FileDescriptor, ParseError> {
+        let s = s.trim();
+        let fd = match s.parse::<i32>() {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+
+        if fd < 0 {
+            return Err(ParseError::EBADF);
         }
-    };
 
-    //若字符串中存在'-'，则分别解析为u32，解析失败则报错
-    let (l,r) = s.split_at(mid);
+        return Ok(FileDescriptor(fd as usize));
+    }
+
+    /// @brief 解析nice
+    ///
+    /// 将传入的字符串解析为nice
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_nice(s: &str) -> Result<i8, ParseError> {
+        let s = s.trim();
+        let nice = match s.parse::<i8>() {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
 
-    let l = l.trim();
-    let l = match l.parse::<u32>(){
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+        if nice > PRIO_MAX || nice < PRIO_MIN {
+            return Err(ParseError::ERANGE);
         }
-    };
-    let r = r.trim();
-    let r = match r.parse::<u32>(){
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+
+        return Ok(nice);
+    }
+
+    /// @brief 解析端口号
+    ///
+    /// 将传入的字符串解析为端口号
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(解析后的值)，否则返回Err
+    pub fn parse_ip_port(s: &str) -> Result<u16, ParseError> {
+        let s = s.trim();
+        let port = match s.parse::<u16>() {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+
+        if port == 0 {
+            return Err(ParseError::EINVAL);
         }
-    };
 
-    return Ok((l,r));
-}
+        return Ok(port);
+    }
 
-/// @brief 解析文件描述符
-/// 
-/// 将传入的字符串解析为文件描述符fd
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_fd(s: &str) -> Result<i32,SystemError> {
-    let s = s.trim();
-    let fd = match s.parse::<i32>() {
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+    /// @brief 解析端口范围
+    ///
+    /// 将传入的字符串解析为端口范围
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok((u16,u16))，否则返回Err
+    pub fn parse_ip_port_range(s: &str) -> Result<(u16, u16), ParseError> {
+        let (l, h) = Self::parse_range(s)?;
+
+        let l = l as u16;
+        let h = h as u16;
+        if l <= 0 || l >= 65535 || h <= 0 || h >= 65535 {
+            return Err(ParseError::EINVAL);
         }
-    };
 
-    if fd < 0 {
-        return Err(SystemError::EBADF);
+        return Ok((l, h));
     }
 
-    return Ok(fd);
-}
+    /// @brief 解析OOM（Out-of-Memory）分数调整值
+    ///
+    /// 将传入的字符串解析为OOM（Out-of-Memory）分数调整值
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(u32)，否则返回Err
+    pub fn parse_ip_prefix_length(s: &str) -> Result<u32, ParseError> {
+        let len = match s.parse::<u32>() {
+            Ok(val) => val,
+            Err(_) => {
+                return Err(ParseError::EINVAL);
+            }
+        };
 
-/// @brief 解析nice
-/// 
-/// 将传入的字符串解析为nice
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_nice(s: &str) -> Result<i8,SystemError> {
-    let s = s.trim();
-    let nice = match s.parse::<i8>() {
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+        if len > 128 {
+            return Err(ParseError::ERANGE);
         }
-    };
 
-    if nice > PRIO_MAX || nice < PRIO_MIN {
-        return Err(SystemError::ERANGE);
+        return Ok(len);
     }
 
-    return Ok(nice);
-}
-
-/// @brief 解析端口号
-/// 
-/// 将传入的字符串解析为端口号
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(解析后的值)，否则返回Err
-pub fn parse_ip_port(s: &str) -> Result<u16,SystemError> {
-    let s = s.trim();
-    let port = match s.parse::<u16>() {
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+    /// @brief 目前为简单的分割字符串，并未提供严谨的Url解析
+    ///
+    /// 将传入的字符串解析为Url结构体的Vec，若Url非法则返回错误
+    ///
+    /// @param s 需解析的字符串
+    ///
+    /// @return 解析成功则返回Ok(Url)，否则返回Err
+    pub fn parse_url(s: &str) -> Result<Vec<Url>, ParseError> {
+        let mut url = Url::default();
+        let url_strs = s.split_whitespace().collect::<Vec<&str>>();
+        let mut urls = Vec::new();
+        for s in url_strs {
+            urls.push(Url {
+                url_string: String::from(s),
+            })
         }
-    };
+        return Ok(urls);
+    }
 
-    if port == 0 {
-        return Err(SystemError::EINVAL);
+    /// @brief 将对应的str解析为对应Unit
+    ///
+    /// 将传入的字符串解析为Unit，解析失败返回错误
+    ///
+    /// @param path 需解析的文件
+    ///
+    /// @return 解析成功则返回Ok(Rc<dyn Unit>)，否则返回Err
+    pub fn parse_unit<T: Unit>(path: &str) -> Result<Rc<T>, ParseError> {
+        return T::from_path(path);
     }
 
-    return Ok(port);
-}
+    /// @brief 将对应的str解析为Rc<dyn Unit>
+    ///
+    /// 将传入的字符串解析为Rc<dyn Unit>，解析失败返回错误
+    ///
+    /// @param path 需解析的文件
+    ///
+    /// @return 解析成功则返回Ok(Rc<dyn Unit>)，否则返回Err
+    pub fn parse_unit_no_type(path: &str) -> Result<Rc<dyn Unit>, ParseError> {
+        let idx = match path.rfind('.') {
+            Some(val) => val,
+            None => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+
+        if idx == path.len() - 1 {
+            //处理非法文件xxxx. 类型
+            return Err(ParseError::EINVAL);
+        }
+
+        let suffix = &path[idx + 1..];
 
-/// @brief 解析端口范围
-/// 
-/// 将传入的字符串解析为端口范围
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok((u16,u16))，否则返回Err
-pub fn parse_ip_port_range(s: &str) -> Result<(u16,u16),SystemError> {
-    let (l,h) = parse_range(s)?;
-
-    let l = l as u16;
-    let h = h as u16;
-    if l <=0 || l >= 65535 || h <= 0 || h >= 65535 {
-        return Err(SystemError::EINVAL);
+        //通过文件后缀分发给不同类型的Unit解析器解析
+        let unit = match suffix {
+            "service" => ServiceParser::parse(path)?,
+            _ => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+
+        return Ok(unit);
     }
 
-    return Ok((l,h));
-}
+    /// @brief 将对应的str解析为对应CmdTask
+    ///
+    /// 将传入的字符串解析为CmdTask组，解析失败返回错误
+    ///
+    /// @param path 需解析的文件
+    ///
+    /// @return 解析成功则返回Ok(Vec<CmdTask>>)，否则返回Err
+    pub fn parse_cmd_task(s: &str) -> Result<Vec<CmdTask>, ParseError> {
+        //分拆成单词Vec
+        let cmds = s.split_whitespace().collect::<Vec<&str>>();
+        let mut tasks = Vec::new();
+        let mut i = 0;
+        while i < cmds.len() {
+            let mut cmd_task = CmdTask {
+                path: String::new(),
+                cmd: String::new(),
+                ignore: false,
+            };
+            //匹配到这里时，这个单词肯定是路径，若路径以-开头则设置ignore
+            cmd_task.ignore = cmds[i].starts_with('-');
+
+            //获取到一个CmdTask的路径部分
+            let mut path = "";
+            if cmd_task.ignore {
+                path = &cmds[i][1..];
+            } else {
+                path = &cmds[i];
+            }
+
+            //得到的非绝对路径则不符合语法要求，报错
+            if !UnitParseUtil::is_absolute_path(path) {
+                return Err(ParseError::EINVAL);
+            }
+
+            cmd_task.path = String::from(path);
 
-/// @brief 解析OOM（Out-of-Memory）分数调整值
-/// 
-/// 将传入的字符串解析为OOM（Out-of-Memory）分数调整值
-/// 
-/// @param s 需解析的字符串
-/// 
-/// @return 解析成功则返回Ok(u32)，否则返回Err
-pub fn parse_ip_prefix_length(s: &str) -> Result<u32,SystemError> {
-    let len = match s.parse::<u32>() {
-        Ok(val) => val,
-        Err(_) => {
-            return Err(SystemError::EINVAL);
+            //i += 1,继续匹配下一个单词
+            i += 1;
+            let mut cmd_str = String::new();
+            while i < cmds.len() && !UnitParseUtil::is_absolute_path(cmds[i]) {
+                //命令可能会有多个单词，将多个命令整理成一个
+                let cmd = cmds[i];
+                cmd_str = format!("{} {}", cmd_str, cmd);
+                i += 1;
+            }
+            cmd_task.cmd = cmd_str;
+            tasks.push(cmd_task);
+            //经过while到这里之后，cmds[i]对应的单词一点是路径，i不需要加一
         }
-    };
+        return Ok(tasks);
+    }
 
-    if len > 128 {
-        return Err(SystemError::ERANGE);
+    /// @brief 判断是否为绝对路径
+    ///
+    /// @param path 路径
+    ///
+    /// @return 解析成功则返回true，否则返回false
+    pub fn is_absolute_path(path: &str) -> bool {
+        let path = Path::new(path);
+        path.is_absolute()
     }
 
-    return Ok(len);
-}
+    /// @brief 将对应的str解析为us(微秒)
+    ///
+    /// 将传入的字符串解析为秒数，解析失败返回错误
+    ///
+    /// @param path 需解析的文件
+    ///
+    /// @return 解析成功则返回Ok(u64)，否则返回Err
+    pub fn parse_sec(s: &str) -> Result<u64, ParseError> {
+        //下列参数分别记录整数部分，小数部分以及单位
+        let mut integer: u64 = 0;
+        let mut frac: u64 = 0;
+        let mut unit: &str = "";
+
+        match s.find('.') {
+            Some(idx) => {
+                //解析整数部分
+                integer = match s[..idx].parse::<u64>() {
+                    Ok(val) => val,
+                    Err(_) => return Err(ParseError::EINVAL),
+                };
+                //获得小数+单位的字符串
+                let frac_and_unit = &s[(idx + 1)..];
+                match frac_and_unit.find(|c: char| !c.is_digit(10)) {
+                    Some(val) => {
+                        //匹配小数部分
+                        frac = match frac_and_unit[..val].parse::<u64>() {
+                            Ok(val) => val,
+                            Err(_) => return Err(ParseError::EINVAL),
+                        };
+                        //单位部分
+                        unit = &frac_and_unit[val..];
+                    }
+                    None => {
+                        //没有单位的情况，直接匹配小数
+                        frac = match frac_and_unit.parse::<u64>() {
+                            Ok(val) => val,
+                            Err(_) => return Err(ParseError::EINVAL),
+                        };
+                        unit = "";
+                    }
+                };
+            }
+            None => {
+                //没有小数点则直接匹配整数部分和单位部分
+                match s.find(|c: char| !c.is_digit(10)) {
+                    Some(idx) => {
+                        integer = match s[..idx].parse::<u64>() {
+                            Ok(val) => val,
+                            Err(_) => return Err(ParseError::EINVAL),
+                        };
+                        unit = &s[idx..];
+                    }
+                    None => {
+                        integer = match s.parse::<u64>() {
+                            Ok(val) => val,
+                            Err(_) => return Err(ParseError::EINVAL),
+                        };
+                        unit = "";
+                    }
+                };
+            }
+        };
+
+        //从时间单位转换表中获取到单位转换为ns的倍数
+        let factor = match SEC_UNIT_TABLE.get(unit) {
+            Some(val) => val,
+            None => {
+                return Err(ParseError::EINVAL);
+            }
+        };
+
+        //计算ns
+        return Ok(integer * factor + (frac * factor) / (10u64.pow(frac.to_string().len() as u32)));
+    }
+
+    /// @brief 判断对应路径是否为目录
+    ///
+    /// @param path 路径
+    ///
+    /// @return true/false
+    pub fn is_dir(path: &str) -> bool {
+        if let Ok(metadata) = fs::metadata(path) {
+            if metadata.is_dir() {
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
+}

src/task/cmdtask/mod.rs

@@ -0,0 +1,9 @@
+//use drstd as std;
+use std::string::String;
+
+#[derive(Debug)]
+pub struct CmdTask {
+    pub path: String,
+    pub cmd: String,
+    pub ignore: bool, //表示忽略这个命令的错误，即使它运行失败也不影响unit正常运作
+}

src/task/mod.rs

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

src/types.rs

@@ -1,2 +0,0 @@
-pub type pid_t = i32;
-pub type mode_t = u32;

src/unit/mod.rs

@@ -1,27 +1,58 @@
-use drstd::std as std;
+use crate::error::ParseError;
+use crate::parse::Segment;
+//use drstd as std;
+use std::any::Any;
+use std::boxed::Box;
+use std::rc::Rc;
 use std::string::String;
 use std::vec::Vec;
-use std::boxed::Box;
-use crate::error::SystemError;
 
-mod service;
-mod target;
+pub mod service;
+pub mod target;
 
 use self::target::TargetUnit;
 
 //所有可解析的Unit都应该实现该trait
 pub trait Unit {
-    fn parse(path: &str) -> Self where Self: Sized;
+    /// @brief 从文件获取到Unit,该函数是解析Unit文件的入口函数
+    ///
+    /// 从path解析Unit属性
+    ///
+    /// @param path 需解析的文件
+    ///
+    /// @return 解析成功则返回对应Unit的Rc指针，否则返回Err
+    fn from_path(path: &str) -> Result<Rc<Self>, ParseError>
+    where
+        Self: Sized;
+
+    fn as_any(&self) -> &dyn Any;
+
+    /// @brief 设置Unit属性
+    ///
+    /// 设置对应Unit属性
+    ///
+    /// @param segment  属性段类型
+    /// 
+    /// @param attr     属性名
+    /// 
+    /// @param val      属性值
+    ///
+    /// @return 设置成功则返回Ok(())，否则返回Err
+    fn set_attr(&mut self, segment: Segment, attr: &str, val: &str) -> Result<(), ParseError>;
 }
 
+//Unit状态
+#[derive(Clone, Copy, Debug)]
 enum UnitState {
     Enabled,
     Disabled,
     Static,
-    Masked
+    Masked,
 }
 
-enum UnitType {
+//Unit类型
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum UnitType {
     Automount,
     Device,
     Mount,
@@ -34,103 +65,130 @@ enum UnitType {
     Swap,
     Target,
     Timer,
+    Unknown,
 }
 
-//记录unit文件基本信息
-struct BaseUnit {
-    unit_part: UnitPart,
-    install_part: InstallPart,
-    state: UnitState,
-    unit_type: UnitType
+//记录unit文件基本信息，这个结构体里面的信息是所有Unit文件都可以有的属性
+pub struct BaseUnit {
+    pub unit_part: UnitPart,
+    pub install_part: InstallPart,
+    pub state: UnitState,
+    pub unit_type: UnitType,
 }
 
-// impl Default for BaseUnit {
-//     fn default() -> Self {
-//         // BaseUnit { 
-//         //     unit_part: UnitPart::default(), 
-//         //     install_part: InstallPart::default(), 
-//         //     state: , unit_type: () }
-//     }
-// }
-
-struct Url {
-    protocol: String,
-    host: String,
-    port: u16,
-    path: String,
-    query: Option<String>,
-    fragment: Option<String>,
+impl Default for BaseUnit {
+    fn default() -> Self {
+        BaseUnit {
+            unit_part: UnitPart::default(),
+            install_part: InstallPart::default(),
+            state: UnitState::Disabled,
+            unit_type: UnitType::Unknown,
+        }
+    }
 }
 
-impl Url {
-    fn new(url_string: &str) -> Result<Self, SystemError> {
-        // 解析 URL 字符串并初始化结构体字段
-        // ...
-
-        // 验证 URL 合法性
-        // ...
-
-        // 返回 URL 结构体实例
-        // ...
-        Err(SystemError::EINVAL)
+impl BaseUnit {
+    pub fn parse_and_set_attribute(&self) -> Result<(), ParseError> {
+        return Ok(());
     }
+}
 
-    fn build(&self) -> String {
-        // 构建 URL 字符串
-        // ...
-        String::new()
-    }
+#[derive(Default)]
+pub struct Url {
+    pub url_string: String, // pub protocol: String,
+                            // pub host: String,
+                            // pub port: Option<u16>,
+                            // pub path: String,
+                            // pub query: Option<String>,
+                            // pub fragment: Option<String>,
 }
 
-struct UnitPart {
-    description: String,
-    documentation: Vec<Url>,
-    requires: Vec<Box<dyn Unit>>,
-    wants: Vec<Box<dyn Unit>>,
-    after: Vec<Box<dyn Unit>>,
-    before: Vec<Box<dyn Unit>>,
-    binds_to: Vec<Box<dyn Unit>>,
-    part_of: Vec<Box<dyn Unit>>,
-    on_failure: Vec<Box<dyn Unit>>,
-    conflicts: Vec<Box<dyn Unit>>
+//对应Unit文件的Unit段
+pub struct UnitPart {
+    pub description: String,
+    pub documentation: Vec<Url>,
+    pub requires: Vec<Rc<dyn Unit>>,
+    pub wants: Vec<Rc<dyn Unit>>,
+    pub after: Vec<Rc<dyn Unit>>,
+    pub before: Vec<Rc<dyn Unit>>,
+    pub binds_to: Vec<Rc<dyn Unit>>,
+    pub part_of: Vec<Rc<dyn Unit>>,
+    pub on_failure: Vec<Rc<dyn Unit>>,
+    pub conflicts: Vec<Rc<dyn Unit>>,
 }
 
 impl Default for UnitPart {
     fn default() -> Self {
-        UnitPart { 
-            description: String::new(), 
-            documentation: Vec::new(), 
-            requires: Vec::new(), 
-            wants: Vec::new(), 
-            after: Vec::new(), 
-            before: Vec::new(), 
-            binds_to: Vec::new(), 
-            part_of: Vec::new(), 
-            on_failure: Vec::new(), 
-            conflicts: Vec::new() 
+        UnitPart {
+            description: String::new(),
+            documentation: Vec::new(),
+            requires: Vec::new(),
+            wants: Vec::new(),
+            after: Vec::new(),
+            before: Vec::new(),
+            binds_to: Vec::new(),
+            part_of: Vec::new(),
+            on_failure: Vec::new(),
+            conflicts: Vec::new(),
         }
     }
 }
 
-struct InstallPart {
-    wanted_by: Vec<TargetUnit>,
-    requires_by: Vec<TargetUnit>,
-    also: Vec<Box<dyn Unit>>,
-    alias: String
+//对应Unit文件的Install段
+pub struct InstallPart {
+    pub wanted_by: Vec<Rc<TargetUnit>>,
+    pub requires_by: Vec<Rc<TargetUnit>>,
+    pub also: Vec<Rc<dyn Unit>>,
+    pub alias: String,
 }
 
 impl Default for InstallPart {
     fn default() -> Self {
-        InstallPart { 
-            wanted_by: Vec::new(), 
-            requires_by: Vec::new(), 
-            also: Vec::new(), 
-            alias: String::new() 
+        InstallPart {
+            wanted_by: Vec::new(),
+            requires_by: Vec::new(),
+            also: Vec::new(),
+            alias: String::new(),
         }
     }
 }
 
-struct CmdTask{
-    path: String,
-    cmd: String
-}
+//对应Unit文件的各种属性
+pub enum BaseUnitAttr {
+    None,
+
+    //Unit段
+    //描述该Unit文件的信息
+    Description,
+    //指定服务文档
+    Documentation,
+    //依赖的其它 Unit 列表
+    Requires,
+    //这个 Unit 启动时，触发启动列出的每个 Unit 模块，而不去考虑这些模板启动是否成功
+    Wants,
+    //后面列出的所有模块全部启动完成以后，才会启动当前的服务
+    After,
+    //在启动指定的任务一个模块之间，都会首先确证当前服务已经运行
+    Before,
+    //这些Unit启动失败时该任务失败，都成功时该任务成功，在这些模板中有任意一个出现意外结束或重启时，这个服务也会跟着终止或重启
+    BindsTo,
+    //仅在列出的任务模块失败或重启时，终止或重启当前服务，而不会随列出模板的启动而启动
+    PartOf,
+    //当这个模板启动失败时，就会自动启动列出的每个模块
+    OnFailure,
+    //与这个模块有冲突的模块，如果列出的模块中有已经在运行的，这个服务就不能启动，反之亦然
+    Conflicts,
+}
+
+pub enum InstallUnitAttr {
+    None,
+    //Install段
+    //依赖当前服务的模块。当前 Unit 激活时（enable）符号链接会放入 /etc/systemd/system 目录下面以 <Target 名> + .wants 后缀构成的子目录中
+    WantedBy,
+    //依赖当前服务的模块。当前 Unit 激活时（enable）符号链接会放入 /etc/systemd/system 目录下面以 <Target 名> + .required 后缀构成的子目录中
+    RequiredBy,
+    //当前 Unit enable/disable 时，同时 enable/disable 的其他 Unit
+    Also,
+    //别名
+    Alias,
+}

src/unit/service/mod.rs

@@ -1,69 +1,153 @@
-use super::{Unit, UnitPart, BaseUnit};
-use drstd::std as std;
+use super::{BaseUnit, Unit};
+use crate::error::ParseError;
+use crate::parse::parse_service::ServiceParser;
+use crate::parse::{AttrParse, Segment};
+use crate::task::cmdtask::CmdTask;
+//use drstd as std;
+use std::rc::Rc;
 use std::string::String;
 use std::vec::Vec;
-use crate::error::SystemError;
-
-use crate::unit::CmdTask;
-
-struct ServiceUnit{
-    unit_base: BaseUnit,
-    service_part: ServicePart
+#[derive(Default)]
+pub struct ServiceUnit {
+    pub unit_base: BaseUnit,
+    pub service_part: ServicePart,
 }
 
-enum ServiceType {
+#[derive(Debug)]
+pub enum ServiceType {
     Simple,
     Forking,
     OneShot,
     Dbus,
     Notify,
-    Idle
+    Idle,
+}
+
+impl Default for ServiceType {
+    fn default() -> Self {
+        ServiceType::Simple
+    }
 }
 
-enum RestartOption {
+#[derive(Debug)]
+pub enum RestartOption {
     AlwaysRestart,
     OnSuccess,
     OnFailure,
     OnAbnormal,
     OnAbort,
-    OnWatchdog
+    OnWatchdog,
+    None,
 }
 
-enum MountFlag {
+impl Default for RestartOption {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
+#[derive(Debug)]
+pub enum MountFlag {
     Shared,
     Slave,
-    Private
+    Private,
+}
+
+impl Default for MountFlag {
+    fn default() -> Self {
+        Self::Private
+    }
 }
 
-struct ServicePart {
+#[derive(Default, Debug)]
+pub struct ServicePart {
     //生命周期相关
-    service_type: ServiceType,
-    /// 
-    remain_after_exit: bool,
-    exec_start: Vec<CmdTask>,
-    exec_start_pre: Vec<CmdTask>,
-    exec_start_pos: Vec<CmdTask>,
-    exec_reload: Vec<CmdTask>,
-    exec_stop: Vec<CmdTask>,
-    exec_stop_post: Vec<CmdTask>,
-    restart_sec: u32,
-    restart: RestartOption,
-    timeout_start_sec: u32,
-    timeout_stop_sec: u32,
+    pub service_type: ServiceType,
+    ///
+    pub remain_after_exit: bool,
+    pub exec_start: Vec<CmdTask>,
+    pub exec_start_pre: Vec<CmdTask>,
+    pub exec_start_pos: Vec<CmdTask>,
+    pub exec_reload: Vec<CmdTask>,
+    pub exec_stop: Vec<CmdTask>,
+    pub exec_stop_post: Vec<CmdTask>,
+    pub restart_sec: u64,
+    pub restart: RestartOption,
+    pub timeout_start_sec: u64,
+    pub timeout_stop_sec: u64,
     //上下文配置相关
-    environment: String,
-    environment_file: String,
-    nice: i8,
-    working_directory: String,
-    root_directory: String,
-    user: String,
-    group: String,
-    mount_flags: MountFlag,
+    pub environment: String,
+    pub environment_file: String,
+    pub nice: i8,
+    pub working_directory: String,
+    pub root_directory: String,
+    pub user: String,
+    pub group: String,
+    pub mount_flags: MountFlag,
     //LimitCPU / LimitSTACK / LimitNOFILE / LimitNPROC 等,后续支持再添加
 }
 
 impl Unit for ServiceUnit {
-    fn parse(path: &str) -> Self {
-        
+    fn as_any(&self) -> &dyn core::any::Any {
+        self
     }
-}
+
+    fn from_path(path: &str) -> Result<Rc<Self>, ParseError>
+    where
+        Self: Sized,
+    {
+        return ServiceParser::parse(path);
+    }
+
+    fn set_attr(&mut self, segment: Segment, attr: &str, val: &str) -> Result<(), ParseError> {
+        if segment != Segment::Service {
+            return Err(ParseError::EINVAL);
+        }
+        return ServiceParser::parse_and_set_attribute(self, attr, val);
+    }
+}
+
+pub enum ServiceUnitAttr {
+    None,
+    //Service段
+    //定义启动时的进程行为
+    Type,
+    //
+    RemainAfterExit,
+    //启动命令
+    ExecStart,
+    //启动当前服务之前执行的命令
+    ExecStartPre,
+    //启动当前服务之后执行的命令
+    ExecStartPos,
+    //重启当前服务时执行的命令
+    ExecReload,
+    //停止当前服务时执行的命令
+    ExecStop,
+    //停止当其服务之后执行的命令
+    ExecStopPost,
+    //自动重启当前服务间隔的秒数
+    RestartSec,
+    //定义何种情况 Systemd 会自动重启当前服务
+    Restart,
+    //启动服务时等待的秒数
+    TimeoutStartSec,
+    //停止服务时的等待秒数，如果超过这个时间仍然没有停止，应该使用 SIGKILL 信号强行杀死服务的进程
+    TimeoutStopSec,
+    //为服务指定环境变量
+    Environment,
+    //指定加载一个包含服务所需的环境变量的列表的文件，文件中的每一行都是一个环境变量的定义
+    EnvironmentFile,
+    //服务的进程优先级，值越小优先级越高，默认为 0。其中 -20 为最高优先级，19 为最低优先级
+    Nice,
+    //指定服务的工作目录
+    WorkingDirectory,
+    //指定服务进程的根目录（/ 目录）。如果配置了这个参数，服务将无法访问指定目录以外的任何文件
+    RootDirectory,
+    //指定运行服务的用户
+    User,
+    //指定运行服务的用户组
+    Group,
+    //服务的 Mount Namespace 配置，会影响进程上下文中挂载点的信息
+    MountFlags,
+}

src/unit/target/mod.rs

@@ -1,17 +1,38 @@
-use drstd::std as std;
-use std::vec::Vec;
+use super::{BaseUnit, Unit};
+use crate::error::ParseError;
+use crate::parse::Segment;
+use core::ops::Deref;
+//use drstd as std;
 use std::boxed::Box;
+use std::rc::Rc;
+use std::vec::Vec;
 
-use super::{Unit, BaseUnit};
-
-
+#[derive(Default)]
 pub struct TargetUnit {
     unit_base: BaseUnit,
-    targets: Vec<Box<dyn Unit>>
+    targets: Vec<Rc<dyn Unit>>,
+}
+
+impl Deref for TargetUnit {
+    type Target = TargetUnit;
+    fn deref(&self) -> &Self::Target {
+        &self
+    }
 }
 
 impl Unit for TargetUnit {
-    fn parse(path: &str) -> Self {
-        
+    fn as_any(&self) -> &dyn core::any::Any {
+        self
+    }
+
+    fn from_path(path: &str) -> Result<Rc<Self>, ParseError>
+    where
+        Self: Sized,
+    {
+        Ok(Rc::new(TargetUnit::default()))
     }
-}
+
+    fn set_attr(&mut self, segement: Segment, attr: &str, val: &str) -> Result<(), ParseError> {
+        Ok(())
+    }
+}

target.json

@@ -0,0 +1,32 @@
+{
+    "arch": "x86_64",
+    "code-model": "kernel",
+    "cpu": "x86-64",
+    "os": "dragonos",
+    "target-endian": "little",
+    "target-pointer-width": "64",
+    "target-c-int-width": "32",
+    "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128",
+    "disable-redzone": true,
+    "features": "-3dnow,-3dnowa,-avx,-avx2",
+    "linker": "rust-lld",
+    "linker-flavor": "ld.lld",
+    "llvm-target": "x86_64-unknown-none",
+    "max-atomic-width": 64,
+    "panic-strategy": "abort",
+    "position-independent-executables": true,
+    "relro-level": "full",
+    "stack-probes": {
+        "kind": "inline-or-call",
+        "min-llvm-version-for-inline": [
+            16,
+            0,
+            0
+        ]
+    },
+    "static-position-independent-executables": true,
+    "supported-sanitizers": [
+        "kcfi"
+    ],
+    "target-pointer-width": "64"
+}