redfish-core/lib/chassis.hpp - openbmc/bmcweb - Gitiles

 /*
 // Copyright (c) 2018 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 */
 #pragma once

 #include "node.hpp"
 #include <boost/container/flat_map.hpp>

 namespace redfish {

 /**
  * DBus types primitives for several generic DBus interfaces
  * TODO(Pawel) consider move this to separate file into boost::dbus
  */
 using ManagedObjectsType = std::vector<
     std::pair<dbus::object_path,
               std::vector<std::pair<
                   std::string,
                   std::vector<std::pair<std::string, dbus::dbus_variant>>>>>>;

 using PropertiesType =
     boost::container::flat_map<std::string, dbus::dbus_variant>;

 /**
  * OnDemandChassisProvider
  * Chassis provider class that retrieves data directly from dbus, before seting
  * it into JSON output. This does not cache any data.
  *
  * Class can be a good example on how to scale different data providing
  * solutions to produce single schema output.
  *
  * TODO(Pawel)
  * This perhaps shall be different file, which has to be chosen on compile time
  * depending on OEM needs
  */
 class OnDemandChassisProvider {
  public:
   /**
    * Function that retrieves all properties for given Chassis Object from
    * EntityManager
    * @param res_name a chassis resource name to query on DBus
    * @param callback a function that shall be called to convert Dbus output into
    * JSON
    */
   template <typename CallbackFunc>
   void get_chassis_data(const std::string &res_name, CallbackFunc &&callback) {
     crow::connections::system_bus->async_method_call(
         [callback{std::move(callback)}](
             const boost::system::error_code error_code,
             const PropertiesType &properties) {
           // Callback requires flat_map<string, string> so prepare one.
           boost::container::flat_map<std::string, std::string> output;
           if (error_code) {
             // Something wrong on DBus, the error_code is not important at this
             // moment, just return success=false, and empty output. Since size
             // of map may vary depending on Chassis type, an empty output could
             // not be treated same way as error.
             callback(false, output);
             return;
           }
           for (const std::pair<const char *, const char *> &p :
                std::array<std::pair<const char *, const char *>, 5>{
                    {{"name", "Name"},
                     {"manufacturer", "Manufacturer"},
                     {"model", "Model"},
                     {"part_number", "PartNumber"},
                     {"serial_number", "SerialNumber"}}}) {
             PropertiesType::const_iterator it = properties.find(p.first);
             if (it != properties.end()) {
               const std::string *s = boost::get<std::string>(&it->second);
               if (s != nullptr) {
                 output[p.second] = *s;
               }
             }
           }
           // Callback with success, and hopefully data.
           callback(true, output);
         },
         {"xyz.openbmc_project.EntityManager",
          "/xyz/openbmc_project/Inventory/Item/Chassis/" + res_name,
          "org.freedesktop.DBus.Properties", "GetAll"},
         "xyz.openbmc_project.Configuration.Chassis");
   }

   /**
    * Function that retrieves all Chassis available through EntityManager.
    * @param callback a function that shall be called to convert Dbus output into
    * JSON.
    */
   template <typename CallbackFunc>
   void get_chassis_list(CallbackFunc &&callback) {
     crow::connections::system_bus->async_method_call(
         [callback{std::move(callback)}](
             const boost::system::error_code error_code,
             const ManagedObjectsType &resp) {
           // Callback requires vector<string> to retrieve all available chassis
           // list.
           std::vector<std::string> chassis_list;
           if (error_code) {
             // Something wrong on DBus, the error_code is not important at this
             // moment, just return success=false, and empty output. Since size
             // of vector may vary depending on information from Entity Manager,
             // and empty output could not be treated same way as error.
             callback(false, chassis_list);
             return;
           }

           // Iterate over all retrieved ObjectPaths.
           for (auto &objpath : resp) {
             // And all interfaces available for certain ObjectPath.
             for (auto &interface : objpath.second) {
               // If interface is xyz.openbmc_project.Configuration.Chassis, this
               // is Chassis.
               if (interface.first ==
                   "xyz.openbmc_project.Configuration.Chassis") {
                 // Cut out everyting until last "/", ...
                 const std::string &chassis_id = objpath.first.value;
                 std::size_t last_pos = chassis_id.rfind("/");
                 if (last_pos != std::string::npos) {
                   // and put it into output vector.
                   chassis_list.emplace_back(chassis_id.substr(last_pos + 1));
                 }
               }
             }
           }
           // Finally make a callback with usefull data
           callback(true, chassis_list);
         },
         {"xyz.openbmc_project.EntityManager",
          "/xyz/openbmc_project/Inventory/Item/Chassis",
          "org.freedesktop.DBus.ObjectManager", "GetManagedObjects"});
   };
 };

 /**
  * ChassisCollection derived class for delivering Chassis Collection Schema
  */
 class ChassisCollection : public Node {
  public:
   template <typename CrowApp>
   ChassisCollection(CrowApp &app) : Node(app, "/redfish/v1/Chassis/") {
     Node::json["@odata.type"] = "#ChassisCollection.ChassisCollection";
     Node::json["@odata.id"] = "/redfish/v1/Chassis";
     Node::json["@odata.context"] =
         "/redfish/v1/$metadata#ChassisCollection.ChassisCollection";
     Node::json["Name"] = "Chassis Collection";

     entityPrivileges = {{crow::HTTPMethod::GET, {{"Login"}}},
                         {crow::HTTPMethod::HEAD, {{"Login"}}},
                         {crow::HTTPMethod::PATCH, {{"ConfigureComponents"}}},
                         {crow::HTTPMethod::PUT, {{"ConfigureComponents"}}},
                         {crow::HTTPMethod::DELETE, {{"ConfigureComponents"}}},
                         {crow::HTTPMethod::POST, {{"ConfigureComponents"}}}};
   }

  private:
   /**
    * Functions triggers appropriate requests on DBus
    */
   void doGet(crow::response &res, const crow::request &req,
              const std::vector<std::string> &params) override {
     // Get chassis list, and call the below callback for JSON preparation
     chassis_provider.get_chassis_list(
         [&](const bool &success, const std::vector<std::string> &output) {
           if (success) {
             // ... prepare json array with appropriate @odata.id links
             nlohmann::json chassis_array = nlohmann::json::array();
             for (const std::string &chassis_item : output) {
               chassis_array.push_back(
                   {{"@odata.id", "/redfish/v1/Chassis/" + chassis_item}});
             }
             // Then attach members, count size and return,
             Node::json["Members"] = chassis_array;
             Node::json["Members@odata.count"] = chassis_array.size();
             res.json_value = Node::json;
           } else {
             // ... otherwise, return INTERNALL ERROR
             res.code = static_cast<int>(HttpRespCode::INTERNAL_ERROR);
           }
           res.end();
         });
   }

   // Chassis Provider object
   // TODO(Pawel) consider move it to singleton
   OnDemandChassisProvider chassis_provider;
 };

 /**
  * Chassis override class for delivering Chassis Schema
  */
 class Chassis : public Node {
  public:
   /*
    * Default Constructor
    */
   template <typename CrowApp>
   Chassis(CrowApp &app)
       : Node(app, "/redfish/v1/Chassis/<str>/", std::string()) {
     Node::json["@odata.type"] = "#Chassis.v1_4_0.Chassis";
     Node::json["@odata.id"] = "/redfish/v1/Chassis";
     Node::json["@odata.context"] = "/redfish/v1/$metadata#Chassis.Chassis";
     Node::json["Name"] = "Chassis Collection";
     Node::json["ChassisType"] = "RackMount";

     entityPrivileges = {{crow::HTTPMethod::GET, {{"Login"}}},
                         {crow::HTTPMethod::HEAD, {{"Login"}}},
                         {crow::HTTPMethod::PATCH, {{"ConfigureComponents"}}},
                         {crow::HTTPMethod::PUT, {{"ConfigureComponents"}}},
                         {crow::HTTPMethod::DELETE, {{"ConfigureComponents"}}},
                         {crow::HTTPMethod::POST, {{"ConfigureComponents"}}}};
   }

  private:
   /**
    * Functions triggers appropriate requests on DBus
    */
   void doGet(crow::response &res, const crow::request &req,
              const std::vector<std::string> &params) override {
     // Check if there is required param, truly entering this shall be
     // impossible.
     if (params.size() != 1) {
       res.code = static_cast<int>(HttpRespCode::INTERNAL_ERROR);
       res.end();
       return;
     }
     const std::string &chassis_id = params[0];
     // Get certain Chassis Data, and call the below callback for JSON
     // preparation lambda requires everything as reference, and chassis_id,
     // which is local by copy
     chassis_provider.get_chassis_data(
         chassis_id,
         [&, chassis_id](const bool &success,
                         const boost::container::flat_map<std::string,
                                                          std::string> &output) {
           // Create JSON copy based on Node::json, this is to avoid possible
           // race condition
           nlohmann::json json_response(Node::json);
           json_response["Thermal"] = {
               {"@odata.id", "/redfish/v1/Chassis/" + chassis_id + "/Thermal"}};
           // If success...
           if (success) {
             // prepare all the schema required fields.
             json_response["@odata.id"] = "/redfish/v1/Chassis/" + chassis_id;
             // also the one from dbus
             for (const std::pair<std::string, std::string> &chassis_item :
                  output) {
               json_response[chassis_item.first] = chassis_item.second;
             }

             json_response["Id"] = chassis_id;
             // prepare respond, and send
             res.json_value = json_response;
           } else {
             // ... otherwise return error
             // TODO(Pawel)consider distinguish between non existing object, and
             // other errors
             res.code = static_cast<int>(HttpRespCode::NOT_FOUND);
           }
           res.end();
         });
   }

   // Chassis Provider object
   // TODO(Pawel) consider move it to singleton
   OnDemandChassisProvider chassis_provider;
 };

 }  // namespace redfish
	/*
	// Copyright (c) 2018 Intel Corporation
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	*/
	#pragma once

	#include "node.hpp"
	#include <boost/container/flat_map.hpp>

	namespace redfish {

	/**
	* DBus types primitives for several generic DBus interfaces
	* TODO(Pawel) consider move this to separate file into boost::dbus
	*/
	using ManagedObjectsType = std::vector<
	std::pair<dbus::object_path,
	std::vector<std::pair<
	std::string,
	std::vector<std::pair<std::string, dbus::dbus_variant>>>>>>;

	using PropertiesType =
	boost::container::flat_map<std::string, dbus::dbus_variant>;

	/**
	* OnDemandChassisProvider
	* Chassis provider class that retrieves data directly from dbus, before seting
	* it into JSON output. This does not cache any data.
	*
	* Class can be a good example on how to scale different data providing
	* solutions to produce single schema output.
	*
	* TODO(Pawel)
	* This perhaps shall be different file, which has to be chosen on compile time
	* depending on OEM needs
	*/
	class OnDemandChassisProvider {
	public:
	/**
	* Function that retrieves all properties for given Chassis Object from
	* EntityManager
	* @param res_name a chassis resource name to query on DBus
	* @param callback a function that shall be called to convert Dbus output into
	* JSON
	*/
	template <typename CallbackFunc>
	void get_chassis_data(const std::string &res_name, CallbackFunc &&callback) {
	crow::connections::system_bus->async_method_call(
	[callback{std::move(callback)}](
	const boost::system::error_code error_code,
	const PropertiesType &properties) {
	// Callback requires flat_map<string, string> so prepare one.
	boost::container::flat_map<std::string, std::string> output;
	if (error_code) {
	// Something wrong on DBus, the error_code is not important at this
	// moment, just return success=false, and empty output. Since size
	// of map may vary depending on Chassis type, an empty output could
	// not be treated same way as error.
	callback(false, output);
	return;
	}
	for (const std::pair<const char , const char > &p :
	std::array<std::pair<const char , const char >, 5>{
	{{"name", "Name"},
	{"manufacturer", "Manufacturer"},
	{"model", "Model"},
	{"part_number", "PartNumber"},
	{"serial_number", "SerialNumber"}}}) {
	PropertiesType::const_iterator it = properties.find(p.first);
	if (it != properties.end()) {
	const std::string *s = boost::get<std::string>(&it->second);
	if (s != nullptr) {
	output[p.second] = *s;
	}
	}
	}
	// Callback with success, and hopefully data.
	callback(true, output);
	},
	{"xyz.openbmc_project.EntityManager",
	"/xyz/openbmc_project/Inventory/Item/Chassis/" + res_name,
	"org.freedesktop.DBus.Properties", "GetAll"},
	"xyz.openbmc_project.Configuration.Chassis");
	}

	/**
	* Function that retrieves all Chassis available through EntityManager.
	* @param callback a function that shall be called to convert Dbus output into
	* JSON.
	*/
	template <typename CallbackFunc>
	void get_chassis_list(CallbackFunc &&callback) {
	crow::connections::system_bus->async_method_call(
	[callback{std::move(callback)}](
	const boost::system::error_code error_code,
	const ManagedObjectsType &resp) {
	// Callback requires vector<string> to retrieve all available chassis
	// list.
	std::vector<std::string> chassis_list;
	if (error_code) {
	// Something wrong on DBus, the error_code is not important at this
	// moment, just return success=false, and empty output. Since size
	// of vector may vary depending on information from Entity Manager,
	// and empty output could not be treated same way as error.
	callback(false, chassis_list);
	return;
	}

	// Iterate over all retrieved ObjectPaths.
	for (auto &objpath : resp) {
	// And all interfaces available for certain ObjectPath.
	for (auto &interface : objpath.second) {
	// If interface is xyz.openbmc_project.Configuration.Chassis, this
	// is Chassis.
	if (interface.first ==
	"xyz.openbmc_project.Configuration.Chassis") {
	// Cut out everyting until last "/", ...
	const std::string &chassis_id = objpath.first.value;
	std::size_t last_pos = chassis_id.rfind("/");
	if (last_pos != std::string::npos) {
	// and put it into output vector.
	chassis_list.emplace_back(chassis_id.substr(last_pos + 1));
	}
	}
	}
	}
	// Finally make a callback with usefull data
	callback(true, chassis_list);
	},
	{"xyz.openbmc_project.EntityManager",
	"/xyz/openbmc_project/Inventory/Item/Chassis",
	"org.freedesktop.DBus.ObjectManager", "GetManagedObjects"});
	};
	};

	/**
	* ChassisCollection derived class for delivering Chassis Collection Schema
	*/
	class ChassisCollection : public Node {
	public:
	template <typename CrowApp>
	ChassisCollection(CrowApp &app) : Node(app, "/redfish/v1/Chassis/") {
	Node::json["@odata.type"] = "#ChassisCollection.ChassisCollection";
	Node::json["@odata.id"] = "/redfish/v1/Chassis";
	Node::json["@odata.context"] =
	"/redfish/v1/$metadata#ChassisCollection.ChassisCollection";
	Node::json["Name"] = "Chassis Collection";

	entityPrivileges = {{crow::HTTPMethod::GET, {{"Login"}}},
	{crow::HTTPMethod::HEAD, {{"Login"}}},
	{crow::HTTPMethod::PATCH, {{"ConfigureComponents"}}},
	{crow::HTTPMethod::PUT, {{"ConfigureComponents"}}},
	{crow::HTTPMethod::DELETE, {{"ConfigureComponents"}}},
	{crow::HTTPMethod::POST, {{"ConfigureComponents"}}}};
	}

	private:
	/**
	* Functions triggers appropriate requests on DBus
	*/
	void doGet(crow::response &res, const crow::request &req,
	const std::vector<std::string> &params) override {
	// Get chassis list, and call the below callback for JSON preparation
	chassis_provider.get_chassis_list(
	[&](const bool &success, const std::vector<std::string> &output) {
	if (success) {
	// ... prepare json array with appropriate @odata.id links
	nlohmann::json chassis_array = nlohmann::json::array();
	for (const std::string &chassis_item : output) {
	chassis_array.push_back(
	{{"@odata.id", "/redfish/v1/Chassis/" + chassis_item}});
	}
	// Then attach members, count size and return,
	Node::json["Members"] = chassis_array;
	Node::json["Members@odata.count"] = chassis_array.size();
	res.json_value = Node::json;
	} else {
	// ... otherwise, return INTERNALL ERROR
	res.code = static_cast<int>(HttpRespCode::INTERNAL_ERROR);
	}
	res.end();
	});
	}

	// Chassis Provider object
	// TODO(Pawel) consider move it to singleton
	OnDemandChassisProvider chassis_provider;
	};

	/**
	* Chassis override class for delivering Chassis Schema
	*/
	class Chassis : public Node {
	public:
	/*
	* Default Constructor
	*/
	template <typename CrowApp>
	Chassis(CrowApp &app)
	: Node(app, "/redfish/v1/Chassis/<str>/", std::string()) {
	Node::json["@odata.type"] = "#Chassis.v1_4_0.Chassis";
	Node::json["@odata.id"] = "/redfish/v1/Chassis";
	Node::json["@odata.context"] = "/redfish/v1/$metadata#Chassis.Chassis";
	Node::json["Name"] = "Chassis Collection";
	Node::json["ChassisType"] = "RackMount";

	entityPrivileges = {{crow::HTTPMethod::GET, {{"Login"}}},
	{crow::HTTPMethod::HEAD, {{"Login"}}},
	{crow::HTTPMethod::PATCH, {{"ConfigureComponents"}}},
	{crow::HTTPMethod::PUT, {{"ConfigureComponents"}}},
	{crow::HTTPMethod::DELETE, {{"ConfigureComponents"}}},
	{crow::HTTPMethod::POST, {{"ConfigureComponents"}}}};
	}

	private:
	/**
	* Functions triggers appropriate requests on DBus
	*/
	void doGet(crow::response &res, const crow::request &req,
	const std::vector<std::string> &params) override {
	// Check if there is required param, truly entering this shall be
	// impossible.
	if (params.size() != 1) {
	res.code = static_cast<int>(HttpRespCode::INTERNAL_ERROR);
	res.end();
	return;
	}
	const std::string &chassis_id = params[0];
	// Get certain Chassis Data, and call the below callback for JSON
	// preparation lambda requires everything as reference, and chassis_id,
	// which is local by copy
	chassis_provider.get_chassis_data(
	chassis_id,
	[&, chassis_id](const bool &success,
	const boost::container::flat_map<std::string,
	std::string> &output) {
	// Create JSON copy based on Node::json, this is to avoid possible
	// race condition
	nlohmann::json json_response(Node::json);
	json_response["Thermal"] = {
	{"@odata.id", "/redfish/v1/Chassis/" + chassis_id + "/Thermal"}};
	// If success...
	if (success) {
	// prepare all the schema required fields.
	json_response["@odata.id"] = "/redfish/v1/Chassis/" + chassis_id;
	// also the one from dbus
	for (const std::pair<std::string, std::string> &chassis_item :
	output) {
	json_response[chassis_item.first] = chassis_item.second;
	}

	json_response["Id"] = chassis_id;
	// prepare respond, and send
	res.json_value = json_response;
	} else {
	// ... otherwise return error
	// TODO(Pawel)consider distinguish between non existing object, and
	// other errors
	res.code = static_cast<int>(HttpRespCode::NOT_FOUND);
	}
	res.end();
	});
	}

	// Chassis Provider object
	// TODO(Pawel) consider move it to singleton
	OnDemandChassisProvider chassis_provider;
	};

	} // namespace redfish