src/report.rs - master - teterkin/vm_load_testing

src/report.rs
174 строки5 KB
alexefan136
upload files
12 ноя 2025, 22:51
12 ноя 2025, 22:51cedcf6a
// src/report.rs

use crate::cpu::CpuResult;
use crate::memory::MemoryResult;
use crate::disk::DiskResult;
use crate::network::NetworkResult;
use crate::system::SystemInfo;
use crate::extra::ExtraInfo;

#[derive(Debug)]
pub struct BenchmarkReport {
    pub system: SystemInfo,
    pub extra: ExtraInfo,
    pub cpu: CpuResult,
    pub memory: MemoryResult,
    pub disk: Option<DiskResult>,
    pub network: NetworkResult,
    pub timestamp: String,
}

pub fn generate_markdown(report: &BenchmarkReport) -> String {
    let disk_section = if let Some(d) = &report.disk {
        format!(
            r#"## Disk Performance

- **Size**: {:.1} MiB
- **Sequential Write**: {:.1} MiB/s
- **Sequential Read**: {:.1} MiB/s
- **Random Read (4K)**: {:.0} IOPS
- **Random Write (4K)**: {:.0} IOPS
- **Fsync Latency**: {:.2} ms
- **Storage Type**: {}

"#,
            d.test_file_size_bytes as f64 / (1024.0 * 1024.0),
            d.sequential_write_mib_s,
            d.sequential_read_mib_s,
            d.random_read_iops,
            d.random_write_iops,
            d.fsync_latency_ms,
            d.storage_type
        )
    } else {
        "## Disk Performance\n- Skipped (disk test disabled or failed)\n\n".to_string()
    };

    let interfaces = if report.network.interface_info.is_empty() {
        "N/A".to_string()
    } else {
        report.network.interface_info
            .iter()
            .map(|iface| {
                format!(
                    "  - **{}**: MTU={} (Driver: {})",
                    iface.name,
                    iface.mtu,
                    iface.driver.as_deref().unwrap_or("unknown")
                )
            })
            .collect::<Vec<_>>()
            .join("\n")
    };

    format!(
        r#"# Cloud VM Benchmark Report

> Generated on {}  

## 🖥️ System Overview

- **Hostname**: {}
- **OS**: {} {}
- **Kernel**: {}
- **Architecture**: {}
- **Virtualization**: {}
- **Uptime**: {} sec
- **CGroup Version**: {}
- **Secure Boot**: {}

## ⚙️ Hardware Summary

### CPU
- **Model**: {}
- **Logical Cores**: {}
- **Physical Cores**: {}
- **Base Frequency**: {} MHz
- **SHA256 Perf**: {:.0} ops/sec
- **Features**: AVX2={}, AES-NI={}

### Memory
- **Total RAM**: {} MiB
- **Tested Size**: {} MiB
- **Write Bandwidth**: {:.2} GiB/s
- **Read Bandwidth**: {:.2} GiB/s
- **Latency**: {:.1} ns
- **Checksum**: 0x{:016x}

### Storage
{}

## 🌐 Network

- **TCP RTT to 1.1.1.1**: {:.2} ms
- **HTTP Download (100 MiB)**: {:.2} MiB/s
- **Interfaces**:
{}

## ℹ️ Additional System Info

- **Kernel Command Line**: `{}`
- **Disks**:
{}

---

> This report is **cloud-provider agnostic**. Use it to compare VMs across AWS, Azure, GCP, Yandex Cloud, OpenStack, etc.
> All benchmarks are self-contained and leave no persistent side effects.

Report ID: `vm-benchmark-{}`  
Tool: Rust-based `vm-benchmark`
"#,
        report.timestamp,
        report.system.hostname,
        report.system.os_name,
        report.system.os_version,
        report.system.kernel_version,
        report.system.architecture,
        report.system.virtualization.as_deref().unwrap_or("none"),
        report.extra.uptime_seconds,
        report.extra.cgroup_version,
        if report.extra.secure_boot { "enabled" } else { "disabled" },
        // CPU
        report.system.cpu_model,
        report.cpu.logical_cores,
        report.cpu.physical_cores,
        report.cpu.base_frequency_mhz.unwrap_or(0),
        report.cpu.ops_per_sec,
        report.cpu.has_avx2,
        report.cpu.has_aes,
        // Memory
        report.system.total_ram_mib,
        report.memory.tested_size_mib,
        report.memory.write_bandwidth_gib_s,
        report.memory.read_bandwidth_gib_s,
        report.memory.latency_ns,
        report.memory.checksum,
        // Disk
        disk_section,
        // Network
        report.network.tcp_rtt_ms,
        report.network.http_dl_mib_s,
        interfaces,
        // Extra
        report.extra.kernel_cmdline,
        // Disks list
        if report.system.disks.is_empty() {
            "  None detected".to_string()
        } else {
            report.system.disks
                .iter()
                .map(|d| format!(
                    "  - **{}**: {} GiB total, {} GiB avail (FS: {}, Type: {})",
                    d.name, d.total_gib, d.available_gib, d.file_system, d.type_
                ))
                .collect::<Vec<_>>()
                .join("\n")
        },
        // Report ID suffix
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .map(|d| d.as_secs())
            .unwrap_or(0)
    )
}