Skip to main content

FmdAdm

Struct FmdAdm

pub struct FmdAdm { /* private fields */ }

Expand description

A handle to the Fault Management Daemon administrative interface.

This handle wraps a C fmd_adm_t pointer that is not thread-safe. FmdAdm is !Send and !Sync — it cannot be shared across threads.

All iterator methods (modules(), cases(), resources(), etc.) eagerly collect results into a Vec. The underlying C API uses callbacks that own the data only for the duration of each invocation, so results must be copied before the callback returns.

Implementations§

impl FmdAdm

pub fn open() -> Result<Self, Error>

Open a connection to the local fault management daemon.

Examples found in repository ?

examples/case_detail.rs (line 26)

25fn main() {
26    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
27    let cases = adm.cases(None).expect("failed to list cases");
28
29    if let Some(c) = cases.first() {
30        println!("Case {} ({})\n", c.uuid, c.code);
31        if let Some(event) = &c.event {
32            print_nvlist(event, 0);
33        } else {
34            println!("  (no event data)");
35        }
36    } else {
37        println!("No cases found.");
38    }
39}

More examples

Hide additional examples

examples/list_modules.rs (line 4)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    println!("=== FMD Modules ===");
7    let modules = adm.modules().expect("failed to list modules");
8    for m in &modules {
9        println!(
10            "  {} v{} - {}{}",
11            m.name,
12            m.version,
13            m.description,
14            if m.failed { " [FAILED]" } else { "" },
15        );
16    }
17    println!("({} modules total)", modules.len());
18
19    println!("\n=== Faulty Resources ===");
20    let resources = adm.resources(true).expect("failed to list resources");
21    if resources.is_empty() {
22        println!("  (none)");
23    } else {
24        for r in &resources {
25            println!("  {} (case {})", r.fmri, r.uuid);
26        }
27    }
28
29    println!("\n=== Cases ===");
30    let cases = adm.cases(None).expect("failed to list cases");
31    if cases.is_empty() {
32        println!("  (none)");
33    } else {
34        for c in &cases {
35            let severity = c
36                .event
37                .as_ref()
38                .and_then(|e| e.lookup("severity"))
39                .and_then(|v| match v {
40                    NvValue::String(s) => Some(s.as_str()),
41                    _ => None,
42                })
43                .unwrap_or("unknown");
44            println!("  {} - {} (severity: {})", c.uuid, c.code, severity);
45        }
46    }
47}

examples/stats.rs (line 4)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(resources.len(), count as usize, "resource count mismatch!");
16
17    // Transports
18    println!("\n=== Transports ===");
19    let xprts = adm.transports().expect("failed to list transports");
20    if xprts.is_empty() {
21        println!("  (none)");
22    } else {
23        for id in &xprts {
24            println!("  transport {id}");
25        }
26    }
27
28    // SERD engines for each module
29    println!("\n=== SERD Engines ===");
30    let modules = adm.modules().expect("failed to list modules");
31    let mut total = 0;
32    for m in &modules {
33        let engines = adm
34            .serd_engines(&m.name)
35            .expect("failed to list serd engines");
36        if !engines.is_empty() {
37            println!("  {} ({} engines):", m.name, engines.len());
38            for e in &engines {
39                println!(
40                    "    {} - count={}, n={}, fired={}",
41                    e.name, e.count, e.n, e.fired,
42                );
43            }
44            total += engines.len();
45        }
46    }
47    if total == 0 {
48        println!("  (none)");
49    }
50
51    // Global stats
52    println!("\n=== Global Stats ===");
53    let stats = adm.stats(None).expect("failed to read stats");
54    for s in &stats {
55        println!("  {}: {} ({})", s.name, s.value, s.description);
56    }
57
58    // Per-module stats for the first module
59    if let Some(m) = modules.first() {
60        println!("\n=== Stats for {} ===", m.name);
61        let mstats = adm
62            .stats(Some(&m.name))
63            .expect("failed to read module stats");
64        for s in &mstats {
65            println!("  {}: {} ({})", s.name, s.value, s.description);
66        }
67    }
68}

pub fn modules(&self) -> Result<Vec<ModuleInfo>, Error>

Iterate over loaded FMD modules.

