libredfish2 0.3.0

A continuation of libredfish, a library to interface with Redfish endpoints.
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::common::*;
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct OemHpSnmppowerthresholdalert {
    pub duration_in_min: i64,
    pub threshold_watts: i64,
    pub trigger: String,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct OemHp {
    #[serde(flatten)]
    pub oem_type: HpType,
    #[serde(rename = "SNMPPowerThresholdAlert")]
    pub snmp_power_threshold_alert: OemHpSnmppowerthresholdalert,
    #[serde(flatten)]
    pub links: LinkType,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct Oem {
    pub hp: OemHp,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct PowercontrolPowerlimit {
    pub limit_in_watts: Option<i64>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct PowercontrolPowermetric {
    pub average_consumed_watts: i64,
    pub interval_in_min: i64,
    pub max_consumed_watts: i64,
    pub min_consumed_watts: i64,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct Powercontrol {
    pub power_capacity_watts: i64,
    pub power_consumed_watts: i64,
    pub power_limit: PowercontrolPowerlimit,
    pub power_metrics: PowercontrolPowermetric,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct PowersuppliesOemHpPowersupplystatus {
    pub state: String,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct PowersuppliesOemHp {
    #[serde(flatten)]
    pub power_type: HpType,
    pub average_power_output_watts: i64,
    pub bay_number: i64,
    pub hotplug_capable: bool,
    pub max_power_output_watts: i64,
    pub mismatched: bool,
    pub power_supply_status: PowersuppliesOemHpPowersupplystatus,
    #[serde(rename = "iPDUCapable")]
    pub i_pdu_capable: bool,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct PowersuppliesOem {
    pub hp: PowersuppliesOemHp,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct Powersupply {
    pub firmware_version: String,
    pub last_power_output_watts: i64,
    pub line_input_voltage: i64,
    pub line_input_voltage_type: String,
    pub model: String,
    pub name: String,
    pub oem: PowersuppliesOem,
    pub power_capacity_watts: i64,
    pub power_supply_type: String,
    pub serial_number: String,
    pub spare_part_number: String,

    pub status: AllStatus,
}

impl Status for Powersupply {
    fn health(&self) -> String {
        self.status.health()
    }

    fn state(&self) -> String {
        self.status.state()
    }
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct Redundancy {
    pub max_num_supported: i64,
    pub member_id: String,
    pub min_num_needed: i64,
    pub mode: String,
    pub name: String,
    pub redundancy_set: Vec<ODataId>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct Power {
    #[serde(flatten)]
    pub odata: ODataLinks,
    pub id: String,
    pub name: String,
    pub oem: Oem,
    pub power_capacity_watts: i64,
    pub power_consumed_watts: i64,
    pub power_control: Vec<Powercontrol>,
    pub power_limit: PowercontrolPowerlimit,
    pub power_metrics: PowercontrolPowermetric,
    pub power_supplies: Vec<Powersupply>,
    pub redundancy: Vec<Redundancy>,
    #[serde(rename = "Type")]
    pub power_type: String,
}

impl StatusVec for Power {
    fn get_vec(&self) -> Vec<Box<dyn Status>> {
        let mut v: Vec<Box<dyn Status>> = Vec::new();
        for res in &self.power_supplies {
            v.push(Box::new(res.clone()))
        }
        v
    }
}

#[test]
fn test_power_parser() {
    let test_data = include_str!("../tests/power.json");
    let result: Power = serde_json::from_str(&test_data).unwrap();
    println!("result: {:#?}", result);
}