1 #pragma once
2 
3 #include "types.hpp"
4 
5 #include <sdbusplus/bus.hpp>
6 
7 #include <any>
8 #include <set>
9 #include <string>
10 #include <vector>
11 
12 namespace utils
13 {
14 
15 class UtilsInterface;
16 
17 using AssociationList = phosphor::software::updater::AssociationList;
18 using std::any;
19 using std::any_cast;
20 
21 /**
22  * @brief Get the implementation of UtilsInterface
23  */
24 const UtilsInterface& getUtils();
25 
26 /**
27  * @brief Get PSU inventory object path from DBus
28  */
29 std::vector<std::string> getPSUInventoryPaths(sdbusplus::bus_t& bus);
30 
31 /** @brief Get service name from object path and interface
32  *
33  * @param[in] bus          - The Dbus bus object
34  * @param[in] path         - The Dbus object path
35  * @param[in] interface    - The Dbus interface
36  *
37  * @return The name of the service
38  */
39 std::string getService(sdbusplus::bus_t& bus, const char* path,
40                        const char* interface);
41 
42 /** @brief Get all the service names from object path and interface
43  *
44  * @param[in] bus          - The Dbus bus object
45  * @param[in] path         - The Dbus object path
46  * @param[in] interface    - The Dbus interface
47  *
48  * @return The name of the services
49  */
50 std::vector<std::string> getServices(sdbusplus::bus_t& bus, const char* path,
51                                      const char* interface);
52 
53 /** @brief The template function to get property from the requested dbus path
54  *
55  * @param[in] bus          - The Dbus bus object
56  * @param[in] service      - The Dbus service name
57  * @param[in] path         - The Dbus object path
58  * @param[in] interface    - The Dbus interface
59  * @param[in] propertyName - The property name to get
60  *
61  * @return The value of the property
62  */
63 template <typename T>
64 T getProperty(sdbusplus::bus_t& bus, const char* service, const char* path,
65               const char* interface, const char* propertyName);
66 
67 /**
68  * @brief Calculate the version id from the version string.
69  *
70  * @details The version id is a unique 8 hexadecimal digit id
71  *          calculated from the version string.
72  *
73  * @param[in] version - The image version string (e.g. v1.99.10-19).
74  *
75  * @return The id.
76  */
77 std::string getVersionId(const std::string& version);
78 
79 /** @brief Get version of PSU specified by the inventory path
80  *
81  * @param[in] inventoryPath - The PSU inventory object path
82  *
83  * @return The version string, or empty string if it fails to get the version
84  */
85 std::string getVersion(const std::string& inventoryPath);
86 
87 /** @brief Get model of PSU specified by the inventory path
88  *
89  * @param[in] inventoryPath - The PSU inventory object path
90  *
91  * @return The model string, or empty string if it fails to get the model
92  */
93 std::string getModel(const std::string& inventoryPath);
94 
95 /** @brief Get latest version from the PSU versions
96  *
97  * @param[in] versions - The list of the versions
98  *
99  * @return The latest version string
100  */
101 std::string getLatestVersion(const std::set<std::string>& versions);
102 
103 /** @brief Check if the PSU is associated
104  *
105  * @param[in] psuInventoryPath - The PSU inventory path
106  * @param[in] assocs - The list of associations
107  *
108  * @return true if the psu is in the association list
109  */
110 bool isAssociated(const std::string& psuInventoryPath,
111                   const AssociationList& assocs);
112 
113 /**
114  * @brief The interface for utils
115  */
116 class UtilsInterface
117 {
118   public:
119     UtilsInterface() = default;
120     UtilsInterface(const UtilsInterface&) = delete;
121     UtilsInterface& operator=(const UtilsInterface&) = delete;
122     UtilsInterface(UtilsInterface&&) = delete;
123     UtilsInterface& operator=(UtilsInterface&&) = delete;
124 
125     // For now the code needs to get property for Present and Version
126     using PropertyType = std::variant<std::string, bool>;
127 
128     virtual ~UtilsInterface() = default;
129 
130     virtual std::vector<std::string>
131         getPSUInventoryPaths(sdbusplus::bus_t& bus) const = 0;
132 
133     virtual std::string getService(sdbusplus::bus_t& bus, const char* path,
134                                    const char* interface) const = 0;
135 
136     virtual std::vector<std::string>
137         getServices(sdbusplus::bus_t& bus, const char* path,
138                     const char* interface) const = 0;
139 
140     virtual std::string getVersionId(const std::string& version) const = 0;
141 
142     virtual std::string getVersion(const std::string& inventoryPath) const = 0;
143 
144     virtual std::string getModel(const std::string& inventoryPath) const = 0;
145 
146     virtual std::string
147         getLatestVersion(const std::set<std::string>& versions) const = 0;
148 
149     virtual bool isAssociated(const std::string& psuInventoryPath,
150                               const AssociationList& assocs) const = 0;
151 
152     virtual any getPropertyImpl(sdbusplus::bus_t& bus, const char* service,
153                                 const char* path, const char* interface,
154                                 const char* propertyName) const = 0;
155 
156     template <typename T>
157     T getProperty(sdbusplus::bus_t& bus, const char* service, const char* path,
158                   const char* interface, const char* propertyName) const
159     {
160         any result =
161             getPropertyImpl(bus, service, path, interface, propertyName);
162         auto value = any_cast<PropertyType>(result);
163         return std::get<T>(value);
164     }
165 };
166 
167 class Utils : public UtilsInterface
168 {
169   public:
170     std::vector<std::string>
171         getPSUInventoryPaths(sdbusplus::bus_t& bus) const override;
172 
173     std::string getService(sdbusplus::bus_t& bus, const char* path,
174                            const char* interface) const override;
175 
176     std::vector<std::string> getServices(sdbusplus::bus_t& bus,
177                                          const char* path,
178                                          const char* interface) const override;
179 
180     std::string getVersionId(const std::string& version) const override;
181 
182     std::string getVersion(const std::string& inventoryPath) const override;
183 
184     std::string getModel(const std::string& inventoryPath) const override;
185 
186     std::string
187         getLatestVersion(const std::set<std::string>& versions) const override;
188 
189     bool isAssociated(const std::string& psuInventoryPath,
190                       const AssociationList& assocs) const override;
191 
192     any getPropertyImpl(sdbusplus::bus_t& bus, const char* service,
193                         const char* path, const char* interface,
194                         const char* propertyName) const override;
195 };
196 
197 inline std::string getService(sdbusplus::bus_t& bus, const char* path,
198                               const char* interface)
199 {
200     return getUtils().getService(bus, path, interface);
201 }
202 
203 inline std::vector<std::string>
204     getServices(sdbusplus::bus_t& bus, const char* path, const char* interface)
205 {
206     return getUtils().getServices(bus, path, interface);
207 }
208 
209 inline std::vector<std::string> getPSUInventoryPaths(sdbusplus::bus_t& bus)
210 {
211     return getUtils().getPSUInventoryPaths(bus);
212 }
213 
214 inline std::string getVersionId(const std::string& version)
215 {
216     return getUtils().getVersionId(version);
217 }
218 
219 inline std::string getVersion(const std::string& inventoryPath)
220 {
221     return getUtils().getVersion(inventoryPath);
222 }
223 
224 inline std::string getModel(const std::string& inventoryPath)
225 {
226     return getUtils().getModel(inventoryPath);
227 }
228 
229 inline std::string getLatestVersion(const std::set<std::string>& versions)
230 {
231     return getUtils().getLatestVersion(versions);
232 }
233 
234 inline bool isAssociated(const std::string& psuInventoryPath,
235                          const AssociationList& assocs)
236 {
237     return getUtils().isAssociated(psuInventoryPath, assocs);
238 }
239 
240 template <typename T>
241 T getProperty(sdbusplus::bus_t& bus, const char* service, const char* path,
242               const char* interface, const char* propertyName)
243 {
244     return getUtils().getProperty<T>(bus, service, path, interface,
245                                      propertyName);
246 }
247 
248 } // namespace utils
249