Examples found in repository ?

examples/list_modules.rs (line 7)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    println!("=== FMD Modules ===");
7    let modules = adm.modules().expect("failed to list modules");
8    for m in &modules {
9        println!(
10            "  {} v{} - {}{}",
11            m.name,
12            m.version,
13            m.description,
14            if m.failed { " [FAILED]" } else { "" },
15        );
16    }
17    println!("({} modules total)", modules.len());
18
19    println!("\n=== Faulty Resources ===");
20    let resources = adm.resources(true).expect("failed to list resources");
21    if resources.is_empty() {
22        println!("  (none)");
23    } else {
24        for r in &resources {
25            println!("  {} (case {})", r.fmri, r.uuid);
26        }
27    }
28
29    println!("\n=== Cases ===");
30    let cases = adm.cases(None).expect("failed to list cases");
31    if cases.is_empty() {
32        println!("  (none)");
33    } else {
34        for c in &cases {
35            let severity = c
36                .event
37                .as_ref()
38                .and_then(|e| e.lookup("severity"))
39                .and_then(|v| match v {
40                    NvValue::String(s) => Some(s.as_str()),
41                    _ => None,
42                })
43                .unwrap_or("unknown");
44            println!("  {} - {} (severity: {})", c.uuid, c.code, severity);
45        }
46    }
47}

More examples

Hide additional examples

examples/stats.rs (line 30)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(resources.len(), count as usize, "resource count mismatch!");
16
17    // Transports
18    println!("\n=== Transports ===");
19    let xprts = adm.transports().expect("failed to list transports");
20    if xprts.is_empty() {
21        println!("  (none)");
22    } else {
23        for id in &xprts {
24            println!("  transport {id}");
25        }
26    }
27
28    // SERD engines for each module
29    println!("\n=== SERD Engines ===");
30    let modules = adm.modules().expect("failed to list modules");
31    let mut total = 0;
32    for m in &modules {
33        let engines = adm
34            .serd_engines(&m.name)
35            .expect("failed to list serd engines");
36        if !engines.is_empty() {
37            println!("  {} ({} engines):", m.name, engines.len());
38            for e in &engines {
39                println!(
40                    "    {} - count={}, n={}, fired={}",
41                    e.name, e.count, e.n, e.fired,
42                );
43            }
44            total += engines.len();
45        }
46    }
47    if total == 0 {
48        println!("  (none)");
49    }
50
51    // Global stats
52    println!("\n=== Global Stats ===");
53    let stats = adm.stats(None).expect("failed to read stats");
54    for s in &stats {
55        println!("  {}: {} ({})", s.name, s.value, s.description);
56    }
57
58    // Per-module stats for the first module
59    if let Some(m) = modules.first() {
60        println!("\n=== Stats for {} ===", m.name);
61        let mstats = adm
62            .stats(Some(&m.name))
63            .expect("failed to read module stats");
64        for s in &mstats {
65            println!("  {}: {} ({})", s.name, s.value, s.description);
66        }
67    }
68}

pub fn resources(&self, all: bool) -> Result<Vec<ResourceInfo>, Error>

Iterate over faulty resources.

If all is true, includes resources that are not directly visible.

Examples found in repository ?

examples/list_modules.rs (line 20)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    println!("=== FMD Modules ===");
7    let modules = adm.modules().expect("failed to list modules");
8    for m in &modules {
9        println!(
10            "  {} v{} - {}{}",
11            m.name,
12            m.version,
13            m.description,
14            if m.failed { " [FAILED]" } else { "" },
15        );
16    }
17    println!("({} modules total)", modules.len());
18
19    println!("\n=== Faulty Resources ===");
20    let resources = adm.resources(true).expect("failed to list resources");
21    if resources.is_empty() {
22        println!("  (none)");
23    } else {
24        for r in &resources {
25            println!("  {} (case {})", r.fmri, r.uuid);
26        }
27    }
28
29    println!("\n=== Cases ===");
30    let cases = adm.cases(None).expect("failed to list cases");
31    if cases.is_empty() {
32        println!("  (none)");
33    } else {
34        for c in &cases {
35            let severity = c
36                .event
37                .as_ref()
38                .and_then(|e| e.lookup("severity"))
39                .and_then(|v| match v {
40                    NvValue::String(s) => Some(s.as_str()),
41                    _ => None,
42                })
43                .unwrap_or("unknown");
44            println!("  {} - {} (severity: {})", c.uuid, c.code, severity);
45        }
46    }
47}

