lhm-client 0.3.0

Client for using the LHM service
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

use lhm_client::{ComputerOptions, HardwareType, LHMClient, SensorType};

#[tokio::main]
async fn main() {
    println!("Connected to client");
    let client = LHMClient::connect().await.unwrap();

    // Set the computer options
    println!("Set options");
    client
        .set_options(ComputerOptions {
            controller_enabled: true,
            cpu_enabled: true,
            gpu_enabled: true,
            motherboard_enabled: true,
            battery_enabled: true,
            memory_enabled: true,
            network_enabled: true,
            psu_enabled: true,
            storage_enabled: true,
        })
        .await
        .unwrap();

    // Perform update to load hardware
    println!("Updated hardware");
    client.update_all().await.unwrap();

    // Request all hardware
    println!("Query hardware");
    let mut hardware = client
        .query_hardware(None, Some(HardwareType::Memory))
        .await
        .unwrap();

    let memory = hardware.first_mut().expect("missing memory hardware");

    println!("Query sensors");
    let sensors = client
        .query_sensors(Some(memory.identifier.clone()), None)
        .await
        .unwrap();

    let memory_used_sensor = sensors
        .iter()
        .find(|sensor| matches!(sensor.ty, SensorType::Data) && sensor.name.eq("Memory Used"))
        .expect("missing memory used");
    let memory_used_gb = memory_used_sensor.value;

    let memory_available_sensor = sensors
        .iter()
        .find(|sensor| matches!(sensor.ty, SensorType::Data) && sensor.name.eq("Memory Available"))
        .expect("missing memory available");
    let memory_available_gb = memory_available_sensor.value;

    let virt_memory_used_sensor = sensors
        .iter()
        .find(|sensor| {
            matches!(sensor.ty, SensorType::Data) && sensor.name.eq("Virtual Memory Used")
        })
        .expect("missing virtual memory used");
    let virt_memory_used_gb = virt_memory_used_sensor.value;

    let virt_memory_available_sensor = sensors
        .iter()
        .find(|sensor| {
            matches!(sensor.ty, SensorType::Data) && sensor.name.eq("Virtual Memory Available")
        })
        .expect("missing virtual memory available");
    let virt_memory_available_gb = virt_memory_available_sensor.value;

    println!("Memory Available: {memory_available_gb:.2}GB");
    println!("Memory Used: {memory_used_gb:.2}GB");

    println!("Virtual Memory Available: {virt_memory_available_gb:.2}GB");
    println!("Virtual Memory Used: {virt_memory_used_gb:.2}GB");
}