Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 1 | /* |
| 2 | // Copyright (c) 2018 Intel Corporation |
| 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 | */ |
| 16 | #pragma once |
| 17 | |
James Feist | b49ac87 | 2019-05-21 15:12:01 -0700 | [diff] [blame] | 18 | #include "health.hpp" |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 19 | #include "led.hpp" |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 20 | #include "node.hpp" |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 21 | |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 22 | #include <boost/container/flat_map.hpp> |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 23 | |
Ed Tanous | abf2add | 2019-01-22 16:40:12 -0800 | [diff] [blame] | 24 | #include <variant> |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 25 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 26 | namespace redfish |
| 27 | { |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 28 | |
| 29 | /** |
Gunnar Mills | beeca0a | 2019-02-14 16:30:45 -0600 | [diff] [blame] | 30 | * @brief Retrieves chassis state properties over dbus |
| 31 | * |
| 32 | * @param[in] aResp - Shared pointer for completing asynchronous calls. |
| 33 | * |
| 34 | * @return None. |
| 35 | */ |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 36 | inline void getChassisState(std::shared_ptr<AsyncResp> aResp) |
Gunnar Mills | beeca0a | 2019-02-14 16:30:45 -0600 | [diff] [blame] | 37 | { |
| 38 | crow::connections::systemBus->async_method_call( |
| 39 | [aResp{std::move(aResp)}]( |
| 40 | const boost::system::error_code ec, |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 41 | const std::variant<std::string>& chassisState) { |
Gunnar Mills | beeca0a | 2019-02-14 16:30:45 -0600 | [diff] [blame] | 42 | if (ec) |
| 43 | { |
| 44 | BMCWEB_LOG_DEBUG << "DBUS response error " << ec; |
| 45 | messages::internalError(aResp->res); |
| 46 | return; |
| 47 | } |
| 48 | |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 49 | const std::string* s = std::get_if<std::string>(&chassisState); |
Gunnar Mills | beeca0a | 2019-02-14 16:30:45 -0600 | [diff] [blame] | 50 | BMCWEB_LOG_DEBUG << "Chassis state: " << *s; |
| 51 | if (s != nullptr) |
| 52 | { |
| 53 | // Verify Chassis State |
| 54 | if (*s == "xyz.openbmc_project.State.Chassis.PowerState.On") |
| 55 | { |
| 56 | aResp->res.jsonValue["PowerState"] = "On"; |
| 57 | aResp->res.jsonValue["Status"]["State"] = "Enabled"; |
| 58 | } |
| 59 | else if (*s == |
| 60 | "xyz.openbmc_project.State.Chassis.PowerState.Off") |
| 61 | { |
| 62 | aResp->res.jsonValue["PowerState"] = "Off"; |
| 63 | aResp->res.jsonValue["Status"]["State"] = "StandbyOffline"; |
| 64 | } |
| 65 | } |
| 66 | }, |
| 67 | "xyz.openbmc_project.State.Chassis", |
| 68 | "/xyz/openbmc_project/state/chassis0", |
| 69 | "org.freedesktop.DBus.Properties", "Get", |
| 70 | "xyz.openbmc_project.State.Chassis", "CurrentPowerState"); |
| 71 | } |
| 72 | |
| 73 | /** |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 74 | * DBus types primitives for several generic DBus interfaces |
| 75 | * TODO(Pawel) consider move this to separate file into boost::dbus |
| 76 | */ |
Ed Tanous | 55c7b7a | 2018-05-22 15:27:24 -0700 | [diff] [blame] | 77 | // Note, this is not a very useful Variant, but because it isn't used to get |
Ed Tanous | aa2e59c | 2018-04-12 12:17:20 -0700 | [diff] [blame] | 78 | // values, it should be as simple as possible |
| 79 | // TODO(ed) invent a nullvariant type |
Cheng C Yang | 5fd7ba6 | 2019-11-28 15:58:08 +0800 | [diff] [blame] | 80 | using VariantType = std::variant<bool, std::string, uint64_t, uint32_t>; |
Ed Tanous | aa2e59c | 2018-04-12 12:17:20 -0700 | [diff] [blame] | 81 | using ManagedObjectsType = std::vector<std::pair< |
| 82 | sdbusplus::message::object_path, |
| 83 | std::vector<std::pair<std::string, |
| 84 | std::vector<std::pair<std::string, VariantType>>>>>>; |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 85 | |
Ed Tanous | aa2e59c | 2018-04-12 12:17:20 -0700 | [diff] [blame] | 86 | using PropertiesType = boost::container::flat_map<std::string, VariantType>; |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 87 | |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 88 | inline void getIntrusionByService(std::shared_ptr<AsyncResp> aResp, |
| 89 | const std::string& service, |
| 90 | const std::string& objPath) |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 91 | { |
| 92 | BMCWEB_LOG_DEBUG << "Get intrusion status by service \n"; |
| 93 | |
| 94 | crow::connections::systemBus->async_method_call( |
| 95 | [aResp{std::move(aResp)}](const boost::system::error_code ec, |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 96 | const std::variant<std::string>& value) { |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 97 | if (ec) |
| 98 | { |
Gunnar Mills | 4e0453b | 2020-07-08 14:00:30 -0500 | [diff] [blame] | 99 | // do not add err msg in redfish response, because this is not |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 100 | // mandatory property |
| 101 | BMCWEB_LOG_ERROR << "DBUS response error " << ec << "\n"; |
| 102 | return; |
| 103 | } |
| 104 | |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 105 | const std::string* status = std::get_if<std::string>(&value); |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 106 | |
| 107 | if (status == nullptr) |
| 108 | { |
| 109 | BMCWEB_LOG_ERROR << "intrusion status read error \n"; |
| 110 | return; |
| 111 | } |
| 112 | |
| 113 | aResp->res.jsonValue["PhysicalSecurity"] = { |
| 114 | {"IntrusionSensorNumber", 1}, {"IntrusionSensor", *status}}; |
| 115 | }, |
| 116 | service, objPath, "org.freedesktop.DBus.Properties", "Get", |
| 117 | "xyz.openbmc_project.Chassis.Intrusion", "Status"); |
| 118 | } |
| 119 | |
| 120 | /** |
| 121 | * Retrieves physical security properties over dbus |
| 122 | */ |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 123 | inline void getPhysicalSecurityData(std::shared_ptr<AsyncResp> aResp) |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 124 | { |
| 125 | crow::connections::systemBus->async_method_call( |
| 126 | [aResp{std::move(aResp)}]( |
| 127 | const boost::system::error_code ec, |
| 128 | const std::vector<std::pair< |
| 129 | std::string, |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 130 | std::vector<std::pair<std::string, std::vector<std::string>>>>>& |
| 131 | subtree) { |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 132 | if (ec) |
| 133 | { |
Gunnar Mills | 4e0453b | 2020-07-08 14:00:30 -0500 | [diff] [blame] | 134 | // do not add err msg in redfish response, because this is not |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 135 | // mandatory property |
| 136 | BMCWEB_LOG_ERROR << "DBUS error: no matched iface " << ec |
| 137 | << "\n"; |
| 138 | return; |
| 139 | } |
| 140 | // Iterate over all retrieved ObjectPaths. |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 141 | for (const auto& object : subtree) |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 142 | { |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 143 | for (const auto& service : object.second) |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 144 | { |
| 145 | getIntrusionByService(aResp, service.first, object.first); |
| 146 | return; |
| 147 | } |
| 148 | } |
| 149 | }, |
| 150 | "xyz.openbmc_project.ObjectMapper", |
| 151 | "/xyz/openbmc_project/object_mapper", |
| 152 | "xyz.openbmc_project.ObjectMapper", "GetSubTree", |
Ed Tanous | 271584a | 2019-07-09 16:24:22 -0700 | [diff] [blame] | 153 | "/xyz/openbmc_project/Intrusion", 1, |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 154 | std::array<const char*, 1>{"xyz.openbmc_project.Chassis.Intrusion"}); |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 155 | } |
| 156 | |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 157 | /** |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 158 | * ChassisCollection derived class for delivering Chassis Collection Schema |
| 159 | */ |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 160 | class ChassisCollection : public Node |
| 161 | { |
| 162 | public: |
Ed Tanous | 52cc112 | 2020-07-18 13:51:21 -0700 | [diff] [blame] | 163 | ChassisCollection(App& app) : Node(app, "/redfish/v1/Chassis/") |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 164 | { |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 165 | entityPrivileges = { |
| 166 | {boost::beast::http::verb::get, {{"Login"}}}, |
| 167 | {boost::beast::http::verb::head, {{"Login"}}}, |
| 168 | {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, |
| 169 | {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, |
| 170 | {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, |
| 171 | {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; |
| 172 | } |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 173 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 174 | private: |
| 175 | /** |
| 176 | * Functions triggers appropriate requests on DBus |
| 177 | */ |
Ed Tanous | cb13a39 | 2020-07-25 19:02:03 +0000 | [diff] [blame] | 178 | void doGet(crow::Response& res, const crow::Request&, |
| 179 | const std::vector<std::string>&) override |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 180 | { |
Ed Tanous | 0f74e64 | 2018-11-12 15:17:05 -0800 | [diff] [blame] | 181 | res.jsonValue["@odata.type"] = "#ChassisCollection.ChassisCollection"; |
| 182 | res.jsonValue["@odata.id"] = "/redfish/v1/Chassis"; |
Ed Tanous | 0f74e64 | 2018-11-12 15:17:05 -0800 | [diff] [blame] | 183 | res.jsonValue["Name"] = "Chassis Collection"; |
| 184 | |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 185 | const std::array<const char*, 2> interfaces = { |
Gunnar Mills | 603a664 | 2019-01-21 17:03:51 -0600 | [diff] [blame] | 186 | "xyz.openbmc_project.Inventory.Item.Board", |
Shawn McCarney | adc4f0d | 2019-07-24 09:21:50 -0500 | [diff] [blame] | 187 | "xyz.openbmc_project.Inventory.Item.Chassis"}; |
Gunnar Mills | 603a664 | 2019-01-21 17:03:51 -0600 | [diff] [blame] | 188 | |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 189 | auto asyncResp = std::make_shared<AsyncResp>(res); |
| 190 | crow::connections::systemBus->async_method_call( |
| 191 | [asyncResp](const boost::system::error_code ec, |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 192 | const std::vector<std::string>& chassisList) { |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 193 | if (ec) |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 194 | { |
Jason M. Bills | f12894f | 2018-10-09 12:45:45 -0700 | [diff] [blame] | 195 | messages::internalError(asyncResp->res); |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 196 | return; |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 197 | } |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 198 | nlohmann::json& chassisArray = |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 199 | asyncResp->res.jsonValue["Members"]; |
| 200 | chassisArray = nlohmann::json::array(); |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 201 | for (const std::string& objpath : chassisList) |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 202 | { |
| 203 | std::size_t lastPos = objpath.rfind("/"); |
| 204 | if (lastPos == std::string::npos) |
| 205 | { |
| 206 | BMCWEB_LOG_ERROR << "Failed to find '/' in " << objpath; |
| 207 | continue; |
| 208 | } |
| 209 | chassisArray.push_back( |
| 210 | {{"@odata.id", "/redfish/v1/Chassis/" + |
| 211 | objpath.substr(lastPos + 1)}}); |
| 212 | } |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 213 | |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 214 | asyncResp->res.jsonValue["Members@odata.count"] = |
| 215 | chassisArray.size(); |
| 216 | }, |
| 217 | "xyz.openbmc_project.ObjectMapper", |
| 218 | "/xyz/openbmc_project/object_mapper", |
| 219 | "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", |
Ed Tanous | 271584a | 2019-07-09 16:24:22 -0700 | [diff] [blame] | 220 | "/xyz/openbmc_project/inventory", 0, interfaces); |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 221 | } |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 222 | }; |
| 223 | |
| 224 | /** |
| 225 | * Chassis override class for delivering Chassis Schema |
| 226 | */ |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 227 | class Chassis : public Node |
| 228 | { |
| 229 | public: |
Ed Tanous | 52cc112 | 2020-07-18 13:51:21 -0700 | [diff] [blame] | 230 | Chassis(App& app) : Node(app, "/redfish/v1/Chassis/<str>/", std::string()) |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 231 | { |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 232 | entityPrivileges = { |
| 233 | {boost::beast::http::verb::get, {{"Login"}}}, |
| 234 | {boost::beast::http::verb::head, {{"Login"}}}, |
| 235 | {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, |
| 236 | {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, |
| 237 | {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, |
| 238 | {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 239 | } |
Rapkiewicz, Pawel | e37f845 | 2018-03-09 13:49:50 +0100 | [diff] [blame] | 240 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 241 | private: |
| 242 | /** |
| 243 | * Functions triggers appropriate requests on DBus |
| 244 | */ |
Ed Tanous | cb13a39 | 2020-07-25 19:02:03 +0000 | [diff] [blame] | 245 | void doGet(crow::Response& res, const crow::Request&, |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 246 | const std::vector<std::string>& params) override |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 247 | { |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 248 | const std::array<const char*, 2> interfaces = { |
Gunnar Mills | 734bfe9 | 2019-01-21 16:33:50 -0600 | [diff] [blame] | 249 | "xyz.openbmc_project.Inventory.Item.Board", |
Shawn McCarney | adc4f0d | 2019-07-24 09:21:50 -0500 | [diff] [blame] | 250 | "xyz.openbmc_project.Inventory.Item.Chassis"}; |
Gunnar Mills | 734bfe9 | 2019-01-21 16:33:50 -0600 | [diff] [blame] | 251 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 252 | // Check if there is required param, truly entering this shall be |
| 253 | // impossible. |
| 254 | if (params.size() != 1) |
| 255 | { |
Jason M. Bills | f12894f | 2018-10-09 12:45:45 -0700 | [diff] [blame] | 256 | messages::internalError(res); |
Ed Tanous | daf36e2 | 2018-04-20 16:01:36 -0700 | [diff] [blame] | 257 | res.end(); |
| 258 | return; |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 259 | } |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 260 | const std::string& chassisId = params[0]; |
Ed Tanous | e0d918b | 2018-03-27 17:41:04 -0700 | [diff] [blame] | 261 | |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 262 | auto asyncResp = std::make_shared<AsyncResp>(res); |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 263 | crow::connections::systemBus->async_method_call( |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 264 | [asyncResp, chassisId(std::string(chassisId))]( |
| 265 | const boost::system::error_code ec, |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 266 | const crow::openbmc_mapper::GetSubTreeType& subtree) { |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 267 | if (ec) |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 268 | { |
Jason M. Bills | f12894f | 2018-10-09 12:45:45 -0700 | [diff] [blame] | 269 | messages::internalError(asyncResp->res); |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 270 | return; |
| 271 | } |
| 272 | // Iterate over all retrieved ObjectPaths. |
| 273 | for (const std::pair< |
| 274 | std::string, |
| 275 | std::vector< |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 276 | std::pair<std::string, std::vector<std::string>>>>& |
| 277 | object : subtree) |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 278 | { |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 279 | const std::string& path = object.first; |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 280 | const std::vector< |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 281 | std::pair<std::string, std::vector<std::string>>>& |
| 282 | connectionNames = object.second; |
Ed Tanous | e0d918b | 2018-03-27 17:41:04 -0700 | [diff] [blame] | 283 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 284 | if (!boost::ends_with(path, chassisId)) |
| 285 | { |
| 286 | continue; |
Ed Tanous | daf36e2 | 2018-04-20 16:01:36 -0700 | [diff] [blame] | 287 | } |
Shawn McCarney | 26f0389 | 2019-05-03 13:20:24 -0500 | [diff] [blame] | 288 | |
James Feist | b49ac87 | 2019-05-21 15:12:01 -0700 | [diff] [blame] | 289 | auto health = std::make_shared<HealthPopulate>(asyncResp); |
| 290 | |
| 291 | crow::connections::systemBus->async_method_call( |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 292 | [health](const boost::system::error_code ec2, |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 293 | std::variant<std::vector<std::string>>& resp) { |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 294 | if (ec2) |
James Feist | b49ac87 | 2019-05-21 15:12:01 -0700 | [diff] [blame] | 295 | { |
| 296 | return; // no sensors = no failures |
| 297 | } |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 298 | std::vector<std::string>* data = |
James Feist | b49ac87 | 2019-05-21 15:12:01 -0700 | [diff] [blame] | 299 | std::get_if<std::vector<std::string>>(&resp); |
| 300 | if (data == nullptr) |
| 301 | { |
| 302 | return; |
| 303 | } |
| 304 | health->inventory = std::move(*data); |
| 305 | }, |
| 306 | "xyz.openbmc_project.ObjectMapper", |
| 307 | path + "/all_sensors", |
| 308 | "org.freedesktop.DBus.Properties", "Get", |
| 309 | "xyz.openbmc_project.Association", "endpoints"); |
| 310 | |
| 311 | health->populate(); |
| 312 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 313 | if (connectionNames.size() < 1) |
| 314 | { |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 315 | BMCWEB_LOG_ERROR << "Got 0 Connection names"; |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 316 | continue; |
| 317 | } |
Ed Tanous | e0d918b | 2018-03-27 17:41:04 -0700 | [diff] [blame] | 318 | |
Johnathan Mantey | 49c53ac | 2019-05-02 09:22:38 -0700 | [diff] [blame] | 319 | asyncResp->res.jsonValue["@odata.type"] = |
Jason M. Bills | adbe192 | 2019-10-14 15:44:35 -0700 | [diff] [blame] | 320 | "#Chassis.v1_10_0.Chassis"; |
Johnathan Mantey | 49c53ac | 2019-05-02 09:22:38 -0700 | [diff] [blame] | 321 | asyncResp->res.jsonValue["@odata.id"] = |
| 322 | "/redfish/v1/Chassis/" + chassisId; |
Johnathan Mantey | 49c53ac | 2019-05-02 09:22:38 -0700 | [diff] [blame] | 323 | asyncResp->res.jsonValue["Name"] = "Chassis Collection"; |
| 324 | asyncResp->res.jsonValue["ChassisType"] = "RackMount"; |
P.K. Lee | dd99e04 | 2020-06-17 19:43:16 +0800 | [diff] [blame] | 325 | asyncResp->res.jsonValue["Actions"]["#Chassis.Reset"] = { |
| 326 | {"target", "/redfish/v1/Chassis/" + chassisId + |
| 327 | "/Actions/Chassis.Reset"}, |
AppaRao Puli | 1cb1a9e | 2020-07-17 23:38:57 +0530 | [diff] [blame] | 328 | {"@Redfish.ActionInfo", "/redfish/v1/Chassis/" + |
| 329 | chassisId + |
| 330 | "/ResetActionInfo"}}; |
Jason M. Bills | adbe192 | 2019-10-14 15:44:35 -0700 | [diff] [blame] | 331 | asyncResp->res.jsonValue["PCIeDevices"] = { |
| 332 | {"@odata.id", |
| 333 | "/redfish/v1/Systems/system/PCIeDevices"}}; |
Johnathan Mantey | 49c53ac | 2019-05-02 09:22:38 -0700 | [diff] [blame] | 334 | |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 335 | const std::string& connectionName = |
Johnathan Mantey | 49c53ac | 2019-05-02 09:22:38 -0700 | [diff] [blame] | 336 | connectionNames[0].first; |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 337 | |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 338 | const std::vector<std::string>& interfaces2 = |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 339 | connectionNames[0].second; |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 340 | const std::array<const char*, 2> hasIndicatorLed = { |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 341 | "xyz.openbmc_project.Inventory.Item.Panel", |
| 342 | "xyz.openbmc_project.Inventory.Item.Board.Motherboard"}; |
| 343 | |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 344 | for (const char* interface : hasIndicatorLed) |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 345 | { |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 346 | if (std::find(interfaces2.begin(), interfaces2.end(), |
| 347 | interface) != interfaces2.end()) |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 348 | { |
| 349 | getIndicatorLedState(asyncResp); |
| 350 | break; |
| 351 | } |
| 352 | } |
| 353 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 354 | crow::connections::systemBus->async_method_call( |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 355 | [asyncResp, chassisId(std::string(chassisId))]( |
Ed Tanous | 90728b5 | 2020-08-19 09:06:34 -0700 | [diff] [blame] | 356 | const boost::system::error_code /*ec2*/, |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 357 | const std::vector<std::pair< |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 358 | std::string, VariantType>>& propertiesList) { |
| 359 | for (const std::pair<std::string, VariantType>& |
| 360 | property : propertiesList) |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 361 | { |
Shawn McCarney | 99cffd7 | 2019-03-01 10:46:20 -0600 | [diff] [blame] | 362 | // Store DBus properties that are also Redfish |
| 363 | // properties with same name and a string value |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 364 | const std::string& propertyName = |
Shawn McCarney | 99cffd7 | 2019-03-01 10:46:20 -0600 | [diff] [blame] | 365 | property.first; |
| 366 | if ((propertyName == "PartNumber") || |
| 367 | (propertyName == "SerialNumber") || |
| 368 | (propertyName == "Manufacturer") || |
| 369 | (propertyName == "Model")) |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 370 | { |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 371 | const std::string* value = |
Shawn McCarney | 99cffd7 | 2019-03-01 10:46:20 -0600 | [diff] [blame] | 372 | std::get_if<std::string>( |
| 373 | &property.second); |
| 374 | if (value != nullptr) |
| 375 | { |
| 376 | asyncResp->res.jsonValue[propertyName] = |
| 377 | *value; |
| 378 | } |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 379 | } |
| 380 | } |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 381 | asyncResp->res.jsonValue["Name"] = chassisId; |
| 382 | asyncResp->res.jsonValue["Id"] = chassisId; |
| 383 | asyncResp->res.jsonValue["Thermal"] = { |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 384 | {"@odata.id", "/redfish/v1/Chassis/" + |
| 385 | chassisId + "/Thermal"}}; |
Ed Tanous | 2474adf | 2018-09-05 16:31:16 -0700 | [diff] [blame] | 386 | // Power object |
| 387 | asyncResp->res.jsonValue["Power"] = { |
| 388 | {"@odata.id", "/redfish/v1/Chassis/" + |
| 389 | chassisId + "/Power"}}; |
Anthony Wilson | 95a3eca | 2019-06-11 10:44:47 -0500 | [diff] [blame] | 390 | // SensorCollection |
| 391 | asyncResp->res.jsonValue["Sensors"] = { |
| 392 | {"@odata.id", "/redfish/v1/Chassis/" + |
| 393 | chassisId + "/Sensors"}}; |
Ed Tanous | 029573d | 2019-02-01 10:57:49 -0800 | [diff] [blame] | 394 | asyncResp->res.jsonValue["Status"] = { |
Ed Tanous | 029573d | 2019-02-01 10:57:49 -0800 | [diff] [blame] | 395 | {"State", "Enabled"}, |
| 396 | }; |
Ed Tanous | 2474adf | 2018-09-05 16:31:16 -0700 | [diff] [blame] | 397 | |
Ed Tanous | 029573d | 2019-02-01 10:57:49 -0800 | [diff] [blame] | 398 | asyncResp->res |
| 399 | .jsonValue["Links"]["ComputerSystems"] = { |
| 400 | {{"@odata.id", "/redfish/v1/Systems/system"}}}; |
| 401 | asyncResp->res.jsonValue["Links"]["ManagedBy"] = { |
| 402 | {{"@odata.id", "/redfish/v1/Managers/bmc"}}}; |
Gunnar Mills | beeca0a | 2019-02-14 16:30:45 -0600 | [diff] [blame] | 403 | getChassisState(asyncResp); |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 404 | }, |
| 405 | connectionName, path, "org.freedesktop.DBus.Properties", |
| 406 | "GetAll", |
| 407 | "xyz.openbmc_project.Inventory.Decorator.Asset"); |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 408 | return; |
| 409 | } |
Ed Tanous | e0d918b | 2018-03-27 17:41:04 -0700 | [diff] [blame] | 410 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 411 | // Couldn't find an object with that name. return an error |
Jason M. Bills | f12894f | 2018-10-09 12:45:45 -0700 | [diff] [blame] | 412 | messages::resourceNotFound( |
Jason M. Bills | adbe192 | 2019-10-14 15:44:35 -0700 | [diff] [blame] | 413 | asyncResp->res, "#Chassis.v1_10_0.Chassis", chassisId); |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 414 | }, |
| 415 | "xyz.openbmc_project.ObjectMapper", |
| 416 | "/xyz/openbmc_project/object_mapper", |
| 417 | "xyz.openbmc_project.ObjectMapper", "GetSubTree", |
Ed Tanous | 271584a | 2019-07-09 16:24:22 -0700 | [diff] [blame] | 418 | "/xyz/openbmc_project/inventory", 0, interfaces); |
Qiang XU | c181942 | 2019-02-27 13:51:32 +0800 | [diff] [blame] | 419 | |
| 420 | getPhysicalSecurityData(asyncResp); |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 421 | } |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 422 | |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 423 | void doPatch(crow::Response& res, const crow::Request& req, |
| 424 | const std::vector<std::string>& params) override |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 425 | { |
| 426 | std::optional<std::string> indicatorLed; |
| 427 | auto asyncResp = std::make_shared<AsyncResp>(res); |
| 428 | |
| 429 | if (params.size() != 1) |
| 430 | { |
| 431 | return; |
| 432 | } |
| 433 | |
| 434 | if (!json_util::readJson(req, res, "IndicatorLED", indicatorLed)) |
| 435 | { |
| 436 | return; |
| 437 | } |
| 438 | |
| 439 | if (!indicatorLed) |
| 440 | { |
| 441 | return; // delete this when we support more patch properties |
| 442 | } |
| 443 | |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 444 | const std::array<const char*, 2> interfaces = { |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 445 | "xyz.openbmc_project.Inventory.Item.Board", |
| 446 | "xyz.openbmc_project.Inventory.Item.Chassis"}; |
| 447 | |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 448 | const std::string& chassisId = params[0]; |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 449 | |
| 450 | crow::connections::systemBus->async_method_call( |
| 451 | [asyncResp, chassisId, indicatorLed]( |
| 452 | const boost::system::error_code ec, |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 453 | const crow::openbmc_mapper::GetSubTreeType& subtree) { |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 454 | if (ec) |
| 455 | { |
| 456 | messages::internalError(asyncResp->res); |
| 457 | return; |
| 458 | } |
| 459 | |
| 460 | // Iterate over all retrieved ObjectPaths. |
| 461 | for (const std::pair< |
| 462 | std::string, |
| 463 | std::vector< |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 464 | std::pair<std::string, std::vector<std::string>>>>& |
| 465 | object : subtree) |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 466 | { |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 467 | const std::string& path = object.first; |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 468 | const std::vector< |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 469 | std::pair<std::string, std::vector<std::string>>>& |
| 470 | connectionNames = object.second; |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 471 | |
| 472 | if (!boost::ends_with(path, chassisId)) |
| 473 | { |
| 474 | continue; |
| 475 | } |
| 476 | |
| 477 | if (connectionNames.size() < 1) |
| 478 | { |
| 479 | BMCWEB_LOG_ERROR << "Got 0 Connection names"; |
| 480 | continue; |
| 481 | } |
| 482 | |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 483 | const std::vector<std::string>& interfaces3 = |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 484 | connectionNames[0].second; |
| 485 | |
| 486 | if (indicatorLed) |
| 487 | { |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 488 | const std::array<const char*, 2> hasIndicatorLed = { |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 489 | "xyz.openbmc_project.Inventory.Item.Panel", |
| 490 | "xyz.openbmc_project.Inventory.Item.Board." |
| 491 | "Motherboard"}; |
| 492 | bool indicatorChassis = false; |
Gunnar Mills | 1214b7e | 2020-06-04 10:11:30 -0500 | [diff] [blame] | 493 | for (const char* interface : hasIndicatorLed) |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 494 | { |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 495 | if (std::find(interfaces3.begin(), |
| 496 | interfaces3.end(), |
| 497 | interface) != interfaces3.end()) |
James Feist | 1c8fba9 | 2019-12-20 15:12:07 -0800 | [diff] [blame] | 498 | { |
| 499 | indicatorChassis = true; |
| 500 | break; |
| 501 | } |
| 502 | } |
| 503 | if (indicatorChassis) |
| 504 | { |
| 505 | setIndicatorLedState(asyncResp, |
| 506 | std::move(*indicatorLed)); |
| 507 | } |
| 508 | else |
| 509 | { |
| 510 | messages::propertyUnknown(asyncResp->res, |
| 511 | "IndicatorLED"); |
| 512 | } |
| 513 | } |
| 514 | return; |
| 515 | } |
| 516 | |
| 517 | messages::resourceNotFound( |
| 518 | asyncResp->res, "#Chassis.v1_10_0.Chassis", chassisId); |
| 519 | }, |
| 520 | "xyz.openbmc_project.ObjectMapper", |
| 521 | "/xyz/openbmc_project/object_mapper", |
| 522 | "xyz.openbmc_project.ObjectMapper", "GetSubTree", |
| 523 | "/xyz/openbmc_project/inventory", 0, interfaces); |
| 524 | } |
Ed Tanous | 62d5e2e | 2018-09-05 16:17:25 -0700 | [diff] [blame] | 525 | }; |
P.K. Lee | dd99e04 | 2020-06-17 19:43:16 +0800 | [diff] [blame] | 526 | |
Ed Tanous | 23a21a1 | 2020-07-25 04:45:05 +0000 | [diff] [blame] | 527 | inline void doChassisPowerCycle(std::shared_ptr<AsyncResp> asyncResp) |
P.K. Lee | dd99e04 | 2020-06-17 19:43:16 +0800 | [diff] [blame] | 528 | { |
| 529 | const char* processName = "xyz.openbmc_project.State.Chassis"; |
| 530 | const char* objectPath = "/xyz/openbmc_project/state/chassis0"; |
| 531 | const char* interfaceName = "xyz.openbmc_project.State.Chassis"; |
| 532 | const char* destProperty = "RequestedPowerTransition"; |
| 533 | const std::string propertyValue = |
| 534 | "xyz.openbmc_project.State.Chassis.Transition.PowerCycle"; |
| 535 | |
| 536 | crow::connections::systemBus->async_method_call( |
| 537 | [asyncResp](const boost::system::error_code ec) { |
| 538 | // Use "Set" method to set the property value. |
| 539 | if (ec) |
| 540 | { |
| 541 | BMCWEB_LOG_DEBUG << "[Set] Bad D-Bus request error: " << ec; |
| 542 | messages::internalError(asyncResp->res); |
| 543 | return; |
| 544 | } |
| 545 | |
| 546 | messages::success(asyncResp->res); |
| 547 | }, |
| 548 | processName, objectPath, "org.freedesktop.DBus.Properties", "Set", |
| 549 | interfaceName, destProperty, std::variant<std::string>{propertyValue}); |
| 550 | } |
| 551 | |
| 552 | /** |
| 553 | * ChassisResetAction class supports the POST method for the Reset |
| 554 | * action. |
| 555 | */ |
| 556 | class ChassisResetAction : public Node |
| 557 | { |
| 558 | public: |
Ed Tanous | 52cc112 | 2020-07-18 13:51:21 -0700 | [diff] [blame] | 559 | ChassisResetAction(App& app) : |
P.K. Lee | dd99e04 | 2020-06-17 19:43:16 +0800 | [diff] [blame] | 560 | Node(app, "/redfish/v1/Chassis/<str>/Actions/Chassis.Reset/", |
| 561 | std::string()) |
| 562 | { |
| 563 | entityPrivileges = { |
| 564 | {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; |
| 565 | } |
| 566 | |
| 567 | private: |
| 568 | /** |
| 569 | * Function handles POST method request. |
| 570 | * Analyzes POST body before sending Reset request data to D-Bus. |
| 571 | */ |
| 572 | void doPost(crow::Response& res, const crow::Request& req, |
Ed Tanous | cb13a39 | 2020-07-25 19:02:03 +0000 | [diff] [blame] | 573 | const std::vector<std::string>&) override |
P.K. Lee | dd99e04 | 2020-06-17 19:43:16 +0800 | [diff] [blame] | 574 | { |
| 575 | BMCWEB_LOG_DEBUG << "Post Chassis Reset."; |
| 576 | |
| 577 | std::string resetType; |
| 578 | auto asyncResp = std::make_shared<AsyncResp>(res); |
| 579 | |
| 580 | if (!json_util::readJson(req, asyncResp->res, "ResetType", resetType)) |
| 581 | { |
| 582 | return; |
| 583 | } |
| 584 | |
| 585 | if (resetType != "PowerCycle") |
| 586 | { |
| 587 | BMCWEB_LOG_DEBUG << "Invalid property value for ResetType: " |
| 588 | << resetType; |
| 589 | messages::actionParameterNotSupported(asyncResp->res, resetType, |
| 590 | "ResetType"); |
| 591 | |
| 592 | return; |
| 593 | } |
| 594 | doChassisPowerCycle(asyncResp); |
| 595 | } |
| 596 | }; |
AppaRao Puli | 1cb1a9e | 2020-07-17 23:38:57 +0530 | [diff] [blame] | 597 | |
| 598 | /** |
| 599 | * ChassisResetActionInfo derived class for delivering Chassis |
| 600 | * ResetType AllowableValues using ResetInfo schema. |
| 601 | */ |
| 602 | class ChassisResetActionInfo : public Node |
| 603 | { |
| 604 | public: |
| 605 | /* |
| 606 | * Default Constructor |
| 607 | */ |
Ed Tanous | 52cc112 | 2020-07-18 13:51:21 -0700 | [diff] [blame] | 608 | ChassisResetActionInfo(App& app) : |
AppaRao Puli | 1cb1a9e | 2020-07-17 23:38:57 +0530 | [diff] [blame] | 609 | Node(app, "/redfish/v1/Chassis/<str>/ResetActionInfo/", std::string()) |
| 610 | { |
| 611 | entityPrivileges = { |
| 612 | {boost::beast::http::verb::get, {{"Login"}}}, |
| 613 | {boost::beast::http::verb::head, {{"Login"}}}, |
| 614 | {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, |
| 615 | {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, |
| 616 | {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, |
| 617 | {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; |
| 618 | } |
| 619 | |
| 620 | private: |
| 621 | /** |
| 622 | * Functions triggers appropriate requests on DBus |
| 623 | */ |
Ed Tanous | cb13a39 | 2020-07-25 19:02:03 +0000 | [diff] [blame] | 624 | void doGet(crow::Response& res, const crow::Request&, |
AppaRao Puli | 1cb1a9e | 2020-07-17 23:38:57 +0530 | [diff] [blame] | 625 | const std::vector<std::string>& params) override |
| 626 | { |
| 627 | if (params.size() != 1) |
| 628 | { |
| 629 | messages::internalError(res); |
| 630 | res.end(); |
| 631 | return; |
| 632 | } |
| 633 | const std::string& chassisId = params[0]; |
| 634 | |
| 635 | res.jsonValue = {{"@odata.type", "#ActionInfo.v1_1_2.ActionInfo"}, |
| 636 | {"@odata.id", "/redfish/v1/Chassis/" + chassisId + |
| 637 | "/ResetActionInfo"}, |
| 638 | {"Name", "Reset Action Info"}, |
| 639 | {"Id", "ResetActionInfo"}, |
| 640 | {"Parameters", |
| 641 | {{{"Name", "ResetType"}, |
| 642 | {"Required", true}, |
| 643 | {"DataType", "String"}, |
| 644 | {"AllowableValues", {"PowerCycle"}}}}}}; |
| 645 | res.end(); |
| 646 | } |
| 647 | }; |
| 648 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 649 | } // namespace redfish |