nv_redfish/manager/
item.rs1use crate::resource::ResetType;
17use crate::schema::manager::Manager as ManagerSchema;
18use crate::schema::manager::ResetToDefaultsType as ManagerResetToDefaultsType;
19use crate::Error;
20use crate::NvBmc;
21use crate::Resource;
22use crate::ResourceSchema;
23use nv_redfish_core::Bmc;
24use nv_redfish_core::ModificationResponse;
25use nv_redfish_core::NavProperty;
26use std::sync::Arc;
27
28#[cfg(feature = "manager-network-protocol")]
29use super::network_protocol::ManagerNetworkProtocol;
30#[cfg(feature = "ethernet-interfaces")]
31use crate::ethernet_interface::EthernetInterfaceCollection;
32#[cfg(feature = "host-interfaces")]
33use crate::host_interface::HostInterfaceCollection;
34#[cfg(feature = "log-services")]
35use crate::log_service::LogService;
36#[cfg(feature = "oem-ami")]
37use crate::oem::ami::config_bmc::ConfigBmc as AmiConfigBmc;
38#[cfg(feature = "oem-dell-attributes")]
39use crate::oem::dell::attributes::DellAttributes;
40#[cfg(feature = "oem-hpe")]
41use crate::oem::hpe::manager::HpeManager;
42#[cfg(feature = "oem-lenovo")]
43use crate::oem::lenovo::manager::LenovoManager;
44#[cfg(feature = "oem-supermicro")]
45use crate::oem::supermicro::manager::SupermicroManager;
46
47pub struct Manager<B: Bmc> {
51 #[allow(dead_code)] bmc: NvBmc<B>,
53 data: Arc<ManagerSchema>,
54}
55
56impl<B: Bmc> Manager<B> {
57 pub(crate) async fn new(
59 bmc: &NvBmc<B>,
60 nav: &NavProperty<ManagerSchema>,
61 ) -> Result<Self, Error<B>> {
62 nav.get(bmc.as_ref())
63 .await
64 .map_err(Error::Bmc)
65 .map(|data| Self {
66 bmc: bmc.clone(),
67 data,
68 })
69 }
70
71 #[must_use]
76 pub fn raw(&self) -> Arc<ManagerSchema> {
77 self.data.clone()
78 }
79
80 #[cfg(feature = "manager-network-protocol")]
88 pub async fn network_protocol(&self) -> Result<Option<ManagerNetworkProtocol<B>>, Error<B>> {
89 if let Some(network_protocol_ref) = &self.data.network_protocol {
90 ManagerNetworkProtocol::new(&self.bmc, network_protocol_ref)
91 .await
92 .map(Some)
93 } else {
94 Ok(None)
95 }
96 }
97
98 pub async fn reset(
105 &self,
106 reset_type: Option<ResetType>,
107 ) -> Result<ModificationResponse<()>, Error<B>>
108 where
109 B::Error: nv_redfish_core::ActionError,
110 {
111 let actions = self
112 .data
113 .actions
114 .as_ref()
115 .ok_or(Error::ActionNotAvailable)?;
116
117 if actions.reset.is_none() {
118 return Err(Error::ActionNotAvailable);
119 }
120
121 actions
122 .reset(self.bmc.as_ref(), reset_type)
123 .await
124 .map_err(Error::Bmc)
125 }
126
127 pub async fn reset_to_defaults(
134 &self,
135 reset_type: ManagerResetToDefaultsType,
136 ) -> Result<ModificationResponse<()>, Error<B>>
137 where
138 B::Error: nv_redfish_core::ActionError,
139 {
140 let actions = self
141 .data
142 .actions
143 .as_ref()
144 .ok_or(Error::ActionNotAvailable)?;
145
146 if actions.reset_to_defaults.is_none() {
147 return Err(Error::ActionNotAvailable);
148 }
149
150 actions
151 .reset_to_defaults(self.bmc.as_ref(), Some(reset_type))
152 .await
153 .map_err(Error::Bmc)
154 }
155
156 #[cfg(feature = "ethernet-interfaces")]
164 pub async fn ethernet_interfaces(
165 &self,
166 ) -> Result<Option<EthernetInterfaceCollection<B>>, crate::Error<B>> {
167 if let Some(p) = &self.data.ethernet_interfaces {
168 EthernetInterfaceCollection::new(&self.bmc, p)
169 .await
170 .map(Some)
171 } else {
172 Ok(None)
173 }
174 }
175
176 #[cfg(feature = "host-interfaces")]
184 pub async fn host_interfaces(
185 &self,
186 ) -> Result<Option<HostInterfaceCollection<B>>, crate::Error<B>> {
187 if let Some(p) = &self.data.host_interfaces {
188 HostInterfaceCollection::new(&self.bmc, p).await.map(Some)
189 } else {
190 Ok(None)
191 }
192 }
193
194 #[cfg(feature = "log-services")]
202 pub async fn log_services(&self) -> Result<Option<Vec<LogService<B>>>, crate::Error<B>> {
203 if let Some(log_services_ref) = &self.data.log_services {
204 let log_services_collection = log_services_ref
205 .get(self.bmc.as_ref())
206 .await
207 .map_err(crate::Error::Bmc)?;
208
209 let mut log_services = Vec::new();
210 for m in &log_services_collection.members {
211 log_services.push(LogService::new(&self.bmc, m).await?);
212 }
213
214 Ok(Some(log_services))
215 } else {
216 Ok(None)
217 }
218 }
219
220 #[cfg(feature = "oem-dell-attributes")]
228 pub async fn oem_dell_attributes(&self) -> Result<Option<DellAttributes<B>>, Error<B>> {
229 DellAttributes::manager_attributes(&self.bmc, &self.data).await
230 }
231
232 #[cfg(feature = "oem-lenovo")]
240 pub fn oem_lenovo(&self) -> Result<Option<LenovoManager<B>>, Error<B>> {
241 LenovoManager::new(&self.bmc, &self.data)
242 }
243
244 #[cfg(feature = "oem-hpe")]
252 pub fn oem_hpe(&self) -> Result<Option<HpeManager<B>>, Error<B>> {
253 HpeManager::new(&self.bmc, &self.data)
254 }
255
256 #[cfg(feature = "oem-supermicro")]
264 pub fn oem_supermicro(&self) -> Result<Option<SupermicroManager<B>>, Error<B>> {
265 SupermicroManager::new(&self.bmc, &self.data)
266 }
267
268 #[cfg(feature = "oem-ami")]
276 pub async fn oem_ami_config_bmc(&self) -> Result<Option<AmiConfigBmc<B>>, Error<B>> {
277 AmiConfigBmc::new(&self.bmc, &self.data).await
278 }
279}
280
281impl<B: Bmc> Resource for Manager<B> {
282 fn resource_ref(&self) -> &ResourceSchema {
283 &self.data.as_ref().base
284 }
285}