diff --git a/control/actions.cpp b/control/actions.cpp
index 00dc8f0..bd2adfc 100644
--- a/control/actions.cpp
+++ b/control/actions.cpp
@@ -73,10 +73,10 @@
         // Set/update the services of the group
         zone.setServices(&group);
         auto services = zone.getGroupServices(&group);
-        auto missingOwner =
-            std::any_of(services.begin(), services.end(), [](const auto& s) {
-                return !std::get<hasOwnerPos>(s);
-            });
+        auto missingOwner = std::any_of(services.begin(), services.end(),
+                                        [](const auto& s) {
+            return !std::get<hasOwnerPos>(s);
+        });
         if (missingOwner)
         {
             zone.setSpeed(speed);
@@ -89,20 +89,20 @@
 void set_request_speed_base_with_max(control::Zone& zone, const Group& group)
 {
     int64_t base = 0;
-    std::for_each(
-        group.begin(), group.end(), [&zone, &base](auto const& entry) {
-            try
-            {
-                auto value = zone.template getPropertyValue<int64_t>(
-                    std::get<pathPos>(entry), std::get<intfPos>(entry),
-                    std::get<propPos>(entry));
-                base = std::max(base, value);
-            }
-            catch (const std::out_of_range& oore)
-            {
-                // Property value not found, base request speed unchanged
-            }
-        });
+    std::for_each(group.begin(), group.end(),
+                  [&zone, &base](const auto& entry) {
+        try
+        {
+            auto value = zone.template getPropertyValue<int64_t>(
+                std::get<pathPos>(entry), std::get<intfPos>(entry),
+                std::get<propPos>(entry));
+            base = std::max(base, value);
+        }
+        catch (const std::out_of_range& oore)
+        {
+            // Property value not found, base request speed unchanged
+        }
+    });
     // A request speed base of 0 defaults to the current target speed
     zone.setRequestSpeedBase(base);
 }
diff --git a/control/actions.hpp b/control/actions.hpp
index 53e2efe..968c1b2 100644
--- a/control/actions.hpp
+++ b/control/actions.hpp
@@ -135,21 +135,21 @@
         if (group.size() != 0)
         {
             auto count = 0;
-            auto sumValue = std::accumulate(
-                group.begin(), group.end(), 0,
-                [&zone, &count](T sum, auto const& entry) {
-                    try
-                    {
-                        return sum + zone.template getPropertyValue<T>(
-                                         std::get<pathPos>(entry),
-                                         std::get<intfPos>(entry),
-                                         std::get<propPos>(entry));
-                    }
-                    catch (const std::out_of_range& oore)
-                    {
-                        count++;
-                        return sum;
-                    }
+            auto sumValue =
+                std::accumulate(group.begin(), group.end(), 0,
+                                [&zone, &count](T sum, auto const& entry) {
+                try
+                {
+                    return sum + zone.template getPropertyValue<T>(
+                                     std::get<pathPos>(entry),
+                                     std::get<intfPos>(entry),
+                                     std::get<propPos>(entry));
+                }
+                catch (const std::out_of_range& oore)
+                {
+                    count++;
+                    return sum;
+                }
                 });
             if ((group.size() - count) > 0)
             {
@@ -157,8 +157,8 @@
                 auto avgValue = sumValue / (groupSize - count);
                 auto it = std::find_if(val_to_speed.begin(), val_to_speed.end(),
                                        [&avgValue](auto const& entry) {
-                                           return avgValue < entry.first;
-                                       });
+                    return avgValue < entry.first;
+                });
                 if (it != std::end(val_to_speed))
                 {
                     speed = (*it).second;
@@ -193,21 +193,21 @@
         if (group.size() != 0)
         {
             auto count = 0;
-            auto sumValue = std::accumulate(
-                group.begin(), group.end(), 0,
-                [&zone, &count](T sum, auto const& entry) {
-                    try
-                    {
-                        return sum + zone.template getPropertyValue<T>(
-                                         std::get<pathPos>(entry),
-                                         std::get<intfPos>(entry),
-                                         std::get<propPos>(entry));
-                    }
-                    catch (const std::out_of_range& oore)
-                    {
-                        count++;
-                        return sum;
-                    }
+            auto sumValue =
+                std::accumulate(group.begin(), group.end(), 0,
+                                [&zone, &count](T sum, auto const& entry) {
+                try
+                {
+                    return sum + zone.template getPropertyValue<T>(
+                                     std::get<pathPos>(entry),
+                                     std::get<intfPos>(entry),
+                                     std::get<propPos>(entry));
+                }
+                catch (const std::out_of_range& oore)
+                {
+                    count++;
+                    return sum;
+                }
                 });
             if ((group.size() - count) > 0)
             {
@@ -215,7 +215,7 @@
                 auto avgValue = sumValue / (groupSize - count);
                 auto prevValue = zone.swapCeilingKeyValue(avgValue);
                 if (avgValue != prevValue)
-                { // Only check if previous and new values differ
+                {     // Only check if previous and new values differ
                     if (avgValue < prevValue)
                     { // Value is decreasing from previous
                         for (auto it = val_to_speed.rbegin();
@@ -307,34 +307,33 @@
     return [speedDelta, factor = std::forward<T>(factor),
             state = std::forward<T>(state)](auto& zone, auto& group) {
         auto netDelta = zone.getIncSpeedDelta();
-        std::for_each(
-            group.begin(), group.end(),
-            [&zone, &state, &factor, &speedDelta,
-             &netDelta](auto const& entry) {
-                try
+        std::for_each(group.begin(), group.end(),
+                      [&zone, &state, &factor, &speedDelta,
+                       &netDelta](auto const& entry) {
+            try
+            {
+                T value = zone.template getPropertyValue<T>(
+                    std::get<pathPos>(entry), std::get<intfPos>(entry),
+                    std::get<propPos>(entry));
+                // TODO openbmc/phosphor-fan-presence#7 - Support possible
+                // state types for comparison
+                if (value >= state)
                 {
-                    T value = zone.template getPropertyValue<T>(
-                        std::get<pathPos>(entry), std::get<intfPos>(entry),
-                        std::get<propPos>(entry));
-                    // TODO openbmc/phosphor-fan-presence#7 - Support possible
-                    // state types for comparison
-                    if (value >= state)
-                    {
-                        // Increase by at least a single delta(factor)
-                        // to attempt bringing under 'state'
-                        auto delta = std::max((value - state), factor);
-                        // Increase is the factor applied to the
-                        // difference times the given speed delta
-                        netDelta = std::max(netDelta,
-                                            static_cast<uint64_t>(
-                                                (delta / factor) * speedDelta));
-                    }
+                    // Increase by at least a single delta(factor)
+                    // to attempt bringing under 'state'
+                    auto delta = std::max((value - state), factor);
+                    // Increase is the factor applied to the
+                    // difference times the given speed delta
+                    netDelta = std::max(
+                        netDelta,
+                        static_cast<uint64_t>((delta / factor) * speedDelta));
                 }
-                catch (const std::out_of_range& oore)
-                {
-                    // Property value not found, netDelta unchanged
-                }
-            });
+            }
+            catch (const std::out_of_range& oore)
+            {
+                // Property value not found, netDelta unchanged
+            }
+        });
         // Request speed change for target speed update
         zone.requestSpeedIncrease(netDelta);
     };
@@ -427,21 +426,20 @@
     return [state = std::forward<T>(state), defEvents = std::move(defEvents),
             altEvents = std::move(altEvents)](auto& zone, auto& group) {
         // Compare all group entries to the state
-        auto useAlt = std::all_of(
-            group.begin(), group.end(), [&zone, &state](auto const& entry) {
-                try
-                {
-                    return zone.template getPropertyValue<T>(
-                               std::get<pathPos>(entry),
-                               std::get<intfPos>(entry),
-                               std::get<propPos>(entry)) == state;
-                }
-                catch (const std::out_of_range& oore)
-                {
-                    // Default to property not equal when not found
-                    return false;
-                }
-            });
+        auto useAlt = std::all_of(group.begin(), group.end(),
+                                  [&zone, &state](auto const& entry) {
+            try
+            {
+                return zone.template getPropertyValue<T>(
+                           std::get<pathPos>(entry), std::get<intfPos>(entry),
+                           std::get<propPos>(entry)) == state;
+            }
+            catch (const std::out_of_range& oore)
+            {
+                // Default to property not equal when not found
+                return false;
+            }
+        });
 
         const std::vector<SetSpeedEvent>* rmEvents = &altEvents;
         const std::vector<SetSpeedEvent>* initEvents = &defEvents;
@@ -528,8 +526,8 @@
                 // Use determined median sensor value to find floor speed
                 auto it = std::find_if(valueToSpeed.begin(), valueToSpeed.end(),
                                        [&median](auto const& entry) {
-                                           return median < entry.first;
-                                       });
+                    return median < entry.first;
+                });
                 if (it != std::end(valueToSpeed))
                 {
                     speed = (*it).second;
@@ -556,21 +554,20 @@
 auto update_default_floor(T&& state, uint64_t speed)
 {
     return [speed, state = std::forward<T>(state)](auto& zone, auto& group) {
-        auto updateDefFloor = std::all_of(
-            group.begin(), group.end(), [&zone, &state](auto const& entry) {
-                try
-                {
-                    return zone.template getPropertyValue<T>(
-                               std::get<pathPos>(entry),
-                               std::get<intfPos>(entry),
-                               std::get<propPos>(entry)) == state;
-                }
-                catch (const std::out_of_range& oore)
-                {
-                    // Default to property not equal when not found
-                    return false;
-                }
-            });
+        auto updateDefFloor = std::all_of(group.begin(), group.end(),
+                                          [&zone, &state](auto const& entry) {
+            try
+            {
+                return zone.template getPropertyValue<T>(
+                           std::get<pathPos>(entry), std::get<intfPos>(entry),
+                           std::get<propPos>(entry)) == state;
+            }
+            catch (const std::out_of_range& oore)
+            {
+                // Default to property not equal when not found
+                return false;
+            }
+        });
 
         if (!updateDefFloor)
         {
@@ -602,35 +599,36 @@
     return [state = std::forward<T>(state),
             events = std::move(events)](auto& zone, auto& group) {
         // Compare all group entries to the state
-        auto useEvents = std::all_of(
-            group.begin(), group.end(), [&zone, &state](auto const& entry) {
-                try
-                {
-                    return zone.template getPropertyValue<T>(
-                               std::get<pathPos>(entry),
-                               std::get<intfPos>(entry),
-                               std::get<propPos>(entry)) == state;
-                }
-                catch (const std::out_of_range& oore)
-                {
-                    // Default to property not equal when not found
-                    return false;
-                }
-            });
+        auto useEvents = std::all_of(group.begin(), group.end(),
+                                     [&zone, &state](auto const& entry) {
+            try
+            {
+                return zone.template getPropertyValue<T>(
+                           std::get<pathPos>(entry), std::get<intfPos>(entry),
+                           std::get<propPos>(entry)) == state;
+            }
+            catch (const std::out_of_range& oore)
+            {
+                // Default to property not equal when not found
+                return false;
+            }
+        });
 
         if (useEvents)
         {
             // Init events
-            std::for_each(
-                events.begin(), events.end(),
-                [&zone](auto const& entry) { zone.initEvent(entry); });
+            std::for_each(events.begin(), events.end(),
+                          [&zone](auto const& entry) {
+                zone.initEvent(entry);
+            });
         }
         else
         {
             // Remove events
-            std::for_each(
-                events.begin(), events.end(),
-                [&zone](auto const& entry) { zone.removeEvent(entry); });
+            std::for_each(events.begin(), events.end(),
+                          [&zone](auto const& entry) {
+                zone.removeEvent(entry);
+            });
         }
     };
 }
diff --git a/control/fanctl.cpp b/control/fanctl.cpp
index 6f4a133..280fbe5 100644
--- a/control/fanctl.cpp
+++ b/control/fanctl.cpp
@@ -57,7 +57,7 @@
  * @return just the fan name.
  */
 
-std::string justFanName(std::string const& path)
+std::string justFanName(const std::string& path)
 {
     std::string fanName;
 
@@ -161,8 +161,8 @@
     }
 
     // load tach sensor paths for each fan
-    pathMap["tach"] =
-        getPathsFromIface(paths["tach"], interfaces["SensorValue"], fanNames);
+    pathMap["tach"] = getPathsFromIface(paths["tach"],
+                                        interfaces["SensorValue"], fanNames);
 
     // load inventory Item data for each fan
     pathMap["inventory"] = getPathsFromIface(
@@ -220,18 +220,18 @@
 
     std::string path("/xyz/openbmc_project/state/bmc0");
     std::string iface("xyz.openbmc_project.State.BMC");
-    ret[3] =
-        SDBusPlus::getProperty<std::string>(path, iface, "CurrentBMCState");
+    ret[3] = SDBusPlus::getProperty<std::string>(path, iface,
+                                                 "CurrentBMCState");
 
     path = "/xyz/openbmc_project/state/chassis0";
     iface = "xyz.openbmc_project.State.Chassis";
-    ret[4] =
-        SDBusPlus::getProperty<std::string>(path, iface, "CurrentPowerState");
+    ret[4] = SDBusPlus::getProperty<std::string>(path, iface,
+                                                 "CurrentPowerState");
 
     path = "/xyz/openbmc_project/state/host0";
     iface = "xyz.openbmc_project.State.Host";
-    ret[5] =
-        SDBusPlus::getProperty<std::string>(path, iface, "CurrentHostState");
+    ret[5] = SDBusPlus::getProperty<std::string>(path, iface,
+                                                 "CurrentHostState");
 
     return ret;
 }
@@ -724,8 +724,8 @@
 
 #ifdef CONTROL_USE_JSON
     // Query dump
-    auto cmdDumpQuery =
-        commands->add_subcommand("query_dump", "Query the dump file");
+    auto cmdDumpQuery = commands->add_subcommand("query_dump",
+                                                 "Query the dump file");
 
     cmdDumpQuery->set_help_flag("-h, --help", "Query the dump file");
     cmdDumpQuery
diff --git a/control/functor.hpp b/control/functor.hpp
index da5ffe1..1208aec 100644
--- a/control/functor.hpp
+++ b/control/functor.hpp
@@ -125,8 +125,8 @@
             }
 
             // Retrieve the property's value applying any visitors necessary
-            auto value =
-                zone.getPropertyValueVisitor<T>(_intf, _prop, it->second);
+            auto value = zone.getPropertyValueVisitor<T>(_intf, _prop,
+                                                         it->second);
 
             _handler(zone, _path, _intf, _prop, std::forward<T>(value));
         }
@@ -159,23 +159,23 @@
     {
         std::for_each(
             group.begin(), group.end(),
-            [&zone, handler = std::move(_handler)](auto const& member) {
-                auto path = std::get<pathPos>(member);
-                auto intf = std::get<intfPos>(member);
-                auto prop = std::get<propPos>(member);
-                try
-                {
-                    auto val = zone.getPropertyByName<T>(path, intf, prop);
-                    handler(zone, path, intf, prop, std::forward<T>(val));
-                }
-                catch (const sdbusplus::exception_t&)
-                {
-                    // Property value not sent to handler
-                }
-                catch (const util::DBusError&)
-                {
-                    // Property value not sent to handler
-                }
+            [&zone, handler = std::move(_handler)](const auto& member) {
+            auto path = std::get<pathPos>(member);
+            auto intf = std::get<intfPos>(member);
+            auto prop = std::get<propPos>(member);
+            try
+            {
+                auto val = zone.getPropertyByName<T>(path, intf, prop);
+                handler(zone, path, intf, prop, std::forward<T>(val));
+            }
+            catch (const sdbusplus::exception_t&)
+            {
+                // Property value not sent to handler
+            }
+            catch (const util::DBusError&)
+            {
+                // Property value not sent to handler
+            }
             });
     }
 
@@ -276,8 +276,8 @@
             }
 
             // Retrieve the property's value applying any visitors necessary
-            auto value =
-                zone.getPropertyValueVisitor<T>(_intf, _prop, itProp->second);
+            auto value = zone.getPropertyValueVisitor<T>(_intf, _prop,
+                                                         itProp->second);
 
             _handler(zone, _path, _intf, _prop, std::forward<T>(value));
         }
@@ -395,8 +395,7 @@
     NameOwner& operator=(const NameOwner&) = default;
     NameOwner(NameOwner&&) = default;
     NameOwner& operator=(NameOwner&&) = default;
-    explicit NameOwner(U&& handler) : _handler(std::forward<U>(handler))
-    {}
+    explicit NameOwner(U&& handler) : _handler(std::forward<U>(handler)) {}
 
     /** @brief Run signal handler function
      *
@@ -431,33 +430,32 @@
     {
         std::string name = "";
         bool hasOwner = false;
-        std::for_each(
-            group.begin(), group.end(),
-            [&zone, &group, &name, &hasOwner,
-             handler = std::move(_handler)](auto const& member) {
-                auto path = std::get<pathPos>(member);
-                auto intf = std::get<intfPos>(member);
-                try
+        std::for_each(group.begin(), group.end(),
+                      [&zone, &group, &name, &hasOwner,
+                       handler = std::move(_handler)](const auto& member) {
+            auto path = std::get<pathPos>(member);
+            auto intf = std::get<intfPos>(member);
+            try
+            {
+                auto servName = zone.getService(path, intf);
+                if (name != servName)
                 {
-                    auto servName = zone.getService(path, intf);
-                    if (name != servName)
-                    {
-                        name = servName;
-                        hasOwner = util::SDBusPlus::callMethodAndRead<bool>(
-                            zone.getBus(), "org.freedesktop.DBus",
-                            "/org/freedesktop/DBus", "org.freedesktop.DBus",
-                            "NameHasOwner", name);
-                        // Update service name owner state list of a group
-                        handler(zone, name, hasOwner);
-                    }
+                    name = servName;
+                    hasOwner = util::SDBusPlus::callMethodAndRead<bool>(
+                        zone.getBus(), "org.freedesktop.DBus",
+                        "/org/freedesktop/DBus", "org.freedesktop.DBus",
+                        "NameHasOwner", name);
+                    // Update service name owner state list of a group
+                    handler(zone, name, hasOwner);
                 }
-                catch (const util::DBusMethodError& e)
-                {
-                    // Failed to get service name owner state
-                    name = "";
-                    hasOwner = false;
-                }
-            });
+            }
+            catch (const util::DBusMethodError& e)
+            {
+                // Failed to get service name owner state
+                name = "";
+                hasOwner = false;
+            }
+        });
     }
 
   private:
diff --git a/control/json/actions/action.hpp b/control/json/actions/action.hpp
index cafa542..dcba6ea 100644
--- a/control/json/actions/action.hpp
+++ b/control/json/actions/action.hpp
@@ -154,11 +154,10 @@
      */
     virtual void addZone(Zone& zone)
     {
-        auto itZone =
-            std::find_if(_zones.begin(), _zones.end(),
-                         [&zone](std::reference_wrapper<Zone>& z) {
-                             return z.get().getName() == zone.getName();
-                         });
+        auto itZone = std::find_if(_zones.begin(), _zones.end(),
+                                   [&zone](std::reference_wrapper<Zone>& z) {
+            return z.get().getName() == zone.getName();
+        });
         if (itZone == _zones.end())
         {
             _zones.emplace_back(std::reference_wrapper<Zone>(zone));
@@ -225,8 +224,8 @@
         json groups = json::array();
         std::for_each(_groups.begin(), _groups.end(),
                       [&groups](const auto& group) {
-                          groups.push_back(group.getName());
-                      });
+            groups.push_back(group.getName());
+        });
         json output;
         output["groups"] = groups;
         return output;
@@ -333,11 +332,11 @@
         else
         {
             // Construct list of available actions
-            auto acts = std::accumulate(
-                std::next(actions.begin()), actions.end(),
-                actions.begin()->first, [](auto list, auto act) {
-                    return std::move(list) + ", " + act.first;
-                });
+            auto acts = std::accumulate(std::next(actions.begin()),
+                                        actions.end(), actions.begin()->first,
+                                        [](auto list, auto act) {
+                return std::move(list) + ", " + act.first;
+            });
             log<level::ERR>(
                 fmt::format("Action '{}' is not registered", name).c_str(),
                 entry("AVAILABLE_ACTIONS=%s", acts.c_str()));
diff --git a/control/json/actions/default_floor.cpp b/control/json/actions/default_floor.cpp
index 5ca3c10..f1cc4af 100644
--- a/control/json/actions/default_floor.cpp
+++ b/control/json/actions/default_floor.cpp
@@ -43,8 +43,8 @@
         auto isMissingOwner =
             std::any_of(members.begin(), members.end(),
                         [&intf = group.getInterface()](const auto& member) {
-                            return !Manager::hasOwner(member, intf);
-                        });
+            return !Manager::hasOwner(member, intf);
+            });
         if (isMissingOwner)
         {
             zone.setFloor(zone.getDefaultFloor());
diff --git a/control/json/actions/get_managed_objects.cpp b/control/json/actions/get_managed_objects.cpp
index eb5600e..099a68b 100644
--- a/control/json/actions/get_managed_objects.cpp
+++ b/control/json/actions/get_managed_objects.cpp
@@ -60,11 +60,11 @@
                 }
 
                 // Look for the ObjectManager as an ancestor of the path.
-                auto hasObjMgr = std::any_of(
-                    objMgrPaths.begin(), objMgrPaths.end(),
-                    [member](const auto& path) {
-                        return member.find(path) != std::string::npos;
-                    });
+                auto hasObjMgr = std::any_of(objMgrPaths.begin(),
+                                             objMgrPaths.end(),
+                                             [member](const auto& path) {
+                    return member.find(path) != std::string::npos;
+                });
 
                 if (!hasObjMgr || services.find(service) == services.end())
                 {
@@ -99,8 +99,8 @@
         // Add zone to _actions
         std::for_each(_actions.begin(), _actions.end(),
                       [&zone](std::unique_ptr<ActionBase>& action) {
-                          action->addZone(zone);
-                      });
+            action->addZone(zone);
+        });
     }
 }
 
diff --git a/control/json/actions/mapped_floor.cpp b/control/json/actions/mapped_floor.cpp
index 906559b..c947098 100644
--- a/control/json/actions/mapped_floor.cpp
+++ b/control/json/actions/mapped_floor.cpp
@@ -158,7 +158,6 @@
                 if (!floorEntry.contains("value") ||
                     !floorEntry.contains("floor"))
                 {
-
                     throw ActionParseError{
                         ActionBase::getName(),
                         "Missing value or floor entries in "
@@ -234,12 +233,11 @@
 {
     std::visit(
         [&value](auto&& val) {
-            using V = std::decay_t<decltype(val)>;
-            if constexpr (std::is_same_v<int32_t, V> ||
-                          std::is_same_v<int64_t, V>)
-            {
-                value = static_cast<double>(val);
-            }
+        using V = std::decay_t<decltype(val)>;
+        if constexpr (std::is_same_v<int32_t, V> || std::is_same_v<int64_t, V>)
+        {
+            value = static_cast<double>(val);
+        }
         },
         value);
 }
@@ -264,16 +262,16 @@
             {
                 std::visit(
                     [&group, this](auto&& val) {
-                        using V = std::decay_t<decltype(val)>;
-                        if constexpr (!std::is_same_v<double, V> &&
-                                      !std::is_same_v<int32_t, V> &&
-                                      !std::is_same_v<int64_t, V>)
-                        {
-                            throw std::runtime_error{fmt::format(
-                                "{}: Group {} has more than one member but "
-                                "isn't numeric",
-                                ActionBase::getName(), group.getName())};
-                        }
+                    using V = std::decay_t<decltype(val)>;
+                    if constexpr (!std::is_same_v<double, V> &&
+                                  !std::is_same_v<int32_t, V> &&
+                                  !std::is_same_v<int64_t, V>)
+                    {
+                        throw std::runtime_error{fmt::format(
+                            "{}: Group {} has more than one member but "
+                            "isn't numeric",
+                            ActionBase::getName(), group.getName())};
+                    }
                     },
                     value);
                 checked = true;
diff --git a/control/json/actions/missing_owner_target.cpp b/control/json/actions/missing_owner_target.cpp
index ccafdc2..30f91b4 100644
--- a/control/json/actions/missing_owner_target.cpp
+++ b/control/json/actions/missing_owner_target.cpp
@@ -47,8 +47,8 @@
         auto isMissingOwner =
             std::any_of(members.begin(), members.end(),
                         [&intf = group.getInterface()](const auto& member) {
-                            return !Manager::hasOwner(member, intf);
-                        });
+            return !Manager::hasOwner(member, intf);
+            });
         // Update zone's target hold based on action results
         zone.setTargetHold(group.getName(), _target, isMissingOwner);
     }
diff --git a/control/json/actions/net_target_increase.cpp b/control/json/actions/net_target_increase.cpp
index cc08cfa..878dd3f 100644
--- a/control/json/actions/net_target_increase.cpp
+++ b/control/json/actions/net_target_increase.cpp
@@ -44,7 +44,6 @@
 
 void NetTargetIncrease::run(Zone& zone)
 {
-
     if (!_stateParameter.empty())
     {
         auto s = Manager::getParameter(_stateParameter);
@@ -59,80 +58,77 @@
     for (const auto& group : _groups)
     {
         const auto& members = group.getMembers();
-        std::for_each(
-            members.begin(), members.end(),
-            [this, &zone, &group, &netDelta](const auto& member) {
-                try
+        std::for_each(members.begin(), members.end(),
+                      [this, &zone, &group, &netDelta](const auto& member) {
+            try
+            {
+                auto value = Manager::getObjValueVariant(
+                    member, group.getInterface(), group.getProperty());
+                if (std::holds_alternative<int64_t>(value) ||
+                    std::holds_alternative<double>(value))
                 {
-                    auto value = Manager::getObjValueVariant(
-                        member, group.getInterface(), group.getProperty());
-                    if (std::holds_alternative<int64_t>(value) ||
-                        std::holds_alternative<double>(value))
+                    // Where a group of int/doubles are greater than or
+                    // equal to the state(some value) provided, request an
+                    // increase of the configured delta times the difference
+                    // between the group member's value and configured state
+                    // value.
+                    if (value >= _state)
                     {
-                        // Where a group of int/doubles are greater than or
-                        // equal to the state(some value) provided, request an
-                        // increase of the configured delta times the difference
-                        // between the group member's value and configured state
-                        // value.
-                        if (value >= _state)
+                        uint64_t incDelta = 0;
+                        if (auto dblPtr = std::get_if<double>(&value))
                         {
-                            uint64_t incDelta = 0;
-                            if (auto dblPtr = std::get_if<double>(&value))
-                            {
-                                incDelta = static_cast<uint64_t>(
-                                    (*dblPtr - std::get<double>(_state)) *
-                                    _delta);
-                            }
-                            else
-                            {
-                                // Increase by at least a single delta
-                                // to attempt bringing under provided 'state'
-                                auto deltaFactor =
-                                    std::max((std::get<int64_t>(value) -
-                                              std::get<int64_t>(_state)),
-                                             int64_t(1));
-                                incDelta =
-                                    static_cast<uint64_t>(deltaFactor * _delta);
-                            }
-                            netDelta = std::max(netDelta, incDelta);
+                            incDelta = static_cast<uint64_t>(
+                                (*dblPtr - std::get<double>(_state)) * _delta);
                         }
-                    }
-                    else if (std::holds_alternative<bool>(value))
-                    {
-                        // Where a group of booleans equal the state(`true` or
-                        // `false`) provided, request an increase of the
-                        // configured delta
-                        if (_state == value)
+                        else
                         {
-                            netDelta = std::max(netDelta, _delta);
+                            // Increase by at least a single delta
+                            // to attempt bringing under provided 'state'
+                            auto deltaFactor =
+                                std::max((std::get<int64_t>(value) -
+                                          std::get<int64_t>(_state)),
+                                         int64_t(1));
+                            incDelta =
+                                static_cast<uint64_t>(deltaFactor * _delta);
                         }
-                    }
-                    else if (std::holds_alternative<std::string>(value))
-                    {
-                        // Where a group of strings equal the state(some string)
-                        // provided, request an increase of the configured delta
-                        if (_state == value)
-                        {
-                            netDelta = std::max(netDelta, _delta);
-                        }
-                    }
-                    else
-                    {
-                        // Unsupported group member type for this action
-                        log<level::ERR>(
-                            fmt::format(
-                                "Action {}: Unsupported group member type "
-                                "given. [object = {} : {} : {}]",
-                                ActionBase::getName(), member,
-                                group.getInterface(), group.getProperty())
-                                .c_str());
+                        netDelta = std::max(netDelta, incDelta);
                     }
                 }
-                catch (const std::out_of_range& oore)
+                else if (std::holds_alternative<bool>(value))
                 {
-                    // Property value not found, netDelta unchanged
+                    // Where a group of booleans equal the state(`true` or
+                    // `false`) provided, request an increase of the
+                    // configured delta
+                    if (_state == value)
+                    {
+                        netDelta = std::max(netDelta, _delta);
+                    }
                 }
-            });
+                else if (std::holds_alternative<std::string>(value))
+                {
+                    // Where a group of strings equal the state(some string)
+                    // provided, request an increase of the configured delta
+                    if (_state == value)
+                    {
+                        netDelta = std::max(netDelta, _delta);
+                    }
+                }
+                else
+                {
+                    // Unsupported group member type for this action
+                    log<level::ERR>(
+                        fmt::format("Action {}: Unsupported group member type "
+                                    "given. [object = {} : {} : {}]",
+                                    ActionBase::getName(), member,
+                                    group.getInterface(), group.getProperty())
+                            .c_str());
+                }
+            }
+            catch (const std::out_of_range& oore)
+            {
+                // Property value not found, netDelta unchanged
+            }
+        });
     }
     // Request increase to target
     zone.requestIncrease(netDelta);
diff --git a/control/json/actions/pcie_card_floors.cpp b/control/json/actions/pcie_card_floors.cpp
index 6c465f3..3d242d3 100644
--- a/control/json/actions/pcie_card_floors.cpp
+++ b/control/json/actions/pcie_card_floors.cpp
@@ -221,8 +221,8 @@
         auto deviceID = getPCIeDeviceProperty(card, deviceIDProp);
         auto vendorID = getPCIeDeviceProperty(card, vendorIDProp);
         auto subsystemID = getPCIeDeviceProperty(card, subsystemIDProp);
-        auto subsystemVendorID =
-            getPCIeDeviceProperty(card, subsystemVendorIDProp);
+        auto subsystemVendorID = getPCIeDeviceProperty(card,
+                                                       subsystemVendorIDProp);
 
         return _cardMetadata->lookup(deviceID, vendorID, subsystemID,
                                      subsystemVendorID);
@@ -251,10 +251,10 @@
 
     // Find the card that plugs in this slot based on if the
     // slot is part of the path, like slotA/cardA
-    auto it = std::find_if(
-        _pcieDevices.begin(), _pcieDevices.end(), [slotPath](const auto& path) {
-            return path.find(slotPath + '/') != std::string::npos;
-        });
+    auto it = std::find_if(_pcieDevices.begin(), _pcieDevices.end(),
+                           [slotPath](const auto& path) {
+        return path.find(slotPath + '/') != std::string::npos;
+    });
 
     if (it == _pcieDevices.end())
     {
diff --git a/control/json/actions/pcie_card_floors.hpp b/control/json/actions/pcie_card_floors.hpp
index a662a6d..081f409 100644
--- a/control/json/actions/pcie_card_floors.hpp
+++ b/control/json/actions/pcie_card_floors.hpp
@@ -106,8 +106,7 @@
      * to distinguish it from ones under different events and also it just
      * makes it uglier in the flight recorder.
      */
-    void setEventName(const std::string& /*name*/) override
-    {}
+    void setEventName(const std::string& /*name*/) override {}
 
   private:
     /**
diff --git a/control/json/actions/set_parameter_from_group_max.cpp b/control/json/actions/set_parameter_from_group_max.cpp
index c7d18a1..b42f582 100644
--- a/control/json/actions/set_parameter_from_group_max.cpp
+++ b/control/json/actions/set_parameter_from_group_max.cpp
@@ -64,19 +64,19 @@
                 bool invalid = false;
                 std::visit(
                     [&group, &invalid, this](auto&& val) {
-                        using V = std::decay_t<decltype(val)>;
-                        if constexpr (!std::is_same_v<double, V> &&
-                                      !std::is_same_v<int32_t, V> &&
-                                      !std::is_same_v<int64_t, V>)
-                        {
-                            log<level::ERR>(fmt::format("{}: Group {} has more "
-                                                        "than one member but "
-                                                        "isn't numeric",
-                                                        ActionBase::getName(),
-                                                        group.getName())
-                                                .c_str());
-                            invalid = true;
-                        }
+                    using V = std::decay_t<decltype(val)>;
+                    if constexpr (!std::is_same_v<double, V> &&
+                                  !std::is_same_v<int32_t, V> &&
+                                  !std::is_same_v<int64_t, V>)
+                    {
+                        log<level::ERR>(fmt::format("{}: Group {} has more "
+                                                    "than one member but "
+                                                    "isn't numeric",
+                                                    ActionBase::getName(),
+                                                    group.getName())
+                                            .c_str());
+                        invalid = true;
+                    }
                     },
                     value);
                 if (invalid)
diff --git a/control/json/actions/target_from_group_max.cpp b/control/json/actions/target_from_group_max.cpp
index ef19cdb..79cacf8 100644
--- a/control/json/actions/target_from_group_max.cpp
+++ b/control/json/actions/target_from_group_max.cpp
@@ -138,7 +138,6 @@
     {
         for (const auto& map : jsonObj.at("map"))
         {
-
             if (!map.contains("value") || !map.contains("target"))
             {
                 throw ActionParseError{ActionBase::getName(),
@@ -187,18 +186,18 @@
             // considered numeric here.
             std::visit(
                 [&group, &invalid, this](auto&& val) {
-                    using V = std::decay_t<decltype(val)>;
-                    if constexpr (!std::is_same_v<double, V> &&
-                                  !std::is_same_v<int32_t, V> &&
-                                  !std::is_same_v<int64_t, V>)
-                    {
-                        log<level::ERR>(fmt::format("{}: Group {}'s member "
-                                                    "isn't numeric",
-                                                    ActionBase::getName(),
-                                                    group.getName())
-                                            .c_str());
-                        invalid = true;
-                    }
+                using V = std::decay_t<decltype(val)>;
+                if constexpr (!std::is_same_v<double, V> &&
+                              !std::is_same_v<int32_t, V> &&
+                              !std::is_same_v<int64_t, V>)
+                {
+                    log<level::ERR>(fmt::format("{}: Group {}'s member "
+                                                "isn't numeric",
+                                                ActionBase::getName(),
+                                                group.getName())
+                                        .c_str());
+                    invalid = true;
+                }
                 },
                 value);
             if (invalid)
diff --git a/control/json/actions/timer_based_actions.cpp b/control/json/actions/timer_based_actions.cpp
index dd5f5ce..e3f3fec 100644
--- a/control/json/actions/timer_based_actions.cpp
+++ b/control/json/actions/timer_based_actions.cpp
@@ -43,10 +43,10 @@
 {
     // If any of groups' value == nullopt(i.e. not configured), action is
     // driven by the service owned state of the group members
-    _byOwner =
-        std::any_of(_groups.begin(), _groups.end(), [](const auto& group) {
-            return group.getValue() == std::nullopt;
-        });
+    _byOwner = std::any_of(_groups.begin(), _groups.end(),
+                           [](const auto& group) {
+        return group.getValue() == std::nullopt;
+    });
 
     setTimerConf(jsonObj);
     setActions(jsonObj);
@@ -62,9 +62,8 @@
                 const auto& members = group.getMembers();
                 return std::any_of(members.begin(), members.end(),
                                    [&group](const auto& member) {
-                                       return !Manager::hasOwner(
-                                           member, group.getInterface());
-                                   });
+                return !Manager::hasOwner(member, group.getInterface());
+                });
             }))
         {
             startTimer();
@@ -80,18 +79,16 @@
         // If all group members have a given value and it matches what's
         // in the cache, start timer and if any do not match, stop
         // timer.
-        if (std::all_of(
-                _groups.begin(), _groups.end(), [&mgr](const auto& group) {
-                    const auto& members = group.getMembers();
-                    return std::all_of(members.begin(), members.end(),
-                                       [&mgr, &group](const auto& member) {
-                                           return group.getValue() ==
-                                                  mgr->getProperty(
-                                                      member,
-                                                      group.getInterface(),
-                                                      group.getProperty());
-                                       });
-                }))
+        if (std::all_of(_groups.begin(), _groups.end(),
+                        [&mgr](const auto& group) {
+            const auto& members = group.getMembers();
+            return std::all_of(members.begin(), members.end(),
+                               [&mgr, &group](const auto& member) {
+                return group.getValue() ==
+                       mgr->getProperty(member, group.getInterface(),
+                                        group.getProperty());
+            });
+            }))
         {
             // Timer will be started(and never stopped) when _groups is empty
             startTimer();
@@ -148,8 +145,8 @@
         // Add zone to _actions
         std::for_each(_actions.begin(), _actions.end(),
                       [&zone](std::unique_ptr<ActionBase>& action) {
-                          action->addZone(zone);
-                      });
+            action->addZone(zone);
+        });
     }
 }
 
diff --git a/control/json/dbus_zone.cpp b/control/json/dbus_zone.cpp
index 733fb94..6397151 100644
--- a/control/json/dbus_zone.cpp
+++ b/control/json/dbus_zone.cpp
@@ -50,11 +50,11 @@
     std::transform(value.begin(), value.end(), value.begin(), toupper);
 
     auto supported = ThermalModeIntf::supported();
-    auto isSupported =
-        std::any_of(supported.begin(), supported.end(), [&value](auto& s) {
-            std::transform(s.begin(), s.end(), s.begin(), toupper);
-            return value == s;
-        });
+    auto isSupported = std::any_of(supported.begin(), supported.end(),
+                                   [&value](auto& s) {
+        std::transform(s.begin(), s.end(), s.begin(), toupper);
+        return value == s;
+    });
 
     if (isSupported && value != current)
     {
diff --git a/control/json/event.cpp b/control/json/event.cpp
index 409006a..74f2ddf 100644
--- a/control/json/event.cpp
+++ b/control/json/event.cpp
@@ -158,9 +158,8 @@
                 std::make_pair(jsonGrp["name"].get<std::string>(), profiles);
             auto grpEntry = std::find_if(availGroups.begin(), availGroups.end(),
                                          [&eventProfile](const auto& grp) {
-                                             return Manager::inConfig(
-                                                 grp.first, eventProfile);
-                                         });
+                return Manager::inConfig(grp.first, eventProfile);
+            });
             if (grpEntry != availGroups.end())
             {
                 auto group = Group(*grpEntry->second);
@@ -190,13 +189,12 @@
             // against all zones matching the event's active profiles
             for (const auto& zone : _zones)
             {
-                configKey eventProfile =
-                    std::make_pair(zone.second->getName(), _profiles);
+                configKey eventProfile = std::make_pair(zone.second->getName(),
+                                                        _profiles);
                 auto zoneEntry = std::find_if(_zones.begin(), _zones.end(),
                                               [&eventProfile](const auto& z) {
-                                                  return Manager::inConfig(
-                                                      z.first, eventProfile);
-                                              });
+                    return Manager::inConfig(z.first, eventProfile);
+                });
                 if (zoneEntry != _zones.end())
                 {
                     actionZones.emplace_back(*zoneEntry->second);
@@ -213,9 +211,8 @@
                     std::make_pair(jsonZone.get<std::string>(), _profiles);
                 auto zoneEntry = std::find_if(_zones.begin(), _zones.end(),
                                               [&eventProfile](const auto& z) {
-                                                  return Manager::inConfig(
-                                                      z.first, eventProfile);
-                                              });
+                    return Manager::inConfig(z.first, eventProfile);
+                });
                 if (zoneEntry != _zones.end())
                 {
                     actionZones.emplace_back(*zoneEntry->second);
@@ -318,14 +315,14 @@
     json actionData;
     std::for_each(_actions.begin(), _actions.end(),
                   [&actionData](const auto& action) {
-                      actionData[action->getUniqueName()] = action->dump();
-                  });
+        actionData[action->getUniqueName()] = action->dump();
+    });
 
     std::vector<std::string> groupData;
     std::for_each(_groups.begin(), _groups.end(),
                   [&groupData](const auto& group) {
-                      groupData.push_back(group.getName());
-                  });
+        groupData.push_back(group.getName());
+    });
 
     json eventData;
     eventData["groups"] = groupData;
diff --git a/control/json/fan.cpp b/control/json/fan.cpp
index fdabea2..26b2174 100644
--- a/control/json/fan.cpp
+++ b/control/json/fan.cpp
@@ -144,9 +144,10 @@
 void Fan::unlockTarget(uint64_t target)
 {
     // find and remove the requested lock
-    auto itr(std::find_if(
-        _lockedTargets.begin(), _lockedTargets.end(),
-        [target](auto lockedTarget) { return target == lockedTarget; }));
+    auto itr(std::find_if(_lockedTargets.begin(), _lockedTargets.end(),
+                          [target](auto lockedTarget) {
+        return target == lockedTarget;
+    }));
 
     if (_lockedTargets.end() != itr)
     {
@@ -155,8 +156,8 @@
         // if additional locks, re-lock at next-highest target
         if (!_lockedTargets.empty())
         {
-            itr =
-                std::max_element(_lockedTargets.begin(), _lockedTargets.end());
+            itr = std::max_element(_lockedTargets.begin(),
+                                   _lockedTargets.end());
 
             // setTarget wont work if any locked targets exist
             decltype(_lockedTargets) temp;
diff --git a/control/json/manager.cpp b/control/json/manager.cpp
index 8adc80c..fe5fc0d 100644
--- a/control/json/manager.cpp
+++ b/control/json/manager.cpp
@@ -168,12 +168,12 @@
         auto fans = getConfig<Fan>(false);
         for (auto& fan : fans)
         {
-            configKey fanProfile =
-                std::make_pair(fan.second->getZone(), fan.first.second);
-            auto itZone = std::find_if(
-                zones.begin(), zones.end(), [&fanProfile](const auto& zone) {
-                    return Manager::inConfig(fanProfile, zone.first);
-                });
+            configKey fanProfile = std::make_pair(fan.second->getZone(),
+                                                  fan.first.second);
+            auto itZone = std::find_if(zones.begin(), zones.end(),
+                                       [&fanProfile](const auto& zone) {
+                return Manager::inConfig(fanProfile, zone.first);
+            });
             if (itZone != zones.end())
             {
                 if (itZone->second->getTarget() != fan.second->getTarget() &&
@@ -271,21 +271,19 @@
     {
         // Profiles must have one match in the other's profiles(and they must be
         // an active profile) to be used in the config
-        return std::any_of(
-            input.second.begin(), input.second.end(),
-            [&comp](const auto& lProfile) {
-                return std::any_of(
-                    comp.second.begin(), comp.second.end(),
-                    [&lProfile](const auto& rProfile) {
-                        if (lProfile != rProfile)
-                        {
-                            return false;
-                        }
-                        auto activeProfs = getActiveProfiles();
-                        return std::find(activeProfs.begin(), activeProfs.end(),
-                                         lProfile) != activeProfs.end();
-                    });
+        return std::any_of(input.second.begin(), input.second.end(),
+                           [&comp](const auto& lProfile) {
+            return std::any_of(comp.second.begin(), comp.second.end(),
+                               [&lProfile](const auto& rProfile) {
+                if (lProfile != rProfile)
+                {
+                    return false;
+                }
+                auto activeProfs = getActiveProfiles();
+                return std::find(activeProfs.begin(), activeProfs.end(),
+                                 lProfile) != activeProfs.end();
             });
+        });
     }
 }
 
@@ -341,9 +339,10 @@
     // Set owner state for specific object given
     auto& ownIntf = _servTree[path][serv];
     ownIntf.first = isOwned;
-    auto itIntf = std::find_if(
-        ownIntf.second.begin(), ownIntf.second.end(),
-        [&intf](const auto& interface) { return intf == interface; });
+    auto itIntf = std::find_if(ownIntf.second.begin(), ownIntf.second.end(),
+                               [&intf](const auto& interface) {
+        return intf == interface;
+    });
     if (itIntf == std::end(ownIntf.second))
     {
         ownIntf.second.emplace_back(intf);
@@ -427,8 +426,8 @@
                 {
                     // Service not found in cache
                     auto intfs = {intf};
-                    pathIter->second[itServ.first] =
-                        std::make_pair(true, intfs);
+                    pathIter->second[itServ.first] = std::make_pair(true,
+                                                                    intfs);
                 }
             }
         }
@@ -680,11 +679,11 @@
 
                     // Look for the ObjectManager as an ancestor from the
                     // member.
-                    auto hasObjMgr = std::any_of(
-                        objMgrPaths.begin(), objMgrPaths.end(),
-                        [&member](const auto& path) {
-                            return member.find(path) != std::string::npos;
-                        });
+                    auto hasObjMgr = std::any_of(objMgrPaths.begin(),
+                                                 objMgrPaths.end(),
+                                                 [&member](const auto& path) {
+                        return member.find(path) != std::string::npos;
+                    });
 
                     if (!hasObjMgr)
                     {
@@ -745,12 +744,12 @@
     // Remove oneshot timers after they expired
     if (data.first == TimerType::oneshot)
     {
-        auto itTimer = std::find_if(
-            _timers.begin(), _timers.end(), [&data](const auto& timer) {
-                return (data.first == timer.first->first &&
-                        (std::get<std::string>(data.second) ==
-                         std::get<std::string>(timer.first->second)));
-            });
+        auto itTimer = std::find_if(_timers.begin(), _timers.end(),
+                                    [&data](const auto& timer) {
+            return (data.first == timer.first->first &&
+                    (std::get<std::string>(data.second) ==
+                     std::get<std::string>(timer.first->second)));
+        });
         if (itTimer != std::end(_timers))
         {
             _timers.erase(itTimer);
@@ -788,8 +787,8 @@
 void Manager::setProfiles()
 {
     // Profiles JSON config file is optional
-    auto confFile =
-        fan::JsonConfig::getConfFile(confAppName, Profile::confFileName, true);
+    auto confFile = fan::JsonConfig::getConfFile(confAppName,
+                                                 Profile::confFileName, true);
 
     _profiles.clear();
     if (!confFile.empty())
@@ -823,16 +822,16 @@
     {
         std::for_each(actions.begin(), actions.end(),
                       [&actList = it->second](auto& action) {
-                          actList.emplace_back(std::ref(action));
-                      });
+            actList.emplace_back(std::ref(action));
+        });
     }
     else
     {
         TriggerActions triggerActions;
         std::for_each(actions.begin(), actions.end(),
                       [&triggerActions](auto& action) {
-                          triggerActions.emplace_back(std::ref(action));
-                      });
+            triggerActions.emplace_back(std::ref(action));
+        });
         _parameterTriggers[name] = std::move(triggerActions);
     }
 }
diff --git a/control/json/manager.hpp b/control/json/manager.hpp
index c169919..ad92720 100644
--- a/control/json/manager.hpp
+++ b/control/json/manager.hpp
@@ -227,18 +227,16 @@
                     if (!profiles.empty() &&
                         !std::any_of(profiles.begin(), profiles.end(),
                                      [](const auto& name) {
-                                         return std::find(
-                                                    getActiveProfiles().begin(),
-                                                    getActiveProfiles().end(),
-                                                    name) !=
-                                                getActiveProfiles().end();
-                                     }))
+                        return std::find(getActiveProfiles().begin(),
+                                         getActiveProfiles().end(),
+                                         name) != getActiveProfiles().end();
+                        }))
                     {
                         continue;
                     }
                 }
-                auto obj =
-                    std::make_unique<T>(entry, std::forward<Args>(args)...);
+                auto obj = std::make_unique<T>(entry,
+                                               std::forward<Args>(args)...);
                 config.emplace(
                     std::make_pair(obj->getName(), obj->getProfiles()),
                     std::move(obj));
diff --git a/control/json/profile.cpp b/control/json/profile.cpp
index 0778820..7cb818b 100644
--- a/control/json/profile.cpp
+++ b/control/json/profile.cpp
@@ -60,11 +60,11 @@
     else
     {
         // Construct list of available methods
-        auto methods = std::accumulate(
-            std::next(_methods.begin()), _methods.end(),
-            _methods.begin()->first, [](auto list, auto method) {
-                return std::move(list) + ", " + method.first;
-            });
+        auto methods = std::accumulate(std::next(_methods.begin()),
+                                       _methods.end(), _methods.begin()->first,
+                                       [](auto list, auto method) {
+            return std::move(list) + ", " + method.first;
+        });
         log<level::ERR>("Configured method not available",
                         entry("JSON=%s", jsonObj["method"].dump().c_str()),
                         entry("METHODS_AVAILABLE=%s", methods.c_str()));
@@ -81,26 +81,23 @@
             "Missing required all_of method properties list");
     }
 
-    return std::all_of(
-        method["properties"].begin(), method["properties"].end(),
-        [](const json& obj) {
-            if (!obj.contains("path") || !obj.contains("interface") ||
-                !obj.contains("property") || !obj.contains("value"))
-            {
-                log<level::ERR>(
-                    "Missing required all_of method property parameters",
-                    entry("JSON=%s", obj.dump().c_str()));
-                throw std::runtime_error(
-                    "Missing required all_of method parameters");
-            }
-            auto variant =
-                util::SDBusPlus::getPropertyVariant<PropertyVariantType>(
-                    obj["path"].get<std::string>(),
-                    obj["interface"].get<std::string>(),
-                    obj["property"].get<std::string>());
+    return std::all_of(method["properties"].begin(), method["properties"].end(),
+                       [](const json& obj) {
+        if (!obj.contains("path") || !obj.contains("interface") ||
+            !obj.contains("property") || !obj.contains("value"))
+        {
+            log<level::ERR>(
+                "Missing required all_of method property parameters",
+                entry("JSON=%s", obj.dump().c_str()));
+            throw std::runtime_error(
+                "Missing required all_of method parameters");
+        }
+        auto variant = util::SDBusPlus::getPropertyVariant<PropertyVariantType>(
+            obj["path"].get<std::string>(), obj["interface"].get<std::string>(),
+            obj["property"].get<std::string>());
 
-            return getJsonValue(obj["value"]) == variant;
-        });
+        return getJsonValue(obj["value"]) == variant;
+    });
 }
 
 } // namespace phosphor::fan::control::json
diff --git a/control/json/triggers/handlers.hpp b/control/json/triggers/handlers.hpp
index 34271c2..8e8595f 100644
--- a/control/json/triggers/handlers.hpp
+++ b/control/json/triggers/handlers.hpp
@@ -16,7 +16,6 @@
 
 struct Handlers
 {
-
   public:
     /**
      * @brief Processes a properties changed signal and updates the property's
@@ -113,8 +112,8 @@
 
         std::vector<std::string> intfs;
         msg.read(intfs);
-        auto itIntf =
-            std::find(intfs.begin(), intfs.end(), std::get<Intf>(obj));
+        auto itIntf = std::find(intfs.begin(), intfs.end(),
+                                std::get<Intf>(obj));
         if (itIntf == intfs.cend())
         {
             // Object's interface not in list of interfaces removed
diff --git a/control/json/triggers/init.cpp b/control/json/triggers/init.cpp
index 7452584..f51a09e 100644
--- a/control/json/triggers/init.cpp
+++ b/control/json/triggers/init.cpp
@@ -160,11 +160,12 @@
         if (!groups.empty() && handler == methods.end())
         {
             // Construct list of available methods
-            auto availMethods = std::accumulate(
-                std::next(methods.begin()), methods.end(),
-                methods.begin()->first, [](auto list, auto method) {
-                    return std::move(list) + ", " + method.first;
-                });
+            auto availMethods = std::accumulate(std::next(methods.begin()),
+                                                methods.end(),
+                                                methods.begin()->first,
+                                                [](auto list, auto method) {
+                return std::move(list) + ", " + method.first;
+            });
             auto msg =
                 fmt::format("Event '{}' requires a supported method given to "
                             "be init driven, available methods: {}",
diff --git a/control/json/triggers/signal.cpp b/control/json/triggers/signal.cpp
index 5cef58d..7169d69 100644
--- a/control/json/triggers/signal.cpp
+++ b/control/json/triggers/signal.cpp
@@ -101,8 +101,8 @@
     {
         // Setup property changed signal handler on the group member's
         // property
-        const auto match =
-            rules::propertiesChanged(member, group.getInterface());
+        const auto match = rules::propertiesChanged(member,
+                                                    group.getInterface());
         SignalPkg signalPkg = {Handlers::propertiesChanged,
                                SignalObject(std::cref(member),
                                             std::cref(group.getInterface()),
@@ -125,8 +125,8 @@
     for (const auto& member : group.getMembers())
     {
         // Setup interfaces added signal handler on the group member
-        const auto match =
-            rules::interfacesAdded() + rules::argNpath(0, member);
+        const auto match = rules::interfacesAdded() +
+                           rules::argNpath(0, member);
         SignalPkg signalPkg = {Handlers::interfacesAdded,
                                SignalObject(std::cref(member),
                                             std::cref(group.getInterface()),
@@ -149,8 +149,8 @@
     for (const auto& member : group.getMembers())
     {
         // Setup interfaces removed signal handler on the group member
-        const auto match =
-            rules::interfacesRemoved() + rules::argNpath(0, member);
+        const auto match = rules::interfacesRemoved() +
+                           rules::argNpath(0, member);
         SignalPkg signalPkg = {Handlers::interfacesRemoved,
                                SignalObject(std::cref(member),
                                             std::cref(group.getInterface()),
@@ -250,11 +250,11 @@
     if (subscriber == signals.end())
     {
         // Construct list of available signals
-        auto availSignals =
-            std::accumulate(std::next(signals.begin()), signals.end(),
-                            signals.begin()->first, [](auto list, auto signal) {
-                                return std::move(list) + ", " + signal.first;
-                            });
+        auto availSignals = std::accumulate(
+            std::next(signals.begin()), signals.end(), signals.begin()->first,
+            [](auto list, auto signal) {
+            return std::move(list) + ", " + signal.first;
+            });
         auto msg =
             fmt::format("Event '{}' requires a supported signal given to be "
                         "triggered by signal, available signals: {}",
@@ -270,8 +270,8 @@
         TriggerActions signalActions;
         std::for_each(actions.begin(), actions.end(),
                       [&signalActions](auto& action) {
-                          signalActions.emplace_back(std::ref(action));
-                      });
+            signalActions.emplace_back(std::ref(action));
+        });
         for (const auto& group : groups)
         {
             // Call signal subscriber for each group
diff --git a/control/json/utils/flight_recorder.cpp b/control/json/utils/flight_recorder.cpp
index 71d4afd..8c8ce06 100644
--- a/control/json/utils/flight_recorder.cpp
+++ b/control/json/utils/flight_recorder.cpp
@@ -71,8 +71,8 @@
 
     std::sort(output.begin(), output.end(),
               [](const auto& left, const auto& right) {
-                  return std::get<Timepoint>(left) < std::get<Timepoint>(right);
-              });
+        return std::get<Timepoint>(left) < std::get<Timepoint>(right);
+    });
 
     auto formatTime = [](const Timepoint& tp) {
         std::stringstream ss;
diff --git a/control/json/utils/pcie_card_metadata.cpp b/control/json/utils/pcie_card_metadata.cpp
index 8e65c7c..6fd8fd1 100644
--- a/control/json/utils/pcie_card_metadata.cpp
+++ b/control/json/utils/pcie_card_metadata.cpp
@@ -119,10 +119,10 @@
         }
 
         Metadata data;
-        data.vendorID =
-            std::stoul(card.at("vendor_id").get<std::string>(), nullptr, 16);
-        data.deviceID =
-            std::stoul(card.at("device_id").get<std::string>(), nullptr, 16);
+        data.vendorID = std::stoul(card.at("vendor_id").get<std::string>(),
+                                   nullptr, 16);
+        data.deviceID = std::stoul(card.at("device_id").get<std::string>(),
+                                   nullptr, 16);
         data.subsystemVendorID = std::stoul(
             card.at("subsystem_vendor_id").get<std::string>(), nullptr, 16);
         data.subsystemID =
@@ -172,15 +172,13 @@
     log<level::DEBUG>(fmt::format("Lookup {:#x} ${:#x} {:#x} {:#x}", deviceID,
                                   vendorID, subsystemID, subsystemVendorID)
                           .c_str());
-    auto card =
-        std::find_if(_cards.begin(), _cards.end(),
-                     [&deviceID, &vendorID, &subsystemID,
-                      &subsystemVendorID](const auto& card) {
-                         return (deviceID == card.deviceID) &&
-                                (vendorID == card.vendorID) &&
-                                (subsystemID == card.subsystemID) &&
-                                (subsystemVendorID == card.subsystemVendorID);
-                     });
+    auto card = std::find_if(_cards.begin(), _cards.end(),
+                             [&deviceID, &vendorID, &subsystemID,
+                              &subsystemVendorID](const auto& card) {
+        return (deviceID == card.deviceID) && (vendorID == card.vendorID) &&
+               (subsystemID == card.subsystemID) &&
+               (subsystemVendorID == card.subsystemVendorID);
+    });
 
     if (card != _cards.end())
     {
diff --git a/control/json/zone.cpp b/control/json/zone.cpp
index ea308b7..2e31465 100644
--- a/control/json/zone.cpp
+++ b/control/json/zone.cpp
@@ -161,10 +161,10 @@
 
 void Zone::lockFanTarget(const std::string& fname, uint64_t target)
 {
-    auto fanItr =
-        std::find_if(_fans.begin(), _fans.end(), [&fname](const auto& fan) {
-            return fan->getName() == fname;
-        });
+    auto fanItr = std::find_if(_fans.begin(), _fans.end(),
+                               [&fname](const auto& fan) {
+        return fan->getName() == fname;
+    });
 
     if (_fans.end() != fanItr)
     {
@@ -181,10 +181,10 @@
 
 void Zone::unlockFanTarget(const std::string& fname, uint64_t target)
 {
-    auto fanItr =
-        std::find_if(_fans.begin(), _fans.end(), [&fname](const auto& fan) {
-            return fan->getName() == fname;
-        });
+    auto fanItr = std::find_if(_fans.begin(), _fans.end(),
+                               [&fname](const auto& fan) {
+        return fan->getName() == fname;
+    });
 
     if (_fans.end() != fanItr)
     {
@@ -232,8 +232,8 @@
 
     auto itHoldMax = std::max_element(_targetHolds.begin(), _targetHolds.end(),
                                       [](const auto& aHold, const auto& bHold) {
-                                          return aHold.second < bHold.second;
-                                      });
+        return aHold.second < bHold.second;
+    });
     if (itHoldMax == _targetHolds.end())
     {
         _isActive = true;
@@ -295,8 +295,8 @@
 
     auto itHoldMax = std::max_element(_floorHolds.begin(), _floorHolds.end(),
                                       [](const auto& aHold, const auto& bHold) {
-                                          return aHold.second < bHold.second;
-                                      });
+        return aHold.second < bHold.second;
+    });
     if (itHoldMax == _floorHolds.end())
     {
         if (_floor != _defaultFloor)
@@ -380,7 +380,7 @@
 void Zone::decTimerExpired()
 {
     // Check all entries are set to allow a decrease
-    auto pred = [](auto const& entry) { return entry.second; };
+    auto pred = [](const auto& entry) { return entry.second; };
     auto decAllowed = std::all_of(_decAllowed.begin(), _decAllowed.end(), pred);
 
     // Only decrease targets when allowed, a requested decrease target delta
@@ -460,11 +460,12 @@
         if (propFuncs == _intfPropHandlers.end())
         {
             // Construct list of available configurable interfaces
-            auto intfs = std::accumulate(
-                std::next(_intfPropHandlers.begin()), _intfPropHandlers.end(),
-                _intfPropHandlers.begin()->first, [](auto list, auto intf) {
-                    return std::move(list) + ", " + intf.first;
-                });
+            auto intfs = std::accumulate(std::next(_intfPropHandlers.begin()),
+                                         _intfPropHandlers.end(),
+                                         _intfPropHandlers.begin()->first,
+                                         [](auto list, auto intf) {
+                return std::move(list) + ", " + intf.first;
+            });
             log<level::ERR>("Configured interface not available",
                             entry("JSON=%s", interface.dump().c_str()),
                             entry("AVAILABLE_INTFS=%s", intfs.c_str()));
@@ -498,7 +499,7 @@
                     std::next(propFuncs->second.begin()),
                     propFuncs->second.end(), propFuncs->second.begin()->first,
                     [](auto list, auto prop) {
-                        return std::move(list) + ", " + prop.first;
+                    return std::move(list) + ", " + prop.first;
                     });
                 log<level::ERR>("Configured property not available",
                                 entry("JSON=%s", property.dump().c_str()),
diff --git a/control/manager.cpp b/control/manager.cpp
index db8dbea..43e500e 100644
--- a/control/manager.cpp
+++ b/control/manager.cpp
@@ -97,8 +97,8 @@
 
         if (std::all_of(conditions.begin(), conditions.end(),
                         [&bus](const auto& condition) {
-                            return checkCondition(bus, condition);
-                        }))
+            return checkCondition(bus, condition);
+            }))
         {
             // Create a Zone object for each zone in this group
             auto& zones = std::get<zoneListPos>(group);
diff --git a/control/preconditions.cpp b/control/preconditions.cpp
index 09284a8..842c178 100644
--- a/control/preconditions.cpp
+++ b/control/preconditions.cpp
@@ -23,22 +23,21 @@
 {
     return [pg = std::move(pg), sse = std::move(sse)](auto& zone, auto& group) {
         // Compare given precondition entries
-        auto precondState =
-            std::all_of(pg.begin(), pg.end(), [&zone](auto const& entry) {
-                try
-                {
-                    return zone.getPropValueVariant(
-                               std::get<pcPathPos>(entry),
-                               std::get<pcIntfPos>(entry),
-                               std::get<pcPropPos>(entry)) ==
-                           std::get<pcValuePos>(entry);
-                }
-                catch (const std::out_of_range& oore)
-                {
-                    // Default to property variants not equal when not found
-                    return false;
-                }
-            });
+        auto precondState = std::all_of(pg.begin(), pg.end(),
+                                        [&zone](auto const& entry) {
+            try
+            {
+                return zone.getPropValueVariant(std::get<pcPathPos>(entry),
+                                                std::get<pcIntfPos>(entry),
+                                                std::get<pcPropPos>(entry)) ==
+                       std::get<pcValuePos>(entry);
+            }
+            catch (const std::out_of_range& oore)
+            {
+                // Default to property variants not equal when not found
+                return false;
+            }
+        });
 
         if (precondState)
         {
@@ -72,10 +71,10 @@
         // Set/update the services of the group
         zone.setServices(&group);
         const auto& services = zone.getGroupServices(&group);
-        auto precondState =
-            std::any_of(services.begin(), services.end(), [](const auto& s) {
-                return !std::get<hasOwnerPos>(s);
-            });
+        auto precondState = std::any_of(services.begin(), services.end(),
+                                        [](const auto& s) {
+            return !std::get<hasOwnerPos>(s);
+        });
 
         if (precondState)
         {
diff --git a/control/triggers.cpp b/control/triggers.cpp
index 362f4b6..eb2580f 100644
--- a/control/triggers.cpp
+++ b/control/triggers.cpp
@@ -13,11 +13,12 @@
 
 Trigger timer(TimerConf&& tConf)
 {
-    return [tConf = std::move(tConf)](
-               control::Zone& zone, const std::string& name, const Group& group,
-               const std::vector<Action>& actions) {
+    return
+        [tConf = std::move(tConf)](control::Zone& zone, const std::string& name,
+                                   const Group& group,
+                                   const std::vector<Action>& actions) {
         zone.addTimer(name, group, actions, tConf);
-    };
+        };
 }
 
 Trigger signal(const std::string& match, SignalHandler&& handler)
@@ -74,9 +75,10 @@
         }
 
         // Run action functions for initial event state
-        std::for_each(
-            actions.begin(), actions.end(),
-            [&zone, &group](auto const& action) { action(zone, group); });
+        std::for_each(actions.begin(), actions.end(),
+                      [&zone, &group](auto const& action) {
+            action(zone, group);
+        });
     };
 }
 
diff --git a/control/zone.cpp b/control/zone.cpp
index 6e95477..46e1f08 100644
--- a/control/zone.cpp
+++ b/control/zone.cpp
@@ -132,7 +132,7 @@
     else
     {
         // Check all entries are set to allow control active
-        auto actPred = [](auto const& entry) { return entry.second; };
+        auto actPred = [](const auto& entry) { return entry.second; };
         _isActive = std::all_of(_active.begin(), _active.end(), actPred);
     }
 }
@@ -143,9 +143,9 @@
     {
         auto& sNames = _services.at(*group);
         auto it = std::find_if(sNames.begin(), sNames.end(),
-                               [&name](auto const& entry) {
-                                   return name == std::get<namePos>(entry);
-                               });
+                               [&name](const auto& entry) {
+            return name == std::get<namePos>(entry);
+        });
         if (it != std::end(sNames))
         {
             // Remove service name from group
@@ -165,9 +165,9 @@
     {
         auto& sNames = _services.at(*group);
         auto it = std::find_if(sNames.begin(), sNames.end(),
-                               [&name](auto const& entry) {
-                                   return name == std::get<namePos>(entry);
-                               });
+                               [&name](const auto& entry) {
+            return name == std::get<namePos>(entry);
+        });
         if (it != std::end(sNames))
         {
             std::get<hasOwnerPos>(*it) = hasOwner;
@@ -210,7 +210,7 @@
 void Zone::setFloor(uint64_t speed)
 {
     // Check all entries are set to allow floor to be set
-    auto pred = [](auto const& entry) { return entry.second; };
+    auto pred = [](const auto& entry) { return entry.second; };
     auto setFloor = std::all_of(_floorChange.begin(), _floorChange.end(), pred);
     if (setFloor)
     {
@@ -262,7 +262,7 @@
 void Zone::decTimerExpired()
 {
     // Check all entries are set to allow a decrease
-    auto pred = [](auto const& entry) { return entry.second; };
+    auto pred = [](const auto& entry) { return entry.second; };
     auto decAllowed = std::all_of(_decAllowed.begin(), _decAllowed.end(), pred);
 
     // Only decrease speeds when allowed,
@@ -299,36 +299,35 @@
 void Zone::initEvent(const SetSpeedEvent& event)
 {
     // Enable event triggers
-    std::for_each(
-        std::get<triggerPos>(event).begin(), std::get<triggerPos>(event).end(),
-        [this, &event](auto const& trigger) {
-            if (!std::get<actionsPos>(event).empty())
-            {
-                std::for_each(
-                    std::get<actionsPos>(event).begin(),
-                    std::get<actionsPos>(event).end(),
-                    [this, &trigger, &event](auto const& action) {
-                        // Default to use group defined with action if exists
-                        if (!std::get<adGroupPos>(action).empty())
-                        {
-                            trigger(*this, std::get<sseNamePos>(event),
-                                    std::get<adGroupPos>(action),
-                                    std::get<adActionsPos>(action));
-                        }
-                        else
-                        {
-                            trigger(*this, std::get<sseNamePos>(event),
-                                    std::get<groupPos>(event),
-                                    std::get<adActionsPos>(action));
-                        }
-                    });
-            }
-            else
-            {
-                trigger(*this, std::get<sseNamePos>(event),
-                        std::get<groupPos>(event), {});
-            }
-        });
+    std::for_each(std::get<triggerPos>(event).begin(),
+                  std::get<triggerPos>(event).end(),
+                  [this, &event](const auto& trigger) {
+        if (!std::get<actionsPos>(event).empty())
+        {
+            std::for_each(std::get<actionsPos>(event).begin(),
+                          std::get<actionsPos>(event).end(),
+                          [this, &trigger, &event](auto const& action) {
+                // Default to use group defined with action if exists
+                if (!std::get<adGroupPos>(action).empty())
+                {
+                    trigger(*this, std::get<sseNamePos>(event),
+                            std::get<adGroupPos>(action),
+                            std::get<adActionsPos>(action));
+                }
+                else
+                {
+                    trigger(*this, std::get<sseNamePos>(event),
+                            std::get<groupPos>(event),
+                            std::get<adActionsPos>(action));
+                }
+            });
+        }
+        else
+        {
+            trigger(*this, std::get<sseNamePos>(event),
+                    std::get<groupPos>(event), {});
+        }
+    });
 }
 
 void Zone::removeEvent(const SetSpeedEvent& event)
@@ -367,7 +366,7 @@
         {
             // TODO openbmc/openbmc#2328 - Use the action function target
             // for comparison
-            auto actsEqual = [](auto const& a1, auto const& a2) {
+            auto actsEqual = [](const auto& a1, const auto& a2) {
                 return a1.target_type().name() == a2.target_type().name();
             };
             if (std::equal(eventActions.begin(), eventActions.end(),
@@ -410,9 +409,10 @@
                         const std::vector<Action>& eventActions)
 {
     // Perform the actions
-    std::for_each(
-        eventActions.begin(), eventActions.end(),
-        [this, &eventGroup](auto const& action) { action(*this, eventGroup); });
+    std::for_each(eventActions.begin(), eventActions.end(),
+                  [this, &eventGroup](const auto& action) {
+        action(*this, eventGroup);
+    });
 }
 
 void Zone::handleEvent(sdbusplus::message_t& msg, const EventData* eventData)
@@ -422,9 +422,9 @@
     // Perform the actions
     std::for_each(std::get<eventActionsPos>(*eventData).begin(),
                   std::get<eventActionsPos>(*eventData).end(),
-                  [this, &eventData](auto const& action) {
-                      action(*this, std::get<eventGroupPos>(*eventData));
-                  });
+                  [this, &eventData](const auto& action) {
+        action(*this, std::get<eventGroupPos>(*eventData));
+    });
 }
 
 const std::string& Zone::getService(const std::string& path,
@@ -436,9 +436,10 @@
     {
         for (auto& serv : srvIter->second)
         {
-            auto it = std::find_if(
-                serv.second.begin(), serv.second.end(),
-                [&intf](auto const& interface) { return intf == interface; });
+            auto it = std::find_if(serv.second.begin(), serv.second.end(),
+                                   [&intf](const auto& interface) {
+                return intf == interface;
+            });
             if (it != std::end(serv.second))
             {
                 // Service found
@@ -534,11 +535,11 @@
     std::transform(value.begin(), value.end(), value.begin(), toupper);
 
     auto supported = ThermalObject::supported();
-    auto isSupported =
-        std::any_of(supported.begin(), supported.end(), [&value](auto& s) {
-            std::transform(s.begin(), s.end(), s.begin(), toupper);
-            return value == s;
-        });
+    auto isSupported = std::any_of(supported.begin(), supported.end(),
+                                   [&value](auto& s) {
+        std::transform(s.begin(), s.end(), s.begin(), toupper);
+        return value == s;
+    });
 
     if (value != current && isSupported)
     {
diff --git a/control/zone.hpp b/control/zone.hpp
index 3decb32..183bd78 100644
--- a/control/zone.hpp
+++ b/control/zone.hpp
@@ -241,23 +241,23 @@
             std::optional<T> value;
             std::visit(
                 [&value](auto&& val) {
-                    // If the type configured is int64, but the sensor value
-                    // property's type is double, scale it by 1000 and return
-                    // the value as an int64 as configured.
-                    using V = std::decay_t<decltype(val)>;
-                    if constexpr (std::is_same_v<T, int64_t> &&
-                                  std::is_same_v<V, double>)
-                    {
-                        val = val * 1000;
-                        value = std::lround(val);
-                    }
-                    // If the type configured matches the sensor value
-                    // property's type, just return the value as its
-                    // given type.
-                    else if constexpr (std::is_same_v<T, V>)
-                    {
-                        value = val;
-                    }
+                // If the type configured is int64, but the sensor value
+                // property's type is double, scale it by 1000 and return
+                // the value as an int64 as configured.
+                using V = std::decay_t<decltype(val)>;
+                if constexpr (std::is_same_v<T, int64_t> &&
+                              std::is_same_v<V, double>)
+                {
+                    val = val * 1000;
+                    value = std::lround(val);
+                }
+                // If the type configured matches the sensor value
+                // property's type, just return the value as its
+                // given type.
+                else if constexpr (std::is_same_v<T, V>)
+                {
+                    value = val;
+                }
                 },
                 variant);
 
@@ -628,11 +628,11 @@
                     // type(T) is available on this interface and read it
                     std::visit(
                         [&value](auto&& val) {
-                            using V = std::decay_t<decltype(val)>;
-                            if constexpr (std::is_same_v<T, V>)
-                            {
-                                value = val;
-                            }
+                        using V = std::decay_t<decltype(val)>;
+                        if constexpr (std::is_same_v<T, V>)
+                        {
+                            value = val;
+                        }
                         },
                         var);