xref: /openbmc/sdbusplus/example/asio-example.cpp (revision 22f0b1884896336512aabcd01d5af955bba8e12c)
1 #include <boost/asio/detached.hpp>
2 #include <boost/asio/io_context.hpp>
3 #include <boost/asio/spawn.hpp>
4 #include <sdbusplus/asio/connection.hpp>
5 #include <sdbusplus/asio/object_server.hpp>
6 #include <sdbusplus/asio/sd_event.hpp>
7 #include <sdbusplus/bus.hpp>
8 #include <sdbusplus/exception.hpp>
9 #include <sdbusplus/server.hpp>
10 #include <sdbusplus/timer.hpp>
11 
12 #include <chrono>
13 #include <ctime>
14 #include <iostream>
15 #include <variant>
16 
17 using variant = std::variant<int, std::string>;
18 
foo(int test)19 int foo(int test)
20 {
21     std::cout << "foo(" << test << ") -> " << (test + 1) << "\n";
22     return ++test;
23 }
24 
25 // called from coroutine context, can make yielding dbus calls
fooYield(boost::asio::yield_context yield,std::shared_ptr<sdbusplus::asio::connection> conn,int test)26 int fooYield(boost::asio::yield_context yield,
27              std::shared_ptr<sdbusplus::asio::connection> conn, int test)
28 {
29     // fetch the real value from testFunction
30     boost::system::error_code ec;
31     std::cout << "fooYield(yield, " << test << ")...\n";
32     int testCount = conn->yield_method_call<int>(
33         yield, ec, "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
34         "xyz.openbmc_project.test", "TestFunction", test);
35     if (ec || testCount != (test + 1))
36     {
37         std::cout << "call to foo failed: ec = " << ec << '\n';
38         return -1;
39     }
40     std::cout << "yielding call to foo OK! (-> " << testCount << ")\n";
41     return testCount;
42 }
43 
methodWithMessage(sdbusplus::message_t &,int test)44 int methodWithMessage(sdbusplus::message_t& /*m*/, int test)
45 {
46     std::cout << "methodWithMessage(m, " << test << ") -> " << (test + 1)
47               << "\n";
48     return ++test;
49 }
50 
voidBar(void)51 int voidBar(void)
52 {
53     std::cout << "voidBar() -> 42\n";
54     return 42;
55 }
56 
do_start_async_method_call_one(std::shared_ptr<sdbusplus::asio::connection> conn,boost::asio::yield_context yield)57 void do_start_async_method_call_one(
58     std::shared_ptr<sdbusplus::asio::connection> conn,
59     boost::asio::yield_context yield)
60 {
61     boost::system::error_code ec;
62     variant testValue;
63     conn->yield_method_call<>(
64         yield, ec, "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
65         "org.freedesktop.DBus.Properties", "Set", "xyz.openbmc_project.test",
66         "int", variant(24));
67     testValue = conn->yield_method_call<variant>(
68         yield, ec, "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
69         "org.freedesktop.DBus.Properties", "Get", "xyz.openbmc_project.test",
70         "int");
71     if (!ec && std::get<int>(testValue) == 24)
72     {
73         std::cout << "async call to Properties.Get serialized via yield OK!\n";
74     }
75     else
76     {
77         std::cout << "ec = " << ec << ": " << std::get<int>(testValue) << "\n";
78     }
79     conn->yield_method_call<void>(
80         yield, ec, "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
81         "org.freedesktop.DBus.Properties", "Set", "xyz.openbmc_project.test",
82         "int", variant(42));
83     testValue = conn->yield_method_call<variant>(
84         yield, ec, "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
85         "org.freedesktop.DBus.Properties", "Get", "xyz.openbmc_project.test",
86         "int");
87     if (!ec && std::get<int>(testValue) == 42)
88     {
89         std::cout << "async call to Properties.Get serialized via yield OK!\n";
90     }
91     else
92     {
93         std::cout << "ec = " << ec << ": " << std::get<int>(testValue) << "\n";
94     }
95 }
96 
do_start_async_ipmi_call(std::shared_ptr<sdbusplus::asio::connection> conn,boost::asio::yield_context yield)97 void do_start_async_ipmi_call(std::shared_ptr<sdbusplus::asio::connection> conn,
98                               boost::asio::yield_context yield)
99 {
100     auto method = conn->new_method_call("xyz.openbmc_project.asio-test",
101                                         "/xyz/openbmc_project/test",
102                                         "xyz.openbmc_project.test", "execute");
103     constexpr uint8_t netFn = 6;
104     constexpr uint8_t lun = 0;
105     constexpr uint8_t cmd = 1;
106     std::map<std::string, variant> options = {{"username", variant("admin")},
107                                               {"privilege", variant(4)}};
108     std::vector<uint8_t> commandData = {4, 3, 2, 1};
109     method.append(netFn, lun, cmd, commandData, options);
110     boost::system::error_code ec;
111     sdbusplus::message_t reply = conn->async_send(method, yield[ec]);
112     std::tuple<uint8_t, uint8_t, uint8_t, uint8_t, std::vector<uint8_t>>
113         tupleOut;
114     try
115     {
116         reply.read(tupleOut);
117     }
118     catch (const sdbusplus::exception::exception& e)
119     {
120         std::cerr << "failed to unpack; sig is " << reply.get_signature()
121                   << "\n";
122     }
123     auto& [rnetFn, rlun, rcmd, cc, responseData] = tupleOut;
124     std::vector<uint8_t> expRsp = {1, 2, 3, 4};
125     if (rnetFn == uint8_t(netFn + 1) && rlun == lun && rcmd == cmd && cc == 0 &&
126         responseData == expRsp)
127     {
128         std::cerr << "ipmi call returns OK!\n";
129     }
130     else
131     {
132         std::cerr << "ipmi call returns unexpected response\n";
133     }
134 }
135 
ipmiInterface(boost::asio::yield_context,uint8_t netFn,uint8_t lun,uint8_t cmd,std::vector<uint8_t> &,const std::map<std::string,variant> &)136 auto ipmiInterface(boost::asio::yield_context /*yield*/, uint8_t netFn,
137                    uint8_t lun, uint8_t cmd, std::vector<uint8_t>& /*data*/,
138                    const std::map<std::string, variant>& /*options*/)
139 {
140     std::vector<uint8_t> reply = {1, 2, 3, 4};
141     uint8_t cc = 0;
142     std::cerr << "ipmiInterface:execute(" << int(netFn) << int(cmd) << ")\n";
143     return std::make_tuple(uint8_t(netFn + 1), lun, cmd, cc, reply);
144 }
145 
do_start_async_to_yield(std::shared_ptr<sdbusplus::asio::connection> conn,boost::asio::yield_context yield)146 void do_start_async_to_yield(std::shared_ptr<sdbusplus::asio::connection> conn,
147                              boost::asio::yield_context yield)
148 {
149     boost::system::error_code ec;
150     int testValue = 0;
151     testValue = conn->yield_method_call<int>(
152         yield, ec, "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
153         "xyz.openbmc_project.test", "TestYieldFunction", int(41));
154 
155     if (!ec && testValue == 42)
156     {
157         std::cout
158             << "yielding call to TestYieldFunction serialized via yield OK!\n";
159     }
160     else
161     {
162         std::cout << "ec = " << ec << ": " << testValue << "\n";
163     }
164 
165     ec.clear();
166     auto badValue = conn->yield_method_call<std::string>(
167         yield, ec, "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
168         "xyz.openbmc_project.test", "TestYieldFunction", int(41));
169 
170     if (!ec)
171     {
172         std::cout
173             << "yielding call to TestYieldFunction returned the wrong type\n";
174     }
175     else
176     {
177         std::cout << "TestYieldFunction expected error: " << ec << "\n";
178     }
179 
180     ec.clear();
181     auto unUsedValue = conn->yield_method_call<std::string>(
182         yield, ec, "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
183         "xyz.openbmc_project.test", "TestYieldFunctionNotExits", int(41));
184 
185     if (!ec)
186     {
187         std::cout << "TestYieldFunctionNotExists returned unexpectedly\n";
188     }
189     else
190     {
191         std::cout << "TestYieldFunctionNotExits expected error: " << ec << "\n";
192     }
193 }
194 
server()195 int server()
196 {
197     // setup connection to dbus
198     boost::asio::io_context io;
199     auto conn = std::make_shared<sdbusplus::asio::connection>(io);
200 
201     // test object server
202     conn->request_name("xyz.openbmc_project.asio-test");
203     auto server = sdbusplus::asio::object_server(conn);
204     std::shared_ptr<sdbusplus::asio::dbus_interface> iface =
205         server.add_interface("/xyz/openbmc_project/test",
206                              "xyz.openbmc_project.test");
207     // test generic properties
208     iface->register_property("int", 33,
209                              sdbusplus::asio::PropertyPermission::readWrite);
210     std::vector<std::string> myStringVec = {"some", "test", "data"};
211     std::vector<std::string> myStringVec2 = {"more", "test", "data"};
212 
213     iface->register_property("myStringVec", myStringVec,
214                              sdbusplus::asio::PropertyPermission::readWrite);
215     iface->register_property("myStringVec2", myStringVec2);
216 
217     // test properties with specialized callbacks
218     iface->register_property("lessThan50", 23,
219                              // custom set
220                              [](const int& req, int& propertyValue) {
221                                  if (req >= 50)
222                                  {
223                                      return false;
224                                  }
225                                  propertyValue = req;
226                                  return true;
227                              });
228     iface->register_property(
229         "TrailTime", std::string("foo"),
230         // custom set
231         [](const std::string& req, std::string& propertyValue) {
232             propertyValue = req;
233             return true;
234         },
235         // custom get
236         [](const std::string& property) {
237             auto now = std::chrono::system_clock::now();
238             auto timePoint = std::chrono::system_clock::to_time_t(now);
239             return property + std::ctime(&timePoint);
240         });
241 
242     // test method creation
243     iface->register_method("TestMethod", [](const int32_t& callCount) {
244         return std::make_tuple(callCount,
245                                "success: " + std::to_string(callCount));
246     });
247 
248     iface->register_method("TestFunction", foo);
249 
250     // fooYield has boost::asio::yield_context as first argument
251     // so will be executed in coroutine context if called
252     iface->register_method("TestYieldFunction",
253                            [conn](boost::asio::yield_context yield, int val) {
254                                return fooYield(yield, conn, val);
255                            });
256 
257     iface->register_method("TestMethodWithMessage", methodWithMessage);
258 
259     iface->register_method("VoidFunctionReturnsInt", voidBar);
260 
261     iface->register_method("execute", ipmiInterface);
262 
263     iface->initialize();
264 
265     io.run();
266 
267     return 0;
268 }
269 
client()270 int client()
271 {
272     using GetSubTreeType = std::vector<std::pair<
273         std::string,
274         std::vector<std::pair<std::string, std::vector<std::string>>>>>;
275     using message = sdbusplus::message_t;
276 
277     // setup connection to dbus
278     boost::asio::io_context io;
279     auto conn = std::make_shared<sdbusplus::asio::connection>(io);
280 
281     int ready = 0;
282     while (!ready)
283     {
284         auto readyMsg = conn->new_method_call(
285             "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
286             "xyz.openbmc_project.test", "VoidFunctionReturnsInt");
287         try
288         {
289             message intMsg = conn->call(readyMsg);
290             intMsg.read(ready);
291         }
292         catch (const sdbusplus::exception::exception& e)
293         {
294             ready = 0;
295             // pause to give the server a chance to start up
296             usleep(10000);
297         }
298     }
299 
300     // test async method call and async send
301     auto mesg =
302         conn->new_method_call("xyz.openbmc_project.ObjectMapper",
303                               "/xyz/openbmc_project/object_mapper",
304                               "xyz.openbmc_project.ObjectMapper", "GetSubTree");
305 
306     int32_t depth = 2;
307     constexpr std::array<std::string_view, 1> interfaces{
308         "xyz.openbmc_project.Sensor.Value"};
309     mesg.append("/xyz/openbmc_project/Sensors", depth, interfaces);
310 
311     conn->async_send(mesg, [](boost::system::error_code ec, message& ret) {
312         std::cout << "async_send callback\n";
313         if (ec || ret.is_method_error())
314         {
315             std::cerr << "error with async_send\n";
316             return;
317         }
318         GetSubTreeType data;
319         ret.read(data);
320         for (auto& item : data)
321         {
322             std::cout << item.first << "\n";
323         }
324     });
325 
326     conn->async_method_call(
327         [](boost::system::error_code ec, GetSubTreeType& subtree) {
328             std::cout << "async_method_call callback\n";
329             if (ec)
330             {
331                 std::cerr << "error with async_method_call\n";
332                 return;
333             }
334             for (auto& item : subtree)
335             {
336                 std::cout << item.first << "\n";
337             }
338         },
339         "xyz.openbmc_project.ObjectMapper",
340         "/xyz/openbmc_project/object_mapper",
341         "xyz.openbmc_project.ObjectMapper", "GetSubTree",
342         "/org/openbmc/control", 2, std::vector<std::string>());
343 
344     std::string nonConstCapture = "lalalala";
345     conn->async_method_call(
346         [nonConstCapture = std::move(nonConstCapture)](
347             boost::system::error_code ec,
348             const std::vector<std::string>& /*things*/) mutable {
349             std::cout << "async_method_call callback\n";
350             nonConstCapture += " stuff";
351             if (ec)
352             {
353                 std::cerr << "async_method_call expected failure: " << ec
354                           << "\n";
355             }
356             else
357             {
358                 std::cerr << "async_method_call should have failed!\n";
359             }
360         },
361         "xyz.openbmc_project.ObjectMapper",
362         "/xyz/openbmc_project/object_mapper",
363         "xyz.openbmc_project.ObjectMapper", "GetSubTree",
364         "/xyz/openbmc_project/sensors", depth, interfaces);
365 
366     // sd_events work too using the default event loop
367     sdbusplus::Timer t1([]() { std::cerr << "*** tock ***\n"; });
368     t1.start(std::chrono::microseconds(1000000));
369     sdbusplus::Timer t2([]() { std::cerr << "*** tick ***\n"; });
370     t2.start(std::chrono::microseconds(500000), true);
371     // add the sd_event wrapper to the io object
372     sdbusplus::asio::sd_event_wrapper sdEvents(io);
373 
374     // set up a client to make an async call to the server
375     // using coroutines (userspace cooperative multitasking)
376     boost::asio::spawn(
377         io,
378         [conn](boost::asio::yield_context yield) {
379             do_start_async_method_call_one(conn, yield);
380         },
381         boost::asio::detached);
382     boost::asio::spawn(
383         io,
384         [conn](boost::asio::yield_context yield) {
385             do_start_async_ipmi_call(conn, yield);
386         },
387         boost::asio::detached);
388     boost::asio::spawn(
389         io,
390         [conn](boost::asio::yield_context yield) {
391             do_start_async_to_yield(conn, yield);
392         },
393         boost::asio::detached);
394 
395     conn->async_method_call(
396         [](boost::system::error_code ec, int32_t testValue) {
397             if (ec)
398             {
399                 std::cerr << "TestYieldFunction returned error with "
400                              "async_method_call (ec = "
401                           << ec << ")\n";
402                 return;
403             }
404             std::cout << "TestYieldFunction return " << testValue << "\n";
405         },
406         "xyz.openbmc_project.asio-test", "/xyz/openbmc_project/test",
407         "xyz.openbmc_project.test", "TestYieldFunction", int32_t(41));
408     io.run();
409 
410     return 0;
411 }
412 
main(int argc,const char * argv[])413 int main(int argc, const char* argv[])
414 {
415     if (argc == 1)
416     {
417         int pid = fork();
418         if (pid == 0)
419         {
420             return client();
421         }
422         else if (pid > 0)
423         {
424             return server();
425         }
426         return pid;
427     }
428     if (std::string(argv[1]) == "--server")
429     {
430         return server();
431     }
432     if (std::string(argv[1]) == "--client")
433     {
434         return client();
435     }
436     std::cout << "usage: " << argv[0] << " [--server | --client]\n";
437     return -1;
438 }
439