fix error & update 1.0.4

Author: zhangzijie-pro

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "command"
-version = "1.0.3"
+version = "1.0.4"
 edition = "2021" 
 authors = ["Zhangzijie <[email protected]>"]
 repository = "https://github.com/zhangzijie-pro/Tiks.git"

command/Cargo.toml

@@ -6,7 +6,6 @@
 // There is some error or other suggestions contact me : [email protected]
 // Cargo run
 
-
 use command::env::init_env;
 use command::run::init_shell;
 use command::start::start_logo::start_logo;

command/bin/main.rs

@@ -125,7 +125,6 @@ pub fn execute_command(command: &str, option: &str, arg: &Vec<String>, session_c
                 _=>{
                     if session_context.user_state.root.check_permission() {
                         session_context.user_state.exit_root();
-                        println!("Switched to root mode: {}", session_context.user_state.root.check_permission());
                     } else {
                         std::process::exit(0);
                     }
@@ -145,7 +144,7 @@ pub fn execute_command(command: &str, option: &str, arg: &Vec<String>, session_c
             }
             _=>Ok((0,"help:\n  -i|-install: install package \n  -u|-update: update this version".to_string()))
         },
-        //
+        "export" => set(&arg[0], &arg[1]),
         "whoami" => whoami(session_context),
         "pd" => match option{  // match arg empty
             "-f"|"-fix" => match arg.is_empty(){
@@ -173,7 +172,7 @@ pub fn execute_other_command(command: &str, option: &str, arg: &[String]) -> Res
     match command {
         "help" => Ok((0,help())),
         "pwd" => pwd(),
-        "time" => get_time(),
+        "time" => Ok(get_time()),
         "history" => history(),
         // test C define here
         "hello_c" => {

command/src/commands/arg.rs

@@ -465,11 +465,11 @@ pub fn sudo(session_context: &mut SessionContext)->io::Result<(usize,String)>{
 
 
 // get time
-pub fn get_time() -> io::Result<(usize,String)>{
+pub fn get_time() -> (usize,String){
     let now = chrono::Local::now();
     let time = now.format("%Y-%m-%d %H:%M:%S").to_string();
 
-    Ok((STATUE_CODE,time))
+    (STATUE_CODE,time)
 }
 
 // grep
@@ -538,7 +538,7 @@ pub fn pipe(command:Vec<String>) -> io::Result<(usize,String)>{
 }
 
 // &&
-pub fn and(command:Vec<String>,session_context: &mut SessionContext) -> Vec<String>{
+pub fn and(command:Vec<String>,session_context: &mut SessionContext) -> Vec<(usize,String)>{
     let mut output:Vec<_> = Vec::new();
     let commands = command.split(|x| x=="&&");
     for c in commands{
@@ -550,7 +550,7 @@ pub fn and(command:Vec<String>,session_context: &mut SessionContext) -> Vec<Stri
 }
 
 // &
-pub fn priority_run(command:Vec<String>,session_context: &mut SessionContext) -> Vec<String>{
+pub fn priority_run(command:Vec<String>,session_context: &mut SessionContext) -> Vec<(usize,String)>{
     let mut output:Vec<_> = Vec::new();
     let commands = command.split(|x| x=="&");
     let mut save_command = Vec::new();

command/src/commands/command.rs

@@ -7,4 +7,11 @@ pub mod signal;
 mod priority;
 pub mod env;
 mod test;
-pub mod start;
+pub mod start;
+mod tauri_func;
+
+pub use crate::root::SESSION;
+pub use crate::start::*;
+pub use crate::tauri_func::run_command;
+pub use crate::commands::command::{HISTROY,history_push,pwd,whoami,get_time};
+pub use crate::set::set::home_dir;

command/src/lib.rs

@@ -1,5 +1,4 @@
 // build root
-
 pub struct UserState{
     pub root: UserRole
 }

command/src/root.rs

@@ -28,8 +28,10 @@ pub fn handle_command(args: Vec<String>) -> (Commands,usize,usize,CommandPriorit
 }
 
 
-pub fn run(args: Vec<String>,session_context: &mut SessionContext) -> String{
-    let (commands,pid,tid,priority) = handle_command(args);
+pub fn run<T>(input: T,session_context: &mut SessionContext) -> (usize,String)
+where Vec<String>: From<T>
+{
+    let (commands,pid,tid,priority) = handle_command(input.into());
     let semaphore = semaphore_new();
     let mut tcb = ThreadControlBlock::new();
     let mut pcb = ProcessManager::new();
@@ -49,17 +51,17 @@ pub fn run(args: Vec<String>,session_context: &mut SessionContext) -> String{
         "ps" => {
             pcb.kill(pid);
             tcb.stop_thread(priority_tid);
-            ps()
+            (tid,ps())
         }
         "kill" => {
             tcb.stop_thread(priority_tid);
             pcb.kill(pid);
-            pcb.kill(arg[0].parse::<usize>().unwrap())
+            (tid,pcb.kill(arg[0].parse::<usize>().unwrap()))
         },
         "sleep" => {
             pcb.kill(pid);
             tcb.stop_thread(priority_tid);
-            sleep(&mut tcb, commands.arg[0].parse::<usize>().unwrap())
+            (tid,sleep(&mut tcb, commands.arg[0].parse::<usize>().unwrap()))
         }
         _ =>{
             // start process and thread
@@ -70,41 +72,36 @@ pub fn run(args: Vec<String>,session_context: &mut SessionContext) -> String{
                     let status = res.0.clone();
                     let result = res.1.clone();
                     if status==0{
-                        //println!("[{}] Done\n{}",tid,result);
                         pcb.kill(pid);
                         tcb.stop_thread(priority_tid);
-                        result
+                        (tid,result)
                     }else{
-                        error_log(res.1.clone());
-                        res.1
+                        error_log(res.1.clone());  
+                        (tid,result)
                     }
-                }else{String::new()}
+                }else{(tid,String::from("Error: Not found"))}
             } else if !session_context.user_state.root.check_permission() && !session_context.root.allowed_commands.contains(&commands.command) {
                 // Execute normal commands
                 // Handle commands normally when user is not in root mode
                 if let Ok(res) = command_match(commands, session_context) {
                     let status = res.0.clone();
                     let result = res.1.clone();
                     if status==0{
-                        //println!("[{}] Done\n{}",tid,result);
                         pcb.kill(pid);
                         tcb.stop_thread(priority_tid);
-                        result
+                        (tid,result)
                     }else{
                         error_log(res.1.clone());
-                        //println!("{}",res.1);
-                        result
+                        (tid,result)
                     }
                 }else {
-                    String::new()
+                    (tid,String::from("Error: Not found"))
                 }
             }else{
-                eprintln!("Permission not support");
-                String::new()
+                (tid,String::from("Error: Permission not support"))
             }
         }
     }
-    
 }
 
 
@@ -147,20 +144,21 @@ pub fn init_shell(session_context: &mut SessionContext){
                     let args: Box<Vec<String>> = Box::new(line.split_whitespace().map(|s| s.to_string()).collect());
                     if args.contains(&"&&".to_string()) {
                         let res = and(*args, session_context);
-                        for r in res{
-                            println!("Done[1]: {r}")
+                        for (t,r) in res{
+                            println!("Done[{t}]: \n{r}")
                         }
                     } else if args.contains(&"|".to_string()) {
-                        let s = pipe(*args).unwrap();
-                        println!("{}", s.1);
+                        let res = pipe(*args).unwrap();
+                        println!("{}",res.1)
                     } else if args.contains(&"&".to_string()) {
                         let res = priority_run(*args, session_context);
-                        for r in res{
-                            println!("Done[1]: {r}")
+                        for (t,r) in res{
+                            println!("Done[{t}]: \n{r}")
+
                         }
                     } else {
-                        let res = run(*args, session_context);
-                        println!("{res}")
+                        let (t,res) = run(*args, session_context);
+                        println!("Done[{t}]: \n{res}")
                     }
 
                 }

command/src/run.rs

@@ -105,7 +105,7 @@ fn get_home_err() -> String{
 }
 
 pub fn error_log(err: String){
-    let time = get_time().unwrap().1;
+    let time = get_time().1;
     let home_path = get_home_err();
     let path = Path::new(&home_path);
 
@@ -134,4 +134,9 @@ pub fn error_log(err: String){
         return;
     }
     // error.log -> $HOME/.Tiks/error.log -> [time]: [Error]
+}
+
+pub fn home_dir() -> String{
+    let binding= dirs::home_dir().unwrap();
+    binding.as_os_str().to_str().map(|x| x.to_string()).unwrap()
 }

command/src/set/set.rs

@@ -0,0 +1,89 @@
+use crate::root::SessionContext;
+use crate::commands::arg::{split, Commands,command_match};
+use crate::process::{add_task::*, ps, sleep};
+use crate::process::process::ProcessManager;
+use crate::process::thread::ThreadControlBlock;
+use crate::run::handle_command;
+use crate::set::set::error_log;
+use crate::signal::semaphore_new;
+
+#[allow(dead_code)]
+pub fn string_to_command(string: String) -> Commands{
+    Commands::from_string(string)
+}
+
+pub fn run_command<T>(input: T,session_context: &mut SessionContext) -> (usize,String)
+where Vec<String>: From<T>
+{
+    let (commands,pid,tid,priority) = handle_command(input.into());
+    let semaphore = semaphore_new();
+    let mut tcb = ThreadControlBlock::new();
+    let mut pcb = ProcessManager::new();
+
+
+    let (command,_option,arg) = split(commands.clone());
+
+    add_command_to_thread(tid, command.clone(), priority, &mut tcb);
+    add_thread_to_process(pid, command.clone(), tcb.clone(), semaphore, &mut pcb);
+    
+    let priority_tid = tcb.get_highest_priority_thread().unwrap();
+    tcb.start_thread(priority_tid);
+    pcb.start_process(pid);
+
+    
+    match command.as_str(){
+        "ps" => {
+            pcb.kill(pid);
+            tcb.stop_thread(priority_tid);
+            (tid,ps())
+        }
+        "kill" => {
+            tcb.stop_thread(priority_tid);
+            pcb.kill(pid);
+            (tid,pcb.kill(arg[0].parse::<usize>().unwrap()))
+        },
+        "sleep" => {
+            pcb.kill(pid);
+            tcb.stop_thread(priority_tid);
+            (tid,sleep(&mut tcb, commands.arg[0].parse::<usize>().unwrap()))
+        }
+        _ =>{
+            // start process and thread
+            if session_context.user_state.root.check_permission(){
+                // Execute root commands
+                // Handle commands differently when user is in root mode
+                if let Ok(res) = command_match(commands, session_context){
+                    let status = res.0.clone();
+                    let result = res.1.clone();
+                    if status==0{
+                        pcb.kill(pid);
+                        tcb.stop_thread(priority_tid);
+                        (tid,result)
+                    }else{
+                        error_log(res.1.clone());  
+                        (tid,result)
+                    }
+                }else{(tid,String::from("Error: Not found"))}
+            } else if !session_context.user_state.root.check_permission() && !session_context.root.allowed_commands.contains(&commands.command) {
+                // Execute normal commands
+                // Handle commands normally when user is not in root mode
+                if let Ok(res) = command_match(commands, session_context) {
+                    let status = res.0.clone();
+                    let result = res.1.clone();
+                    if status==0{
+                        pcb.kill(pid);
+                        tcb.stop_thread(priority_tid);
+                        (tid,result)
+                    }else{
+                        error_log(res.1.clone());
+                        (tid,result)
+                    }
+                }else {
+                    (tid,String::from("Error: Not found"))
+                }
+            }else{
+                (tid,String::from("Error: Permission not support"))
+            }
+        }
+    }
+}