1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
#pragma once
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <sdbusplus/server.hpp>
#include <xyz/openbmc_project/Inventory/Manager/server.hpp>
#include "filters.hpp"
#include "actions.hpp"
namespace phosphor
{
namespace inventory
{
namespace manager
{
namespace details
{
namespace interface
{
namespace holder
{
/** @struct Base
* @brief sdbusplus server interface holder base.
*
* Provides a common type for assembling containers of sdbusplus server
* interfaces. Typically a multiple inheritance scheme (sdbusplus::object)
* would be used for this; however, for objects created by PIM the interfaces
* are not known at build time.
*/
struct Base
{
Base() = default;
virtual ~Base() = default;
Base(const Base&) = delete;
Base& operator=(const Base&) = delete;
Base(Base&&) = default;
Base& operator=(Base&&) = default;
};
/** @struct Holder
* @brief sdbusplus server interface holder.
*
* Holds a pointer to an sdbusplus server interface instance.
*
* @tparam T - The sdbusplus server interface type to hold.
*/
template <typename T>
struct Holder final : public Base
{
Holder() = delete;
~Holder() = default;
Holder(const Holder&) = delete;
Holder& operator=(const Holder&) = delete;
Holder(Holder&&) = default;
Holder& operator=(Holder&&) = default;
explicit Holder(auto &&ptr) noexcept : _ptr(std::move(ptr)) {}
/** @brief sdbusplus server interface holder factory method.
*
* @param bus[in] - An sdbusplus bus connection
* @param bus[in] - The path of the object for which
* an interface is to be held.
* @returns A held interface.
*/
static auto make(sdbusplus::bus::bus &bus, const char *path)
{
return static_cast<std::unique_ptr<Base>>(
std::make_unique<Holder<T>>(
std::make_unique<T>(bus, path)));
}
private:
std::unique_ptr<T> _ptr;
};
} // namespace holder
} // namespace interface
} // namespace details
/** @class Manager
* @brief OpenBMC inventory manager implementation.
*
* A concrete implementation for the xyz.openbmc_project.Inventory.Manager
* DBus API.
*/
class Manager final :
public sdbusplus::server::xyz::openbmc_project::Inventory::Manager
{
public:
Manager() = delete;
Manager(const Manager&) = delete;
Manager& operator=(const Manager&) = delete;
Manager(Manager&&) = default;
Manager& operator=(Manager&&) = default;
~Manager() = default;
/** @brief Construct an inventory manager.
*
* @param[in] bus - An sdbusplus bus connection.
* @param[in] busname - The DBus busname to own.
* @param[in] root - The DBus path on which to implement
* an inventory manager.
* @param[in] iface - The DBus inventory interface to implement.
*/
Manager(sdbusplus::bus::bus &&, const char *, const char*, const char*);
using Object = std::map<
std::string, std::map<
std::string, sdbusplus::message::variant<std::string>>>;
/** @brief Start processing DBus messages. */
void run() noexcept;
/** @brief Provided for testing only. */
void shutdown() noexcept;
/** @brief sd_bus Notify method implementation callback. */
void notify(std::string path, Object) override;
/** @brief sd_bus signal callback. */
void signal(sdbusplus::message::message &, auto &);
/** @brief Drop an object from DBus. */
void destroyObject(const char *);
using Event = std::tuple<
const char *,
filters::details::Wrapper,
actions::details::Wrapper>;
using SigArgs = std::vector<
std::unique_ptr<
std::tuple<
Manager *,
const Event *>>>;
using SigArg = SigArgs::value_type::element_type;
private:
using Holder = details::interface::holder::Base;
using HolderPtr = std::unique_ptr<Holder>;
using InterfaceComposite = std::map<std::string, HolderPtr>;
using ObjectReferences = std::map<std::string, InterfaceComposite>;
using Events = std::map<const char *, Event>;
/** @brief Provided for testing only. */
bool _shutdown;
/** @brief Path prefix applied to any relative paths. */
const char * _root;
/** @brief A container of sdbusplus server interface references. */
ObjectReferences _refs;
/** @brief A container contexts for signal callbacks. */
SigArgs _sigargs;
/** @brief A container of sdbusplus signal matches. */
std::vector<sdbusplus::server::match::match> _matches;
/** @brief Persistent sdbusplus DBus bus connection. */
sdbusplus::bus::bus _bus;
/** @brief sdbusplus org.freedesktop.DBus.ObjectManager reference. */
sdbusplus::server::manager::manager _manager;
/** @brief A container of pimgen generated events and responses. */
static const Events _events;
};
} // namespace manager
} // namespace inventory
} // namespace phosphor
// vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