More examples

Hide additional examples

examples/stats.rs (line 7)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(resources.len(), count as usize, "resource count mismatch!");
16
17    // Transports
18    println!("\n=== Transports ===");
19    let xprts = adm.transports().expect("failed to list transports");
20    if xprts.is_empty() {
21        println!("  (none)");
22    } else {
23        for id in &xprts {
24            println!("  transport {id}");
25        }
26    }
27
28    // SERD engines for each module
29    println!("\n=== SERD Engines ===");
30    let modules = adm.modules().expect("failed to list modules");
31    let mut total = 0;
32    for m in &modules {
33        let engines = adm
34            .serd_engines(&m.name)
35            .expect("failed to list serd engines");
36        if !engines.is_empty() {
37            println!("  {} ({} engines):", m.name, engines.len());
38            for e in &engines {
39                println!(
40                    "    {} - count={}, n={}, fired={}",
41                    e.name, e.count, e.n, e.fired,
42                );
43            }
44            total += engines.len();
45        }
46    }
47    if total == 0 {
48        println!("  (none)");
49    }
50
51    // Global stats
52    println!("\n=== Global Stats ===");
53    let stats = adm.stats(None).expect("failed to read stats");
54    for s in &stats {
55        println!("  {}: {} ({})", s.name, s.value, s.description);
56    }
57
58    // Per-module stats for the first module
59    if let Some(m) = modules.first() {
60        println!("\n=== Stats for {} ===", m.name);
61        let mstats = adm
62            .stats(Some(&m.name))
63            .expect("failed to read module stats");
64        for s in &mstats {
65            println!("  {}: {} ({})", s.name, s.value, s.description);
66        }
67    }
68}

pub fn resource_count(&self, all: bool) -> Result<u32, Error>

Get the count of faulty resources.

Examples found in repository ?

examples/stats.rs (line 8)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(resources.len(), count as usize, "resource count mismatch!");
16
17    // Transports
18    println!("\n=== Transports ===");
19    let xprts = adm.transports().expect("failed to list transports");
20    if xprts.is_empty() {
21        println!("  (none)");
22    } else {
23        for id in &xprts {
24            println!("  transport {id}");
25        }
26    }
27
28    // SERD engines for each module
29    println!("\n=== SERD Engines ===");
30    let modules = adm.modules().expect("failed to list modules");
31    let mut total = 0;
32    for m in &modules {
33        let engines = adm
34            .serd_engines(&m.name)
35            .expect("failed to list serd engines");
36        if !engines.is_empty() {
37            println!("  {} ({} engines):", m.name, engines.len());
38            for e in &engines {
39                println!(
40                    "    {} - count={}, n={}, fired={}",
41                    e.name, e.count, e.n, e.fired,
42                );
43            }
44            total += engines.len();
45        }
46    }
47    if total == 0 {
48        println!("  (none)");
49    }
50
51    // Global stats
52    println!("\n=== Global Stats ===");
53    let stats = adm.stats(None).expect("failed to read stats");
54    for s in &stats {
55        println!("  {}: {} ({})", s.name, s.value, s.description);
56    }
57
58    // Per-module stats for the first module
59    if let Some(m) = modules.first() {
60        println!("\n=== Stats for {} ===", m.name);
61        let mstats = adm
62            .stats(Some(&m.name))
63            .expect("failed to read module stats");
64        for s in &mstats {
65            println!("  {}: {} ({})", s.name, s.value, s.description);
66        }
67    }
68}

pub fn resource_repaired(&mut self, fmri: &str) -> Result<(), Error>

Mark a resource (by FMRI) as repaired.

pub fn resource_replaced(&mut self, fmri: &str) -> Result<(), Error>

Mark a resource (by FMRI) as replaced.

pub fn resource_acquit( &mut self, fmri: &str, case_uuid: &Uuid, ) -> Result<(), Error>

Acquit a resource (by FMRI) for a specific case UUID.

