rufish

rufish is an asynchronous Redfish client library written in Rust for BMC/server out-of-band management via the DMTF Redfish REST API.

Features

• ✅ Async HTTP/HTTPS client (based on reqwest + tokio)
• ✅ Session-based authentication (X-Auth-Token) with fallback to Basic Auth
• ✅ Builder pattern — inject custom reqwest::Client, existing session tokens, or credentials
• ✅ Session persistence — get/set tokens for cross-restart reuse
• ✅ Self-signed certificate support (common for BMCs)
• ✅ Typed Rust structs for all major Redfish resources
• ✅ High-level API for common operations:
  • Systems, Chassis, Managers
  • Power & Thermal monitoring
  • Processors, Memory, Storage, Drives
  • Ethernet Interfaces (System & Manager)
  • Chassis Indicator LED (LocationIndicatorActive / IndicatorLED)
  • Power control (On/Off/Restart/Cycle)
  • Boot override (PXE, BIOS Setup, HDD, etc.)
  • Account management
  • Log services
  • Update & Event services
• ✅ Enriched APIs for UI/dashboard integration:
  • System Health Summary (aggregated status from thermal/power/processors/memory)
  • Storage Overview (controllers + RAID volumes + unassigned drives in one call)
  • Enriched Log Entries (auto-translated via message registry)
  • User Management (create/delete/change password/set role/unlock)
  • Simplified Event Subscription
• ✅ SSE (Server-Sent Events) — real-time event streaming from BMC
• ✅ BIOS Config Export/Import — export from one system, diff, and apply to others
• ✅ Hardware Topology — full system/chassis/manager/processor/memory tree for UI
• ✅ Firmware Update with Progress — update + poll with progress callback
• ✅ Auto-Retry + Session Renewal — automatic re-login on 401, exponential backoff on network errors
• ✅ Multi-Host Pool — manage fleets of BMCs with concurrency control
• ✅ Low-level GET/POST/PATCH/DELETE for any Redfish endpoint
• ✅ Registry metadata support — parse BIOS/attribute/message registries into UI-friendly structs
• ✅ Proper error handling with typed errors

Quick Start

use rufish::RedfishClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = RedfishClient::new("10.0.0.5", "admin", "password")?;
    client.login().await?;

    // Service Root
    let root = client.get_service_root().await?;
    println!("Redfish version: {:?}", root.redfish_version);

    // List systems
    let systems = client.list_systems().await?;
    println!("Systems: {:?}", systems.members_count);

    // Get system details
    let sys = client.get_system("1").await?;
    println!("Model: {:?}, Power: {:?}", sys.model, sys.power_state);

    // Power control
    client.power_on("1").await?;
    client.graceful_shutdown("1").await?;

    // Thermal monitoring
    let thermal = client.get_thermal("1").await?;
    for t in thermal.temperatures.unwrap_or_default() {
        println!("{}: {}°C", t.name.unwrap_or_default(), t.reading_celsius.unwrap_or(0.0));
    }

    // Boot override
    client.set_boot_pxe("1").await?;

    client.logout().await?;
    Ok(())
}

Builder Pattern

use rufish::RedfishClient;

// Custom reqwest client (e.g. native-tls, http1_only)
let custom = reqwest::Client::builder()
    .use_native_tls()
    .http1_only()
    .danger_accept_invalid_certs(true)
    .build()?;

let client = RedfishClient::builder("10.0.0.5")
    .credentials("admin", "password")
    .client(custom)
    .build()?;

// Or restore a persisted session (no login needed)
let client = RedfishClient::builder("10.0.0.5")
    .credentials("admin", "password")
    .session("saved-token", "/redfish/v1/SessionService/Sessions/1")
    .build()?;

API Summary

Session & Construction

Resources (GET)

Actions (POST/PATCH)

Virtual Media

BIOS & Secure Boot

Registry Metadata (for UI)

The get_bios_attributes_full() method returns Vec<RegistryAttribute> with:

• Display names, descriptions, and grouping for form layout
• Attribute types (Enum/String/Integer/Boolean/Password)
• Allowed values with display names (for dropdowns)
• Current and pending values
• Read-only / hidden flags
• Value bounds and string length limits

Enriched APIs (UI/Dashboard)

Multi-Host Pool

use rufish::RedfishPool;

let mut pool = RedfishPool::new(10); // max 10 concurrent
pool.add("bmc-01", "admin", "pass")?;
pool.add("bmc-02", "admin", "pass")?;
pool.login_all().await;

let results = pool.for_each(|client| async move {
    client.power_on("1").await
}).await;

Storage / RAID

Network & Certificates

Event Subscriptions

Firmware Update

Tasks & Pagination

Raw Access

Dependencies

[dependencies]
reqwest = { version = "0.12", features = ["json", "rustls-tls"], default-features = false }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
thiserror = "1"
log = "0.4"

License

MIT OR Apache-2.0