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
|
#pragma once
#include "types.hpp"
#include <fstream>
#include <phosphor-logging/log.hpp>
#include <sdbusplus/bus.hpp>
namespace phosphor
{
namespace time
{
namespace utils
{
using namespace phosphor::logging;
/** @brief Read data with type T from file
*
* @param[in] fileName - The name of file to read from
*
* @return The data with type T
*/
template <typename T>
T readData(const char* fileName)
{
T data{};
std::ifstream fs(fileName);
if (fs.is_open())
{
fs >> data;
}
return data;
}
/** @brief Write data with type T to file
*
* @param[in] fileName - The name of file to write to
* @param[in] data - The data with type T to write to file
*/
template <typename T>
void writeData(const char* fileName, T&& data)
{
std::ofstream fs(fileName, std::ios::out);
if (fs.is_open())
{
fs << std::forward<T>(data);
}
}
/** @brief The template function to get property from the requested dbus path
*
* @param[in] bus - The Dbus bus object
* @param[in] service - The Dbus service name
* @param[in] path - The Dbus object path
* @param[in] interface - The Dbus interface
* @param[in] propertyName - The property name to get
*
* @return The value of the property
*/
template <typename T>
T getProperty(sdbusplus::bus::bus& bus, const char* service, const char* path,
const char* interface, const char* propertyName)
{
auto method = bus.new_method_call(service, path,
"org.freedesktop.DBus.Properties", "Get");
method.append(interface, propertyName);
try
{
sdbusplus::message::variant<T> value{};
auto reply = bus.call(method);
reply.read(value);
return sdbusplus::message::variant_ns::get<T>(value);
}
catch (const sdbusplus::exception::SdBusError& ex)
{
log<level::ERR>("GetProperty call failed", entry("PATH=%s", path),
entry("INTERFACE=%s", interface),
entry("PROPERTY=%s", propertyName));
throw std::runtime_error("GetProperty call failed");
}
}
/** @brief Get service name from object path and interface
*
* @param[in] bus - The Dbus bus object
* @param[in] path - The Dbus object path
* @param[in] interface - The Dbus interface
*
* @return The name of the service
*/
std::string getService(sdbusplus::bus::bus& bus, const char* path,
const char* interface);
/** @brief Convert a string to enum Mode
*
* Convert the time mode string to enum.
* Valid strings are
* "xyz.openbmc_project.Time.Synchronization.Method.NTP"
* "xyz.openbmc_project.Time.Synchronization.Method.Manual"
* If it's not a valid time mode string, it means something
* goes wrong so raise exception.
*
* @param[in] mode - The string of time mode
*
* @return The Mode enum
*/
Mode strToMode(const std::string& mode);
/** @brief Convert a string to enum Owner
*
* Convert the time owner string to enum.
* Valid strings are
* "xyz.openbmc_project.Time.Owner.Owners.BMC"
* "xyz.openbmc_project.Time.Owner.Owners.Host"
* "xyz.openbmc_project.Time.Owner.Owners.Both"
* "xyz.openbmc_project.Time.Owner.Owners.Split"
* If it's not a valid time owner string, it means something
* goes wrong so raise exception.
*
* @param[in] owner - The string of time owner
*
* @return The Owner enum
*/
Owner strToOwner(const std::string& owner);
/** @brief Convert a mode enum to mode string
*
* @param[in] mode - The Mode enum
*
* @return The string of the mode
*/
std::string modeToStr(Mode mode);
/** @brief Convert a owner enum to owner string
*
* @param[in] owner - The Owner enum
*
* @return The string of the owner
*/
std::string ownerToStr(Owner owner);
} // namespace utils
} // namespace time
} // namespace phosphor
|