pub fn cases(&self, url: Option<&str>) -> Result<Vec<CaseInfo>, Error>

Iterate over cases, optionally filtered by URL.

Examples found in repository ?

examples/case_detail.rs (line 27)

25fn main() {
26    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
27    let cases = adm.cases(None).expect("failed to list cases");
28
29    if let Some(c) = cases.first() {
30        println!("Case {} ({})\n", c.uuid, c.code);
31        if let Some(event) = &c.event {
32            print_nvlist(event, 0);
33        } else {
34            println!("  (no event data)");
35        }
36    } else {
37        println!("No cases found.");
38    }
39}

More examples

Hide additional examples

examples/list_modules.rs (line 30)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    println!("=== FMD Modules ===");
7    let modules = adm.modules().expect("failed to list modules");
8    for m in &modules {
9        println!(
10            "  {} v{} - {}{}",
11            m.name,
12            m.version,
13            m.description,
14            if m.failed { " [FAILED]" } else { "" },
15        );
16    }
17    println!("({} modules total)", modules.len());
18
19    println!("\n=== Faulty Resources ===");
20    let resources = adm.resources(true).expect("failed to list resources");
21    if resources.is_empty() {
22        println!("  (none)");
23    } else {
24        for r in &resources {
25            println!("  {} (case {})", r.fmri, r.uuid);
26        }
27    }
28
29    println!("\n=== Cases ===");
30    let cases = adm.cases(None).expect("failed to list cases");
31    if cases.is_empty() {
32        println!("  (none)");
33    } else {
34        for c in &cases {
35            let severity = c
36                .event
37                .as_ref()
38                .and_then(|e| e.lookup("severity"))
39                .and_then(|v| match v {
40                    NvValue::String(s) => Some(s.as_str()),
41                    _ => None,
42                })
43                .unwrap_or("unknown");
44            println!("  {} - {} (severity: {})", c.uuid, c.code, severity);
45        }
46    }
47}

pub fn case_acquit(&mut self, uuid: &Uuid) -> Result<(), Error>

Acquit a case by UUID.

pub fn serd_engines(&self, module: &str) -> Result<Vec<SerdInfo>, Error>

Iterate over SERD engines for a module.

Examples found in repository ?

examples/stats.rs (line 34)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(resources.len(), count as usize, "resource count mismatch!");
16
17    // Transports
18    println!("\n=== Transports ===");
19    let xprts = adm.transports().expect("failed to list transports");
20    if xprts.is_empty() {
21        println!("  (none)");
22    } else {
23        for id in &xprts {
24            println!("  transport {id}");
25        }
26    }
27
28    // SERD engines for each module
29    println!("\n=== SERD Engines ===");
30    let modules = adm.modules().expect("failed to list modules");
31    let mut total = 0;
32    for m in &modules {
33        let engines = adm
34            .serd_engines(&m.name)
35            .expect("failed to list serd engines");
36        if !engines.is_empty() {
37            println!("  {} ({} engines):", m.name, engines.len());
38            for e in &engines {
39                println!(
40                    "    {} - count={}, n={}, fired={}",
41                    e.name, e.count, e.n, e.fired,
42                );
43            }
44            total += engines.len();
45        }
46    }
47    if total == 0 {
48        println!("  (none)");
49    }
50
51    // Global stats
52    println!("\n=== Global Stats ===");
53    let stats = adm.stats(None).expect("failed to read stats");
54    for s in &stats {
55        println!("  {}: {} ({})", s.name, s.value, s.description);
56    }
57
58    // Per-module stats for the first module
59    if let Some(m) = modules.first() {
60        println!("\n=== Stats for {} ===", m.name);
61        let mstats = adm
62            .stats(Some(&m.name))
63            .expect("failed to read module stats");
64        for s in &mstats {
65            println!("  {}: {} ({})", s.name, s.value, s.description);
66        }
67    }
68}

pub fn transports(&self) -> Result<Vec<TransportId>, Error>

Iterate over transports.

Examples found in repository ?

