1 #include <phosphor-logging/elog-errors.hpp>
2 #include <phosphor-logging/log.hpp>
3 #include "xyz/openbmc_project/Common/error.hpp"
4 #include "settings.hpp"
5 
6 namespace settings
7 {
8 
9 using namespace phosphor::logging;
10 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
11 
12 constexpr auto mapperService = "xyz.openbmc_project.ObjectMapper";
13 constexpr auto mapperPath = "/xyz/openbmc_project/object_mapper";
14 constexpr auto mapperIntf = "xyz.openbmc_project.ObjectMapper";
15 
16 Objects::Objects(sdbusplus::bus::bus& bus):
17     bus(bus)
18 {
19     std::vector<std::string> settingsIntfs =
20         {autoRebootIntf, powerRestoreIntf};
21     auto depth = 0;
22 
23     auto mapperCall = bus.new_method_call(mapperService,
24                                           mapperPath,
25                                           mapperIntf,
26                                           "GetSubTree");
27     mapperCall.append(root);
28     mapperCall.append(depth);
29     mapperCall.append(settingsIntfs);
30     auto response = bus.call(mapperCall);
31     if (response.is_method_error())
32     {
33         log<level::ERR>("Error in mapper GetSubTree");
34         elog<InternalFailure>();
35     }
36 
37     using Interfaces = std::vector<Interface>;
38     using MapperResponse = std::map<Path, std::map<Service, Interfaces>>;
39     MapperResponse result;
40     response.read(result);
41     if (result.empty())
42     {
43         log<level::ERR>("Invalid response from mapper");
44         elog<InternalFailure>();
45     }
46 
47     for (const auto& iter : result)
48     {
49         const Path& path = iter.first;
50         const Interface& interface = iter.second.begin()->second[0];
51 
52         if (autoRebootIntf == interface)
53         {
54             autoReboot = path;
55         }
56         else if (powerRestoreIntf == interface)
57         {
58             powerRestorePolicy = path;
59         }
60     }
61 }
62 
63 Service Objects::service(const Path& path, const Interface& interface) const
64 {
65     using Interfaces = std::vector<Interface>;
66     auto mapperCall = bus.new_method_call(mapperService,
67                                           mapperPath,
68                                           mapperIntf,
69                                           "GetObject");
70     mapperCall.append(path);
71     mapperCall.append(Interfaces({interface}));
72 
73     auto response = bus.call(mapperCall);
74     if (response.is_method_error())
75     {
76         log<level::ERR>("Error in mapper GetObject");
77         elog<InternalFailure>();
78     }
79 
80     std::map<Service, Interfaces> result;
81     response.read(result);
82     if (result.empty())
83     {
84         log<level::ERR>("Invalid response from mapper");
85         elog<InternalFailure>();
86     }
87 
88     return result.begin()->first;
89 }
90 
91 } // namespace settings
92