Skip to main content

nv_redfish/manager/
item.rs

1// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2// SPDX-License-Identifier: Apache-2.0
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
16use crate::schema::redfish::manager::Manager as ManagerSchema;
17use crate::Error;
18use crate::NvBmc;
19use crate::Resource;
20use crate::ResourceSchema;
21use nv_redfish_core::Bmc;
22use nv_redfish_core::NavProperty;
23use std::sync::Arc;
24
25#[cfg(feature = "ethernet-interfaces")]
26use crate::ethernet_interface::EthernetInterfaceCollection;
27#[cfg(feature = "log-services")]
28use crate::log_service::LogService;
29
30/// Represents a manager (BMC) in the system.
31///
32/// Provides access to manager information and associated services.
33pub struct Manager<B: Bmc> {
34    bmc: NvBmc<B>,
35    data: Arc<ManagerSchema>,
36}
37
38impl<B: Bmc> Manager<B> {
39    /// Create a new manager handle.
40    pub(crate) async fn new(
41        bmc: &NvBmc<B>,
42        nav: &NavProperty<ManagerSchema>,
43    ) -> Result<Self, Error<B>> {
44        nav.get(bmc.as_ref())
45            .await
46            .map_err(Error::Bmc)
47            .map(|data| Self {
48                bmc: bmc.clone(),
49                data,
50            })
51    }
52
53    /// Get the raw schema data for this manager.
54    ///
55    /// Returns an `Arc` to the underlying schema, allowing cheap cloning
56    /// and sharing of the data.
57    #[must_use]
58    pub fn raw(&self) -> Arc<ManagerSchema> {
59        self.data.clone()
60    }
61
62    /// Get ethernet interfaces for this manager.
63    ///
64    /// # Errors
65    ///
66    /// Returns an error if:
67    /// - The manager does not have / provide ethernet interfaces
68    /// - Fetching log ethernet internet data fails
69    #[cfg(feature = "ethernet-interfaces")]
70    pub async fn ethernet_interfaces(
71        &self,
72    ) -> Result<EthernetInterfaceCollection<B>, crate::Error<B>> {
73        let p = self
74            .data
75            .ethernet_interfaces
76            .as_ref()
77            .ok_or(crate::Error::EthernetInterfacesNotAvailable)?;
78        EthernetInterfaceCollection::new(&self.bmc, p).await
79    }
80
81    /// Get log services for this manager.
82    ///
83    /// # Errors
84    ///
85    /// Returns an error if:
86    /// - The manager does not have log services
87    /// - Fetching log service data fails
88    #[cfg(feature = "log-services")]
89    pub async fn log_services(&self) -> Result<Vec<LogService<B>>, crate::Error<B>> {
90        let log_services_ref = self
91            .data
92            .log_services
93            .as_ref()
94            .ok_or(crate::Error::LogServiceNotAvailable)?;
95
96        let log_services_collection = log_services_ref
97            .get(self.bmc.as_ref())
98            .await
99            .map_err(crate::Error::Bmc)?;
100
101        let mut log_services = Vec::new();
102        for m in &log_services_collection.members {
103            log_services.push(LogService::new(&self.bmc, m).await?);
104        }
105
106        Ok(log_services)
107    }
108}
109
110impl<B: Bmc> Resource for Manager<B> {
111    fn resource_ref(&self) -> &ResourceSchema {
112        &self.data.as_ref().base
113    }
114}