zouni 0.2.1

Variety of functions that `std` does not offer or `std` offers but are not satisfiable
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use serde::{Deserialize, Serialize};
use shared_child::SharedChild;
#[cfg(target_os = "windows")]
use std::os::windows::process::CommandExt;
use std::{
    collections::HashMap,
    io::Read,
    process::{Command, Stdio},
    sync::{
        atomic::{AtomicU16, Ordering},
        Arc, LazyLock, Mutex,
    },
};
#[cfg(target_os = "windows")]
use windows::Win32::System::Threading::CREATE_NO_WINDOW;

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SpawnOption {
    pub program: String,
    pub args: Option<Vec<String>>,
    pub cancellation_token: Option<String>,
}

#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct CommandStatus {
    pub success: bool,
    pub code: Option<i32>,
    pub error: Option<String>,
}

#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct Output {
    pub status: CommandStatus,
    pub stdout: String,
    pub stderr: String,
}

impl Output {
    fn error(code: Option<i32>, error: Option<String>) -> Self {
        Self {
            status: CommandStatus {
                success: false,
                code,
                error,
            },
            ..Default::default()
        }
    }
}

static CHILDREN: LazyLock<Mutex<HashMap<String, Arc<SharedChild>>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
static UUID: AtomicU16 = AtomicU16::new(0);

pub async fn spawn(option: SpawnOption) -> Result<Output, Output> {
    let mut command = Command::new(option.program);
    if let Some(args) = option.args {
        command.args(args);
    }
    command.stdout(Stdio::piped());
    command.stderr(Stdio::piped());

    #[cfg(windows)]
    command.creation_flags(CREATE_NO_WINDOW.0);

    let token = if let Some(token) = option.cancellation_token {
        token
    } else {
        UUID.fetch_add(1, Ordering::Relaxed).to_string()
    };

    let child = SharedChild::spawn(&mut command).map_err(|e| Output::error(e.raw_os_error(), Some(e.to_string())))?;
    {
        CHILDREN.lock().unwrap().insert(token.clone(), Arc::new(child));
    }

    smol::spawn(async move {
        let mut children = CHILDREN.lock().unwrap();
        let child = children.get(&token).unwrap();
        match child.wait() {
            Ok(exit_status) => {
                let stdout = if let Some(mut out) = child.take_stdout() {
                    let mut buf = String::new();
                    out.read_to_string(&mut buf).map_err(|e| Output::error(e.raw_os_error(), Some(e.to_string())))?;
                    buf
                } else {
                    String::new()
                };

                let stderr = if let Some(mut out) = child.take_stderr() {
                    let mut buf = String::new();
                    out.read_to_string(&mut buf).map_err(|e| Output::error(e.raw_os_error(), Some(e.to_string())))?;
                    buf
                } else {
                    String::new()
                };

                children.remove(&token);

                let result = Output {
                    status: CommandStatus {
                        success: exit_status.success(),
                        code: exit_status.code(),
                        error: None,
                    },
                    stderr,
                    stdout,
                };

                if exit_status.success() {
                    Ok(result)
                } else {
                    Err(result)
                }
            }
            Err(e) => Err(Output {
                status: CommandStatus {
                    success: false,
                    code: e.raw_os_error(),
                    error: Some(e.to_string()),
                },
                stderr: String::new(),
                stdout: String::new(),
            }),
        }
    })
    .await
}

pub fn kill(cancellation_token: String) -> Result<(), String> {
    if let Ok(mut children) = CHILDREN.try_lock() {
        if children.contains_key(&cancellation_token) {
            children.get_mut(&cancellation_token).unwrap().kill().map_err(|e| e.to_string())?;
            children.remove(&cancellation_token);
        }
    }

    Ok(())
}

pub fn clear() {
    let children = {
        let mut lock = CHILDREN.lock().unwrap();
        std::mem::take(&mut *lock)
    };
    for child in children.into_values() {
        let _ = child.kill();
    }
}