blob: 10035a11c5f049b392841cf6e3476f106f564373 [file] [log] [blame]
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +02001#include "report_manager.hpp"
2
Wludzik, Jozefe2362792020-10-27 17:23:55 +01003#include "report.hpp"
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +00004#include "types/report_types.hpp"
Krzysztof Grobelnye8fc5752021-02-05 14:30:45 +00005#include "utils/conversion.hpp"
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +01006#include "utils/generate_id.hpp"
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +00007#include "utils/transform.hpp"
Wludzik, Jozefe2362792020-10-27 17:23:55 +01008
9#include <phosphor-logging/log.hpp>
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +020010#include <sdbusplus/exception.hpp>
11
Wludzik, Jozefe2362792020-10-27 17:23:55 +010012#include <stdexcept>
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +020013#include <system_error>
14
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +000015ReadingParameters
16 convertToReadingParameters(ReadingParametersPastVersion params)
17{
18 return utils::transform(params, [](const auto& param) {
19 using namespace std::chrono_literals;
20
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +010021 const auto& [sensorPath, operationType, id, metadata] = param;
22
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +000023 return ReadingParameters::value_type(
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +010024 std::vector<
25 std::tuple<sdbusplus::message::object_path, std::string>>{
26 {sensorPath, metadata}},
27 operationType, id, utils::enumToString(CollectionTimeScope::point),
28 0u);
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +000029 });
30}
31
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +020032ReportManager::ReportManager(
Wludzik, Jozef2f9f9b82020-10-13 09:07:45 +020033 std::unique_ptr<interfaces::ReportFactory> reportFactoryIn,
Wludzik, Jozefe2362792020-10-27 17:23:55 +010034 std::unique_ptr<interfaces::JsonStorage> reportStorageIn,
Krzysztof Grobelnye6d48872022-02-08 13:41:30 +010035 const std::shared_ptr<sdbusplus::asio::object_server>& objServerIn) :
Wludzik, Jozef2f9f9b82020-10-13 09:07:45 +020036 reportFactory(std::move(reportFactoryIn)),
Krzysztof Grobelnye6d48872022-02-08 13:41:30 +010037 reportStorage(std::move(reportStorageIn)), objServer(objServerIn)
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +020038{
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +020039 reports.reserve(maxReports);
Krzysztof Grobelny6ccfcbf2020-11-04 09:31:36 +010040
Wludzik, Jozefe2362792020-10-27 17:23:55 +010041 loadFromPersistent();
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +020042
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +020043 reportManagerIface = objServer->add_unique_interface(
Wludzik, Jozef2f9f9b82020-10-13 09:07:45 +020044 reportManagerPath, reportManagerIfaceName, [this](auto& dbusIface) {
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +020045 dbusIface.register_property_r(
Wludzik, Jozef503c1582020-12-11 14:48:01 +010046 "MaxReports", size_t{}, sdbusplus::vtable::property_::const_,
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +020047 [](const auto&) { return maxReports; });
48 dbusIface.register_property_r(
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +010049 "MaxReportIdLength", size_t{},
Karol Niczyj32859b62021-05-19 10:20:46 +020050 sdbusplus::vtable::property_::const_,
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +010051 [](const auto&) { return maxReportIdLength; });
Karol Niczyj32859b62021-05-19 10:20:46 +020052 dbusIface.register_property_r(
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +020053 "MinInterval", uint64_t{}, sdbusplus::vtable::property_::const_,
54 [](const auto&) -> uint64_t { return minInterval.count(); });
Krzysztof Grobelny60fee072022-01-13 16:25:04 +010055 dbusIface.register_property_r(
56 "SupportedOperationTypes", std::vector<std::string>{},
57 sdbusplus::vtable::property_::const_,
58 [](const auto&) -> std::vector<std::string> {
Szymon Dompkefdb06a12022-02-11 11:04:44 +010059 return utils::transform<std::vector>(
Krzysztof Grobelny60fee072022-01-13 16:25:04 +010060 utils::convDataOperationType, [](const auto& item) {
61 return std::string(item.first);
62 });
63 });
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +020064
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +020065 dbusIface.register_method(
Wludzik, Jozefe2362792020-10-27 17:23:55 +010066 "AddReport", [this](boost::asio::yield_context& yield,
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +010067 const std::string& reportId,
Wludzik, Jozef2f9f9b82020-10-13 09:07:45 +020068 const std::string& reportingType,
69 const bool emitsReadingsUpdate,
70 const bool logToMetricReportsCollection,
71 const uint64_t interval,
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +000072 ReadingParametersPastVersion metricParams) {
Lukasz Kazmierczak7e098e92021-09-16 15:59:56 +020073 constexpr auto enabledDefault = true;
Szymon Dompke3eb56862021-09-20 15:32:04 +020074 constexpr uint64_t appendLimitDefault = 0;
75 constexpr ReportUpdates reportUpdatesDefault =
Krzysztof Grobelny51497a02021-11-09 14:56:22 +010076 ReportUpdates::overwrite;
77
78 std::vector<ReportAction> reportActions;
79
80 if (emitsReadingsUpdate)
81 {
82 reportActions.emplace_back(
83 ReportAction::emitsReadingsUpdate);
84 }
85 if (logToMetricReportsCollection)
86 {
87 reportActions.emplace_back(
88 ReportAction::logToMetricReportsCollection);
89 }
90
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +010091 return addReport(yield, reportId, reportId,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +010092 utils::toReportingType(reportingType),
93 reportActions, Milliseconds(interval),
94 appendLimitDefault, reportUpdatesDefault,
95 convertToReadingParameters(
96 std::move(metricParams)),
97 enabledDefault)
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +000098 .getPath();
99 });
100
101 dbusIface.register_method(
102 "AddReportFutureVersion",
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100103 [this](
104 boost::asio::yield_context& yield,
105 const std::string& reportId, const std::string& reportName,
106 const std::string& reportingType,
107 const std::string& reportUpdates,
108 const uint64_t appendLimit,
109 const std::vector<std::string>& reportActions,
110 const uint64_t interval, ReadingParameters metricParams) {
Lukasz Kazmierczak7e098e92021-09-16 15:59:56 +0200111 constexpr auto enabledDefault = true;
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100112 return addReport(yield, reportId, reportName,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100113 utils::toReportingType(reportingType),
114 utils::transform(
115 reportActions,
116 [](const auto& reportAction) {
117 return utils::toReportAction(
118 reportAction);
119 }),
Szymon Dompke3eb56862021-09-20 15:32:04 +0200120 Milliseconds(interval), appendLimit,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100121 utils::toReportUpdates(reportUpdates),
122 std::move(metricParams), enabledDefault)
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000123 .getPath();
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +0200124 });
125 });
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +0200126}
127
Wludzik, Jozef2f9f9b82020-10-13 09:07:45 +0200128void ReportManager::removeReport(const interfaces::Report* report)
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +0200129{
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +0200130 reports.erase(
131 std::remove_if(reports.begin(), reports.end(),
132 [report](const auto& x) { return report == x.get(); }),
133 reports.end());
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +0200134}
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100135
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000136void ReportManager::verifyAddReport(
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100137 const std::string& reportId, const std::string& reportName,
138 const ReportingType reportingType, Milliseconds interval,
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000139 const ReportUpdates reportUpdates, const uint64_t appendLimit,
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000140 const std::vector<LabeledMetricParameters>& readingParams)
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100141{
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100142 if (reportingType == ReportingType::onChange)
143 {
144 throw sdbusplus::exception::SdBusError(
145 static_cast<int>(std::errc::invalid_argument),
146 "Invalid reportingType");
147 }
148
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100149 if (reports.size() >= maxReports)
150 {
151 throw sdbusplus::exception::SdBusError(
152 static_cast<int>(std::errc::too_many_files_open),
153 "Reached maximal report count");
154 }
155
Krzysztof Grobelnye6c417c2022-02-02 17:25:53 +0100156 if (appendLimit > maxAppendLimit &&
157 appendLimit != std::numeric_limits<uint64_t>::max())
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000158 {
159 throw sdbusplus::exception::SdBusError(
160 static_cast<int>(std::errc::invalid_argument),
161 "Append limit out of range");
162 }
163
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100164 if (reportingType == ReportingType::periodic && interval < minInterval)
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100165 {
166 throw sdbusplus::exception::SdBusError(
167 static_cast<int>(std::errc::invalid_argument), "Invalid interval");
168 }
Wludzik, Jozefbc766b42020-12-08 16:06:22 +0100169
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000170 size_t metricCount = 0;
171 for (auto metricParam : readingParams)
172 {
173 auto metricParamsVec =
174 metricParam.at_label<utils::tstring::SensorPath>();
175 metricCount += metricParamsVec.size();
176 }
Krzysztof Grobelnye8fc5752021-02-05 14:30:45 +0000177
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000178 if (readingParams.size() > maxNumberMetrics ||
179 metricCount > maxNumberMetrics)
Wludzik, Jozefbc766b42020-12-08 16:06:22 +0100180 {
181 throw sdbusplus::exception::SdBusError(
182 static_cast<int>(std::errc::argument_list_too_long),
183 "Too many reading parameters");
184 }
Krzysztof Grobelnye8fc5752021-02-05 14:30:45 +0000185
186 try
187 {
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000188 namespace ts = utils::tstring;
189
190 for (const LabeledMetricParameters& item : readingParams)
Krzysztof Grobelnye8fc5752021-02-05 14:30:45 +0000191 {
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000192 utils::toOperationType(
193 utils::toUnderlying(item.at_label<ts::OperationType>()));
Krzysztof Grobelnye8fc5752021-02-05 14:30:45 +0000194 }
195 }
196 catch (const std::exception& e)
197 {
198 throw sdbusplus::exception::SdBusError(
199 static_cast<int>(std::errc::invalid_argument), e.what());
200 }
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000201}
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100202
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000203interfaces::Report& ReportManager::addReport(
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100204 boost::asio::yield_context& yield, const std::string& reportId,
205 const std::string& reportName, const ReportingType reportingType,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100206 const std::vector<ReportAction>& reportActions, Milliseconds interval,
207 const uint64_t appendLimit, const ReportUpdates reportUpdates,
Lukasz Kazmierczak7e098e92021-09-16 15:59:56 +0200208 ReadingParameters metricParams, const bool enabled)
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000209{
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000210 auto labeledMetricParams =
211 reportFactory->convertMetricParams(yield, metricParams);
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000212
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100213 return addReport(reportId, reportName, reportingType, reportActions,
214 interval, appendLimit, reportUpdates,
215 std::move(labeledMetricParams), enabled);
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000216}
217
218interfaces::Report& ReportManager::addReport(
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100219 const std::string& reportId, const std::string& reportName,
220 const ReportingType reportingType,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100221 const std::vector<ReportAction>& reportActions, Milliseconds interval,
222 const uint64_t appendLimit, const ReportUpdates reportUpdates,
Lukasz Kazmierczak7e098e92021-09-16 15:59:56 +0200223 std::vector<LabeledMetricParameters> labeledMetricParams,
224 const bool enabled)
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000225{
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100226 const auto existingReportIds = utils::transform(
227 reports, [](const auto& report) { return report->getId(); });
228
Krzysztof Grobelnya950e422021-12-31 13:49:00 +0100229 auto [id, name] = utils::generateId(reportId, reportName, reportNameDefault,
230 existingReportIds, maxReportIdLength);
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100231
232 verifyAddReport(id, name, reportingType, interval, reportUpdates,
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000233 appendLimit, labeledMetricParams);
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000234
Krzysztof Grobelnye6d48872022-02-08 13:41:30 +0100235 reports.emplace_back(reportFactory->make(
236 id, name, reportingType, reportActions, interval, appendLimit,
237 reportUpdates, *this, *reportStorage, labeledMetricParams, enabled));
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000238 return *reports.back();
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100239}
240
241void ReportManager::loadFromPersistent()
242{
243 std::vector<interfaces::JsonStorage::FilePath> paths =
244 reportStorage->list();
245
246 for (const auto& path : paths)
247 {
248 std::optional<nlohmann::json> data = reportStorage->load(path);
249 try
250 {
251 size_t version = data->at("Version").get<size_t>();
252 if (version != Report::reportVersion)
253 {
254 throw std::logic_error("Invalid version");
255 }
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100256 bool enabled = data->at("Enabled").get<bool>();
257 std::string& id = data->at("Id").get_ref<std::string&>();
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100258 std::string& name = data->at("Name").get_ref<std::string&>();
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100259
260 uint32_t reportingType = data->at("ReportingType").get<uint32_t>();
261 std::vector<ReportAction> reportActions = utils::transform(
262 data->at("ReportActions").get<std::vector<uint32_t>>(),
263 [](const auto reportAction) {
264 return utils::toReportAction(reportAction);
265 });
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100266 uint64_t interval = data->at("Interval").get<uint64_t>();
Szymon Dompke3eb56862021-09-20 15:32:04 +0200267 uint64_t appendLimit = data->at("AppendLimit").get<uint64_t>();
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100268 uint32_t reportUpdates = data->at("ReportUpdates").get<uint32_t>();
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000269 auto readingParameters =
270 data->at("ReadingParameters")
271 .get<std::vector<LabeledMetricParameters>>();
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100272
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100273 addReport(id, name, utils::toReportingType(reportingType),
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100274 reportActions, Milliseconds(interval), appendLimit,
275 utils::toReportUpdates(reportUpdates),
276 std::move(readingParameters), enabled);
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100277 }
278 catch (const std::exception& e)
279 {
280 phosphor::logging::log<phosphor::logging::level::ERR>(
281 "Failed to load report from storage",
282 phosphor::logging::entry(
Wludzik, Jozef982c5b52021-01-02 12:05:21 +0100283 "FILENAME=%s",
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100284 static_cast<std::filesystem::path>(path).c_str()),
Wludzik, Jozef982c5b52021-01-02 12:05:21 +0100285 phosphor::logging::entry("EXCEPTION_MSG=%s", e.what()));
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100286 reportStorage->remove(path);
287 }
288 }
289}