nu_command/system/
uname.rs

1use nu_engine::command_prelude::*;
2use nu_protocol::{record, Value};
3
4#[derive(Clone)]
5pub struct UName;
6
7impl Command for UName {
8    fn name(&self) -> &str {
9        "uname"
10    }
11
12    fn signature(&self) -> Signature {
13        Signature::build("uname")
14            .input_output_types(vec![(Type::Nothing, Type::table())])
15            .category(Category::System)
16    }
17
18    fn description(&self) -> &str {
19        "Print certain system information using uutils/coreutils uname."
20    }
21
22    fn search_terms(&self) -> Vec<&str> {
23        // add other terms?
24        vec!["system", "coreutils"]
25    }
26
27    fn run(
28        &self,
29        _engine_state: &EngineState,
30        _stack: &mut Stack,
31        call: &Call,
32        _input: PipelineData,
33    ) -> Result<PipelineData, ShellError> {
34        let span = call.head;
35        // Simulate `uname -all` is called every time
36        let opts = uu_uname::Options {
37            all: true,
38            kernel_name: false,
39            nodename: false,
40            kernel_release: false,
41            kernel_version: false,
42            machine: false,
43            processor: false,
44            hardware_platform: false,
45            os: false,
46        };
47        let output = uu_uname::UNameOutput::new(&opts).map_err(|e| ShellError::GenericError {
48            error: format!("{}", e),
49            msg: format!("{}", e),
50            span: None,
51            help: None,
52            inner: Vec::new(),
53        })?;
54        let outputs = [
55            output.kernel_name,
56            output.nodename,
57            output.kernel_release,
58            output.kernel_version,
59            output.machine,
60            output.os,
61        ];
62        let outputs = outputs
63            .iter()
64            .map(|name| {
65                Ok(name
66                    .as_ref()
67                    .ok_or("unknown")
68                    .map_err(|_| ShellError::NotFound { span })?
69                    .to_string())
70            })
71            .collect::<Result<Vec<String>, ShellError>>()?;
72        Ok(PipelineData::Value(
73            Value::record(
74                record! {
75                    "kernel-name" => Value::string(outputs[0].clone(), span),
76                    "nodename" => Value::string(outputs[1].clone(), span),
77                    "kernel-release" => Value::string(outputs[2].clone(), span),
78                    "kernel-version" => Value::string(outputs[3].clone(), span),
79                    "machine" => Value::string(outputs[4].clone(), span),
80                    "operating-system" => Value::string(outputs[5].clone(), span),
81                },
82                span,
83            ),
84            None,
85        ))
86    }
87
88    fn examples(&self) -> Vec<Example> {
89        vec![Example {
90            description: "Print all information",
91            example: "uname",
92            result: None,
93        }]
94    }
95}