hardware_report 0.1.7

Hardware inventory reports for observability and cluster acceptance testing
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

/*
Copyright 2024 San Francisco Compute Company

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

//! Example of using the hardware_report library
//!
//! This demonstrates both the new Ports & Adapters API and the legacy compatibility.

use hardware_report::{new_domain::HardwareReport, ReportConfig, ServerInfo};
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    println!("Hardware Report Library Usage Examples");
    println!("======================================");

    // Example 1: Legacy API (backward compatibility)
    println!("\n1. Using Legacy API:");
    match ServerInfo::collect() {
        Ok(server_info) => {
            println!("   Hostname: {}", server_info.hostname);
            println!("   CPU: {}", server_info.summary.cpu_summary);
            println!("   Memory: {}", server_info.summary.total_memory);
            println!("   Storage: {}", server_info.summary.total_storage);
        }
        Err(e) => {
            println!("   Error: {}", e);
        }
    }

    // Example 2: New Domain Types (can convert between old and new)
    println!("\n2. Type Conversion:");
    match ServerInfo::collect() {
        Ok(legacy_info) => {
            // Convert legacy to new format
            let new_report: HardwareReport = legacy_info.into();
            println!("   Converted to new format:");
            println!(
                "   System: {} ({})",
                new_report.hostname, new_report.summary.system_info.product_name
            );
            println!("   CPUs: {}", new_report.summary.total_gpus);
        }
        Err(e) => {
            println!("   Error: {}", e);
        }
    }

    // Example 3: New Configuration Options
    println!("\n3. New Configuration API:");
    let config = ReportConfig {
        include_sensitive: false,
        skip_sudo: true,
        command_timeout: 10,
        verbose: false,
    };
    println!(
        "   Created config with timeout: {} seconds",
        config.command_timeout
    );

    // Example 4: Pure parsing functions
    println!("\n4. Pure Parsing Functions:");
    use hardware_report::new_domain::parsers::cpu::parse_lscpu_output;

    let sample_lscpu = r#"Model name:                      Intel(R) Core(TM) i7-10875H CPU @ 2.30GHz
CPU(s):                          16
Thread(s) per core:              2
Core(s) per socket:              8
Socket(s):                       1
CPU MHz:                         2300.000"#;

    match parse_lscpu_output(sample_lscpu) {
        Ok(cpu_info) => {
            println!("   Parsed CPU: {}", cpu_info.model);
            println!(
                "   Cores: {}, Threads: {}, Sockets: {}",
                cpu_info.cores, cpu_info.threads, cpu_info.sockets
            );
        }
        Err(e) => {
            println!("   Parse error: {}", e);
        }
    }

    println!("\n✅ All examples completed successfully!");
    println!("\nNote: The new service factory will be available in Phase 4");
    println!("      For now, use ServerInfo::collect() for actual hardware detection");

    Ok(())
}