os_info 3.14.0

Detect the operating system type and version.
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

use std::process::Command;

use log::error;
use nix::sys::utsname::uname as nix_uname;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[allow(dead_code)]
pub enum UnameField {
    Sysname,
    Release,
    Version,
    Machine,
    Nodename,
    OperatingSystem,
}

impl UnameField {
    fn cli_arg_name(&self) -> &'static str {
        match self {
            UnameField::Sysname => "-s",
            UnameField::Release => "-r",
            UnameField::Version => "-v",
            UnameField::Machine => "-m",
            UnameField::Nodename => "-n",
            UnameField::OperatingSystem => "-o",
        }
    }

    fn supports_uname_syscall(&self) -> bool {
        self != &UnameField::OperatingSystem
    }

    fn get_from_syscall(&self) -> Option<String> {
        if !self.supports_uname_syscall() {
            return None;
        }

        let utsname = match nix_uname() {
            Ok(utsname) => utsname,
            Err(e) => {
                log::error!("Failed to invoke native uname: {e:?}");
                return None;
            }
        };

        let val_os = match self {
            UnameField::Sysname => utsname.sysname(),
            UnameField::Release => utsname.release(),
            UnameField::Version => utsname.version(),
            UnameField::Machine => utsname.machine(),
            UnameField::Nodename => utsname.nodename(),
            UnameField::OperatingSystem => return None,
        };

        let val = val_os.to_str();
        if val.is_none() {
            error!("Failed to convert uname value to string: {val_os:?}");
            return None;
        }

        val.map(String::from)
    }
}

pub fn uname(field: UnameField) -> Option<String> {
    field
        .get_from_syscall()
        .or_else(|| uname_cli(field.cli_arg_name()))
}

fn uname_cli(arg: &str) -> Option<String> {
    Command::new("uname")
        .arg(arg)
        .output()
        .map_err(|e| {
            error!("Failed to invoke 'uname {}': {:?}", arg, e);
        })
        .ok()
        .and_then(|out| {
            if out.status.success() {
                Some(String::from_utf8_lossy(&out.stdout).trim_end().to_owned())
            } else {
                error!("'uname {}' failed with status: {:?}", arg, out.status);
                None
            }
        })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn uname_nonempty() {
        let val = uname(UnameField::Sysname).expect("uname failed");
        assert!(!val.is_empty());
    }
}