blob: f5dc105fc5fc864bcd567a4632b63d1491aabd1d [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,
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +020035 const std::shared_ptr<sdbusplus::asio::object_server>& objServerIn) :
Wludzik, Jozef2f9f9b82020-10-13 09:07:45 +020036 reportFactory(std::move(reportFactoryIn)),
Wludzik, Jozefe2362792020-10-27 17:23:55 +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 Grobelny64b75a52020-09-18 10:17:16 +020055
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +020056 dbusIface.register_method(
Wludzik, Jozefe2362792020-10-27 17:23:55 +010057 "AddReport", [this](boost::asio::yield_context& yield,
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +010058 const std::string& reportId,
Wludzik, Jozef2f9f9b82020-10-13 09:07:45 +020059 const std::string& reportingType,
60 const bool emitsReadingsUpdate,
61 const bool logToMetricReportsCollection,
62 const uint64_t interval,
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +000063 ReadingParametersPastVersion metricParams) {
Lukasz Kazmierczak7e098e92021-09-16 15:59:56 +020064 constexpr auto enabledDefault = true;
Szymon Dompke3eb56862021-09-20 15:32:04 +020065 constexpr uint64_t appendLimitDefault = 0;
66 constexpr ReportUpdates reportUpdatesDefault =
Krzysztof Grobelny51497a02021-11-09 14:56:22 +010067 ReportUpdates::overwrite;
68
69 std::vector<ReportAction> reportActions;
70
71 if (emitsReadingsUpdate)
72 {
73 reportActions.emplace_back(
74 ReportAction::emitsReadingsUpdate);
75 }
76 if (logToMetricReportsCollection)
77 {
78 reportActions.emplace_back(
79 ReportAction::logToMetricReportsCollection);
80 }
81
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +010082 return addReport(yield, reportId, reportId,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +010083 utils::toReportingType(reportingType),
84 reportActions, Milliseconds(interval),
85 appendLimitDefault, reportUpdatesDefault,
86 convertToReadingParameters(
87 std::move(metricParams)),
88 enabledDefault)
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +000089 .getPath();
90 });
91
92 dbusIface.register_method(
93 "AddReportFutureVersion",
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +010094 [this](
95 boost::asio::yield_context& yield,
96 const std::string& reportId, const std::string& reportName,
97 const std::string& reportingType,
98 const std::string& reportUpdates,
99 const uint64_t appendLimit,
100 const std::vector<std::string>& reportActions,
101 const uint64_t interval, ReadingParameters metricParams) {
Lukasz Kazmierczak7e098e92021-09-16 15:59:56 +0200102 constexpr auto enabledDefault = true;
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100103 return addReport(yield, reportId, reportName,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100104 utils::toReportingType(reportingType),
105 utils::transform(
106 reportActions,
107 [](const auto& reportAction) {
108 return utils::toReportAction(
109 reportAction);
110 }),
Szymon Dompke3eb56862021-09-20 15:32:04 +0200111 Milliseconds(interval), appendLimit,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100112 utils::toReportUpdates(reportUpdates),
113 std::move(metricParams), enabledDefault)
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000114 .getPath();
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +0200115 });
116 });
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +0200117}
118
Wludzik, Jozef2f9f9b82020-10-13 09:07:45 +0200119void ReportManager::removeReport(const interfaces::Report* report)
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +0200120{
Wludzik, Jozefcb88cfd2020-09-28 16:38:57 +0200121 reports.erase(
122 std::remove_if(reports.begin(), reports.end(),
123 [report](const auto& x) { return report == x.get(); }),
124 reports.end());
Krzysztof Grobelny64b75a52020-09-18 10:17:16 +0200125}
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100126
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000127void ReportManager::verifyAddReport(
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100128 const std::string& reportId, const std::string& reportName,
129 const ReportingType reportingType, Milliseconds interval,
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000130 const ReportUpdates reportUpdates, const uint64_t appendLimit,
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000131 const std::vector<LabeledMetricParameters>& readingParams)
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100132{
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100133 if (reportingType == ReportingType::onChange)
134 {
135 throw sdbusplus::exception::SdBusError(
136 static_cast<int>(std::errc::invalid_argument),
137 "Invalid reportingType");
138 }
139
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100140 if (reports.size() >= maxReports)
141 {
142 throw sdbusplus::exception::SdBusError(
143 static_cast<int>(std::errc::too_many_files_open),
144 "Reached maximal report count");
145 }
146
Krzysztof Grobelnye6c417c2022-02-02 17:25:53 +0100147 if (appendLimit > maxAppendLimit &&
148 appendLimit != std::numeric_limits<uint64_t>::max())
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000149 {
150 throw sdbusplus::exception::SdBusError(
151 static_cast<int>(std::errc::invalid_argument),
152 "Append limit out of range");
153 }
154
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100155 if (reportingType == ReportingType::periodic && interval < minInterval)
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100156 {
157 throw sdbusplus::exception::SdBusError(
158 static_cast<int>(std::errc::invalid_argument), "Invalid interval");
159 }
Wludzik, Jozefbc766b42020-12-08 16:06:22 +0100160
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000161 size_t metricCount = 0;
162 for (auto metricParam : readingParams)
163 {
164 auto metricParamsVec =
165 metricParam.at_label<utils::tstring::SensorPath>();
166 metricCount += metricParamsVec.size();
167 }
Krzysztof Grobelnye8fc5752021-02-05 14:30:45 +0000168
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000169 if (readingParams.size() > maxNumberMetrics ||
170 metricCount > maxNumberMetrics)
Wludzik, Jozefbc766b42020-12-08 16:06:22 +0100171 {
172 throw sdbusplus::exception::SdBusError(
173 static_cast<int>(std::errc::argument_list_too_long),
174 "Too many reading parameters");
175 }
Krzysztof Grobelnye8fc5752021-02-05 14:30:45 +0000176
177 try
178 {
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000179 namespace ts = utils::tstring;
180
181 for (const LabeledMetricParameters& item : readingParams)
Krzysztof Grobelnye8fc5752021-02-05 14:30:45 +0000182 {
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000183 utils::toOperationType(
184 utils::toUnderlying(item.at_label<ts::OperationType>()));
Krzysztof Grobelnye8fc5752021-02-05 14:30:45 +0000185 }
186 }
187 catch (const std::exception& e)
188 {
189 throw sdbusplus::exception::SdBusError(
190 static_cast<int>(std::errc::invalid_argument), e.what());
191 }
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000192}
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100193
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000194interfaces::Report& ReportManager::addReport(
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100195 boost::asio::yield_context& yield, const std::string& reportId,
196 const std::string& reportName, const ReportingType reportingType,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100197 const std::vector<ReportAction>& reportActions, Milliseconds interval,
198 const uint64_t appendLimit, const ReportUpdates reportUpdates,
Lukasz Kazmierczak7e098e92021-09-16 15:59:56 +0200199 ReadingParameters metricParams, const bool enabled)
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000200{
Krzysztof Grobelnydcc4e192021-03-08 09:09:34 +0000201 auto labeledMetricParams =
202 reportFactory->convertMetricParams(yield, metricParams);
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000203
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100204 return addReport(reportId, reportName, reportingType, reportActions,
205 interval, appendLimit, reportUpdates,
206 std::move(labeledMetricParams), enabled);
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000207}
208
209interfaces::Report& ReportManager::addReport(
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100210 const std::string& reportId, const std::string& reportName,
211 const ReportingType reportingType,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100212 const std::vector<ReportAction>& reportActions, Milliseconds interval,
213 const uint64_t appendLimit, const ReportUpdates reportUpdates,
Lukasz Kazmierczak7e098e92021-09-16 15:59:56 +0200214 std::vector<LabeledMetricParameters> labeledMetricParams,
215 const bool enabled)
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000216{
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100217 const auto existingReportIds = utils::transform(
218 reports, [](const auto& report) { return report->getId(); });
219
Krzysztof Grobelnya950e422021-12-31 13:49:00 +0100220 auto [id, name] = utils::generateId(reportId, reportName, reportNameDefault,
221 existingReportIds, maxReportIdLength);
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100222
223 verifyAddReport(id, name, reportingType, interval, reportUpdates,
Ankita Vilas Gawadecd5b0b72022-01-20 20:55:04 +0000224 appendLimit, labeledMetricParams);
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000225
Szymon Dompke3eb56862021-09-20 15:32:04 +0200226 reports.emplace_back(reportFactory->make(
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100227 id, name, reportingType, reportActions, interval, appendLimit,
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100228 reportUpdates, *this, *reportStorage, labeledMetricParams, enabled));
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000229 return *reports.back();
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100230}
231
232void ReportManager::loadFromPersistent()
233{
234 std::vector<interfaces::JsonStorage::FilePath> paths =
235 reportStorage->list();
236
237 for (const auto& path : paths)
238 {
239 std::optional<nlohmann::json> data = reportStorage->load(path);
240 try
241 {
242 size_t version = data->at("Version").get<size_t>();
243 if (version != Report::reportVersion)
244 {
245 throw std::logic_error("Invalid version");
246 }
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100247 bool enabled = data->at("Enabled").get<bool>();
248 std::string& id = data->at("Id").get_ref<std::string&>();
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100249 std::string& name = data->at("Name").get_ref<std::string&>();
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100250
251 uint32_t reportingType = data->at("ReportingType").get<uint32_t>();
252 std::vector<ReportAction> reportActions = utils::transform(
253 data->at("ReportActions").get<std::vector<uint32_t>>(),
254 [](const auto reportAction) {
255 return utils::toReportAction(reportAction);
256 });
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100257 uint64_t interval = data->at("Interval").get<uint64_t>();
Szymon Dompke3eb56862021-09-20 15:32:04 +0200258 uint64_t appendLimit = data->at("AppendLimit").get<uint64_t>();
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100259 uint32_t reportUpdates = data->at("ReportUpdates").get<uint32_t>();
Krzysztof Grobelnyd2238192020-12-02 09:27:28 +0000260 auto readingParameters =
261 data->at("ReadingParameters")
262 .get<std::vector<LabeledMetricParameters>>();
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100263
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100264 addReport(id, name, utils::toReportingType(reportingType),
Krzysztof Grobelny51497a02021-11-09 14:56:22 +0100265 reportActions, Milliseconds(interval), appendLimit,
266 utils::toReportUpdates(reportUpdates),
267 std::move(readingParameters), enabled);
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100268 }
269 catch (const std::exception& e)
270 {
271 phosphor::logging::log<phosphor::logging::level::ERR>(
272 "Failed to load report from storage",
273 phosphor::logging::entry(
Wludzik, Jozef982c5b52021-01-02 12:05:21 +0100274 "FILENAME=%s",
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100275 static_cast<std::filesystem::path>(path).c_str()),
Wludzik, Jozef982c5b52021-01-02 12:05:21 +0100276 phosphor::logging::entry("EXCEPTION_MSG=%s", e.what()));
Wludzik, Jozefe2362792020-10-27 17:23:55 +0100277 reportStorage->remove(path);
278 }
279 }
280}
Wludzik, Jozefd960e1f2021-01-08 09:25:59 +0100281
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100282void ReportManager::updateReport(const std::string& id)
Wludzik, Jozefd960e1f2021-01-08 09:25:59 +0100283{
284 for (auto& report : reports)
285 {
Krzysztof Grobelnyb8cc78d2021-11-29 15:54:53 +0100286 if (report->getId() == id)
Wludzik, Jozefd960e1f2021-01-08 09:25:59 +0100287 {
288 report->updateReadings();
289 return;
290 }
291 }
292}