examples/stats.rs (line 19)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(resources.len(), count as usize, "resource count mismatch!");
16
17    // Transports
18    println!("\n=== Transports ===");
19    let xprts = adm.transports().expect("failed to list transports");
20    if xprts.is_empty() {
21        println!("  (none)");
22    } else {
23        for id in &xprts {
24            println!("  transport {id}");
25        }
26    }
27
28    // SERD engines for each module
29    println!("\n=== SERD Engines ===");
30    let modules = adm.modules().expect("failed to list modules");
31    let mut total = 0;
32    for m in &modules {
33        let engines = adm
34            .serd_engines(&m.name)
35            .expect("failed to list serd engines");
36        if !engines.is_empty() {
37            println!("  {} ({} engines):", m.name, engines.len());
38            for e in &engines {
39                println!(
40                    "    {} - count={}, n={}, fired={}",
41                    e.name, e.count, e.n, e.fired,
42                );
43            }
44            total += engines.len();
45        }
46    }
47    if total == 0 {
48        println!("  (none)");
49    }
50
51    // Global stats
52    println!("\n=== Global Stats ===");
53    let stats = adm.stats(None).expect("failed to read stats");
54    for s in &stats {
55        println!("  {}: {} ({})", s.name, s.value, s.description);
56    }
57
58    // Per-module stats for the first module
59    if let Some(m) = modules.first() {
60        println!("\n=== Stats for {} ===", m.name);
61        let mstats = adm
62            .stats(Some(&m.name))
63            .expect("failed to read module stats");
64        for s in &mstats {
65            println!("  {}: {} ({})", s.name, s.value, s.description);
66        }
67    }
68}

pub fn stats(&self, module: Option<&str>) -> Result<Vec<Stat>, Error>

Read statistics, optionally for a specific module.

Examples found in repository ?

examples/stats.rs (line 53)

3fn main() {
4    let adm = FmdAdm::open().expect("failed to open fmd adm handle");
5
6    // Validate resource_count against resources().len()
7    let resources = adm.resources(true).expect("failed to list resources");
8    let count = adm.resource_count(true).expect("failed to count resources");
9    println!("=== Resources ===");
10    println!(
11        "  resources(all=true).len() = {}, resource_count(all=true) = {}",
12        resources.len(),
13        count,
14    );
15    assert_eq!(resources.len(), count as usize, "resource count mismatch!");
16
17    // Transports
18    println!("\n=== Transports ===");
19    let xprts = adm.transports().expect("failed to list transports");
20    if xprts.is_empty() {
21        println!("  (none)");
22    } else {
23        for id in &xprts {
24            println!("  transport {id}");
25        }
26    }
27
28    // SERD engines for each module
29    println!("\n=== SERD Engines ===");
30    let modules = adm.modules().expect("failed to list modules");
31    let mut total = 0;
32    for m in &modules {
33        let engines = adm
34            .serd_engines(&m.name)
35            .expect("failed to list serd engines");
36        if !engines.is_empty() {
37            println!("  {} ({} engines):", m.name, engines.len());
38            for e in &engines {
39                println!(
40                    "    {} - count={}, n={}, fired={}",
41                    e.name, e.count, e.n, e.fired,
42                );
43            }
44            total += engines.len();
45        }
46    }
47    if total == 0 {
48        println!("  (none)");
49    }
50
51    // Global stats
52    println!("\n=== Global Stats ===");
53    let stats = adm.stats(None).expect("failed to read stats");
54    for s in &stats {
55        println!("  {}: {} ({})", s.name, s.value, s.description);
56    }
57
58    // Per-module stats for the first module
59    if let Some(m) = modules.first() {
60        println!("\n=== Stats for {} ===", m.name);
61        let mstats = adm
62            .stats(Some(&m.name))
63            .expect("failed to read module stats");
64        for s in &mstats {
65            println!("  {}: {} ({})", s.name, s.value, s.description);
66        }
67    }
68}

Trait Implementations§

impl Drop for FmdAdm

fn drop(&mut self)

Executes the destructor for this type. Read more

Auto Trait Implementations§

impl Freeze for FmdAdm

impl RefUnwindSafe for FmdAdm

impl !Send for FmdAdm

impl !Sync for FmdAdm

impl Unpin for FmdAdm

impl UnsafeUnpin for FmdAdm

impl UnwindSafe for FmdAdm

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.