clang-format: update latest spec and reformat
Copy the latest format file from the docs repository and apply.
Change-Id: Ic2bc1d98d8ad469a3477f9059ec890fc8339907d
Signed-off-by: Patrick Williams <patrick@stwcx.xyz>
diff --git a/.clang-format b/.clang-format
index d43e884..e5530e6 100644
--- a/.clang-format
+++ b/.clang-format
@@ -17,9 +17,7 @@
AllowShortIfStatementsOnASingleLine: Never
AllowShortLambdasOnASingleLine: true
AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true
BinPackParameters: true
BitFieldColonSpacing: None
@@ -43,12 +41,14 @@
SplitEmptyRecord: false
SplitEmptyNamespace: false
BreakAfterAttributes: Never
+BreakAfterReturnType: Automatic
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: AfterColon
BreakInheritanceList: AfterColon
BreakStringLiterals: false
+BreakTemplateDeclarations: Yes
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
@@ -87,7 +87,7 @@
IndentWrappedFunctionNames: true
InsertNewlineAtEOF: true
KeepEmptyLinesAtTheStartOfBlocks: false
-LambdaBodyIndentation: OuterScope
+LambdaBodyIndentation: Signature
LineEnding: LF
MacroBlockBegin: ''
MacroBlockEnd: ''
@@ -98,13 +98,14 @@
ObjCSpaceBeforeProtocolList: true
PackConstructorInitializers: BinPack
PenaltyBreakAssignment: 25
-PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakBeforeFirstCallParameter: 50
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PenaltyIndentedWhitespace: 0
+PenaltyReturnTypeOnItsOwnLine: 150
+PenaltyIndentedWhitespace: 1
PointerAlignment: Left
QualifierAlignment: Left
ReferenceAlignment: Left
diff --git a/src/discrete_threshold.cpp b/src/discrete_threshold.cpp
index 0d98c28..6fd4212 100644
--- a/src/discrete_threshold.cpp
+++ b/src/discrete_threshold.cpp
@@ -34,8 +34,8 @@
ThresholdOperations::updateSensors(this, std::move(newSensors));
}
-DiscreteThreshold::ThresholdDetail&
- DiscreteThreshold::getDetails(const interfaces::Sensor& sensor)
+DiscreteThreshold::ThresholdDetail& DiscreteThreshold::getDetails(
+ const interfaces::Sensor& sensor)
{
return ThresholdOperations::getDetails(this, sensor);
}
diff --git a/src/errors.cpp b/src/errors.cpp
index fe88fd0..e38a370 100644
--- a/src/errors.cpp
+++ b/src/errors.cpp
@@ -9,8 +9,8 @@
InvalidArgument::InvalidArgument(std::string_view propertyNameArg) :
propertyName(propertyNameArg),
- errWhatDetailed("Invalid argument was given for property: "s +
- description())
+ errWhatDetailed(
+ "Invalid argument was given for property: "s + description())
{}
InvalidArgument::InvalidArgument(std::string_view propertyNameArg,
diff --git a/src/interfaces/json_storage.hpp b/src/interfaces/json_storage.hpp
index 491d4d9..26f4027 100644
--- a/src/interfaces/json_storage.hpp
+++ b/src/interfaces/json_storage.hpp
@@ -21,8 +21,8 @@
virtual void store(const FilePath& subPath, const nlohmann::json& data) = 0;
virtual bool remove(const FilePath& subPath) = 0;
virtual bool exist(const FilePath& path) const = 0;
- virtual std::optional<nlohmann::json>
- load(const FilePath& subPath) const = 0;
+ virtual std::optional<nlohmann::json> load(
+ const FilePath& subPath) const = 0;
virtual std::vector<FilePath> list() const = 0;
};
diff --git a/src/interfaces/metric.hpp b/src/interfaces/metric.hpp
index 63f4cf7..6ad5ca4 100644
--- a/src/interfaces/metric.hpp
+++ b/src/interfaces/metric.hpp
@@ -23,8 +23,8 @@
virtual LabeledMetricParameters dumpConfiguration() const = 0;
virtual uint64_t metricCount() const = 0;
virtual void registerForUpdates(interfaces::MetricListener& listener) = 0;
- virtual void
- unregisterFromUpdates(interfaces::MetricListener& listener) = 0;
+ virtual void unregisterFromUpdates(
+ interfaces::MetricListener& listener) = 0;
virtual void updateReadings(Milliseconds) = 0;
virtual bool isTimerRequired() const = 0;
};
diff --git a/src/interfaces/report_factory.hpp b/src/interfaces/report_factory.hpp
index 9448598..c8e23c3 100644
--- a/src/interfaces/report_factory.hpp
+++ b/src/interfaces/report_factory.hpp
@@ -24,26 +24,25 @@
public:
virtual ~ReportFactory() = default;
- virtual std::vector<LabeledMetricParameters>
- convertMetricParams(boost::asio::yield_context& yield,
- const ReadingParameters& metricParams) const = 0;
- virtual std::vector<LabeledMetricParameters>
- convertMetricParams(const ReadingParameters& metricParams) const = 0;
+ virtual std::vector<LabeledMetricParameters> convertMetricParams(
+ boost::asio::yield_context& yield,
+ const ReadingParameters& metricParams) const = 0;
+ virtual std::vector<LabeledMetricParameters> convertMetricParams(
+ const ReadingParameters& metricParams) const = 0;
virtual void updateMetrics(
std::vector<std::shared_ptr<interfaces::Metric>>& metrics, bool enabled,
const std::vector<LabeledMetricParameters>& labeledMetricParams)
const = 0;
- virtual std::unique_ptr<interfaces::Report>
- make(const std::string& id, const std::string& name,
- const ReportingType reportingType,
- const std::vector<ReportAction>& reportActions,
- Milliseconds period, uint64_t appendLimit,
- const ReportUpdates reportUpdates, ReportManager& reportManager,
- JsonStorage& reportStorage,
- std::vector<LabeledMetricParameters> labeledMetricParams,
- bool enabled, Readings) const = 0;
+ virtual std::unique_ptr<interfaces::Report> make(
+ const std::string& id, const std::string& name,
+ const ReportingType reportingType,
+ const std::vector<ReportAction>& reportActions, Milliseconds period,
+ uint64_t appendLimit, const ReportUpdates reportUpdates,
+ ReportManager& reportManager, JsonStorage& reportStorage,
+ std::vector<LabeledMetricParameters> labeledMetricParams, bool enabled,
+ Readings) const = 0;
};
} // namespace interfaces
diff --git a/src/interfaces/sensor.hpp b/src/interfaces/sensor.hpp
index 78a762e..7829ea7 100644
--- a/src/interfaces/sensor.hpp
+++ b/src/interfaces/sensor.hpp
@@ -46,8 +46,8 @@
virtual std::string metadata() const = 0;
virtual std::string getName() const = 0;
virtual void registerForUpdates(const std::weak_ptr<SensorListener>&) = 0;
- virtual void
- unregisterFromUpdates(const std::weak_ptr<SensorListener>&) = 0;
+ virtual void unregisterFromUpdates(
+ const std::weak_ptr<SensorListener>&) = 0;
virtual LabeledSensorInfo getLabeledSensorInfo() const = 0;
};
diff --git a/src/interfaces/trigger_factory.hpp b/src/interfaces/trigger_factory.hpp
index 947af43..d52cb33 100644
--- a/src/interfaces/trigger_factory.hpp
+++ b/src/interfaces/trigger_factory.hpp
@@ -31,12 +31,12 @@
const LabeledTriggerThresholdParams& labeledThresholdParams,
const std::vector<LabeledSensorInfo>& labeledSensorsInfo) const = 0;
- virtual std::vector<LabeledSensorInfo>
- getLabeledSensorsInfo(boost::asio::yield_context& yield,
- const SensorsInfo& sensorsInfo) const = 0;
+ virtual std::vector<LabeledSensorInfo> getLabeledSensorsInfo(
+ boost::asio::yield_context& yield,
+ const SensorsInfo& sensorsInfo) const = 0;
- virtual std::vector<LabeledSensorInfo>
- getLabeledSensorsInfo(const SensorsInfo& sensorsInfo) const = 0;
+ virtual std::vector<LabeledSensorInfo> getLabeledSensorsInfo(
+ const SensorsInfo& sensorsInfo) const = 0;
virtual void updateThresholds(
std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
diff --git a/src/main.cpp b/src/main.cpp
index 59a2d30..bea8a13 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -20,13 +20,13 @@
signals.async_wait(
[&ioc](const boost::system::error_code ec, const int& sig) {
- if (ec)
- {
- throw std::runtime_error("Signal should not be canceled");
- }
+ if (ec)
+ {
+ throw std::runtime_error("Signal should not be canceled");
+ }
- ioc.stop();
- });
+ ioc.stop();
+ });
phosphor::logging::log<phosphor::logging::level::INFO>(
"Telemetry starting");
diff --git a/src/metric.cpp b/src/metric.cpp
index c1c5fd2..9f32b59 100644
--- a/src/metric.cpp
+++ b/src/metric.cpp
@@ -32,8 +32,8 @@
listeners.erase(
std::remove_if(listeners.begin(), listeners.end(),
[&listener](const interfaces::MetricListener& item) {
- return &item == &listener;
- }),
+ return &item == &listener;
+ }),
listeners.end());
}
@@ -104,8 +104,8 @@
}
}
-metrics::CollectionData&
- Metric::findAssociatedData(const interfaces::Sensor& notifier)
+metrics::CollectionData& Metric::findAssociatedData(
+ const interfaces::Sensor& notifier)
{
auto it = std::find_if(
sensors.begin(), sensors.end(),
diff --git a/src/metric.hpp b/src/metric.hpp
index fa462cb..3ceee17 100644
--- a/src/metric.hpp
+++ b/src/metric.hpp
@@ -30,8 +30,8 @@
bool isTimerRequired() const override;
private:
- metrics::CollectionData&
- findAssociatedData(const interfaces::Sensor& notifier);
+ metrics::CollectionData& findAssociatedData(
+ const interfaces::Sensor& notifier);
std::vector<MetricValue> readings;
Sensors sensors;
diff --git a/src/metrics/collection_data.cpp b/src/metrics/collection_data.cpp
index 915f570..11ef1b0 100644
--- a/src/metrics/collection_data.cpp
+++ b/src/metrics/collection_data.cpp
@@ -84,8 +84,8 @@
if (timestamp > duration.t)
{
- readings.front().first = std::max(readings.front().first,
- timestamp - duration.t);
+ readings.front().first =
+ std::max(readings.front().first, timestamp - duration.t);
}
}
@@ -122,10 +122,9 @@
std::vector<ReadingItem> readings;
};
-std::vector<std::unique_ptr<CollectionData>>
- makeCollectionData(size_t size, OperationType op,
- CollectionTimeScope timeScope,
- CollectionDuration duration)
+std::vector<std::unique_ptr<CollectionData>> makeCollectionData(
+ size_t size, OperationType op, CollectionTimeScope timeScope,
+ CollectionDuration duration)
{
using namespace std::string_literals;
@@ -136,10 +135,11 @@
switch (timeScope)
{
case CollectionTimeScope::interval:
- std::generate_n(std::back_inserter(result), size,
- [cf = makeCollectionFunction(op), duration] {
- return std::make_unique<DataInterval>(cf, duration);
- });
+ std::generate_n(
+ std::back_inserter(result), size,
+ [cf = makeCollectionFunction(op), duration] {
+ return std::make_unique<DataInterval>(cf, duration);
+ });
break;
case CollectionTimeScope::point:
std::generate_n(std::back_inserter(result), size,
@@ -148,8 +148,8 @@
case CollectionTimeScope::startup:
std::generate_n(std::back_inserter(result), size,
[cf = makeCollectionFunction(op)] {
- return std::make_unique<DataStartup>(cf);
- });
+ return std::make_unique<DataStartup>(cf);
+ });
break;
}
diff --git a/src/metrics/collection_data.hpp b/src/metrics/collection_data.hpp
index 251e704..1742369 100644
--- a/src/metrics/collection_data.hpp
+++ b/src/metrics/collection_data.hpp
@@ -25,8 +25,7 @@
std::optional<double> lastValue;
};
-std::vector<std::unique_ptr<CollectionData>>
- makeCollectionData(size_t size, OperationType, CollectionTimeScope,
- CollectionDuration);
+std::vector<std::unique_ptr<CollectionData>> makeCollectionData(
+ size_t size, OperationType, CollectionTimeScope, CollectionDuration);
} // namespace metrics
diff --git a/src/metrics/collection_function.cpp b/src/metrics/collection_function.cpp
index 21c8111..5044216 100644
--- a/src/metrics/collection_function.cpp
+++ b/src/metrics/collection_function.cpp
@@ -11,11 +11,15 @@
double calculate(const std::vector<ReadingItem>& readings,
Milliseconds) const override
{
- return std::min_element(readings.begin(), readings.end(),
- [](const auto& left, const auto& right) {
- return std::make_tuple(!std::isfinite(left.second), left.second) <
- std::make_tuple(!std::isfinite(right.second), right.second);
- })->second;
+ return std::min_element(
+ readings.begin(), readings.end(),
+ [](const auto& left, const auto& right) {
+ return std::make_tuple(!std::isfinite(left.second),
+ left.second) <
+ std::make_tuple(!std::isfinite(right.second),
+ right.second);
+ })
+ ->second;
}
double calculateForStartupInterval(std::vector<ReadingItem>& readings,
@@ -33,11 +37,15 @@
double calculate(const std::vector<ReadingItem>& readings,
Milliseconds) const override
{
- return std::max_element(readings.begin(), readings.end(),
- [](const auto& left, const auto& right) {
- return std::make_tuple(std::isfinite(left.second), left.second) <
- std::make_tuple(std::isfinite(right.second), right.second);
- })->second;
+ return std::max_element(
+ readings.begin(), readings.end(),
+ [](const auto& left, const auto& right) {
+ return std::make_tuple(std::isfinite(left.second),
+ left.second) <
+ std::make_tuple(std::isfinite(right.second),
+ right.second);
+ })
+ ->second;
}
double calculateForStartupInterval(std::vector<ReadingItem>& readings,
@@ -115,9 +123,9 @@
return valueSum;
}
- double
- calculateForStartupInterval(std::vector<ReadingItem>& readings,
- const Milliseconds timestamp) const override
+ double calculateForStartupInterval(
+ std::vector<ReadingItem>& readings,
+ const Milliseconds timestamp) const override
{
const auto result = calculate(readings, timestamp);
if (readings.size() > 2 && std::isfinite(result))
@@ -143,8 +151,8 @@
}
};
-std::shared_ptr<CollectionFunction>
- makeCollectionFunction(OperationType operationType)
+std::shared_ptr<CollectionFunction> makeCollectionFunction(
+ OperationType operationType)
{
using namespace std::string_literals;
@@ -159,9 +167,9 @@
case OperationType::sum:
return std::make_shared<FunctionSummation>();
default:
- throw std::runtime_error("op: "s +
- utils::enumToString(operationType) +
- " is not supported"s);
+ throw std::runtime_error(
+ "op: "s + utils::enumToString(operationType) +
+ " is not supported"s);
}
}
diff --git a/src/metrics/collection_function.hpp b/src/metrics/collection_function.hpp
index 610f015..fdeafc3 100644
--- a/src/metrics/collection_function.hpp
+++ b/src/metrics/collection_function.hpp
@@ -20,9 +20,8 @@
virtual double calculate(const std::vector<ReadingItem>& readings,
Milliseconds timestamp) const = 0;
- virtual double
- calculateForStartupInterval(std::vector<ReadingItem>& readings,
- Milliseconds timestamp) const = 0;
+ virtual double calculateForStartupInterval(
+ std::vector<ReadingItem>& readings, Milliseconds timestamp) const = 0;
};
std::shared_ptr<CollectionFunction> makeCollectionFunction(OperationType);
diff --git a/src/numeric_threshold.cpp b/src/numeric_threshold.cpp
index 2a02a92..9a141f6 100644
--- a/src/numeric_threshold.cpp
+++ b/src/numeric_threshold.cpp
@@ -29,8 +29,8 @@
ThresholdOperations::updateSensors(this, std::move(newSensors));
}
-NumericThreshold::ThresholdDetail&
- NumericThreshold::getDetails(const interfaces::Sensor& sensor)
+NumericThreshold::ThresholdDetail& NumericThreshold::getDetails(
+ const interfaces::Sensor& sensor)
{
return ThresholdOperations::getDetails(this, sensor);
}
@@ -56,10 +56,10 @@
return;
}
- bool crossedDecreasing = thresholdValue < prevValue &&
- thresholdValue > value;
- bool crossedIncreasing = thresholdValue > prevValue &&
- thresholdValue < value;
+ bool crossedDecreasing =
+ thresholdValue < prevValue && thresholdValue > value;
+ bool crossedIncreasing =
+ thresholdValue > prevValue && thresholdValue < value;
if (!crossedDecreasing && !crossedIncreasing && thresholdValue == prevValue)
{
diff --git a/src/persistent_json_storage.cpp b/src/persistent_json_storage.cpp
index 97326fe..fadc083 100644
--- a/src/persistent_json_storage.cpp
+++ b/src/persistent_json_storage.cpp
@@ -15,8 +15,8 @@
{
if (std::filesystem::is_symlink(currentPath))
{
- std::string warningStr = std::format("{} is a symlink",
- currentPath.string());
+ std::string warningStr =
+ std::format("{} is a symlink", currentPath.string());
phosphor::logging::log<phosphor::logging::level::WARNING>(
warningStr.c_str());
return true;
@@ -95,8 +95,8 @@
return true;
}
-std::optional<nlohmann::json>
- PersistentJsonStorage::load(const FilePath& filePath) const
+std::optional<nlohmann::json> PersistentJsonStorage::load(
+ const FilePath& filePath) const
{
const auto path = join(directory, filePath);
if (!std::filesystem::exists(path))
@@ -121,8 +121,8 @@
return result;
}
-std::vector<interfaces::JsonStorage::FilePath>
- PersistentJsonStorage::list() const
+std::vector<interfaces::JsonStorage::FilePath> PersistentJsonStorage::list()
+ const
{
std::vector<interfaces::JsonStorage::FilePath> result;
if (!std::filesystem::exists(directory))
@@ -143,9 +143,8 @@
return result;
}
-std::filesystem::path
- PersistentJsonStorage::join(const std::filesystem::path& left,
- const std::filesystem::path& right)
+std::filesystem::path PersistentJsonStorage::join(
+ const std::filesystem::path& left, const std::filesystem::path& right)
{
return left / right;
}
diff --git a/src/report.cpp b/src/report.cpp
index 21302b4..90b6b8a 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -18,19 +18,18 @@
#include <numeric>
#include <optional>
-Report::Report(boost::asio::io_context& ioc,
- const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
- const std::string& reportId, const std::string& reportName,
- const ReportingType reportingTypeIn,
- std::vector<ReportAction> reportActionsIn,
- const Milliseconds intervalIn, const uint64_t appendLimitIn,
- const ReportUpdates reportUpdatesIn,
- interfaces::ReportManager& reportManager,
- interfaces::JsonStorage& reportStorageIn,
- std::vector<std::shared_ptr<interfaces::Metric>> metricsIn,
- const interfaces::ReportFactory& reportFactory,
- const bool enabledIn, std::unique_ptr<interfaces::Clock> clock,
- Readings readingsIn) :
+Report::Report(
+ boost::asio::io_context& ioc,
+ const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
+ const std::string& reportId, const std::string& reportName,
+ const ReportingType reportingTypeIn,
+ std::vector<ReportAction> reportActionsIn, const Milliseconds intervalIn,
+ const uint64_t appendLimitIn, const ReportUpdates reportUpdatesIn,
+ interfaces::ReportManager& reportManager,
+ interfaces::JsonStorage& reportStorageIn,
+ std::vector<std::shared_ptr<interfaces::Metric>> metricsIn,
+ const interfaces::ReportFactory& reportFactory, const bool enabledIn,
+ std::unique_ptr<interfaces::Clock> clock, Readings readingsIn) :
id(reportId), path(utils::pathAppend(utils::constants::reportDirPath, id)),
name(reportName), reportingType(reportingTypeIn), interval(intervalIn),
reportActions(reportActionsIn.begin(), reportActionsIn.end()),
@@ -44,27 +43,27 @@
{
readingParameters =
toReadingParameters(utils::transform(metrics, [](const auto& metric) {
- return metric->dumpConfiguration();
- }));
+ return metric->dumpConfiguration();
+ }));
reportActions.insert(ReportAction::logToMetricReportsCollection);
deleteIface = objServer->add_unique_interface(
getPath(), deleteIfaceName,
[this, &ioc, &reportManager](auto& dbusIface) {
- dbusIface.register_method("Delete", [this, &ioc, &reportManager] {
- if (persistency)
- {
- persistency = false;
+ dbusIface.register_method("Delete", [this, &ioc, &reportManager] {
+ if (persistency)
+ {
+ persistency = false;
- reportIface->signal_property("Persistency");
- }
+ reportIface->signal_property("Persistency");
+ }
- boost::asio::post(ioc, [this, &reportManager] {
- reportManager.removeReport(this);
+ boost::asio::post(ioc, [this, &reportManager] {
+ reportManager.removeReport(this);
+ });
});
});
- });
auto errorMessages = verify(reportingType, interval);
state.set<ReportFlags::enabled, ReportFlags::valid>(enabledIn,
@@ -75,29 +74,29 @@
messanger.on_receive<messages::TriggerPresenceChangedInd>(
[this](const auto& msg) {
- const auto oldSize = triggerIds.size();
+ const auto oldSize = triggerIds.size();
- if (msg.presence == messages::Presence::Exist)
- {
- if (utils::contains(msg.reportIds, id))
+ if (msg.presence == messages::Presence::Exist)
{
- triggerIds.insert(msg.triggerId);
+ if (utils::contains(msg.reportIds, id))
+ {
+ triggerIds.insert(msg.triggerId);
+ }
+ else if (!utils::contains(msg.reportIds, id))
+ {
+ triggerIds.erase(msg.triggerId);
+ }
}
- else if (!utils::contains(msg.reportIds, id))
+ else if (msg.presence == messages::Presence::Removed)
{
triggerIds.erase(msg.triggerId);
}
- }
- else if (msg.presence == messages::Presence::Removed)
- {
- triggerIds.erase(msg.triggerId);
- }
- if (triggerIds.size() != oldSize)
- {
- reportIface->signal_property("Triggers");
- }
- });
+ if (triggerIds.size() != oldSize)
+ {
+ reportIface->signal_property("Triggers");
+ }
+ });
messanger.on_receive<messages::UpdateReportInd>([this](const auto& msg) {
if (utils::contains(msg.reportIds, id))
@@ -170,8 +169,8 @@
void Report::setReadingBuffer(const ReportUpdates newReportUpdates)
{
- const auto newBufferSize = deduceBufferSize(newReportUpdates,
- reportingType);
+ const auto newBufferSize =
+ deduceBufferSize(newReportUpdates, reportingType);
if (readingsBuffer.size() != newBufferSize)
{
readingsBuffer.clearAndResize(newBufferSize);
@@ -187,94 +186,96 @@
}
}
-std::unique_ptr<sdbusplus::asio::dbus_interface>
- Report::makeReportInterface(const interfaces::ReportFactory& reportFactory)
+std::unique_ptr<sdbusplus::asio::dbus_interface> Report::makeReportInterface(
+ const interfaces::ReportFactory& reportFactory)
{
- auto dbusIface = objServer->add_unique_interface(getPath(),
- reportIfaceName);
+ auto dbusIface =
+ objServer->add_unique_interface(getPath(), reportIfaceName);
dbusIface->register_property_rw<bool>(
"Enabled", sdbusplus::vtable::property_::emits_change,
[this](bool newVal, auto& oldValue) {
- if (newVal != state.get<ReportFlags::enabled>())
- {
- state.set<ReportFlags::enabled>(oldValue = newVal);
+ if (newVal != state.get<ReportFlags::enabled>())
+ {
+ state.set<ReportFlags::enabled>(oldValue = newVal);
- persistency = storeConfiguration();
- }
- return 1;
- }, [this](const auto&) { return state.get<ReportFlags::enabled>(); });
+ persistency = storeConfiguration();
+ }
+ return 1;
+ },
+ [this](const auto&) { return state.get<ReportFlags::enabled>(); });
dbusIface->register_method(
"SetReportingProperties",
[this](std::string newReportingType, uint64_t newInterval) {
- ReportingType newReportingTypeT = reportingType;
+ ReportingType newReportingTypeT = reportingType;
- if (!newReportingType.empty())
- {
- newReportingTypeT = utils::toReportingType(newReportingType);
- }
-
- Milliseconds newIntervalT = interval;
-
- if (newInterval != std::numeric_limits<uint64_t>::max())
- {
- newIntervalT = Milliseconds(newInterval);
- }
-
- auto errorMessages = verify(newReportingTypeT, newIntervalT);
-
- if (!errorMessages.empty())
- {
- if (newIntervalT != interval)
+ if (!newReportingType.empty())
{
- throw errors::InvalidArgument("Interval");
+ newReportingTypeT = utils::toReportingType(newReportingType);
}
- throw errors::InvalidArgument("ReportingType");
- }
+ Milliseconds newIntervalT = interval;
- if (reportingType != newReportingTypeT)
- {
- reportingType = newReportingTypeT;
- reportIface->signal_property("ReportingType");
- }
+ if (newInterval != std::numeric_limits<uint64_t>::max())
+ {
+ newIntervalT = Milliseconds(newInterval);
+ }
- if (interval != newIntervalT)
- {
- interval = newIntervalT;
- reportIface->signal_property("Interval");
- }
+ auto errorMessages = verify(newReportingTypeT, newIntervalT);
- if (state.set<ReportFlags::valid>(errorMessages.empty()) ==
- StateEvent::active)
- {
- scheduleTimer();
- }
+ if (!errorMessages.empty())
+ {
+ if (newIntervalT != interval)
+ {
+ throw errors::InvalidArgument("Interval");
+ }
- persistency = storeConfiguration();
+ throw errors::InvalidArgument("ReportingType");
+ }
- setReadingBuffer(reportUpdates);
- });
+ if (reportingType != newReportingTypeT)
+ {
+ reportingType = newReportingTypeT;
+ reportIface->signal_property("ReportingType");
+ }
+
+ if (interval != newIntervalT)
+ {
+ interval = newIntervalT;
+ reportIface->signal_property("Interval");
+ }
+
+ if (state.set<ReportFlags::valid>(errorMessages.empty()) ==
+ StateEvent::active)
+ {
+ scheduleTimer();
+ }
+
+ persistency = storeConfiguration();
+
+ setReadingBuffer(reportUpdates);
+ });
dbusIface->register_property_r<uint64_t>(
"Interval", sdbusplus::vtable::property_::emits_change,
[this](const auto&) { return interval.count(); });
dbusIface->register_property_rw<bool>(
"Persistency", sdbusplus::vtable::property_::emits_change,
[this](bool newVal, auto& oldVal) {
- if (newVal == persistency)
- {
+ if (newVal == persistency)
+ {
+ return 1;
+ }
+ if (newVal)
+ {
+ persistency = oldVal = storeConfiguration();
+ }
+ else
+ {
+ reportStorage.remove(reportFileName());
+ persistency = oldVal = false;
+ }
return 1;
- }
- if (newVal)
- {
- persistency = oldVal = storeConfiguration();
- }
- else
- {
- reportStorage.remove(reportFileName());
- persistency = oldVal = false;
- }
- return 1;
- }, [this](const auto&) { return persistency; });
+ },
+ [this](const auto&) { return persistency; });
dbusIface->register_property_r("Readings", readings,
sdbusplus::vtable::property_::emits_change,
@@ -286,75 +287,81 @@
"ReadingParameters", readingParameters,
sdbusplus::vtable::property_::emits_change,
[this, &reportFactory](auto newVal, auto& oldVal) {
- auto labeledMetricParams = reportFactory.convertMetricParams(newVal);
- ReportManager::verifyMetricParams(labeledMetricParams);
- reportFactory.updateMetrics(metrics, state.get<ReportFlags::enabled>(),
- labeledMetricParams);
- readingParameters = toReadingParameters(
- utils::transform(metrics, [](const auto& metric) {
- return metric->dumpConfiguration();
- }));
- metricCount = getMetricCount(metrics);
- setReadingBuffer(reportUpdates);
- persistency = storeConfiguration();
- oldVal = std::move(newVal);
- return 1;
- }, [this](const auto&) { return readingParameters; });
- dbusIface->register_property_r<bool>("EmitsReadingsUpdate",
- sdbusplus::vtable::property_::none,
- [this](const auto&) {
- return reportActions.contains(ReportAction::emitsReadingsUpdate);
- });
+ auto labeledMetricParams =
+ reportFactory.convertMetricParams(newVal);
+ ReportManager::verifyMetricParams(labeledMetricParams);
+ reportFactory.updateMetrics(metrics,
+ state.get<ReportFlags::enabled>(),
+ labeledMetricParams);
+ readingParameters = toReadingParameters(
+ utils::transform(metrics, [](const auto& metric) {
+ return metric->dumpConfiguration();
+ }));
+ metricCount = getMetricCount(metrics);
+ setReadingBuffer(reportUpdates);
+ persistency = storeConfiguration();
+ oldVal = std::move(newVal);
+ return 1;
+ },
+ [this](const auto&) { return readingParameters; });
+ dbusIface->register_property_r<bool>(
+ "EmitsReadingsUpdate", sdbusplus::vtable::property_::none,
+ [this](const auto&) {
+ return reportActions.contains(ReportAction::emitsReadingsUpdate);
+ });
dbusIface->register_property_r<std::string>(
"Name", sdbusplus::vtable::property_::const_,
[this](const auto&) { return name; });
- dbusIface->register_property_r<bool>("LogToMetricReportsCollection",
- sdbusplus::vtable::property_::const_,
- [this](const auto&) {
- return reportActions.contains(
- ReportAction::logToMetricReportsCollection);
- });
+ dbusIface->register_property_r<bool>(
+ "LogToMetricReportsCollection", sdbusplus::vtable::property_::const_,
+ [this](const auto&) {
+ return reportActions.contains(
+ ReportAction::logToMetricReportsCollection);
+ });
dbusIface->register_property_rw<std::vector<std::string>>(
"ReportActions", sdbusplus::vtable::property_::emits_change,
[this](auto newVal, auto& oldVal) {
- auto tmp = utils::transform<std::unordered_set>(
- newVal, [](const auto& reportAction) {
- return utils::toReportAction(reportAction);
- });
- tmp.insert(ReportAction::logToMetricReportsCollection);
+ auto tmp = utils::transform<std::unordered_set>(
+ newVal, [](const auto& reportAction) {
+ return utils::toReportAction(reportAction);
+ });
+ tmp.insert(ReportAction::logToMetricReportsCollection);
- if (tmp != reportActions)
- {
- reportActions = tmp;
- persistency = storeConfiguration();
- oldVal = std::move(newVal);
- }
- return 1;
- }, [this](const auto&) {
- return utils::transform<std::vector>(reportActions,
- [](const auto reportAction) {
- return utils::enumToString(reportAction);
+ if (tmp != reportActions)
+ {
+ reportActions = tmp;
+ persistency = storeConfiguration();
+ oldVal = std::move(newVal);
+ }
+ return 1;
+ },
+ [this](const auto&) {
+ return utils::transform<std::vector>(
+ reportActions, [](const auto reportAction) {
+ return utils::enumToString(reportAction);
+ });
});
- });
dbusIface->register_property_r<uint64_t>(
"AppendLimit", sdbusplus::vtable::property_::emits_change,
[this](const auto&) { return appendLimit; });
- dbusIface->register_property_rw("ReportUpdates", std::string(),
- sdbusplus::vtable::property_::emits_change,
- [this](auto newVal, auto& oldVal) {
- setReportUpdates(utils::toReportUpdates(newVal));
- oldVal = newVal;
- return 1;
- }, [this](const auto&) { return utils::enumToString(reportUpdates); });
+ dbusIface->register_property_rw(
+ "ReportUpdates", std::string(),
+ sdbusplus::vtable::property_::emits_change,
+ [this](auto newVal, auto& oldVal) {
+ setReportUpdates(utils::toReportUpdates(newVal));
+ oldVal = newVal;
+ return 1;
+ },
+ [this](const auto&) { return utils::enumToString(reportUpdates); });
dbusIface->register_property_r(
"Triggers", std::vector<sdbusplus::message::object_path>{},
sdbusplus::vtable::property_::emits_change, [this](const auto&) {
- return utils::transform<std::vector>(triggerIds,
- [](const auto& triggerId) {
- return utils::pathAppend(utils::constants::triggerDirPath,
- triggerId);
+ return utils::transform<std::vector>(
+ triggerIds, [](const auto& triggerId) {
+ return utils::pathAppend(utils::constants::triggerDirPath,
+ triggerId);
+ });
});
- });
dbusIface->register_method("Update", [this] {
if (reportingType == ReportingType::onRequest)
{
@@ -489,16 +496,17 @@
data["Id"] = id;
data["Name"] = name;
data["ReportingType"] = utils::toUnderlying(reportingType);
- data["ReportActions"] = utils::transform(reportActions,
- [](const auto reportAction) {
- return utils::toUnderlying(reportAction);
- });
+ data["ReportActions"] =
+ utils::transform(reportActions, [](const auto reportAction) {
+ return utils::toUnderlying(reportAction);
+ });
data["Interval"] = interval.count();
data["AppendLimit"] = appendLimit;
data["ReportUpdates"] = utils::toUnderlying(reportUpdates);
- data["ReadingParameters"] = utils::transform(
- metrics,
- [](const auto& metric) { return metric->dumpConfiguration(); });
+ data["ReadingParameters"] =
+ utils::transform(metrics, [](const auto& metric) {
+ return metric->dumpConfiguration();
+ });
if (shouldStoreMetricValues())
{
@@ -524,15 +532,16 @@
std::to_string(std::hash<std::string>{}(id))};
}
-std::unordered_set<std::string>
- Report::collectTriggerIds(boost::asio::io_context& ioc) const
+std::unordered_set<std::string> Report::collectTriggerIds(
+ boost::asio::io_context& ioc) const
{
utils::Messanger tmp(ioc);
auto result = std::unordered_set<std::string>();
- tmp.on_receive<messages::CollectTriggerIdResp>(
- [&result](const auto& msg) { result.insert(msg.triggerId); });
+ tmp.on_receive<messages::CollectTriggerIdResp>([&result](const auto& msg) {
+ result.insert(msg.triggerId);
+ });
tmp.send(messages::CollectTriggerIdReq{id});
diff --git a/src/report.hpp b/src/report.hpp
index bb164d9..2fbd078 100644
--- a/src/report.hpp
+++ b/src/report.hpp
@@ -87,8 +87,8 @@
void deactivate();
private:
- std::unique_ptr<sdbusplus::asio::dbus_interface>
- makeReportInterface(const interfaces::ReportFactory& reportFactory);
+ std::unique_ptr<sdbusplus::asio::dbus_interface> makeReportInterface(
+ const interfaces::ReportFactory& reportFactory);
static void timerProcForPeriodicReport(boost::system::error_code,
Report& self);
static void timerProcForOnChangeReport(boost::system::error_code,
@@ -102,8 +102,8 @@
static uint64_t getMetricCount(
const std::vector<std::shared_ptr<interfaces::Metric>>& metrics);
interfaces::JsonStorage::FilePath reportFileName() const;
- std::unordered_set<std::string>
- collectTriggerIds(boost::asio::io_context& ioc) const;
+ std::unordered_set<std::string> collectTriggerIds(
+ boost::asio::io_context& ioc) const;
bool storeConfiguration() const;
bool shouldStoreMetricValues() const;
void updateReadings();
diff --git a/src/report_factory.cpp b/src/report_factory.cpp
index c798247..ec1ee05 100644
--- a/src/report_factory.cpp
+++ b/src/report_factory.cpp
@@ -25,18 +25,19 @@
std::vector<LabeledMetricParameters> labeledMetricParams, bool enabled,
Readings readings) const
{
- auto metrics = utils::transform(labeledMetricParams,
- [this](const LabeledMetricParameters& param)
- -> std::shared_ptr<interfaces::Metric> {
- namespace ts = utils::tstring;
+ auto metrics = utils::transform(
+ labeledMetricParams,
+ [this](const LabeledMetricParameters& param)
+ -> std::shared_ptr<interfaces::Metric> {
+ namespace ts = utils::tstring;
- return std::make_shared<Metric>(
- getSensors(param.at_label<ts::SensorPath>()),
- param.at_label<ts::OperationType>(),
- param.at_label<ts::CollectionTimeScope>(),
- param.at_label<ts::CollectionDuration>(),
- std::make_unique<Clock>());
- });
+ return std::make_shared<Metric>(
+ getSensors(param.at_label<ts::SensorPath>()),
+ param.at_label<ts::OperationType>(),
+ param.at_label<ts::CollectionTimeScope>(),
+ param.at_label<ts::CollectionDuration>(),
+ std::make_unique<Clock>());
+ });
return std::make_unique<Report>(
bus->get_io_context(), objServer, id, name, reportingType,
@@ -56,8 +57,9 @@
{
auto existing = std::find_if(oldMetrics.begin(), oldMetrics.end(),
[labeledMetricParam](auto metric) {
- return labeledMetricParam == metric->dumpConfiguration();
- });
+ return labeledMetricParam ==
+ metric->dumpConfiguration();
+ });
if (existing != oldMetrics.end())
{
@@ -96,13 +98,14 @@
{
using namespace utils::tstring;
- return utils::transform(sensorPaths,
- [this](const LabeledSensorInfo& sensorPath)
- -> std::shared_ptr<interfaces::Sensor> {
- return sensorCache.makeSensor<Sensor>(
- sensorPath.at_label<Service>(), sensorPath.at_label<Path>(),
- sensorPath.at_label<Metadata>(), bus->get_io_context(), bus);
- });
+ return utils::transform(
+ sensorPaths,
+ [this](const LabeledSensorInfo& sensorPath)
+ -> std::shared_ptr<interfaces::Sensor> {
+ return sensorCache.makeSensor<Sensor>(
+ sensorPath.at_label<Service>(), sensorPath.at_label<Path>(),
+ sensorPath.at_label<Metadata>(), bus->get_io_context(), bus);
+ });
}
std::vector<LabeledMetricParameters> ReportFactory::convertMetricParams(
@@ -147,8 +150,8 @@
{
auto it = std::find_if(tree.begin(), tree.end(),
[path = sensorPath](const auto& v) {
- return v.first == path;
- });
+ return v.first == path;
+ });
if (it != tree.end() && it->second.size() == 1)
{
diff --git a/src/report_factory.hpp b/src/report_factory.hpp
index f49be6d..a13d9c9 100644
--- a/src/report_factory.hpp
+++ b/src/report_factory.hpp
@@ -29,16 +29,15 @@
const std::vector<LabeledMetricParameters>& labeledMetricParams)
const override;
- std::unique_ptr<interfaces::Report>
- make(const std::string& reportId, const std::string& name,
- const ReportingType reportingType,
- const std::vector<ReportAction>& reportActions,
- Milliseconds period, uint64_t appendLimitIn,
- const ReportUpdates reportUpdatesIn,
- interfaces::ReportManager& reportManager,
- interfaces::JsonStorage& reportStorage,
- std::vector<LabeledMetricParameters> labeledMetricParams,
- bool enabled, Readings) const override;
+ std::unique_ptr<interfaces::Report> make(
+ const std::string& reportId, const std::string& name,
+ const ReportingType reportingType,
+ const std::vector<ReportAction>& reportActions, Milliseconds period,
+ uint64_t appendLimitIn, const ReportUpdates reportUpdatesIn,
+ interfaces::ReportManager& reportManager,
+ interfaces::JsonStorage& reportStorage,
+ std::vector<LabeledMetricParameters> labeledMetricParams, bool enabled,
+ Readings) const override;
private:
Sensors getSensors(const std::vector<LabeledSensorInfo>& sensorPaths) const;
diff --git a/src/report_manager.cpp b/src/report_manager.cpp
index e9ccbb8..2959d25 100644
--- a/src/report_manager.cpp
+++ b/src/report_manager.cpp
@@ -28,59 +28,65 @@
reportManagerIface = objServer->add_unique_interface(
reportManagerPath, reportManagerIfaceName, [this](auto& dbusIface) {
- dbusIface.register_property_r("MaxReports", size_t{},
- sdbusplus::vtable::property_::const_,
- [](const auto&) { return maxReports; });
- dbusIface.register_property_r(
- "MinInterval", uint64_t{}, sdbusplus::vtable::property_::const_,
- [](const auto&) -> uint64_t { return minInterval.count(); });
- dbusIface.register_property_r(
- "SupportedOperationTypes", std::vector<std::string>{},
- sdbusplus::vtable::property_::const_,
- [](const auto&) -> std::vector<std::string> {
- return utils::transform<std::vector>(
- utils::convDataOperationType,
- [](const auto& item) { return std::string(item.first); });
+ dbusIface.register_property_r(
+ "MaxReports", size_t{}, sdbusplus::vtable::property_::const_,
+ [](const auto&) { return maxReports; });
+ dbusIface.register_property_r(
+ "MinInterval", uint64_t{}, sdbusplus::vtable::property_::const_,
+ [](const auto&) -> uint64_t { return minInterval.count(); });
+ dbusIface.register_property_r(
+ "SupportedOperationTypes", std::vector<std::string>{},
+ sdbusplus::vtable::property_::const_,
+ [](const auto&) -> std::vector<std::string> {
+ return utils::transform<std::vector>(
+ utils::convDataOperationType, [](const auto& item) {
+ return std::string(item.first);
+ });
+ });
+ dbusIface.register_method(
+ "AddReport",
+ [this](boost::asio::yield_context& yield, std::string reportId,
+ std::string reportName, std::string reportingType,
+ std::string reportUpdates, uint64_t appendLimit,
+ std::vector<std::string> reportActions,
+ uint64_t interval, ReadingParameters readingParameters,
+ bool enabled) {
+ if (reportingType.empty())
+ {
+ reportingType =
+ utils::enumToString(ReportingType::onRequest);
+ }
+
+ if (reportUpdates.empty())
+ {
+ reportUpdates =
+ utils::enumToString(ReportUpdates::overwrite);
+ }
+
+ if (appendLimit == std::numeric_limits<uint64_t>::max())
+ {
+ appendLimit = maxAppendLimit;
+ }
+
+ if (interval == std::numeric_limits<uint64_t>::max())
+ {
+ interval = 0;
+ }
+
+ return addReport(yield, reportId, reportName,
+ utils::toReportingType(reportingType),
+ utils::transform(
+ reportActions,
+ [](const auto& reportAction) {
+ return utils::toReportAction(
+ reportAction);
+ }),
+ Milliseconds(interval), appendLimit,
+ utils::toReportUpdates(reportUpdates),
+ readingParameters, enabled)
+ .getPath();
+ });
});
- dbusIface.register_method(
- "AddReport",
- [this](boost::asio::yield_context& yield, std::string reportId,
- std::string reportName, std::string reportingType,
- std::string reportUpdates, uint64_t appendLimit,
- std::vector<std::string> reportActions, uint64_t interval,
- ReadingParameters readingParameters, bool enabled) {
- if (reportingType.empty())
- {
- reportingType = utils::enumToString(ReportingType::onRequest);
- }
-
- if (reportUpdates.empty())
- {
- reportUpdates = utils::enumToString(ReportUpdates::overwrite);
- }
-
- if (appendLimit == std::numeric_limits<uint64_t>::max())
- {
- appendLimit = maxAppendLimit;
- }
-
- if (interval == std::numeric_limits<uint64_t>::max())
- {
- interval = 0;
- }
-
- return addReport(yield, reportId, reportName,
- utils::toReportingType(reportingType),
- utils::transform(reportActions,
- [](const auto& reportAction) {
- return utils::toReportAction(reportAction);
- }),
- Milliseconds(interval), appendLimit,
- utils::toReportUpdates(reportUpdates),
- readingParameters, enabled)
- .getPath();
- });
- });
}
void ReportManager::removeReport(const interfaces::Report* report)
@@ -135,8 +141,8 @@
const uint64_t appendLimit, const ReportUpdates reportUpdates,
ReadingParameters metricParams, const bool enabled)
{
- auto labeledMetricParams = reportFactory->convertMetricParams(yield,
- metricParams);
+ auto labeledMetricParams =
+ reportFactory->convertMetricParams(yield, metricParams);
return addReport(reportId, reportName, reportingType, reportActions,
interval, appendLimit, reportUpdates,
@@ -190,8 +196,8 @@
std::vector<ReportAction> reportActions = utils::transform(
data->at("ReportActions").get<std::vector<uint32_t>>(),
[](const auto reportAction) {
- return utils::toReportAction(reportAction);
- });
+ return utils::toReportAction(reportAction);
+ });
uint64_t interval = data->at("Interval").get<uint64_t>();
uint64_t appendLimit = data->at("AppendLimit").get<uint64_t>();
uint32_t reportUpdates = data->at("ReportUpdates").get<uint32_t>();
diff --git a/src/report_manager.hpp b/src/report_manager.hpp
index 710d3ce..c836dc3 100644
--- a/src/report_manager.hpp
+++ b/src/report_manager.hpp
@@ -54,14 +54,13 @@
const std::vector<ReportAction>& reportActions, Milliseconds interval,
const uint64_t appendLimit, const ReportUpdates reportUpdates,
ReadingParameters metricParams, const bool enabled);
- interfaces::Report&
- addReport(const std::string& reportId, const std::string& reportName,
- const ReportingType reportingType,
- const std::vector<ReportAction>& reportActions,
- Milliseconds interval, const uint64_t appendLimit,
- const ReportUpdates reportUpdates,
- std::vector<LabeledMetricParameters> metricParams,
- const bool enabled, Readings);
+ interfaces::Report& addReport(
+ const std::string& reportId, const std::string& reportName,
+ const ReportingType reportingType,
+ const std::vector<ReportAction>& reportActions, Milliseconds interval,
+ const uint64_t appendLimit, const ReportUpdates reportUpdates,
+ std::vector<LabeledMetricParameters> metricParams, const bool enabled,
+ Readings);
void loadFromPersistent();
public:
diff --git a/src/sensor.cpp b/src/sensor.cpp
index f6f232b..ae5385f 100644
--- a/src/sensor.cpp
+++ b/src/sensor.cpp
@@ -49,19 +49,19 @@
"xyz.openbmc_project.Sensor.Value", "Value",
[lock, id = sensorId, weakSelf = weak_from_this()](
boost::system::error_code ec, double newValue) {
- if (ec)
- {
- phosphor::logging::log<phosphor::logging::level::WARNING>(
- "DBus 'GetProperty' call failed on Sensor Value",
- phosphor::logging::entry("SENSOR_PATH=%s", id.path.c_str()),
- phosphor::logging::entry("ERROR_CODE=%d", ec.value()));
- return;
- }
- if (auto self = weakSelf.lock())
- {
- self->updateValue(newValue);
- }
- });
+ if (ec)
+ {
+ phosphor::logging::log<phosphor::logging::level::WARNING>(
+ "DBus 'GetProperty' call failed on Sensor Value",
+ phosphor::logging::entry("SENSOR_PATH=%s", id.path.c_str()),
+ phosphor::logging::entry("ERROR_CODE=%d", ec.value()));
+ return;
+ }
+ if (auto self = weakSelf.lock())
+ {
+ self->updateValue(newValue);
+ }
+ });
}
void Sensor::registerForUpdates(
@@ -92,13 +92,14 @@
{
if (auto listener = weakListener.lock())
{
- listeners.erase(std::remove_if(listeners.begin(), listeners.end(),
- [listenerToUnregister = listener.get()](
- const auto& listener) {
- return (listener.expired() ||
- listener.lock().get() == listenerToUnregister);
- }),
- listeners.end());
+ listeners.erase(
+ std::remove_if(
+ listeners.begin(), listeners.end(),
+ [listenerToUnregister = listener.get()](const auto& listener) {
+ return (listener.expired() ||
+ listener.lock().get() == listenerToUnregister);
+ }),
+ listeners.end());
}
}
@@ -129,15 +130,15 @@
using namespace std::string_literals;
- const auto param = "type='signal',member='PropertiesChanged',path='"s +
- sensorId.path +
- "',arg0='xyz.openbmc_project.Sensor.Value'"s;
+ const auto param =
+ "type='signal',member='PropertiesChanged',path='"s + sensorId.path +
+ "',arg0='xyz.openbmc_project.Sensor.Value'"s;
signalMonitor = std::make_unique<sdbusplus::bus::match_t>(
*bus, param,
[weakSelf = weak_from_this()](sdbusplus::message_t& message) {
- signalProc(weakSelf, message);
- });
+ signalProc(weakSelf, message);
+ });
}
void Sensor::signalProc(const std::weak_ptr<Sensor>& weakSelf,
diff --git a/src/sensor_cache.cpp b/src/sensor_cache.cpp
index 3b9c83d..5ba12a4 100644
--- a/src/sensor_cache.cpp
+++ b/src/sensor_cache.cpp
@@ -3,8 +3,9 @@
SensorCache::SensorsContainer::iterator SensorCache::findExpiredSensor(
SensorCache::SensorsContainer::iterator begin)
{
- return std::find_if(begin, sensors.end(),
- [](const auto& item) { return item.second.expired(); });
+ return std::find_if(begin, sensors.end(), [](const auto& item) {
+ return item.second.expired();
+ });
}
void SensorCache::cleanupExpiredSensors()
diff --git a/src/sensor_cache.hpp b/src/sensor_cache.hpp
index bebc4c6..34dbae9 100644
--- a/src/sensor_cache.hpp
+++ b/src/sensor_cache.hpp
@@ -12,9 +12,8 @@
{
public:
template <class SensorType, class... Args>
- std::shared_ptr<SensorType> makeSensor(std::string_view service,
- std::string_view path,
- Args&&... args)
+ std::shared_ptr<SensorType> makeSensor(
+ std::string_view service, std::string_view path, Args&&... args)
{
cleanupExpiredSensors();
diff --git a/src/trigger.cpp b/src/trigger.cpp
index 0b94711..f534dbd 100644
--- a/src/trigger.cpp
+++ b/src/trigger.cpp
@@ -32,174 +32,186 @@
{
deleteIface = objServer->add_unique_interface(
path, deleteIfaceName, [this, &ioc, &triggerManager](auto& dbusIface) {
- dbusIface.register_method("Delete", [this, &ioc, &triggerManager] {
- if (persistent)
- {
- triggerStorage.remove(fileName);
- }
- messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Removed, *id, {}});
- boost::asio::post(ioc, [this, &triggerManager] {
- triggerManager.removeTrigger(this);
+ dbusIface.register_method("Delete", [this, &ioc, &triggerManager] {
+ if (persistent)
+ {
+ triggerStorage.remove(fileName);
+ }
+ messanger.send(messages::TriggerPresenceChangedInd{
+ messages::Presence::Removed, *id, {}});
+ boost::asio::post(ioc, [this, &triggerManager] {
+ triggerManager.removeTrigger(this);
+ });
});
});
- });
triggerIface = objServer->add_unique_interface(
path, triggerIfaceName, [this, &triggerFactory](auto& dbusIface) {
- persistent = storeConfiguration();
- dbusIface.register_property_rw(
- "Persistent", persistent,
- sdbusplus::vtable::property_::emits_change,
- [this](bool newVal, const auto&) {
- if (newVal == persistent)
- {
- return 1;
- }
- if (newVal)
- {
- persistent = storeConfiguration();
- }
- else
- {
- triggerStorage.remove(fileName);
- persistent = false;
- }
- return 1;
- }, [this](const auto&) { return persistent; });
+ persistent = storeConfiguration();
+ dbusIface.register_property_rw(
+ "Persistent", persistent,
+ sdbusplus::vtable::property_::emits_change,
+ [this](bool newVal, const auto&) {
+ if (newVal == persistent)
+ {
+ return 1;
+ }
+ if (newVal)
+ {
+ persistent = storeConfiguration();
+ }
+ else
+ {
+ triggerStorage.remove(fileName);
+ persistent = false;
+ }
+ return 1;
+ },
+ [this](const auto&) { return persistent; });
- dbusIface.register_property_rw(
- "Thresholds", TriggerThresholdParams{},
- sdbusplus::vtable::property_::emits_change,
- [this, &triggerFactory](auto newVal, auto& oldVal) {
- auto newThresholdParams =
- std::visit(utils::ToLabeledThresholdParamConversion(), newVal);
- TriggerManager::verifyThresholdParams(newThresholdParams);
- triggerFactory.updateThresholds(thresholds, *id, triggerActions,
- reportIds, sensors,
- newThresholdParams);
- oldVal = std::move(newVal);
- return 1;
- }, [this](const auto&) {
- return fromLabeledThresholdParam(getLabeledThresholds());
+ dbusIface.register_property_rw(
+ "Thresholds", TriggerThresholdParams{},
+ sdbusplus::vtable::property_::emits_change,
+ [this, &triggerFactory](auto newVal, auto& oldVal) {
+ auto newThresholdParams = std::visit(
+ utils::ToLabeledThresholdParamConversion(), newVal);
+ TriggerManager::verifyThresholdParams(newThresholdParams);
+ triggerFactory.updateThresholds(
+ thresholds, *id, triggerActions, reportIds, sensors,
+ newThresholdParams);
+ oldVal = std::move(newVal);
+ return 1;
+ },
+ [this](const auto&) {
+ return fromLabeledThresholdParam(getLabeledThresholds());
+ });
+
+ dbusIface.register_property_rw(
+ "DiscreteThresholds", std::vector<discrete::ThresholdParam>{},
+ sdbusplus::vtable::property_::emits_change,
+ [this, &triggerFactory](
+ const std::vector<discrete::ThresholdParam>& newVal,
+ std::vector<discrete::ThresholdParam>& oldVal) {
+ LabeledTriggerThresholdParams newThresholdParams =
+ utils::ToLabeledThresholdParamConversion()(newVal);
+ TriggerManager::verifyThresholdParams(newThresholdParams);
+ triggerFactory.updateThresholds(
+ thresholds, *id, triggerActions, reportIds, sensors,
+ newThresholdParams);
+ oldVal = std::move(newVal);
+ return 1;
+ },
+ [this](const auto&) {
+ TriggerThresholdParams unlabeled =
+ fromLabeledThresholdParam(getLabeledThresholds());
+ auto* ptr =
+ std::get_if<std::vector<discrete::ThresholdParam>>(
+ &unlabeled);
+ if (ptr == nullptr)
+ {
+ // If internal type doesn't match, return empty set
+ return std::vector<discrete::ThresholdParam>{};
+ }
+ return *ptr;
+ });
+
+ dbusIface.register_property_rw(
+ "NumericThresholds", std::vector<numeric::ThresholdParam>{},
+ sdbusplus::vtable::property_::emits_change,
+ [this, &triggerFactory](
+ const std::vector<numeric::ThresholdParam>& newVal,
+ std::vector<numeric::ThresholdParam>& oldVal) {
+ LabeledTriggerThresholdParams newThresholdParams =
+ utils::ToLabeledThresholdParamConversion()(newVal);
+ TriggerManager::verifyThresholdParams(newThresholdParams);
+ triggerFactory.updateThresholds(
+ thresholds, *id, triggerActions, reportIds, sensors,
+ newThresholdParams);
+ oldVal = std::move(newVal);
+ return 1;
+ },
+ [this](const auto&) {
+ TriggerThresholdParams unlabeled =
+ fromLabeledThresholdParam(getLabeledThresholds());
+ auto* ptr =
+ std::get_if<std::vector<numeric::ThresholdParam>>(
+ &unlabeled);
+ if (ptr == nullptr)
+ {
+ // If internal type doesn't match, return empty set
+ return std::vector<numeric::ThresholdParam>{};
+ }
+ return *ptr;
+ });
+ dbusIface.register_property_rw(
+ "Sensors", SensorsInfo{},
+ sdbusplus::vtable::property_::emits_change,
+ [this, &triggerFactory](auto newVal, auto& oldVal) {
+ auto labeledSensorInfo =
+ triggerFactory.getLabeledSensorsInfo(newVal);
+ triggerFactory.updateSensors(sensors, labeledSensorInfo);
+ for (const auto& threshold : thresholds)
+ {
+ threshold->updateSensors(sensors);
+ }
+ oldVal = std::move(newVal);
+ return 1;
+ },
+ [this](const auto&) {
+ return utils::fromLabeledSensorsInfo(
+ getLabeledSensorInfo());
+ });
+
+ dbusIface.register_property_rw(
+ "Reports", std::vector<sdbusplus::message::object_path>(),
+ sdbusplus::vtable::property_::emits_change,
+ [this](auto newVal, auto& oldVal) {
+ auto newReportIds = utils::transform<std::vector>(
+ newVal, [](const auto& path) {
+ return utils::reportPathToId(path);
+ });
+ TriggerManager::verifyReportIds(newReportIds);
+ *reportIds = newReportIds;
+ messanger.send(messages::TriggerPresenceChangedInd{
+ messages::Presence::Exist, *id, *reportIds});
+ oldVal = std::move(newVal);
+ return 1;
+ },
+ [this](const auto&) {
+ return utils::transform<std::vector>(
+ *reportIds, [](const auto& id) {
+ return utils::pathAppend(
+ utils::constants::reportDirPath, id);
+ });
+ });
+
+ dbusIface.register_property_r(
+ "Discrete", isDiscreate(), sdbusplus::vtable::property_::const_,
+ [this](const auto& x) { return isDiscreate(); });
+
+ dbusIface.register_property_rw(
+ "Name", name, sdbusplus::vtable::property_::emits_change,
+ [this](auto newVal, auto& oldVal) {
+ if (newVal.length() > utils::constants::maxIdNameLength)
+ {
+ throw errors::InvalidArgument("Name",
+ "Name is too long.");
+ }
+ name = oldVal = newVal;
+ return 1;
+ },
+ [this](const auto&) { return name; });
+
+ dbusIface.register_property_r(
+ "TriggerActions", std::vector<std::string>(),
+ sdbusplus::vtable::property_::const_, [this](const auto&) {
+ return utils::transform(triggerActions,
+ [](const auto& action) {
+ return actionToString(action);
+ });
+ });
});
- dbusIface.register_property_rw(
- "DiscreteThresholds", std::vector<discrete::ThresholdParam>{},
- sdbusplus::vtable::property_::emits_change,
- [this, &triggerFactory](
- const std::vector<discrete::ThresholdParam>& newVal,
- std::vector<discrete::ThresholdParam>& oldVal) {
- LabeledTriggerThresholdParams newThresholdParams =
- utils::ToLabeledThresholdParamConversion()(newVal);
- TriggerManager::verifyThresholdParams(newThresholdParams);
- triggerFactory.updateThresholds(thresholds, *id, triggerActions,
- reportIds, sensors,
- newThresholdParams);
- oldVal = std::move(newVal);
- return 1;
- },
- [this](const auto&) {
- TriggerThresholdParams unlabeled =
- fromLabeledThresholdParam(getLabeledThresholds());
- auto* ptr =
- std::get_if<std::vector<discrete::ThresholdParam>>(&unlabeled);
- if (ptr == nullptr)
- {
- // If internal type doesn't match, return empty set
- return std::vector<discrete::ThresholdParam>{};
- }
- return *ptr;
- });
-
- dbusIface.register_property_rw(
- "NumericThresholds", std::vector<numeric::ThresholdParam>{},
- sdbusplus::vtable::property_::emits_change,
- [this, &triggerFactory](
- const std::vector<numeric::ThresholdParam>& newVal,
- std::vector<numeric::ThresholdParam>& oldVal) {
- LabeledTriggerThresholdParams newThresholdParams =
- utils::ToLabeledThresholdParamConversion()(newVal);
- TriggerManager::verifyThresholdParams(newThresholdParams);
- triggerFactory.updateThresholds(thresholds, *id, triggerActions,
- reportIds, sensors,
- newThresholdParams);
- oldVal = std::move(newVal);
- return 1;
- },
- [this](const auto&) {
- TriggerThresholdParams unlabeled =
- fromLabeledThresholdParam(getLabeledThresholds());
- auto* ptr =
- std::get_if<std::vector<numeric::ThresholdParam>>(&unlabeled);
- if (ptr == nullptr)
- {
- // If internal type doesn't match, return empty set
- return std::vector<numeric::ThresholdParam>{};
- }
- return *ptr;
- });
- dbusIface.register_property_rw(
- "Sensors", SensorsInfo{},
- sdbusplus::vtable::property_::emits_change,
- [this, &triggerFactory](auto newVal, auto& oldVal) {
- auto labeledSensorInfo =
- triggerFactory.getLabeledSensorsInfo(newVal);
- triggerFactory.updateSensors(sensors, labeledSensorInfo);
- for (const auto& threshold : thresholds)
- {
- threshold->updateSensors(sensors);
- }
- oldVal = std::move(newVal);
- return 1;
- }, [this](const auto&) {
- return utils::fromLabeledSensorsInfo(getLabeledSensorInfo());
- });
-
- dbusIface.register_property_rw(
- "Reports", std::vector<sdbusplus::message::object_path>(),
- sdbusplus::vtable::property_::emits_change,
- [this](auto newVal, auto& oldVal) {
- auto newReportIds = utils::transform<std::vector>(
- newVal,
- [](const auto& path) { return utils::reportPathToId(path); });
- TriggerManager::verifyReportIds(newReportIds);
- *reportIds = newReportIds;
- messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, *id, *reportIds});
- oldVal = std::move(newVal);
- return 1;
- }, [this](const auto&) {
- return utils::transform<std::vector>(*reportIds,
- [](const auto& id) {
- return utils::pathAppend(utils::constants::reportDirPath, id);
- });
- });
-
- dbusIface.register_property_r(
- "Discrete", isDiscreate(), sdbusplus::vtable::property_::const_,
- [this](const auto& x) { return isDiscreate(); });
-
- dbusIface.register_property_rw(
- "Name", name, sdbusplus::vtable::property_::emits_change,
- [this](auto newVal, auto& oldVal) {
- if (newVal.length() > utils::constants::maxIdNameLength)
- {
- throw errors::InvalidArgument("Name", "Name is too long.");
- }
- name = oldVal = newVal;
- return 1;
- }, [this](const auto&) { return name; });
-
- dbusIface.register_property_r(
- "TriggerActions", std::vector<std::string>(),
- sdbusplus::vtable::property_::const_, [this](const auto&) {
- return utils::transform(triggerActions, [](const auto& action) {
- return actionToString(action);
- });
- });
- });
-
for (const auto& threshold : thresholds)
{
threshold->initialize();
@@ -207,11 +219,11 @@
messanger.on_receive<messages::CollectTriggerIdReq>(
[this](const auto& msg) {
- if (utils::contains(*reportIds, msg.reportId))
- {
- messanger.send(messages::CollectTriggerIdResp{*id});
- }
- });
+ if (utils::contains(*reportIds, msg.reportId))
+ {
+ messanger.send(messages::CollectTriggerIdResp{*id});
+ }
+ });
messanger.send(messages::TriggerPresenceChangedInd{
messages::Presence::Exist, *id, *reportIds});
@@ -231,9 +243,10 @@
data["Id"] = *id;
data["Name"] = name;
data["ThresholdParamsDiscriminator"] = labeledThresholdParams.index();
- data["TriggerActions"] = utils::transform(
- triggerActions,
- [](const auto& action) { return actionToString(action); });
+ data["TriggerActions"] =
+ utils::transform(triggerActions, [](const auto& action) {
+ return actionToString(action);
+ });
data["ThresholdParams"] =
utils::labeledThresholdParamsToJson(labeledThresholdParams);
data["ReportIds"] = *reportIds;
diff --git a/src/trigger_actions.cpp b/src/trigger_actions.cpp
index 9466b77..5b57abb 100644
--- a/src/trigger_actions.cpp
+++ b/src/trigger_actions.cpp
@@ -44,11 +44,10 @@
throw std::runtime_error("Invalid value");
}
-void LogToJournal::commit(const std::string& triggerId,
- const ThresholdName thresholdNameInIn,
- const std::string& sensorName,
- const Milliseconds timestamp,
- const TriggerValue triggerValue)
+void LogToJournal::commit(
+ const std::string& triggerId, const ThresholdName thresholdNameInIn,
+ const std::string& sensorName, const Milliseconds timestamp,
+ const TriggerValue triggerValue)
{
double value = std::get<double>(triggerValue);
std::string thresholdName = ::numeric::typeToString(type);
@@ -101,11 +100,10 @@
throw std::runtime_error("Invalid type");
}
-void LogToRedfishEventLog::commit(const std::string& triggerId,
- const ThresholdName thresholdNameInIn,
- const std::string& sensorName,
- const Milliseconds timestamp,
- const TriggerValue triggerValue)
+void LogToRedfishEventLog::commit(
+ const std::string& triggerId, const ThresholdName thresholdNameInIn,
+ const std::string& sensorName, const Milliseconds timestamp,
+ const TriggerValue triggerValue)
{
double value = std::get<double>(triggerValue);
auto messageId = getRedfishMessageId(value);
@@ -168,11 +166,10 @@
namespace discrete
{
-void LogToJournal::commit(const std::string& triggerId,
- const ThresholdName thresholdNameIn,
- const std::string& sensorName,
- const Milliseconds timestamp,
- const TriggerValue triggerValue)
+void LogToJournal::commit(
+ const std::string& triggerId, const ThresholdName thresholdNameIn,
+ const std::string& sensorName, const Milliseconds timestamp,
+ const TriggerValue triggerValue)
{
auto value = std::get<std::string>(triggerValue);
@@ -186,11 +183,10 @@
phosphor::logging::log<phosphor::logging::level::INFO>(msg.c_str());
}
-void LogToRedfishEventLog::commit(const std::string& triggerId,
- const ThresholdName thresholdNameIn,
- const std::string& sensorName,
- const Milliseconds timestamp,
- const TriggerValue triggerValue)
+void LogToRedfishEventLog::commit(
+ const std::string& triggerId, const ThresholdName thresholdNameIn,
+ const std::string& sensorName, const Milliseconds timestamp,
+ const TriggerValue triggerValue)
{
auto value = std::get<std::string>(triggerValue);
@@ -239,26 +235,24 @@
namespace onChange
{
-void LogToJournal::commit(const std::string& triggerId,
- const ThresholdName thresholdNameIn,
- const std::string& sensorName,
- const Milliseconds timestamp,
- const TriggerValue triggerValue)
+void LogToJournal::commit(
+ const std::string& triggerId, const ThresholdName thresholdNameIn,
+ const std::string& sensorName, const Milliseconds timestamp,
+ const TriggerValue triggerValue)
{
auto value = triggerValueToString(triggerValue);
- std::string msg = "Discrete condition 'OnChange' of trigger '" + triggerId +
- "' is met on sensor: " + sensorName +
- ", recorded value: " + value +
- ", timestamp: " + timestampToString(timestamp);
+ std::string msg =
+ "Discrete condition 'OnChange' of trigger '" + triggerId +
+ "' is met on sensor: " + sensorName + ", recorded value: " + value +
+ ", timestamp: " + timestampToString(timestamp);
phosphor::logging::log<phosphor::logging::level::INFO>(msg.c_str());
}
-void LogToRedfishEventLog::commit(const std::string& triggerId,
- const ThresholdName thresholdNameIn,
- const std::string& sensorName,
- const Milliseconds timestamp,
- const TriggerValue triggerValue)
+void LogToRedfishEventLog::commit(
+ const std::string& triggerId, const ThresholdName thresholdNameIn,
+ const std::string& sensorName, const Milliseconds timestamp,
+ const TriggerValue triggerValue)
{
auto value = triggerValueToString(triggerValue);
@@ -305,11 +299,10 @@
} // namespace onChange
} // namespace discrete
-void UpdateReport::commit(const std::string& triggerId,
- const ThresholdName thresholdNameIn,
- const std::string& sensorName,
- const Milliseconds timestamp,
- const TriggerValue triggerValue)
+void UpdateReport::commit(
+ const std::string& triggerId, const ThresholdName thresholdNameIn,
+ const std::string& sensorName, const Milliseconds timestamp,
+ const TriggerValue triggerValue)
{
if (reportIds->empty())
{
diff --git a/src/trigger_factory.cpp b/src/trigger_factory.cpp
index 22b7ea5..d6bfa3f 100644
--- a/src/trigger_factory.cpp
+++ b/src/trigger_factory.cpp
@@ -223,10 +223,10 @@
const std::vector<LabeledSensorInfo>& labeledSensorsInfo) const
{
const auto& sensors = getSensors(labeledSensorsInfo);
- auto triggerActions = utils::transform(triggerActionsIn,
- [](const auto& triggerActionStr) {
- return toTriggerAction(triggerActionStr);
- });
+ auto triggerActions =
+ utils::transform(triggerActionsIn, [](const auto& triggerActionStr) {
+ return toTriggerAction(triggerActionStr);
+ });
std::vector<std::shared_ptr<interfaces::Threshold>> thresholds;
auto id = std::make_unique<const std::string>(idIn);
@@ -260,8 +260,9 @@
{
auto existing = std::find_if(oldSensors.begin(), oldSensors.end(),
[labeledSensorInfo](auto sensor) {
- return labeledSensorInfo == sensor->getLabeledSensorInfo();
- });
+ return labeledSensorInfo ==
+ sensor->getLabeledSensorInfo();
+ });
if (existing != oldSensors.end())
{
@@ -281,9 +282,8 @@
currentSensors = std::move(newSensors);
}
-std::vector<LabeledSensorInfo>
- TriggerFactory::getLabeledSensorsInfo(boost::asio::yield_context& yield,
- const SensorsInfo& sensorsInfo) const
+std::vector<LabeledSensorInfo> TriggerFactory::getLabeledSensorsInfo(
+ boost::asio::yield_context& yield, const SensorsInfo& sensorsInfo) const
{
if (sensorsInfo.empty())
{
@@ -293,8 +293,8 @@
return parseSensorTree(tree, sensorsInfo);
}
-std::vector<LabeledSensorInfo>
- TriggerFactory::getLabeledSensorsInfo(const SensorsInfo& sensorsInfo) const
+std::vector<LabeledSensorInfo> TriggerFactory::getLabeledSensorsInfo(
+ const SensorsInfo& sensorsInfo) const
{
if (sensorsInfo.empty())
{
@@ -304,9 +304,8 @@
return parseSensorTree(tree, sensorsInfo);
}
-std::vector<LabeledSensorInfo>
- TriggerFactory::parseSensorTree(const std::vector<utils::SensorTree>& tree,
- const SensorsInfo& sensorsInfo)
+std::vector<LabeledSensorInfo> TriggerFactory::parseSensorTree(
+ const std::vector<utils::SensorTree>& tree, const SensorsInfo& sensorsInfo)
{
return utils::transform(sensorsInfo, [&tree](const auto& item) {
const auto& [sensorPath, metadata] = item;
diff --git a/src/trigger_factory.hpp b/src/trigger_factory.hpp
index a2ad568..586c9f7 100644
--- a/src/trigger_factory.hpp
+++ b/src/trigger_factory.hpp
@@ -16,21 +16,21 @@
std::shared_ptr<sdbusplus::asio::object_server> objServer,
SensorCache& sensorCache);
- std::unique_ptr<interfaces::Trigger>
- make(const std::string& id, const std::string& name,
- const std::vector<std::string>& triggerActions,
- const std::vector<std::string>& reportIds,
- interfaces::TriggerManager& triggerManager,
- interfaces::JsonStorage& triggerStorage,
- const LabeledTriggerThresholdParams& labeledThresholdParams,
- const std::vector<LabeledSensorInfo>& labeledSensorsinfo)
- const override;
+ std::unique_ptr<interfaces::Trigger> make(
+ const std::string& id, const std::string& name,
+ const std::vector<std::string>& triggerActions,
+ const std::vector<std::string>& reportIds,
+ interfaces::TriggerManager& triggerManager,
+ interfaces::JsonStorage& triggerStorage,
+ const LabeledTriggerThresholdParams& labeledThresholdParams,
+ const std::vector<LabeledSensorInfo>& labeledSensorsinfo)
+ const override;
- std::vector<LabeledSensorInfo>
- getLabeledSensorsInfo(boost::asio::yield_context& yield,
- const SensorsInfo& sensorsInfo) const override;
- std::vector<LabeledSensorInfo>
- getLabeledSensorsInfo(const SensorsInfo& sensorsInfo) const override;
+ std::vector<LabeledSensorInfo> getLabeledSensorsInfo(
+ boost::asio::yield_context& yield,
+ const SensorsInfo& sensorsInfo) const override;
+ std::vector<LabeledSensorInfo> getLabeledSensorsInfo(
+ const SensorsInfo& sensorsInfo) const override;
void updateThresholds(
std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
@@ -52,9 +52,9 @@
Sensors getSensors(
const std::vector<LabeledSensorInfo>& labeledSensorsInfo) const;
- static std::vector<LabeledSensorInfo>
- parseSensorTree(const std::vector<utils::SensorTree>& tree,
- const SensorsInfo& sensorsInfo);
+ static std::vector<LabeledSensorInfo> parseSensorTree(
+ const std::vector<utils::SensorTree>& tree,
+ const SensorsInfo& sensorsInfo);
void updateDiscreteThresholds(
std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
diff --git a/src/trigger_manager.cpp b/src/trigger_manager.cpp
index 5cc824e..f65b120 100644
--- a/src/trigger_manager.cpp
+++ b/src/trigger_manager.cpp
@@ -23,42 +23,45 @@
managerIface = objServer->add_unique_interface(
triggerManagerPath, triggerManagerIfaceName, [this](auto& iface) {
- iface.register_method(
- "AddTrigger",
- [this](
- boost::asio::yield_context& yield, const std::string& id,
- const std::string& name,
- const std::vector<std::string>& triggerActions,
- const SensorsInfo& sensors,
- const std::vector<sdbusplus::message::object_path>& reports,
- const std::vector<numeric::ThresholdParam>& numericThresholds,
- const std::vector<discrete::ThresholdParam>&
- discreteThresholds) {
- LabeledTriggerThresholdParams labeledTriggerThresholdParams;
- if (!numericThresholds.empty())
- {
- labeledTriggerThresholdParams =
- utils::ToLabeledThresholdParamConversion()(
- numericThresholds);
- }
- if (!discreteThresholds.empty())
- {
- labeledTriggerThresholdParams =
- utils::ToLabeledThresholdParamConversion()(
- discreteThresholds);
- }
- std::vector<LabeledSensorInfo> labeledSensorsInfo =
- triggerFactory->getLabeledSensorsInfo(yield, sensors);
+ iface.register_method(
+ "AddTrigger",
+ [this](
+ boost::asio::yield_context& yield, const std::string& id,
+ const std::string& name,
+ const std::vector<std::string>& triggerActions,
+ const SensorsInfo& sensors,
+ const std::vector<sdbusplus::message::object_path>& reports,
+ const std::vector<numeric::ThresholdParam>&
+ numericThresholds,
+ const std::vector<discrete::ThresholdParam>&
+ discreteThresholds) {
+ LabeledTriggerThresholdParams labeledTriggerThresholdParams;
+ if (!numericThresholds.empty())
+ {
+ labeledTriggerThresholdParams =
+ utils::ToLabeledThresholdParamConversion()(
+ numericThresholds);
+ }
+ if (!discreteThresholds.empty())
+ {
+ labeledTriggerThresholdParams =
+ utils::ToLabeledThresholdParamConversion()(
+ discreteThresholds);
+ }
+ std::vector<LabeledSensorInfo> labeledSensorsInfo =
+ triggerFactory->getLabeledSensorsInfo(yield, sensors);
- auto reportIds = utils::transform<std::vector>(
- reports,
- [](const auto& item) { return utils::reportPathToId(item); });
+ auto reportIds = utils::transform<std::vector>(
+ reports, [](const auto& item) {
+ return utils::reportPathToId(item);
+ });
- return addTrigger(id, name, triggerActions, labeledSensorsInfo,
- reportIds, labeledTriggerThresholdParams)
- .getPath();
+ return addTrigger(id, name, triggerActions,
+ labeledSensorsInfo, reportIds,
+ labeledTriggerThresholdParams)
+ .getPath();
+ });
});
- });
}
void TriggerManager::removeTrigger(const interfaces::Trigger* trigger)
diff --git a/src/trigger_manager.hpp b/src/trigger_manager.hpp
index 65ee2af..79376c4 100644
--- a/src/trigger_manager.hpp
+++ b/src/trigger_manager.hpp
@@ -40,12 +40,12 @@
const std::vector<std::string>& reportIds,
const LabeledTriggerThresholdParams& thresholdParams) const;
- interfaces::Trigger&
- addTrigger(const std::string& triggerId, const std::string& triggerName,
- const std::vector<std::string>& triggerActions,
- const std::vector<LabeledSensorInfo>& labeledSensors,
- const std::vector<std::string>& reportIds,
- const LabeledTriggerThresholdParams& labeledThresholdParams);
+ interfaces::Trigger& addTrigger(
+ const std::string& triggerId, const std::string& triggerName,
+ const std::vector<std::string>& triggerActions,
+ const std::vector<LabeledSensorInfo>& labeledSensors,
+ const std::vector<std::string>& reportIds,
+ const LabeledTriggerThresholdParams& labeledThresholdParams);
void loadFromPersistent();
public:
diff --git a/src/types/collection_time_scope.hpp b/src/types/collection_time_scope.hpp
index 79db567..eb836f7 100644
--- a/src/types/collection_time_scope.hpp
+++ b/src/types/collection_time_scope.hpp
@@ -37,8 +37,8 @@
"StartupInterval",
CollectionTimeScope::startup)}};
-inline CollectionTimeScope
- toCollectionTimeScope(std::underlying_type_t<CollectionTimeScope> value)
+inline CollectionTimeScope toCollectionTimeScope(
+ std::underlying_type_t<CollectionTimeScope> value)
{
return toEnum<CollectionTimeScope,
minEnumValue(convDataCollectionTimeScope),
diff --git a/src/types/error_type.hpp b/src/types/error_type.hpp
index ae2dd4b..00e9bb1 100644
--- a/src/types/error_type.hpp
+++ b/src/types/error_type.hpp
@@ -23,9 +23,9 @@
static constexpr auto propertyName = ConstexprString{"ErrorType"};
};
-constexpr auto convDataErrorType = std::array{
- std::make_pair<std::string_view, ErrorType>("PropertyConflict",
- ErrorType::propertyConflict)};
+constexpr auto convDataErrorType =
+ std::array{std::make_pair<std::string_view, ErrorType>(
+ "PropertyConflict", ErrorType::propertyConflict)};
inline ErrorType toErrorType(std::underlying_type_t<ErrorType> value)
{
diff --git a/src/types/operation_type.hpp b/src/types/operation_type.hpp
index e7f6ed2..4c62d58 100644
--- a/src/types/operation_type.hpp
+++ b/src/types/operation_type.hpp
@@ -38,8 +38,8 @@
"xyz.openbmc_project.Telemetry.Report.OperationType.Summation",
OperationType::sum)}};
-inline OperationType
- toOperationType(std::underlying_type_t<OperationType> value)
+inline OperationType toOperationType(
+ std::underlying_type_t<OperationType> value)
{
return toEnum<OperationType, minEnumValue(convDataOperationType),
maxEnumValue(convDataOperationType)>(value);
diff --git a/src/types/readings.cpp b/src/types/readings.cpp
index 47d86fc..2f6246b 100644
--- a/src/types/readings.cpp
+++ b/src/types/readings.cpp
@@ -12,8 +12,8 @@
return LabeledReadings{
std::get<0>(readings),
utils::transform(std::get<1>(readings), [](const auto& readingData) {
- return LabeledReadingData{readingData};
- })};
+ return LabeledReadingData{readingData};
+ })};
}
Readings toReadings(const LabeledReadings& labeledReadings)
@@ -21,8 +21,8 @@
return Readings{labeledReadings.at_label<ts::Timestamp>(),
utils::transform(labeledReadings.at_label<ts::Readings>(),
[](const auto& labeledReadingData) {
- return labeledReadingData.to_tuple();
- })};
+ return labeledReadingData.to_tuple();
+ })};
}
} // namespace utils
diff --git a/src/types/report_action.hpp b/src/types/report_action.hpp
index 1ec74f9..9e9761d 100644
--- a/src/types/report_action.hpp
+++ b/src/types/report_action.hpp
@@ -23,14 +23,15 @@
};
constexpr std::array<std::pair<std::string_view, ReportAction>, 2>
- convDataReportAction = {{std::make_pair<std::string_view, ReportAction>(
- "xyz.openbmc_project.Telemetry.Report."
- "ReportActions.EmitsReadingsUpdate",
- ReportAction::emitsReadingsUpdate),
- std::make_pair<std::string_view, ReportAction>(
- "xyz.openbmc_project.Telemetry.Report."
- "ReportActions.LogToMetricReportsCollection",
- ReportAction::logToMetricReportsCollection)}};
+ convDataReportAction = {
+ {std::make_pair<std::string_view, ReportAction>(
+ "xyz.openbmc_project.Telemetry.Report."
+ "ReportActions.EmitsReadingsUpdate",
+ ReportAction::emitsReadingsUpdate),
+ std::make_pair<std::string_view, ReportAction>(
+ "xyz.openbmc_project.Telemetry.Report."
+ "ReportActions.LogToMetricReportsCollection",
+ ReportAction::logToMetricReportsCollection)}};
inline ReportAction toReportAction(std::underlying_type_t<ReportAction> value)
{
diff --git a/src/types/report_types.cpp b/src/types/report_types.cpp
index bba0e6b..009f2cb 100644
--- a/src/types/report_types.cpp
+++ b/src/types/report_types.cpp
@@ -2,23 +2,25 @@
#include "utils/transform.hpp"
-ReadingParameters
- toReadingParameters(const std::vector<LabeledMetricParameters>& labeled)
+ReadingParameters toReadingParameters(
+ const std::vector<LabeledMetricParameters>& labeled)
{
namespace ts = utils::tstring;
- return utils::transform(labeled,
- [](const LabeledMetricParameters& metricParams) {
- return ReadingParameters::value_type(
- utils::transform(metricParams.at_label<ts::SensorPath>(),
- [](const LabeledSensorInfo& sensorParameters) {
- return std::tuple<sdbusplus::message::object_path, std::string>(
- sensorParameters.at_label<ts::Path>(),
- sensorParameters.at_label<ts::Metadata>());
- }),
- utils::enumToString(metricParams.at_label<ts::OperationType>()),
- utils::enumToString(
- metricParams.at_label<ts::CollectionTimeScope>()),
- metricParams.at_label<ts::CollectionDuration>().t.count());
- });
+ return utils::transform(
+ labeled, [](const LabeledMetricParameters& metricParams) {
+ return ReadingParameters::value_type(
+ utils::transform(
+ metricParams.at_label<ts::SensorPath>(),
+ [](const LabeledSensorInfo& sensorParameters) {
+ return std::tuple<sdbusplus::message::object_path,
+ std::string>(
+ sensorParameters.at_label<ts::Path>(),
+ sensorParameters.at_label<ts::Metadata>());
+ }),
+ utils::enumToString(metricParams.at_label<ts::OperationType>()),
+ utils::enumToString(
+ metricParams.at_label<ts::CollectionTimeScope>()),
+ metricParams.at_label<ts::CollectionDuration>().t.count());
+ });
}
diff --git a/src/types/report_types.hpp b/src/types/report_types.hpp
index c40c76d..d47efee 100644
--- a/src/types/report_types.hpp
+++ b/src/types/report_types.hpp
@@ -30,5 +30,5 @@
std::variant<std::monostate, bool, uint64_t, std::string,
std::vector<std::string>, ReadingParameters>;
-ReadingParameters
- toReadingParameters(const std::vector<LabeledMetricParameters>& labeled);
+ReadingParameters toReadingParameters(
+ const std::vector<LabeledMetricParameters>& labeled);
diff --git a/src/types/report_updates.hpp b/src/types/report_updates.hpp
index 9286e24..4de183a 100644
--- a/src/types/report_updates.hpp
+++ b/src/types/report_updates.hpp
@@ -38,8 +38,8 @@
"AppendWrapsWhenFull",
ReportUpdates::appendWrapsWhenFull)};
-inline ReportUpdates
- toReportUpdates(std::underlying_type_t<ReportUpdates> value)
+inline ReportUpdates toReportUpdates(
+ std::underlying_type_t<ReportUpdates> value)
{
return toEnum<ReportUpdates, minEnumValue(convDataReportUpdates),
maxEnumValue(convDataReportUpdates)>(value);
diff --git a/src/types/reporting_type.hpp b/src/types/reporting_type.hpp
index f179eb7..2643b08 100644
--- a/src/types/reporting_type.hpp
+++ b/src/types/reporting_type.hpp
@@ -37,8 +37,8 @@
"xyz.openbmc_project.Telemetry.Report.ReportingType.Periodic",
ReportingType::periodic)}};
-inline ReportingType
- toReportingType(std::underlying_type_t<ReportingType> value)
+inline ReportingType toReportingType(
+ std::underlying_type_t<ReportingType> value)
{
return toEnum<ReportingType, minEnumValue(convDataReportingType),
maxEnumValue(convDataReportingType)>(value);
diff --git a/src/types/trigger_types.hpp b/src/types/trigger_types.hpp
index 2c53a8b..d13495f 100644
--- a/src/types/trigger_types.hpp
+++ b/src/types/trigger_types.hpp
@@ -129,11 +129,10 @@
using ThresholdParam = std::tuple<std::string, uint64_t, std::string, double>;
-using LabeledThresholdParam =
- utils::LabeledTuple<std::tuple<Type, uint64_t, Direction, double>,
- utils::tstring::Type, utils::tstring::DwellTime,
- utils::tstring::Direction,
- utils::tstring::ThresholdValue>;
+using LabeledThresholdParam = utils::LabeledTuple<
+ std::tuple<Type, uint64_t, Direction, double>, utils::tstring::Type,
+ utils::tstring::DwellTime, utils::tstring::Direction,
+ utils::tstring::ThresholdValue>;
} // namespace numeric
using TriggerThresholdParams =
@@ -148,8 +147,8 @@
std::variant<std::monostate, numeric::LabeledThresholdParam,
discrete::LabeledThresholdParam>;
-inline bool
- isTriggerThresholdDiscrete(const LabeledTriggerThresholdParams& params)
+inline bool isTriggerThresholdDiscrete(
+ const LabeledTriggerThresholdParams& params)
{
return std::holds_alternative<std::vector<discrete::LabeledThresholdParam>>(
params);
diff --git a/src/utils/conversion.hpp b/src/utils/conversion.hpp
index e92249a..ea37c4f 100644
--- a/src/utils/conversion.hpp
+++ b/src/utils/conversion.hpp
@@ -57,8 +57,8 @@
}
template <class T, size_t N>
-constexpr inline T
- minEnumValue(std::array<std::pair<std::string_view, T>, N> data)
+constexpr inline T minEnumValue(
+ std::array<std::pair<std::string_view, T>, N> data)
{
auto min = data[0].second;
for (auto [key, value] : data)
@@ -72,8 +72,8 @@
}
template <class T, size_t N>
-constexpr inline T
- maxEnumValue(std::array<std::pair<std::string_view, T>, N> data)
+constexpr inline T maxEnumValue(
+ std::array<std::pair<std::string_view, T>, N> data)
{
auto max = data[0].second;
for (auto [key, value] : data)
@@ -101,9 +101,8 @@
}
template <class T, size_t N>
-inline std::string_view
- enumToString(const std::array<std::pair<std::string_view, T>, N>& data,
- T value)
+inline std::string_view enumToString(
+ const std::array<std::pair<std::string_view, T>, N>& data, T value)
{
auto it = std::find_if(
std::begin(data), std::end(data),
diff --git a/src/utils/conversion_trigger.cpp b/src/utils/conversion_trigger.cpp
index d577f76..29545db 100644
--- a/src/utils/conversion_trigger.cpp
+++ b/src/utils/conversion_trigger.cpp
@@ -21,11 +21,11 @@
const std::vector<numeric::ThresholdParam>& arg) const
{
return utils::transform(arg, [](const auto& thresholdParam) {
- const auto& [type, dwellTime, direction,
- thresholdValue] = thresholdParam;
- return numeric::LabeledThresholdParam(numeric::toType(type), dwellTime,
- numeric::toDirection(direction),
- thresholdValue);
+ const auto& [type, dwellTime, direction, thresholdValue] =
+ thresholdParam;
+ return numeric::LabeledThresholdParam(
+ numeric::toType(type), dwellTime, numeric::toDirection(direction),
+ thresholdValue);
});
}
@@ -33,8 +33,8 @@
const std::vector<discrete::ThresholdParam>& arg) const
{
return utils::transform(arg, [](const auto& thresholdParam) {
- const auto& [userId, severity, dwellTime,
- thresholdValue] = thresholdParam;
+ const auto& [userId, severity, dwellTime, thresholdValue] =
+ thresholdParam;
return discrete::LabeledThresholdParam(
userId, utils::toSeverity(severity), dwellTime, thresholdValue);
});
@@ -45,13 +45,14 @@
{
return utils::transform(
arg, [](const numeric::LabeledThresholdParam& labeledThresholdParam) {
- return numeric::ThresholdParam(
- numeric::typeToString(labeledThresholdParam.at_label<ts::Type>()),
- labeledThresholdParam.at_label<ts::DwellTime>(),
- numeric::directionToString(
- labeledThresholdParam.at_label<ts::Direction>()),
- labeledThresholdParam.at_label<ts::ThresholdValue>());
- });
+ return numeric::ThresholdParam(
+ numeric::typeToString(
+ labeledThresholdParam.at_label<ts::Type>()),
+ labeledThresholdParam.at_label<ts::DwellTime>(),
+ numeric::directionToString(
+ labeledThresholdParam.at_label<ts::Direction>()),
+ labeledThresholdParam.at_label<ts::ThresholdValue>());
+ });
}
TriggerThresholdParams FromLabeledThresholdParamConversion::operator()(
@@ -59,12 +60,13 @@
{
return utils::transform(
arg, [](const discrete::LabeledThresholdParam& labeledThresholdParam) {
- return discrete::ThresholdParam(
- labeledThresholdParam.at_label<ts::UserId>(),
- utils::enumToString(labeledThresholdParam.at_label<ts::Severity>()),
- labeledThresholdParam.at_label<ts::DwellTime>(),
- labeledThresholdParam.at_label<ts::ThresholdValue>());
- });
+ return discrete::ThresholdParam(
+ labeledThresholdParam.at_label<ts::UserId>(),
+ utils::enumToString(
+ labeledThresholdParam.at_label<ts::Severity>()),
+ labeledThresholdParam.at_label<ts::DwellTime>(),
+ labeledThresholdParam.at_label<ts::ThresholdValue>());
+ });
}
SensorsInfo fromLabeledSensorsInfo(const std::vector<LabeledSensorInfo>& infos)
@@ -76,8 +78,8 @@
});
}
-TriggerThresholdParams
- fromLabeledThresholdParam(const std::vector<LabeledThresholdParam>& params)
+TriggerThresholdParams fromLabeledThresholdParam(
+ const std::vector<LabeledThresholdParam>& params)
{
namespace ts = utils::tstring;
if (params.empty())
diff --git a/src/utils/conversion_trigger.hpp b/src/utils/conversion_trigger.hpp
index 10b0c03..7c76a01 100644
--- a/src/utils/conversion_trigger.hpp
+++ b/src/utils/conversion_trigger.hpp
@@ -10,10 +10,10 @@
{
public:
LabeledTriggerThresholdParams operator()(const std::monostate& arg) const;
- LabeledTriggerThresholdParams
- operator()(const std::vector<numeric::ThresholdParam>& arg) const;
- LabeledTriggerThresholdParams
- operator()(const std::vector<discrete::ThresholdParam>& arg) const;
+ LabeledTriggerThresholdParams operator()(
+ const std::vector<numeric::ThresholdParam>& arg) const;
+ LabeledTriggerThresholdParams operator()(
+ const std::vector<discrete::ThresholdParam>& arg) const;
};
class FromLabeledThresholdParamConversion
@@ -27,8 +27,8 @@
SensorsInfo fromLabeledSensorsInfo(const std::vector<LabeledSensorInfo>& infos);
-TriggerThresholdParams
- fromLabeledThresholdParam(const std::vector<LabeledThresholdParam>& params);
+TriggerThresholdParams fromLabeledThresholdParam(
+ const std::vector<LabeledThresholdParam>& params);
nlohmann::json labeledThresholdParamsToJson(
const LabeledTriggerThresholdParams& labeledThresholdParams);
diff --git a/src/utils/dbus_mapper.hpp b/src/utils/dbus_mapper.hpp
index 5f07445..24adc7a 100644
--- a/src/utils/dbus_mapper.hpp
+++ b/src/utils/dbus_mapper.hpp
@@ -20,9 +20,9 @@
constexpr std::array<const char*, 1> sensorInterfaces = {
"xyz.openbmc_project.Sensor.Value"};
-inline std::vector<SensorTree>
- getSubTreeSensors(boost::asio::yield_context& yield,
- const std::shared_ptr<sdbusplus::asio::connection>& bus)
+inline std::vector<SensorTree> getSubTreeSensors(
+ boost::asio::yield_context& yield,
+ const std::shared_ptr<sdbusplus::asio::connection>& bus)
{
boost::system::error_code ec;
@@ -38,8 +38,8 @@
return tree;
}
-inline std::vector<SensorTree>
- getSubTreeSensors(const std::shared_ptr<sdbusplus::asio::connection>& bus)
+inline std::vector<SensorTree> getSubTreeSensors(
+ const std::shared_ptr<sdbusplus::asio::connection>& bus)
{
auto method_call =
bus->new_method_call("xyz.openbmc_project.ObjectMapper",
diff --git a/src/utils/dbus_path_utils.hpp b/src/utils/dbus_path_utils.hpp
index c1bda62..4e287e8 100644
--- a/src/utils/dbus_path_utils.hpp
+++ b/src/utils/dbus_path_utils.hpp
@@ -25,10 +25,10 @@
constexpr size_t maxIdNameLength{TELEMETRY_MAX_ID_NAME_LENGTH};
constexpr size_t maxDbusPathLength{TELEMETRY_MAX_DBUS_PATH_LENGTH};
-constexpr size_t maxTriggeFullIdLength{maxDbusPathLength -
- triggerDirStr.length()};
-constexpr size_t maxReportFullIdLength{maxDbusPathLength -
- reportDirStr.length()};
+constexpr size_t maxTriggeFullIdLength{
+ maxDbusPathLength - triggerDirStr.length()};
+constexpr size_t maxReportFullIdLength{
+ maxDbusPathLength - reportDirStr.length()};
static_assert(maxPrefixesInId * (maxPrefixLength + 1) + maxIdNameLength <=
maxTriggeFullIdLength,
diff --git a/src/utils/labeled_tuple.hpp b/src/utils/labeled_tuple.hpp
index 062b908..7c05a58 100644
--- a/src/utils/labeled_tuple.hpp
+++ b/src/utils/labeled_tuple.hpp
@@ -110,8 +110,8 @@
static U& ref();
template <class U>
- static std::true_type
- check(decltype(utils::to_json(ref<nlohmann::json>(), ref<const U>()))*);
+ static std::true_type check(decltype(utils::to_json(ref<nlohmann::json>(),
+ ref<const U>()))*);
template <class>
static std::false_type check(...);
@@ -205,11 +205,15 @@
bool operator==(const LabeledTuple& other) const
{
- return std::apply([&](auto&&... x) {
- return std::apply([&](auto&&... y) {
- return (true && ... && detail::eq(x, y));
- }, value);
- }, other.value);
+ return std::apply(
+ [&](auto&&... x) {
+ return std::apply(
+ [&](auto&&... y) {
+ return (true && ... && detail::eq(x, y));
+ },
+ value);
+ },
+ other.value);
}
bool operator<(const LabeledTuple& other) const
diff --git a/src/utils/make_id_name.cpp b/src/utils/make_id_name.cpp
index 0f78ab6..cc53a24 100644
--- a/src/utils/make_id_name.cpp
+++ b/src/utils/make_id_name.cpp
@@ -49,16 +49,19 @@
{
strippedId = defaultName;
}
- strippedId.erase(std::remove_if(strippedId.begin(), strippedId.end(),
- [](char c) {
- return c == '/' || utils::constants::allowedCharactersInPath.find(c) ==
- std::string_view::npos;
- }),
- strippedId.end());
+ strippedId.erase(
+ std::remove_if(
+ strippedId.begin(), strippedId.end(),
+ [](char c) {
+ return c == '/' ||
+ utils::constants::allowedCharactersInPath.find(c) ==
+ std::string_view::npos;
+ }),
+ strippedId.end());
size_t idx = 0;
- std::string tmpId = prefixes +
- strippedId.substr(0, constants::maxIdNameLength);
+ std::string tmpId =
+ prefixes + strippedId.substr(0, constants::maxIdNameLength);
while (std::find(conflictIds.begin(), conflictIds.end(), tmpId) !=
conflictIds.end())
@@ -83,10 +86,9 @@
} // namespace details
-std::pair<std::string, std::string>
- makeIdName(std::string_view id, std::string_view name,
- std::string_view defaultName,
- const std::vector<std::string>& conflictIds)
+std::pair<std::string, std::string> makeIdName(
+ std::string_view id, std::string_view name, std::string_view defaultName,
+ const std::vector<std::string>& conflictIds)
{
if (name.length() > constants::maxIdNameLength)
{
diff --git a/src/utils/make_id_name.hpp b/src/utils/make_id_name.hpp
index 2c4ce75..55c169b 100644
--- a/src/utils/make_id_name.hpp
+++ b/src/utils/make_id_name.hpp
@@ -7,9 +7,8 @@
namespace utils
{
-std::pair<std::string, std::string>
- makeIdName(std::string_view id, std::string_view name,
- std::string_view defaultName,
- const std::vector<std::string>& conflictIds);
+std::pair<std::string, std::string> makeIdName(
+ std::string_view id, std::string_view name, std::string_view defaultName,
+ const std::vector<std::string>& conflictIds);
} // namespace utils
diff --git a/src/utils/messanger_service.cpp b/src/utils/messanger_service.cpp
index 56c38f6..e04de34 100644
--- a/src/utils/messanger_service.cpp
+++ b/src/utils/messanger_service.cpp
@@ -18,8 +18,8 @@
{
contexts_.erase(std::remove_if(contexts_.begin(), contexts_.end(),
[&context](const auto& item) {
- return item.get() == &context;
- }),
+ return item.get() == &context;
+ }),
contexts_.end());
}
diff --git a/src/utils/threshold_operations.hpp b/src/utils/threshold_operations.hpp
index 99ae4a5..f75c12a 100644
--- a/src/utils/threshold_operations.hpp
+++ b/src/utils/threshold_operations.hpp
@@ -18,9 +18,8 @@
}
template <typename ThresholdType>
- static typename ThresholdType::ThresholdDetail&
- getDetails(ThresholdType* thresholdPtr,
- const interfaces::Sensor& sensor)
+ static typename ThresholdType::ThresholdDetail& getDetails(
+ ThresholdType* thresholdPtr, const interfaces::Sensor& sensor)
{
auto it = std::find_if(
thresholdPtr->sensorDetails.begin(),
diff --git a/tests/src/dbus_environment.cpp b/tests/src/dbus_environment.cpp
index bfe347c..03eec50 100644
--- a/tests/src/dbus_environment.cpp
+++ b/tests/src/dbus_environment.cpp
@@ -72,9 +72,9 @@
Milliseconds timeout)
{
auto& data = futures[std::string(name)];
- auto ret = waitForFutures(std::move(data), true, [](auto sum, auto val) {
- return sum && val;
- }, timeout);
+ auto ret = waitForFutures(
+ std::move(data), true, [](auto sum, auto val) { return sum && val; },
+ timeout);
data = std::vector<std::future<bool>>{};
return ret;
}
diff --git a/tests/src/dbus_environment.hpp b/tests/src/dbus_environment.hpp
index 8519b29..068fa3e 100644
--- a/tests/src/dbus_environment.hpp
+++ b/tests/src/dbus_environment.hpp
@@ -81,9 +81,9 @@
std::vector<std::future<T>> futures;
futures.emplace_back(std::move(future));
- return waitForFutures(std::move(futures), T{},
- [](auto, const auto& value) { return value; },
- timeout);
+ return waitForFutures(
+ std::move(futures), T{},
+ [](auto, const auto& value) { return value; }, timeout);
}
static bool waitForFuture(std::string_view name,
@@ -103,20 +103,20 @@
*DbusEnvironment::getBus(), DbusEnvironment::serviceName(), path,
interfaceName, property,
[&propertyPromise](const boost::system::error_code& ec, T t) {
- if (ec)
- {
- utils::setException(propertyPromise, "GetProperty failed");
- return;
- }
- propertyPromise.set_value(t);
- });
+ if (ec)
+ {
+ utils::setException(propertyPromise, "GetProperty failed");
+ return;
+ }
+ propertyPromise.set_value(t);
+ });
return DbusEnvironment::waitForFuture(std::move(propertyFuture));
}
template <class T>
- static boost::system::error_code
- setProperty(const std::string& path, const std::string& interfaceName,
- const std::string& property, const T& newValue)
+ static boost::system::error_code setProperty(
+ const std::string& path, const std::string& interfaceName,
+ const std::string& property, const T& newValue)
{
auto promise = std::promise<boost::system::error_code>();
auto future = promise.get_future();
@@ -125,23 +125,23 @@
interfaceName, property, std::move(newValue),
[promise = std::move(promise)](
boost::system::error_code ec) mutable {
- promise.set_value(ec);
- });
+ promise.set_value(ec);
+ });
return DbusEnvironment::waitForFuture(std::move(future));
}
template <class... Args>
- static boost::system::error_code
- callMethod(const std::string& path, const std::string& interface,
- const std::string& method, Args&&... args)
+ static boost::system::error_code callMethod(
+ const std::string& path, const std::string& interface,
+ const std::string& method, Args&&... args)
{
auto promise = std::promise<boost::system::error_code>();
auto future = promise.get_future();
DbusEnvironment::getBus()->async_method_call(
[promise = std::move(promise)](
boost::system::error_code ec) mutable {
- promise.set_value(ec);
- },
+ promise.set_value(ec);
+ },
DbusEnvironment::serviceName(), path, interface, method,
std::forward<Args>(args)...);
return DbusEnvironment::waitForFuture(std::move(future));
diff --git a/tests/src/helpers/labeled_tuple_helpers.hpp b/tests/src/helpers/labeled_tuple_helpers.hpp
index 4ee70c1..a5b92bc 100644
--- a/tests/src/helpers/labeled_tuple_helpers.hpp
+++ b/tests/src/helpers/labeled_tuple_helpers.hpp
@@ -8,9 +8,9 @@
{
template <class... Args, class... Labels>
-inline void
- PrintTo(const LabeledTuple<std::tuple<Args...>, Labels...>& labeledTuple,
- std::ostream* os)
+inline void PrintTo(
+ const LabeledTuple<std::tuple<Args...>, Labels...>& labeledTuple,
+ std::ostream* os)
{
nlohmann::json json;
to_json(json, labeledTuple);
diff --git a/tests/src/mocks/report_factory_mock.hpp b/tests/src/mocks/report_factory_mock.hpp
index 7cf4489..71709df 100644
--- a/tests/src/mocks/report_factory_mock.hpp
+++ b/tests/src/mocks/report_factory_mock.hpp
@@ -9,16 +9,17 @@
class ReportFactoryMock : public interfaces::ReportFactory
{
- static std::vector<LabeledMetricParameters>
- convertToLabeled(const ReadingParameters& readingParams)
+ static std::vector<LabeledMetricParameters> convertToLabeled(
+ const ReadingParameters& readingParams)
{
return utils::transform(readingParams, [](const auto& params) {
return LabeledMetricParameters(
utils::transform(std::get<0>(params),
[](const auto& sensorData) {
- return LabeledSensorInfo("Service", std::get<0>(sensorData),
+ return LabeledSensorInfo(
+ "Service", std::get<0>(sensorData),
std::get<1>(sensorData));
- }),
+ }),
utils::toOperationType(std::get<1>(params)),
utils::toCollectionTimeScope(std::get<2>(params)),
CollectionDuration(Milliseconds(std::get<3>(params))));
@@ -41,8 +42,8 @@
ON_CALL(*this,
make(A<const std::string&>(), _, _, _, _, _, _, _, _, _, _, _))
.WillByDefault(WithArgs<0>(Invoke([](const std::string& id) {
- return std::make_unique<NiceMock<ReportMock>>(id);
- })));
+ return std::make_unique<NiceMock<ReportMock>>(id);
+ })));
}
MOCK_METHOD(std::vector<LabeledMetricParameters>, convertMetricParams,
diff --git a/tests/src/mocks/sensor_mock.hpp b/tests/src/mocks/sensor_mock.hpp
index 9b7f28b..eb3a75d 100644
--- a/tests/src/mocks/sensor_mock.hpp
+++ b/tests/src/mocks/sensor_mock.hpp
@@ -24,8 +24,8 @@
return Id("SensorMock", service, path);
}
- static std::vector<std::shared_ptr<interfaces::Sensor>>
- makeSensorMocks(const std::vector<LabeledSensorInfo>& sensorsInfo)
+ static std::vector<std::shared_ptr<interfaces::Sensor>> makeSensorMocks(
+ const std::vector<LabeledSensorInfo>& sensorsInfo)
{
using namespace testing;
std::vector<std::shared_ptr<NiceMock<SensorMock>>> result;
diff --git a/tests/src/mocks/threshold_mock.hpp b/tests/src/mocks/threshold_mock.hpp
index 2f81b60..f1eab00 100644
--- a/tests/src/mocks/threshold_mock.hpp
+++ b/tests/src/mocks/threshold_mock.hpp
@@ -20,8 +20,8 @@
MOCK_METHOD(void, updateSensors, (Sensors newSensors), (override));
- static std::vector<std::shared_ptr<interfaces::Threshold>>
- makeThresholds(const LabeledTriggerThresholdParams& params)
+ static std::vector<std::shared_ptr<interfaces::Threshold>> makeThresholds(
+ const LabeledTriggerThresholdParams& params)
{
using namespace testing;
std::vector<std::shared_ptr<NiceMock<ThresholdMock>>> result;
diff --git a/tests/src/mocks/trigger_factory_mock.hpp b/tests/src/mocks/trigger_factory_mock.hpp
index a733ca4..d3d83e5 100644
--- a/tests/src/mocks/trigger_factory_mock.hpp
+++ b/tests/src/mocks/trigger_factory_mock.hpp
@@ -18,8 +18,8 @@
ON_CALL(*this, make(A<const std::string&>(), _, _, _, _, _, _, _))
.WillByDefault(WithArgs<0>(Invoke([](const std::string& id) {
- return std::make_unique<NiceMock<TriggerMock>>(id);
- })));
+ return std::make_unique<NiceMock<TriggerMock>>(id);
+ })));
}
MOCK_METHOD(std::unique_ptr<interfaces::Trigger>, make,
@@ -75,8 +75,8 @@
*this, make(params.id(), params.name(),
utils::transform(params.triggerActions(),
[](const auto& action) {
- return actionToString(action);
- }),
+ return actionToString(action);
+ }),
params.reportIds(), tm, triggerStorage,
params.thresholdParams(), params.sensors()));
}
diff --git a/tests/src/params/trigger_params.hpp b/tests/src/params/trigger_params.hpp
index ae97732..cd968a4 100644
--- a/tests/src/params/trigger_params.hpp
+++ b/tests/src/params/trigger_params.hpp
@@ -18,10 +18,10 @@
public:
TriggerParams()
{
- reportsProperty = utils::transform(reportIdsProperty,
- [](const auto& id) {
- return utils::pathAppend(utils::constants::reportDirPath, id);
- });
+ reportsProperty =
+ utils::transform(reportIdsProperty, [](const auto& id) {
+ return utils::pathAppend(utils::constants::reportDirPath, id);
+ });
}
TriggerParams& id(std::string_view val)
@@ -70,10 +70,10 @@
TriggerParams& reportIds(std::vector<std::string> val)
{
reportIdsProperty = std::move(val);
- reportsProperty = utils::transform<std::vector>(reportIdsProperty,
- [](const auto& id) {
- return utils::pathAppend(utils::constants::reportDirPath, id);
- });
+ reportsProperty = utils::transform<std::vector>(
+ reportIdsProperty, [](const auto& id) {
+ return utils::pathAppend(utils::constants::reportDirPath, id);
+ });
return *this;
}
@@ -99,8 +99,8 @@
return labeledThresholdsProperty;
}
- const std::vector<numeric::LabeledThresholdParam>
- numericThresholdParams() const
+ const std::vector<numeric::LabeledThresholdParam> numericThresholdParams()
+ const
{
const auto* num = std::get_if<0>(&labeledThresholdsProperty);
if (num == nullptr)
@@ -110,8 +110,8 @@
return *num;
}
- const std::vector<discrete::LabeledThresholdParam>
- discreteThresholdParams() const
+ const std::vector<discrete::LabeledThresholdParam> discreteThresholdParams()
+ const
{
const auto* num = std::get_if<1>(&labeledThresholdsProperty);
if (num == nullptr)
diff --git a/tests/src/stubs/dbus_sensor_object.cpp b/tests/src/stubs/dbus_sensor_object.cpp
index 224e1de..e4f402e 100644
--- a/tests/src/stubs/dbus_sensor_object.cpp
+++ b/tests/src/stubs/dbus_sensor_object.cpp
@@ -16,12 +16,13 @@
const std::shared_ptr<sdbusplus::asio::object_server>& objServer) :
ioc(ioc), bus(bus), objServer(objServer)
{
- sensorIface = objServer->add_unique_interface(path(), interface(),
- [this](auto& iface) {
- iface.register_property_r(property.value(), value,
- sdbusplus::vtable::property_::emits_change,
- [this](const auto&) { return value; });
- });
+ sensorIface = objServer->add_unique_interface(
+ path(), interface(), [this](auto& iface) {
+ iface.register_property_r(
+ property.value(), value,
+ sdbusplus::vtable::property_::emits_change,
+ [this](const auto&) { return value; });
+ });
}
void DbusSensorObject::setValue(double v)
diff --git a/tests/src/test_detached_timer.cpp b/tests/src/test_detached_timer.cpp
index a9dd6c0..90bc877 100644
--- a/tests/src/test_detached_timer.cpp
+++ b/tests/src/test_detached_timer.cpp
@@ -25,8 +25,9 @@
setPromise();
});
- auto elapsed = DbusEnvironment::measureTime(
- [] { DbusEnvironment::waitForFuture("timer"); });
+ auto elapsed = DbusEnvironment::measureTime([] {
+ DbusEnvironment::waitForFuture("timer");
+ });
EXPECT_THAT(elapsed, AllOf(Ge(100ms), Lt(200ms)));
EXPECT_THAT(value, Eq(1u));
diff --git a/tests/src/test_discrete_threshold.cpp b/tests/src/test_discrete_threshold.cpp
index 36d3a29..9003d49 100644
--- a/tests/src/test_discrete_threshold.cpp
+++ b/tests/src/test_discrete_threshold.cpp
@@ -27,10 +27,10 @@
std::unique_ptr<NiceMock<ClockMock>> clockMockPtr =
std::make_unique<NiceMock<ClockMock>>();
- std::shared_ptr<DiscreteThreshold>
- makeThreshold(Milliseconds dwellTime, std::string thresholdValue,
- discrete::Severity severity = discrete::Severity::ok,
- std::string thresholdName = "treshold name")
+ std::shared_ptr<DiscreteThreshold> makeThreshold(
+ Milliseconds dwellTime, std::string thresholdValue,
+ discrete::Severity severity = discrete::Severity::ok,
+ std::string thresholdName = "treshold name")
{
std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
actions.push_back(std::move(actionMockPtr));
@@ -61,8 +61,8 @@
{
EXPECT_CALL(*sensor,
registerForUpdates(Truly([sut = sut.get()](const auto& x) {
- return x.lock().get() == sut;
- })));
+ return x.lock().get() == sut;
+ })));
}
sut->initialize();
@@ -230,8 +230,9 @@
TriggerValue(GetParam().thresholdValue)))
.WillOnce(DoAll(
InvokeWithoutArgs([idx = index, ×tamps] {
- timestamps[idx] = std::chrono::high_resolution_clock::now();
- }),
+ timestamps[idx] =
+ std::chrono::high_resolution_clock::now();
+ }),
InvokeWithoutArgs(DbusEnvironment::setPromise("commit"))));
}
diff --git a/tests/src/test_metric.cpp b/tests/src/test_metric.cpp
index f042c9e..85cd9c9 100644
--- a/tests/src/test_metric.cpp
+++ b/tests/src/test_metric.cpp
@@ -26,8 +26,8 @@
clockFake.system.set(systemTimestamp);
}
- static std::vector<std::shared_ptr<SensorMock>>
- makeSensorMocks(size_t amount)
+ static std::vector<std::shared_ptr<SensorMock>> makeSensorMocks(
+ size_t amount)
{
std::vector<std::shared_ptr<SensorMock>> result;
for (size_t i = 0; i < amount; ++i)
@@ -66,8 +66,8 @@
EXPECT_CALL(*sensorMocks.front(),
registerForUpdates(Truly([sut = sut.get()](const auto& a0) {
- return a0.lock().get() == sut;
- })));
+ return a0.lock().get() == sut;
+ })));
sut->initialize();
}
@@ -78,8 +78,8 @@
EXPECT_CALL(*sensorMocks.front(),
unregisterFromUpdates(Truly([sut = sut.get()](const auto& a0) {
- return a0.lock().get() == sut;
- })));
+ return a0.lock().get() == sut;
+ })));
sut->deinitialize();
}
@@ -351,8 +351,8 @@
clockFake.advance(timestamp);
}
- const auto [expectedTimestamp,
- expectedReading] = GetParam().expectedReading();
+ const auto [expectedTimestamp, expectedReading] =
+ GetParam().expectedReading();
const auto readings = sut->getUpdatedReadings();
EXPECT_THAT(readings, ElementsAre(MetricValue{"metadata0", expectedReading,
@@ -370,8 +370,8 @@
sut->getUpdatedReadings();
}
- const auto [expectedTimestamp,
- expectedReading] = GetParam().expectedReading();
+ const auto [expectedTimestamp, expectedReading] =
+ GetParam().expectedReading();
const auto readings = sut->getUpdatedReadings();
EXPECT_THAT(readings, ElementsAre(MetricValue{"metadata0", expectedReading,
diff --git a/tests/src/test_numeric_threshold.cpp b/tests/src/test_numeric_threshold.cpp
index 587a1bb..2bcbfac 100644
--- a/tests/src/test_numeric_threshold.cpp
+++ b/tests/src/test_numeric_threshold.cpp
@@ -60,8 +60,8 @@
{
EXPECT_CALL(*sensor,
registerForUpdates(Truly([sut = sut.get()](const auto& x) {
- return x.lock().get() == sut;
- })));
+ return x.lock().get() == sut;
+ })));
}
sut->initialize();
@@ -205,8 +205,9 @@
_, TriggerValue(value)))
.WillOnce(DoAll(
InvokeWithoutArgs([idx = index, ×tamps] {
- timestamps[idx] = std::chrono::high_resolution_clock::now();
- }),
+ timestamps[idx] =
+ std::chrono::high_resolution_clock::now();
+ }),
InvokeWithoutArgs(DbusEnvironment::setPromise("commit"))));
}
@@ -251,109 +252,111 @@
}
};
-INSTANTIATE_TEST_SUITE_P(_, TestNumericThresholdNoDwellTime,
- Values(NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0})
- .Updates({{0, 89.0}})
- .Expected({}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0})
- .Updates({{0, 91.0}})
- .Expected({{0, 91.0}}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0})
- .Updates({{0, 99.0}, {0, 80.0}, {0, 98.0}})
- .Expected({{0, 99.0}, {0, 98.0}}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0, 100.0})
- .Updates({{0, 99.0}, {1, 98.0}})
- .Expected({{0, 99.0}}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0})
- .Updates({{0, 91.0}})
- .Expected({}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0})
- .Updates({{0, 80.0}})
- .Expected({{0, 80.0}}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0})
- .Updates({{0, 80.0}, {0, 99.0}, {0, 85.0}})
- .Expected({{0, 80.0}, {0, 85.0}}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0, 99.0})
- .Updates({{0, 80.0}, {1, 88.0}})
- .Expected({{0, 80.0}, {1, 88.0}}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::either)
- .InitialValues({98.0})
- .Updates({{0, 91.0}})
- .Expected({}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::either)
- .InitialValues({100.0})
- .Updates({{0, 80.0}, {0, 85.0}, {0, 91.0}})
- .Expected({{0, 80.0}, {0, 91.0}}),
- NumericParams()
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::either)
- .InitialValues({100.0, 80.0})
- .Updates({{0, 85.0}, {1, 91.0}})
- .Expected({{0, 85.0}, {1, 91.0}}),
- NumericParams()
- .ThresholdValue(30.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({40.0})
- .Updates({{0, 30.0}, {0, 20.0}})
- .Expected({{0, 20.0}}),
- NumericParams()
- .ThresholdValue(30.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({20.0})
- .Updates({{0, 30.0}, {0, 20.0}})
- .Expected({}),
- NumericParams()
- .ThresholdValue(30.0)
- .Direction(numeric::Direction::either)
- .InitialValues({20.0})
- .Updates({{0, 30.0}, {0, 20.0}})
- .Expected({}),
- NumericParams()
- .ThresholdValue(30.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({20.0})
- .Updates({{0, 30.0}, {0, 40.0}})
- .Expected({{0, 40.0}}),
- NumericParams()
- .ThresholdValue(30.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({40.0})
- .Updates({{0, 30.0}, {0, 40.0}})
- .Expected({}),
- NumericParams()
- .ThresholdValue(30.0)
- .Direction(numeric::Direction::either)
- .InitialValues({40.0})
- .Updates({{0, 30.0}, {0, 40.0}})
- .Expected({})));
+INSTANTIATE_TEST_SUITE_P(
+ _, TestNumericThresholdNoDwellTime,
+ Values(
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0})
+ .Updates({{0, 89.0}})
+ .Expected({}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0})
+ .Updates({{0, 91.0}})
+ .Expected({{0, 91.0}}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0})
+ .Updates({{0, 99.0}, {0, 80.0}, {0, 98.0}})
+ .Expected({{0, 99.0}, {0, 98.0}}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0, 100.0})
+ .Updates({{0, 99.0}, {1, 98.0}})
+ .Expected({{0, 99.0}}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0})
+ .Updates({{0, 91.0}})
+ .Expected({}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0})
+ .Updates({{0, 80.0}})
+ .Expected({{0, 80.0}}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0})
+ .Updates({{0, 80.0}, {0, 99.0}, {0, 85.0}})
+ .Expected({{0, 80.0}, {0, 85.0}}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0, 99.0})
+ .Updates({{0, 80.0}, {1, 88.0}})
+ .Expected({{0, 80.0}, {1, 88.0}}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({98.0})
+ .Updates({{0, 91.0}})
+ .Expected({}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({100.0})
+ .Updates({{0, 80.0}, {0, 85.0}, {0, 91.0}})
+ .Expected({{0, 80.0}, {0, 91.0}}),
+ NumericParams()
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({100.0, 80.0})
+ .Updates({{0, 85.0}, {1, 91.0}})
+ .Expected({{0, 85.0}, {1, 91.0}}),
+ NumericParams()
+ .ThresholdValue(30.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({40.0})
+ .Updates({{0, 30.0}, {0, 20.0}})
+ .Expected({{0, 20.0}}),
+ NumericParams()
+ .ThresholdValue(30.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({20.0})
+ .Updates({{0, 30.0}, {0, 20.0}})
+ .Expected({}),
+ NumericParams()
+ .ThresholdValue(30.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({20.0})
+ .Updates({{0, 30.0}, {0, 20.0}})
+ .Expected({}),
+ NumericParams()
+ .ThresholdValue(30.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({20.0})
+ .Updates({{0, 30.0}, {0, 40.0}})
+ .Expected({{0, 40.0}}),
+ NumericParams()
+ .ThresholdValue(30.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({40.0})
+ .Updates({{0, 30.0}, {0, 40.0}})
+ .Expected({}),
+ NumericParams()
+ .ThresholdValue(30.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({40.0})
+ .Updates({{0, 30.0}, {0, 40.0}})
+ .Expected({})));
TEST_P(TestNumericThresholdNoDwellTime, senorsIsUpdatedMultipleTimes)
{
@@ -378,163 +381,165 @@
INSTANTIATE_TEST_SUITE_P(
SleepAfterEveryUpdate, TestNumericThresholdWithDwellTime,
- Values(NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0})
- .Updates({{0, 89.0, 200ms}})
- .Expected({}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0})
- .Updates({{0, 91.0, 200ms}})
- .Expected({{0, 91.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0})
- .Updates({{0, 99.0, 200ms}, {0, 80.0, 100ms}, {0, 98.0, 200ms}})
- .Expected({{0, 99.0, 200ms}, {0, 98.0, 500ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0, 99.0})
- .Updates({{0, 100.0, 100ms}, {1, 86.0, 100ms}})
- .Expected({{0, 100.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0})
- .Updates({{0, 91.0, 200ms}})
- .Expected({}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0})
- .Updates({{0, 80.0, 200ms}})
- .Expected({{0, 80.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0})
- .Updates({{0, 80.0, 200ms}, {0, 99.0, 100ms}, {0, 85.0, 200ms}})
- .Expected({{0, 80.0, 200ms}, {0, 85.0, 500ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0, 99.0})
- .Updates({{0, 80.0, 200ms}, {1, 88.0, 200ms}})
- .Expected({{0, 80.0, 200ms}, {1, 88.0, 400ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::either)
- .InitialValues({98.0})
- .Updates({{0, 91.0, 200ms}})
- .Expected({}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::either)
- .InitialValues({100.0})
- .Updates({{0, 80.0, 100ms}, {0, 85.0, 100ms}, {0, 91.0, 200ms}})
- .Expected({{0, 80.0, 200ms}, {0, 91.0, 400ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::either)
- .InitialValues({100.0, 80.0})
- .Updates({{0, 85.0, 100ms}, {1, 91.0, 200ms}})
- .Expected({{0, 85.0, 200ms}, {1, 91.0, 300ms}})));
+ Values(
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0})
+ .Updates({{0, 89.0, 200ms}})
+ .Expected({}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0})
+ .Updates({{0, 91.0, 200ms}})
+ .Expected({{0, 91.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0})
+ .Updates({{0, 99.0, 200ms}, {0, 80.0, 100ms}, {0, 98.0, 200ms}})
+ .Expected({{0, 99.0, 200ms}, {0, 98.0, 500ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0, 99.0})
+ .Updates({{0, 100.0, 100ms}, {1, 86.0, 100ms}})
+ .Expected({{0, 100.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0})
+ .Updates({{0, 91.0, 200ms}})
+ .Expected({}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0})
+ .Updates({{0, 80.0, 200ms}})
+ .Expected({{0, 80.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0})
+ .Updates({{0, 80.0, 200ms}, {0, 99.0, 100ms}, {0, 85.0, 200ms}})
+ .Expected({{0, 80.0, 200ms}, {0, 85.0, 500ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0, 99.0})
+ .Updates({{0, 80.0, 200ms}, {1, 88.0, 200ms}})
+ .Expected({{0, 80.0, 200ms}, {1, 88.0, 400ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({98.0})
+ .Updates({{0, 91.0, 200ms}})
+ .Expected({}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({100.0})
+ .Updates({{0, 80.0, 100ms}, {0, 85.0, 100ms}, {0, 91.0, 200ms}})
+ .Expected({{0, 80.0, 200ms}, {0, 91.0, 400ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({100.0, 80.0})
+ .Updates({{0, 85.0, 100ms}, {1, 91.0, 200ms}})
+ .Expected({{0, 85.0, 200ms}, {1, 91.0, 300ms}})));
INSTANTIATE_TEST_SUITE_P(
SleepAfterLastUpdate, TestNumericThresholdWithDwellTime,
- Values(NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0})
- .Updates({{0, 89.0, 300ms}})
- .Expected({}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0})
- .Updates({{0, 91.0, 300ms}})
- .Expected({{0, 91.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0})
- .Updates({{0, 99.0}, {0, 80.0}, {0, 98.0, 300ms}})
- .Expected({{0, 98.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::increasing)
- .InitialValues({80.0, 99.0})
- .Updates({{0, 100.0}, {1, 98.0, 300ms}})
- .Expected({{0, 100.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0})
- .Updates({{0, 91.0, 300ms}})
- .Expected({}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0})
- .Updates({{0, 80.0, 300ms}})
- .Expected({{0, 80.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0})
- .Updates({{0, 80.0}, {0, 99.0}, {0, 85.0, 300ms}})
- .Expected({{0, 85.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::decreasing)
- .InitialValues({100.0, 99.0})
- .Updates({{0, 80.0}, {1, 88.0, 300ms}})
- .Expected({{0, 80.0, 200ms}, {1, 88.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::either)
- .InitialValues({98.0})
- .Updates({{0, 91.0, 300ms}})
- .Expected({}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::either)
- .InitialValues({100.0})
- .Updates({{0, 80.0}, {0, 85.0}, {0, 91.0, 300ms}})
- .Expected({{0, 91.0, 200ms}}),
- NumericParams()
- .DwellTime(200ms)
- .ThresholdValue(90.0)
- .Direction(numeric::Direction::either)
- .InitialValues({100.0, 80.0})
- .Updates({{0, 85.0}, {1, 91.0, 300ms}})
- .Expected({{0, 85.0, 200ms}, {1, 91.0, 200ms}})));
+ Values(
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0})
+ .Updates({{0, 89.0, 300ms}})
+ .Expected({}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0})
+ .Updates({{0, 91.0, 300ms}})
+ .Expected({{0, 91.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0})
+ .Updates({{0, 99.0}, {0, 80.0}, {0, 98.0, 300ms}})
+ .Expected({{0, 98.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::increasing)
+ .InitialValues({80.0, 99.0})
+ .Updates({{0, 100.0}, {1, 98.0, 300ms}})
+ .Expected({{0, 100.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0})
+ .Updates({{0, 91.0, 300ms}})
+ .Expected({}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0})
+ .Updates({{0, 80.0, 300ms}})
+ .Expected({{0, 80.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0})
+ .Updates({{0, 80.0}, {0, 99.0}, {0, 85.0, 300ms}})
+ .Expected({{0, 85.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::decreasing)
+ .InitialValues({100.0, 99.0})
+ .Updates({{0, 80.0}, {1, 88.0, 300ms}})
+ .Expected({{0, 80.0, 200ms}, {1, 88.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({98.0})
+ .Updates({{0, 91.0, 300ms}})
+ .Expected({}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({100.0})
+ .Updates({{0, 80.0}, {0, 85.0}, {0, 91.0, 300ms}})
+ .Expected({{0, 91.0, 200ms}}),
+ NumericParams()
+ .DwellTime(200ms)
+ .ThresholdValue(90.0)
+ .Direction(numeric::Direction::either)
+ .InitialValues({100.0, 80.0})
+ .Updates({{0, 85.0}, {1, 91.0, 300ms}})
+ .Expected({{0, 85.0, 200ms}, {1, 91.0, 200ms}})));
TEST_P(TestNumericThresholdWithDwellTime, senorsIsUpdatedMultipleTimes)
{
diff --git a/tests/src/test_on_change_threshold.cpp b/tests/src/test_on_change_threshold.cpp
index 0623a10..b4a6fd3 100644
--- a/tests/src/test_on_change_threshold.cpp
+++ b/tests/src/test_on_change_threshold.cpp
@@ -51,8 +51,8 @@
{
EXPECT_CALL(*sensor,
registerForUpdates(Truly([sut = sut.get()](const auto& x) {
- return x.lock().get() == sut;
- })));
+ return x.lock().get() == sut;
+ })));
}
sut->initialize();
diff --git a/tests/src/test_persistent_json_storage.cpp b/tests/src/test_persistent_json_storage.cpp
index cec0019..c83d5f1 100644
--- a/tests/src/test_persistent_json_storage.cpp
+++ b/tests/src/test_persistent_json_storage.cpp
@@ -116,14 +116,14 @@
struct TestFileSymlink
{
- static interfaces::JsonStorage::FilePath
- setupSymlinks(const std::filesystem::path& originalFile,
- const interfaces::JsonStorage::DirectoryPath& directory)
+ static interfaces::JsonStorage::FilePath setupSymlinks(
+ const std::filesystem::path& originalFile,
+ const interfaces::JsonStorage::DirectoryPath& directory)
{
- auto linkPath = std::filesystem::path(directory) /
- "report/symlink.json";
- std::filesystem::create_directories(std::filesystem::path(directory) /
- "report");
+ auto linkPath =
+ std::filesystem::path(directory) / "report/symlink.json";
+ std::filesystem::create_directories(
+ std::filesystem::path(directory) / "report");
std::filesystem::create_symlink(originalFile, linkPath);
return interfaces::JsonStorage::FilePath(linkPath);
}
@@ -131,17 +131,17 @@
struct TestDirectorySymlink
{
- static interfaces::JsonStorage::FilePath
- setupSymlinks(const std::filesystem::path& originalFile,
- const interfaces::JsonStorage::DirectoryPath& directory)
+ static interfaces::JsonStorage::FilePath setupSymlinks(
+ const std::filesystem::path& originalFile,
+ const interfaces::JsonStorage::DirectoryPath& directory)
{
auto linkPath = std::filesystem::path(directory) / "reportLink";
- std::filesystem::create_directories(std::filesystem::path(directory) /
- "report");
+ std::filesystem::create_directories(
+ std::filesystem::path(directory) / "report");
std::filesystem::create_directory_symlink(originalFile.parent_path(),
linkPath);
- return interfaces::JsonStorage::FilePath(linkPath /
- originalFile.filename());
+ return interfaces::JsonStorage::FilePath(
+ linkPath / originalFile.filename());
}
};
diff --git a/tests/src/test_report.cpp b/tests/src/test_report.cpp
index 709efdd..4e5e7ae 100644
--- a/tests/src/test_report.cpp
+++ b/tests/src/test_report.cpp
@@ -153,18 +153,16 @@
}
template <class T>
- static boost::system::error_code setProperty(const std::string& path,
- const std::string& property,
- const T& newValue)
+ static boost::system::error_code setProperty(
+ const std::string& path, const std::string& property, const T& newValue)
{
return DbusEnvironment::setProperty<T>(path, Report::reportIfaceName,
property, newValue);
}
template <class... Args>
- static boost::system::error_code callMethod(const std::string& path,
- const std::string& method,
- Args&&... args)
+ static boost::system::error_code callMethod(
+ const std::string& path, const std::string& method, Args&&... args)
{
return DbusEnvironment::callMethod(path, Report::reportIfaceName,
"SetReportingProperties",
@@ -198,8 +196,9 @@
std::promise<boost::system::error_code> methodPromise;
DbusEnvironment::getBus()->async_method_call(
[&methodPromise](boost::system::error_code ec) {
- methodPromise.set_value(ec);
- }, DbusEnvironment::serviceName(), path, interface, method);
+ methodPromise.set_value(ec);
+ },
+ DbusEnvironment::serviceName(), path, interface, method);
return DbusEnvironment::waitForFuture(methodPromise.get_future());
}
@@ -213,9 +212,8 @@
return call(path, Report::deleteIfaceName, "Delete");
}
- static std::pair<std::string, std::vector<std::string>>
- makeStateDetail(const std::string& detailType,
- std::vector<std::string> detailArgs)
+ static std::pair<std::string, std::vector<std::string>> makeStateDetail(
+ const std::string& detailType, std::vector<std::string> detailArgs)
{
return make_pair(detailType, detailArgs);
}
@@ -236,8 +234,8 @@
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "ReportActions"),
Eq(utils::transform(defaultParams().reportActions(), [](const auto v) {
- return utils::enumToString(v);
- })));
+ return utils::enumToString(v);
+ })));
EXPECT_THAT(getProperty<bool>(sut->getPath(), "EmitsReadingsUpdate"),
Eq(utils::contains(defaultParams().reportActions(),
ReportAction::emitsReadingsUpdate)));
@@ -381,8 +379,8 @@
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "ReportActions"),
Eq(utils::transform(defaultParams().reportActions(), [](const auto v) {
- return utils::enumToString(v);
- })));
+ return utils::enumToString(v);
+ })));
}
TEST_F(TestReport, createReportWithEmptyActions)
@@ -409,8 +407,8 @@
ReportParams()
.reportId("TestId_1")
.reportActions(utils::transform(newActions, [](const auto& action) {
- return utils::toReportAction(action);
- })));
+ return utils::toReportAction(action);
+ })));
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "ReportActions"),
Eq(expectedActions));
@@ -439,9 +437,9 @@
{
uint64_t newValue = ReportManager::minInterval.count() - 1;
- EXPECT_THAT(
- callMethod(sut->getPath(), "SetReportingProperties", "", newValue),
- Eq(boost::system::errc::invalid_argument));
+ EXPECT_THAT(callMethod(sut->getPath(), "SetReportingProperties", "",
+ newValue),
+ Eq(boost::system::errc::invalid_argument));
EXPECT_THAT(getProperty<uint64_t>(sut->getPath(), "Interval"),
Eq(defaultParams().interval().count()));
@@ -456,9 +454,9 @@
uint64_t newValue = ReportManager::minInterval.count();
- EXPECT_THAT(
- callMethod(report->getPath(), "SetReportingProperties", "", newValue),
- Eq(boost::system::errc::invalid_argument));
+ EXPECT_THAT(callMethod(report->getPath(), "SetReportingProperties", "",
+ newValue),
+ Eq(boost::system::errc::invalid_argument));
EXPECT_THAT(getProperty<uint64_t>(report->getPath(), "Interval"),
Eq(defaultParams().interval().count()));
@@ -728,12 +726,12 @@
void SetUp() override {}
};
-INSTANTIATE_TEST_SUITE_P(InvalidNames, TestReportInvalidIds,
- Values(defaultParams().reportId("/"),
- defaultParams().reportId("/Invalid"),
- defaultParams().reportId("Invalid/"),
- defaultParams().reportId("Invalid/Invalid/"),
- defaultParams().reportId("Invalid?")));
+INSTANTIATE_TEST_SUITE_P(
+ InvalidNames, TestReportInvalidIds,
+ Values(defaultParams().reportId("/"), defaultParams().reportId("/Invalid"),
+ defaultParams().reportId("Invalid/"),
+ defaultParams().reportId("Invalid/Invalid/"),
+ defaultParams().reportId("Invalid?")));
TEST_P(TestReportInvalidIds, failsToCreateReportWithInvalidName)
{
@@ -773,8 +771,8 @@
clockFake.system.advance(10ms);
messanger.send(messages::UpdateReportInd{{sut->getId()}});
- const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
- "Readings");
+ const auto [timestamp, readings] =
+ getProperty<Readings>(sut->getPath(), "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(systemTimestamp + 10ms));
}
@@ -785,8 +783,8 @@
setProperty(sut->getPath(), "Enabled", false);
messanger.send(messages::UpdateReportInd{{sut->getId()}});
- const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
- "Readings");
+ const auto [timestamp, readings] =
+ getProperty<Readings>(sut->getPath(), "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(0ms));
}
@@ -796,8 +794,8 @@
clockFake.system.advance(10ms);
messanger.send(messages::UpdateReportInd{{sut->getId() + "x"s}});
- const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
- "Readings");
+ const auto [timestamp, readings] =
+ getProperty<Readings>(sut->getPath(), "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(0ms));
}
@@ -817,8 +815,8 @@
ASSERT_THAT(update(sut->getPath()), Eq(boost::system::errc::success));
- const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
- "Readings");
+ const auto [timestamp, readings] =
+ getProperty<Readings>(sut->getPath(), "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(systemTimestamp + 10ms));
}
@@ -827,8 +825,8 @@
{
ASSERT_THAT(update(sut->getPath()), Eq(boost::system::errc::success));
- const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
- "Readings");
+ const auto [timestamp, readings] =
+ getProperty<Readings>(sut->getPath(), "Readings");
EXPECT_THAT(readings, ElementsAre(std::make_tuple("b"s, 17.1, 114u),
std::make_tuple("bb"s, 42.0, 74u)));
@@ -900,8 +898,8 @@
clockFake.system.advance(10ms);
DbusEnvironment::sleepFor(ReportManager::minInterval + 1ms);
- const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
- "Readings");
+ const auto [timestamp, readings] =
+ getProperty<Readings>(sut->getPath(), "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(systemTimestamp + 10ms));
}
@@ -910,8 +908,8 @@
{
DbusEnvironment::sleepFor(ReportManager::minInterval + 1ms);
- const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
- "Readings");
+ const auto [timestamp, readings] =
+ getProperty<Readings>(sut->getPath(), "Readings");
EXPECT_THAT(readings, ElementsAre(std::make_tuple("b"s, 17.1, 114u),
std::make_tuple("bb"s, 42.0, 74u)));
@@ -949,8 +947,8 @@
auto readings()
{
- auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
- "Readings");
+ auto [timestamp,
+ readings] = getProperty<Readings>(sut->getPath(), "Readings");
return readings;
}
@@ -1150,8 +1148,8 @@
{
EXPECT_CALL(*metric, registerForUpdates(_))
.WillOnce(Invoke([&args](const interfaces::MetricListener& report) {
- args.emplace_back(&report);
- }));
+ args.emplace_back(&report);
+ }));
;
}
@@ -1238,8 +1236,8 @@
{
messanger.on_receive<messages::CollectTriggerIdReq>(
[this, triggerId](const auto& msg) {
- messanger.send(messages::CollectTriggerIdResp{triggerId});
- });
+ messanger.send(messages::CollectTriggerIdResp{triggerId});
+ });
}
sut = makeReport(ReportParams());
diff --git a/tests/src/test_report_manager.cpp b/tests/src/test_report_manager.cpp
index be199c7..53eac37 100644
--- a/tests/src/test_report_manager.cpp
+++ b/tests/src/test_report_manager.cpp
@@ -46,9 +46,9 @@
EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _))
.Times(AnyNumber());
- sut = std::make_unique<ReportManager>(std::move(reportFactoryMockPtr),
- std::move(storageMockPtr),
- DbusEnvironment::getObjServer());
+ sut = std::make_unique<ReportManager>(
+ std::move(reportFactoryMockPtr), std::move(storageMockPtr),
+ DbusEnvironment::getObjServer());
}
void TearDown() override
@@ -65,8 +65,8 @@
DbusEnvironment::getBus()->async_method_call(
[&addReportPromise](boost::system::error_code ec,
const std::string& path) {
- addReportPromise.set_value({ec, path});
- },
+ addReportPromise.set_value({ec, path});
+ },
DbusEnvironment::serviceName(), ReportManager::reportManagerPath,
ReportManager::reportManagerIfaceName, "AddReport",
std::forward<Args>(args)...);
@@ -79,9 +79,10 @@
params.reportId(), params.reportName(),
utils::enumToString(params.reportingType()),
utils::enumToString(params.reportUpdates()), params.appendLimit(),
- utils::transform(
- params.reportActions(),
- [](const auto v) { return utils::enumToString(v); }),
+ utils::transform(params.reportActions(),
+ [](const auto v) {
+ return utils::enumToString(v);
+ }),
params.interval().count(),
toReadingParameters(params.metricParameters()), params.enabled());
}
@@ -389,11 +390,11 @@
for (size_t i = 0; i < ReportManager::maxNumberMetrics + 1; i++)
{
- metricParams.emplace_back(
- LabeledMetricParameters{{},
- OperationType::avg,
- CollectionTimeScope::point,
- CollectionDuration(Milliseconds(0u))});
+ metricParams.emplace_back(LabeledMetricParameters{
+ {},
+ OperationType::avg,
+ CollectionTimeScope::point,
+ CollectionDuration(Milliseconds(0u))});
}
reportParams.metricParameters(std::move(metricParams));
@@ -444,8 +445,8 @@
EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
}
- reportParams.reportId(reportParams.reportName() +
- std::to_string(ReportManager::maxReports));
+ reportParams.reportId(
+ reportParams.reportName() + std::to_string(ReportManager::maxReports));
auto [ec, path] = addReport(reportParams);
EXPECT_THAT(ec.value(), Eq(boost::system::errc::too_many_files_open));
@@ -548,9 +549,9 @@
void makeReportManager()
{
- sut = std::make_unique<ReportManager>(std::move(reportFactoryMockPtr),
- std::move(storageMockPtr),
- DbusEnvironment::getObjServer());
+ sut = std::make_unique<ReportManager>(
+ std::move(reportFactoryMockPtr), std::move(storageMockPtr),
+ DbusEnvironment::getObjServer());
}
nlohmann::json data = nlohmann::json{
diff --git a/tests/src/test_sensor.cpp b/tests/src/test_sensor.cpp
index 8738bde..3a3bcc9 100644
--- a/tests/src/test_sensor.cpp
+++ b/tests/src/test_sensor.cpp
@@ -28,8 +28,8 @@
DbusEnvironment::synchronizeIoc();
}
- void
- registerForUpdates(std::shared_ptr<interfaces::SensorListener> listener)
+ void registerForUpdates(
+ std::shared_ptr<interfaces::SensorListener> listener)
{
sut->registerForUpdates(listener);
DbusEnvironment::synchronizeIoc();
@@ -107,18 +107,18 @@
TEST_F(TestSensor, getNameReturnsPathWhenMetadataIsNotSet)
{
static const char* path = "/telemetry/ut/DbusSensorObject2";
- sut = sensorCache.makeSensor<Sensor>(DbusEnvironment::serviceName(), path,
- "", DbusEnvironment::getIoc(),
- DbusEnvironment::getBus());
+ sut = sensorCache.makeSensor<Sensor>(
+ DbusEnvironment::serviceName(), path, "", DbusEnvironment::getIoc(),
+ DbusEnvironment::getBus());
EXPECT_EQ(sut->getName(), path);
}
TEST_F(TestSensor, getNameReturnsMetadataWhenMetadataIsSet)
{
static const char* path = "/telemetry/ut/DbusSensorObject2";
- sut = sensorCache.makeSensor<Sensor>(DbusEnvironment::serviceName(), path,
- "metadata2", DbusEnvironment::getIoc(),
- DbusEnvironment::getBus());
+ sut = sensorCache.makeSensor<Sensor>(
+ DbusEnvironment::serviceName(), path, "metadata2",
+ DbusEnvironment::getIoc(), DbusEnvironment::getBus());
EXPECT_EQ(sut->getName(), "metadata2");
}
diff --git a/tests/src/test_sensor_cache.cpp b/tests/src/test_sensor_cache.cpp
index 3d12563..8c3295d 100644
--- a/tests/src/test_sensor_cache.cpp
+++ b/tests/src/test_sensor_cache.cpp
@@ -64,10 +64,10 @@
TEST_P(TestSensorCacheP, shouldReturnDifferentSensorWhenIdsAreDifferent)
{
- auto sensor1 = sut.makeSensor<NiceMock<SensorMock>>(id<0>().service,
- id<0>().path);
- auto sensor2 = sut.makeSensor<NiceMock<SensorMock>>(id<1>().service,
- id<1>().path);
+ auto sensor1 =
+ sut.makeSensor<NiceMock<SensorMock>>(id<0>().service, id<0>().path);
+ auto sensor2 =
+ sut.makeSensor<NiceMock<SensorMock>>(id<1>().service, id<1>().path);
ASSERT_THAT(sensor1.get(), Not(Eq(sensor2.get())));
ASSERT_THAT(sensor1->mockId, Not(Eq(sensor2->mockId)));
@@ -75,10 +75,10 @@
TEST_F(TestSensorCache, shouldReturnSameSensorWhenSensorWithSameIdStillExists)
{
- auto sensor1 = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
- "sensor-path");
- auto sensor2 = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
- "sensor-path");
+ auto sensor1 =
+ sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path");
+ auto sensor2 =
+ sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path");
ASSERT_THAT(sensor1.get(), Eq(sensor2.get()));
ASSERT_THAT(sensor1->mockId, Eq(sensor2->mockId));
@@ -86,21 +86,21 @@
TEST_F(TestSensorCache, shouldReturnDifferentSensorWhenPreviousSensorExpired)
{
- auto mockId1 = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
- "sensor-path")
- ->mockId;
- auto mockId2 = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
- "sensor-path")
- ->mockId;
+ auto mockId1 =
+ sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path")
+ ->mockId;
+ auto mockId2 =
+ sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path")
+ ->mockId;
ASSERT_THAT(mockId2, Not(Eq(mockId1)));
}
TEST_F(TestSensorCache, shouldCreateSensorWithCorrespondingId)
{
- auto id = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
- "sensor-path")
- ->id();
+ auto id =
+ sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path")
+ ->id();
auto expected = SensorMock::makeId("sensor-service", "sensor-path");
diff --git a/tests/src/test_trigger.cpp b/tests/src/test_trigger.cpp
index 98162ca..c2f7774 100644
--- a/tests/src/test_trigger.cpp
+++ b/tests/src/test_trigger.cpp
@@ -67,8 +67,8 @@
sut = makeTrigger(triggerParams);
}
- static std::vector<LabeledSensorInfo>
- convertToLabeledSensor(const SensorsInfo& sensorsInfo)
+ static std::vector<LabeledSensorInfo> convertToLabeledSensor(
+ const SensorsInfo& sensorsInfo)
{
return utils::transform(sensorsInfo, [](const auto& sensorInfo) {
const auto& [sensorPath, sensorMetadata] = sensorInfo;
@@ -107,9 +107,8 @@
}
template <class T>
- static boost::system::error_code setProperty(const std::string& path,
- const std::string& property,
- const T& newValue)
+ static boost::system::error_code setProperty(
+ const std::string& path, const std::string& property, const T& newValue)
{
return DbusEnvironment::setProperty<T>(path, Trigger::triggerIfaceName,
property, newValue);
@@ -140,8 +139,9 @@
std::promise<boost::system::error_code> methodPromise;
DbusEnvironment::getBus()->async_method_call(
[&methodPromise](boost::system::error_code ec) {
- methodPromise.set_value(ec);
- }, DbusEnvironment::serviceName(), path, Trigger::deleteIfaceName,
+ methodPromise.set_value(ec);
+ },
+ DbusEnvironment::serviceName(), path, Trigger::deleteIfaceName,
"Delete");
return DbusEnvironment::waitForFuture(methodPromise.get_future());
}
@@ -519,8 +519,8 @@
ASSERT_THAT(storedConfiguration.at("TriggerActions"),
Eq(utils::transform(triggerParams.triggerActions(),
[](const auto& action) {
- return actionToString(action);
- })));
+ return actionToString(action);
+ })));
}
TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerReportIds)
diff --git a/tests/src/test_trigger_manager.cpp b/tests/src/test_trigger_manager.cpp
index 3204b19..f425350 100644
--- a/tests/src/test_trigger_manager.cpp
+++ b/tests/src/test_trigger_manager.cpp
@@ -19,8 +19,8 @@
{
public:
TriggerParams triggerParams;
- std::pair<boost::system::error_code, std::string>
- addTrigger(const TriggerParams& params)
+ std::pair<boost::system::error_code, std::string> addTrigger(
+ const TriggerParams& params)
{
const auto sensorInfos =
utils::fromLabeledSensorsInfo(params.sensors());
@@ -38,14 +38,15 @@
DbusEnvironment::getBus()->async_method_call(
[&addTriggerPromise](boost::system::error_code ec,
const std::string& path) {
- addTriggerPromise.set_value({ec, path});
- },
+ addTriggerPromise.set_value({ec, path});
+ },
DbusEnvironment::serviceName(), TriggerManager::triggerManagerPath,
TriggerManager::triggerManagerIfaceName, "AddTrigger", params.id(),
params.name(),
- utils::transform(
- params.triggerActions(),
- [](const auto& action) { return actionToString(action); }),
+ utils::transform(params.triggerActions(),
+ [](const auto& action) {
+ return actionToString(action);
+ }),
sensorInfos, params.reports(), numThresh2, discThresh2);
return DbusEnvironment::waitForFuture(addTriggerPromise.get_future());
}
@@ -393,8 +394,8 @@
EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
}
- triggerParams.id(TriggerParams().id() +
- std::to_string(TriggerManager::maxTriggers));
+ triggerParams.id(
+ TriggerParams().id() + std::to_string(TriggerManager::maxTriggers));
auto [ec, path] = addTrigger(triggerParams);
EXPECT_THAT(ec.value(), Eq(boost::system::errc::too_many_files_open));
EXPECT_THAT(path, Eq(std::string()));
@@ -473,8 +474,8 @@
TriggerParams().thresholdParams().index()},
{"TriggerActions", utils::transform(TriggerParams().triggerActions(),
[](const auto& action) {
- return actionToString(action);
- })},
+ return actionToString(action);
+ })},
{"ThresholdParams", utils::labeledThresholdParamsToJson(
TriggerParams().thresholdParams())},
{"ReportIds", TriggerParams().reportIds()},