service运行逻辑及其生命周期 (#12)

* 完成整体Unit文件的解析框架，完成对Service文件的解析

* 完成Service的解析，重构代码结构，优化解析错误处理

* update

* 简要的启动逻辑

* 简要的启动逻辑

* 重构整体数据结构，解决之前出现的问题

* 启动shell（不完善）

* 细化service各生命周期操作

* 细化service生命周期，能够从DragonOS中读取服务配置文件

Makefile

@@ -1,7 +1,7 @@
 OUTPUT_DIR = $(DADK_BUILD_CACHE_DIR_DRAGONREACH_0_1_0)
 
 build:
-	cargo -Z build-std=core,alloc,compiler_builtins build --target ./target.json > build.txt
+	cargo -Z build-std=core,alloc,compiler_builtins build --target ./target.json
 
 install:
 	cp ./parse_test/shell.service $(ROOT_PATH)/bin/sysroot/etc/reach/system/shell.service

parse_test/shell.service

@@ -3,6 +3,6 @@ Description=Shell
 
 [Service]
 Type=simple
-ExecStart=/bin/shell.el
+ExecStart=/bin/shell.elf
 Restart=always
 RestartSec=5000

src/executor/mod.rs

@@ -15,7 +15,7 @@ use crate::{
 
 use self::dep_graph::DepGraph;
 
-#[derive(Debug,Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum ExitStatus {
     Success,
     Failure,
@@ -26,12 +26,12 @@ pub enum ExitStatus {
 
 impl ExitStatus {
     /// ## 从错误码获得退出状态
-    /// 
+    ///
     /// 注意，该方法只会返回Success(exit_code == 0)和Abnormal(exit_code != 0)两种状态
     /// 其他DragonReach定义的退出状态需要手动指定
-    /// 
+    ///
     /// ### return Success(exit_code == 0)、Abnormal(exit_code != 0)
-    pub fn from_exit_code(exit_code: i32) -> Self{
+    pub fn from_exit_code(exit_code: i32) -> Self {
         match exit_code {
             0 => return Self::Success,
             _ => return Self::Abnormal,

src/executor/service_executor/mod.rs

@@ -71,74 +71,25 @@ impl ServiceExecutor {
             }
         }
 
-        //获取环境变量
-        //先获取指定的环境变量
-        let mut envs = Vec::from(service.service_part().environment());
-
-        //若指定了环境变量文件，则解析环境变量文件
-        let env_file = service.service_part().environment_file();
-        if env_file.len() > 0 {
-            let env_reader = match UnitParser::get_reader(env_file, UnitType::Unknown) {
-                Ok(reader) => reader,
-                Err(_) => {
-                    return Err(RuntimeError::new(RuntimeErrorType::Custom(
-                        "Incorrect environment variable configuration file".to_string(),
-                    )));
-                }
-            };
-            for line in env_reader.lines() {
-                if let Ok(line) = line {
-                    let x = match UnitParseUtil::parse_env(line.as_str()) {
-                        Ok(v) => v,
-                        Err(_) => {
-                            return Err(RuntimeError::new(RuntimeErrorType::Custom(
-                                "Failed to parse environment variable configuration file"
-                                    .to_string(),
-                            )));
-                        }
-                    };
-                    envs.push(x);
-                }
-            }
-        }
-
-        //服务配置环境变量，配置工作目录
-        //获取工作目录
-        let mut dir = service.service_part().working_directory();
-        if dir.is_empty() {
-            dir = "/";
-        }
         //获取启动命令
         let exec_start = service.service_part().exec_start();
         println!("exec:{}", exec_start.path);
-        //处理ExecStartsPre,准备在服务启动前执行的命令
+
         //TODO:设置uid与gid
-        let cmds = service.service_part().exec_start_pre().clone();
-        let proc = unsafe {
-            Command::new(&exec_start.path)
-                .args(&exec_start.cmd)
-                .current_dir(dir)
-                .envs(envs)
-                .stderr(Stdio::inherit())
-                .stdout(Stdio::inherit())
-                .stdin(Stdio::inherit())
-                .pre_exec(move || {
-                    for cmdtask in cmds.clone() {
-                        match cmdtask.exec() {
-                            Ok(_) => (),
-                            Err(e) => {
-                                eprintln!("{}", e.error_format());
-                                return Err(Error::new(
-                                    ErrorKind::Interrupted,
-                                    "ExecStartPreFailed",
-                                ));
-                            }
-                        };
-                    }
-                    Ok(())
-                })
-                .spawn()
-        };
+
+        //处理ExecStartsPre,准备在服务启动前执行的命令
+        Self::exec_start_pre(service)?;
+
+        //创建服务进程
+        //服务配置环境变量，配置工作目录
+        let proc = Command::new(&exec_start.path)
+            .args(&exec_start.cmd)
+            .current_dir(service.service_part().working_directory())
+            .envs(Vec::from(service.service_part().environment()))
+            .stderr(Stdio::inherit())
+            .stdout(Stdio::inherit())
+            .stdin(Stdio::inherit())
+            .spawn();
 
         match proc {
             Ok(p) => {
@@ -185,7 +136,21 @@ impl ServiceExecutor {
     fn exec_start_pos(service: &ServiceUnit) -> Result<(), RuntimeError> {
         let cmds = service.service_part().exec_start_pos();
         for cmd in cmds {
-            cmd.exec()?;
+            cmd.spawn(
+                service.service_part().working_directory().to_string(),
+                service.service_part().environment(),
+            )?;
+        }
+        Ok(())
+    }
+
+    fn exec_start_pre(service: &ServiceUnit) -> Result<(), RuntimeError> {
+        let cmds = service.service_part().exec_start_pre();
+        for cmd in cmds {
+            cmd.spawn(
+                service.service_part().working_directory().to_string(),
+                service.service_part().environment(),
+            )?;
         }
         Ok(())
     }
@@ -194,7 +159,10 @@ impl ServiceExecutor {
     fn exec_stop(service: &mut ServiceUnit) -> Result<(), RuntimeError> {
         let cmds = service.service_part().exec_stop();
         for cmd in cmds {
-            cmd.exec()?;
+            cmd.no_spawn(
+                service.service_part().working_directory().to_string(),
+                service.service_part().environment(),
+            )?;
         }
         Ok(())
     }
@@ -203,7 +171,10 @@ impl ServiceExecutor {
     fn exec_stop_post(service: &mut ServiceUnit) -> Result<(), RuntimeError> {
         let cmds = service.service_part().exec_stop_post();
         for cmd in cmds {
-            cmd.exec()?;
+            cmd.no_spawn(
+                service.service_part().working_directory().to_string(),
+                service.service_part().environment(),
+            )?;
         }
         Ok(())
     }
@@ -211,7 +182,10 @@ impl ServiceExecutor {
     fn exec_reload(service: &mut ServiceUnit) -> Result<(), RuntimeError> {
         let cmds = service.service_part().exec_reload();
         for cmd in cmds {
-            cmd.exec()?;
+            cmd.no_spawn(
+                service.service_part().working_directory().to_string(),
+                service.service_part().environment(),
+            )?;
         }
         Ok(())
     }

src/main.rs

@@ -41,52 +41,6 @@ const DRAGON_REACH_UNIT_DIR: &'static str = "/etc/reach/system/";
 #[cfg(target_os = "dragonos")]
 #[no_mangle]
 fn main() {
-    // use parse::UnitParser;
-
-    // use crate::{
-    //     executor::Executor,
-    //     manager::{Manager, UnitManager},
-    //     parse::parse_util::UnitParseUtil,
-    // };
-    // let id = ServiceUnit::from_path("/etc/reach/system/shell.service").unwrap();
-
-    // if id != 0 {
-    //     let unit = UnitManager::get_unit_with_id(&id).unwrap();
-    //     if let Err(e) = Executor::exec(&unit) {
-    //         eprintln!("Err:{}", e.error_format());
-    //     }
-    // }
-
-    // loop{
-
-    // }
-
-    //================================
-    // use std::process::Command;
-    // use std::process::Stdio;
-    // let proc = unsafe {
-    //     Command::new("/bin/shell.elf")
-    //         .stderr(Stdio::inherit())
-    //         .stdout(Stdio::inherit())
-    //         .stdin(Stdio::inherit())
-    //         .spawn()
-    // };
-
-    // match proc {
-    //     Ok(p) => {
-    //         println!("Service running...");
-    //     }
-    //     Err(err) => {
-    //         eprintln!(": Service startup failed: {}",err);
-    //     }
-    // }
-
-    // loop {
-
-    // }
-
-    //========================================
-
     use parse::UnitParser;
 
     use crate::{
@@ -100,17 +54,17 @@ fn main() {
     if let Ok(entries) = fs::read_dir(DRAGON_REACH_UNIT_DIR) {
         for entry in entries {
             if let Ok(entry) = entry {
-                let filename = entry.file_name();
-                let filename = filename.to_str().unwrap();
-                units_file_name.push(filename.to_string());
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_file() {
+                        let filename = entry.file_name();
+                        let filename = filename.to_str().unwrap();
+                        units_file_name.push(filename.to_string());
+                    }
+                }
             }
         }
     }
 
-    units_file_name.push(String::from("shell.service"));
-
-    println!("files: {:?}", units_file_name);
-
     //启动服务
     for path in units_file_name {
         let id = match UnitParser::from_path(&path) {
@@ -152,22 +106,22 @@ fn main() {
     };
 
     let mut units_file_name = Vec::new();
-    // //读取目录里面的unit文件
-    // if let Ok(entries) = fs::read_dir(DRAGON_REACH_UNIT_DIR) {
-    //     for entry in entries {
-    //         if let Ok(entry) = entry {
-    //             if let Ok(file_type) = entry.file_type() {
-    //                 if file_type.is_file() {
-    //                     let filename = entry.file_name();
-    //                     let filename = filename.to_str().unwrap();
-    //                     units_file_name.push(filename.to_string());
-    //                 }
-    //             }
-    //         }
-    //     }
-    // }
-
-    units_file_name.push("/home/heyicong/DragonReach/parse_test/test.service");
+    //读取目录里面的unit文件
+    if let Ok(entries) = fs::read_dir("/bin") {
+        for entry in entries {
+            if let Ok(entry) = entry {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_file() {
+                        let filename = entry.file_name();
+                        let filename = filename.to_str().unwrap();
+                        //units_file_name.push(filename.to_string());
+                    }
+                }
+            }
+        }
+    }
+  
+    units_file_name.push("/home/heyicong/DragonReach/parse_test/test.service".to_string());
 
     //启动服务
     for path in units_file_name {
@@ -195,7 +149,7 @@ fn main() {
         Manager::check_running_status();
         //println!(".");
 
-        let t = time.elapsed().as_secs_f64();
-        println!("{}",t);
+        let t = time.elapsed().as_micros();
+        //println!("{}",t);
     }
 }

src/manager/mod.rs

@@ -39,10 +39,7 @@ impl Manager {
                     eprintln!("unit error: {}", e);
 
                     //test
-                    exited_unit.push((
-                        *unit.id(),
-                        ExitStatus::from_exit_code(!0),
-                    ));
+                    exited_unit.push((*unit.id(), ExitStatus::from_exit_code(!0)));
 
                     //从表中去除该任务
                     dead_unit.push(*unit.id());

src/manager/unit_manager/mod.rs

@@ -23,12 +23,15 @@ lazy_static! {
 
     // id到unit的映射表，全局的Unit管理表
     static ref ID_TO_UNIT_MAP: RwLock<HashMap<usize,Arc<Mutex<dyn Unit>>>> = RwLock::new(HashMap::new());
-    
+
     // 辅助表，通过服务名映射其id
     static ref PATH_TO_UNIT_MAP: RwLock<HashMap<u64,usize>> = RwLock::new(HashMap::new());
 
     // 全局运行中的Unit表
     pub(super) static ref RUNNING_TABLE: RwLock<RunningTableManager> = RwLock::new(RunningTableManager { running_table: Vec::new() });
+
+    // CMD进程表，用于处理Unit的CMD派生进程(ExecStartPre等命令派生进程)
+    pub(super) static ref CMD_PROCESS_TABLE: RwLock<HashMap<u32,Mutex<Child>>> = RwLock::new(HashMap::new());
 }
 
 pub struct RunningTableManager {
@@ -146,38 +149,49 @@ impl UnitManager {
         }
     }
 
-    pub fn contains_id(id: &usize) -> bool{
+    pub fn contains_id(id: &usize) -> bool {
         ID_TO_UNIT_MAP.read().unwrap().contains_key(id)
     }
 
-    pub fn pop_a_idle_service() -> Option<Arc<Mutex<dyn Unit>>>{
+    pub fn pop_a_idle_service() -> Option<Arc<Mutex<dyn Unit>>> {
         let id = IDLE_SERVIEC_DEQUE.lock().unwrap().pop_front();
         match id {
             Some(id) => {
                 return Self::get_unit_with_id(&id);
             }
-            None =>{
+            None => {
                 return None;
             }
         }
     }
 
-    pub fn push_a_idle_service(id: usize){
+    pub fn push_a_idle_service(id: usize) {
         if !Self::contains_id(&id) {
             return;
         }
         IDLE_SERVIEC_DEQUE.lock().unwrap().push_back(id);
     }
 
-    pub fn push_flag_running(id: usize){
+    pub fn push_flag_running(id: usize) {
         let mut t = FLAG_RUNNING.write().unwrap();
-        if t.contains(&id){
+        if t.contains(&id) {
             return;
         }
         t.push(id);
     }
 
-    pub fn running_count() -> usize{
+    pub fn running_count() -> usize {
         return RUNNING_TABLE.read().unwrap().running_table.len();
     }
+
+    pub fn push_cmd_proc(proc: Child) {
+        CMD_PROCESS_TABLE
+            .write()
+            .unwrap()
+            .insert(proc.id(), Mutex::new(proc));
+    }
+
+    pub fn remove_cmd_proc(id: u32) {
+        CMD_PROCESS_TABLE.write().unwrap().remove(&id);
+    }
 }

src/parse/parse_util/mod.rs

@@ -10,8 +10,8 @@ use crate::{
 use drstd as std;
 
 use std::{
-    any::Any, format, fs, os::unix::prelude::PermissionsExt, path::Path, print, println,
-    string::String, string::ToString, sync::Arc, vec, vec::Vec,
+    any::Any, format, fs, io::BufRead, os::unix::prelude::PermissionsExt, path::Path, print,
+    println, string::String, string::ToString, sync::Arc, vec, vec::Vec,
 };
 
 use super::{
@@ -707,4 +707,18 @@ impl UnitParseUtil {
         }
         UnitType::Unknown
     }
+
+    pub fn parse_environment_file(env_file: &str) -> Result<Vec<(String, String)>, ParseError> {
+        let mut envs = Vec::new();
+        if env_file.len() > 0 {
+            let env_reader = UnitParser::get_reader(env_file, UnitType::Unknown)?;
+            for line in env_reader.lines() {
+                if let Ok(line) = line {
+                    let x = UnitParseUtil::parse_env(line.as_str())?;
+                    envs.push(x);
+                }
+            }
+        }
+        return Ok(envs);
+    }
 }

src/task/cmdtask/mod.rs

@@ -1,9 +1,17 @@
 #[cfg(target_os = "dragonos")]
 use drstd as std;
 
-use std::{print,println,eprint, eprintln, process::Command, string::String, vec::Vec};
+use std::{
+    eprint, eprintln, print, println,
+    process::{Child, Command},
+    string::String,
+    vec::Vec,
+};
 
-use crate::error::runtime_error::{RuntimeError, RuntimeErrorType};
+use crate::{
+    error::runtime_error::{RuntimeError, RuntimeErrorType},
+    manager::UnitManager,
+};
 
 #[derive(Debug, Clone, Default)]
 pub struct CmdTask {
@@ -13,15 +21,37 @@ pub struct CmdTask {
 }
 
 impl CmdTask {
-    pub fn exec(&self) -> Result<(), RuntimeError> {
-        let result = Command::new(&self.path).args(&self.cmd).output();
+    pub fn spawn(&self, dir: String, envs: &[(String, String)]) -> Result<(), RuntimeError> {
+        let result = Command::new(&self.path)
+            .args(&self.cmd)
+            .current_dir(dir)
+            .envs(Vec::from(envs))
+            .spawn();
+        match result {
+            Ok(proc) => {
+                UnitManager::push_cmd_proc(proc);
+            }
+            Err(err) => {
+                if !self.ignore {
+                    eprintln!("{}: Command failed: {}", self.path, err);
+                    return Err(RuntimeError::new(RuntimeErrorType::ExecFailed));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub fn no_spawn(&self, dir: String, envs: &[(String, String)]) -> Result<(), RuntimeError> {
+        let result = Command::new(&self.path)
+            .args(&self.cmd)
+            .current_dir(dir)
+            .envs(Vec::from(envs))
+            .output();
         match result {
             Ok(output) => {
-                let stdout = String::from_utf8_lossy(&output.stdout);
-                print!("{}",stdout);
-                if !output.status.success() && !self.ignore {
-                    let stderr = String::from_utf8_lossy(&output.stderr);
-                    eprintln!("{}: Command failed: {}", self.path, stderr);
+                print!("{}", String::from_utf8_lossy(&output.stdout));
+                eprint!("{}", String::from_utf8_lossy(&output.stderr));
+                if !output.status.success() {
                     return Err(RuntimeError::new(RuntimeErrorType::ExecFailed));
                 }
             }

src/unit/mod.rs

@@ -96,11 +96,9 @@ pub trait Unit: Sync + Send + Debug {
     }
 
     /// ## Unit退出后逻辑
-    /// 
+    ///
     /// 一般只有可运行的Unit(如Service)需要重写此函数
-    fn after_exit(&mut self,exit_status: ExitStatus){
-
-    }
+    fn after_exit(&mut self, exit_status: ExitStatus) {}
 }
 
 //Unit状态

src/unit/service/mod.rs

@@ -3,6 +3,7 @@ use crate::error::runtime_error::{RuntimeError, RuntimeErrorType};
 use crate::error::{parse_error::ParseError, parse_error::ParseErrorType};
 use crate::executor::ExitStatus;
 use crate::executor::service_executor::ServiceExecutor;
+use crate::executor::ExitStatus;
 use crate::manager::UnitManager;
 use crate::parse::graph::Graph;
 use crate::parse::parse_service::ServiceParser;
@@ -18,12 +19,23 @@ use std::rc::Rc;
 use std::string::String;
 use std::sync::Arc;
 use std::vec::Vec;
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug)]
 pub struct ServiceUnit {
     unit_base: BaseUnit,
     service_part: ServicePart,
 }
 
+impl Default for ServiceUnit {
+    fn default() -> Self {
+        let mut sp = ServicePart::default();
+        sp.working_directory = String::from("/");
+        Self {
+            unit_base: BaseUnit::default(),
+            service_part: sp,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub enum ServiceType {
     Simple,
@@ -40,15 +52,15 @@ impl Default for ServiceType {
     }
 }
 
-#[derive(Debug, Clone, Copy,PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum RestartOption {
-    AlwaysRestart,  //总是重启
-    OnSuccess,  //在该服务正常退出时
-    OnFailure,  //在该服务启动失败时
-    OnAbnormal, //在该服务以非0错误码退出时
-    OnAbort,    //在该服务显示退出时(通过DragonReach手动退出)
-    OnWatchdog, //定时观测进程无响应时(当前未实现)
-    None,       //不重启
+    AlwaysRestart, //总是重启
+    OnSuccess,     //在该服务正常退出时
+    OnFailure,     //在该服务启动失败时
+    OnAbnormal,    //在该服务以非0错误码退出时
+    OnAbort,       //在该服务显示退出时(通过DragonReach手动退出)
+    OnWatchdog,    //定时观测进程无响应时(当前未实现)
+    None,          //不重启
 }
 
 impl Default for RestartOption {
@@ -58,27 +70,27 @@ impl Default for RestartOption {
 }
 
 impl RestartOption {
-    pub fn is_restart(&self,exit_status: &ExitStatus) -> bool{
-        if *self == Self::AlwaysRestart{
+    pub fn is_restart(&self, exit_status: &ExitStatus) -> bool {
+        if *self == Self::AlwaysRestart {
             return true;
         }
 
-        match (*self,*exit_status) {
-            (Self::OnSuccess,ExitStatus::Success) =>{
+        match (*self, *exit_status) {
+            (Self::OnSuccess, ExitStatus::Success) => {
                 return true;
-            },
-            (Self::OnAbnormal,ExitStatus::Abnormal) =>{
+            }
+            (Self::OnAbnormal, ExitStatus::Abnormal) => {
                 return true;
-            },
-            (Self::OnAbort,ExitStatus::Abort) =>{
+            }
+            (Self::OnAbort, ExitStatus::Abort) => {
                 return true;
-            },
-            (Self::OnFailure,ExitStatus::Failure) =>{
+            }
+            (Self::OnFailure, ExitStatus::Failure) => {
                 return true;
-            },
-            (Self::OnWatchdog,ExitStatus::Watchdog) =>{
+            }
+            (Self::OnWatchdog, ExitStatus::Watchdog) => {
                 return true;
-            },
+            }
             _ => {
                 return false;
             }
@@ -117,7 +129,6 @@ pub struct ServicePart {
     timeout_stop_sec: u64,
     //上下文配置相关
     environment: Vec<(String, String)>,
-    environment_file: String,
     nice: i8,
     working_directory: String,
     root_directory: String,
@@ -175,8 +186,8 @@ impl Unit for ServiceUnit {
         return &mut self.unit_base;
     }
 
-    fn after_exit(&mut self,exit_status: ExitStatus) {
-        ServiceExecutor::after_exit(self,exit_status);
+    fn after_exit(&mut self, exit_status: ExitStatus) {
+        ServiceExecutor::after_exit(self, exit_status);
     }
 }
 
@@ -306,7 +317,8 @@ impl ServicePart {
                 if !UnitParseUtil::is_valid_file(val) {
                     return Err(ParseError::new(ParseErrorType::EFILE, String::new(), 0));
                 }
-                self.environment_file = String::from(val);
+                self.environment
+                    .extend(UnitParseUtil::parse_environment_file(val)?);
             }
             ServiceUnitAttr::Nice => {
                 self.nice = UnitParseUtil::parse_nice(val)?;
@@ -394,10 +406,6 @@ impl ServicePart {
         &self.environment
     }
 
-    pub fn environment_file(&self) -> &str {
-        &self.environment_file
-    }
-
     pub fn nice(&self) -> i8 {
         self.nice
     }