nu 0.1.2

A shell for the GitHub era
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

use crate::errors::ShellError;
use crate::object::base::OF64;
use crate::object::SpannedDictBuilder;
use crate::object::{Primitive, Value};
use crate::prelude::*;
use sys_info::*;
use sysinfo::{ComponentExt, DiskExt, NetworkExt, RefreshKind, SystemExt};

pub fn sysinfo(args: CommandArgs) -> Result<OutputStream, ShellError> {
    let mut idx = SpannedDictBuilder::new(args.name_span);

    if let (Ok(name), Ok(version)) = (os_type(), os_release()) {
        let mut os_idx = SpannedDictBuilder::new(args.name_span);
        os_idx.insert("name", Primitive::String(name));
        os_idx.insert("version", Primitive::String(version));

        idx.insert_spanned("os", os_idx.into_spanned_value());
    }

    if let (Ok(num_cpu), Ok(cpu_speed)) = (cpu_num(), cpu_speed()) {
        let mut cpu_idx = SpannedDictBuilder::new(args.name_span);
        cpu_idx.insert("num", Primitive::Int(num_cpu as i64));
        cpu_idx.insert("speed", Primitive::Int(cpu_speed as i64));

        idx.insert_spanned("cpu", cpu_idx);
    }

    if let Ok(x) = loadavg() {
        let mut load_idx = SpannedDictBuilder::new(args.name_span);

        load_idx.insert("1min", Primitive::Float(OF64::from(x.one)));
        load_idx.insert("5min", Primitive::Float(OF64::from(x.five)));
        load_idx.insert("15min", Primitive::Float(OF64::from(x.fifteen)));

        idx.insert_spanned("load avg", load_idx);
    }

    if let Ok(x) = mem_info() {
        let mut mem_idx = SpannedDictBuilder::new(args.name_span);

        mem_idx.insert("total", Primitive::Bytes(x.total as u64 * 1024));
        mem_idx.insert("free", Primitive::Bytes(x.free as u64 * 1024));
        mem_idx.insert("avail", Primitive::Bytes(x.avail as u64 * 1024));
        mem_idx.insert("buffers", Primitive::Bytes(x.buffers as u64 * 1024));
        mem_idx.insert("cached", Primitive::Bytes(x.cached as u64 * 1024));
        mem_idx.insert("swap total", Primitive::Bytes(x.swap_total as u64 * 1024));
        mem_idx.insert("swap free", Primitive::Bytes(x.swap_free as u64 * 1024));

        idx.insert_spanned("mem", mem_idx);
    }

    /*
    if let Ok(x) = disk_info() {
        let mut disk_idx = indexmap::IndexMap::new();
        disk_idx.insert(
            "total".to_string(),
            Value::Primitive(Primitive::Bytes(x.total as u128 * 1024)),
        );
        disk_idx.insert(
            "free".to_string(),
            Value::Primitive(Primitive::Bytes(x.free as u128 * 1024)),
        );
    }
    */

    if let Ok(x) = hostname() {
        idx.insert("hostname", Primitive::String(x));
    }

    #[cfg(not(windows))]
    {
        if let Ok(x) = boottime() {
            let mut boottime_idx = SpannedDictBuilder::new(args.name_span);
            boottime_idx.insert("days", Primitive::Int(x.tv_sec / (24 * 3600)));
            boottime_idx.insert("hours", Primitive::Int((x.tv_sec / 3600) % 24));
            boottime_idx.insert("mins", Primitive::Int((x.tv_sec / 60) % 60));

            idx.insert_spanned("uptime", boottime_idx);
        }
    }

    let system = sysinfo::System::new_with_specifics(RefreshKind::everything().without_processes());
    let components_list = system.get_components_list();
    if components_list.len() > 0 {
        let mut v: Vec<Spanned<Value>> = vec![];
        for component in components_list {
            let mut component_idx = SpannedDictBuilder::new(args.name_span);
            component_idx.insert("name", Primitive::String(component.get_label().to_string()));
            component_idx.insert(
                "temp",
                Primitive::Float(OF64::from(component.get_temperature() as f64)),
            );
            component_idx.insert(
                "max",
                Primitive::Float(OF64::from(component.get_max() as f64)),
            );
            if let Some(critical) = component.get_critical() {
                component_idx.insert("critical", Primitive::Float(OF64::from(critical as f64)));
            }
            v.push(component_idx.into());
        }
        idx.insert("temps", Value::List(v));
    }

    let disks = system.get_disks();
    if disks.len() > 0 {
        let mut v = vec![];

        for disk in disks {
            let mut disk_idx = SpannedDictBuilder::new(args.name_span);
            disk_idx.insert("name", Value::string(disk.get_name().to_string_lossy()));
            disk_idx.insert("available", Value::bytes(disk.get_available_space()));
            disk_idx.insert("total", Value::bytes(disk.get_total_space()));
            v.push(disk_idx.into());
        }

        idx.insert("disks", Value::List(v));
    }

    let network = system.get_network();
    let incoming = network.get_income();
    let outgoing = network.get_outcome();

    let mut network_idx = SpannedDictBuilder::new(args.name_span);
    network_idx.insert("incoming", Value::bytes(incoming));
    network_idx.insert("outgoing", Value::bytes(outgoing));
    idx.insert_spanned("network", network_idx);

    let stream = stream![idx.into_spanned_value()];

    Ok(stream.from_input_stream())
}