diff --git a/bmc/file_handler.cpp b/bmc/file_handler.cpp
index 829f92c..8005b8f 100644
--- a/bmc/file_handler.cpp
+++ b/bmc/file_handler.cpp
@@ -52,8 +52,8 @@
     return file.good();
 }
 
-std::optional<std::vector<uint8_t>> FileHandler::read(std::uint32_t offset,
-                                                      std::uint32_t size)
+std::optional<std::vector<uint8_t>>
+    FileHandler::read(std::uint32_t offset, std::uint32_t size)
 {
     uint32_t file_size = getSize();
     if (offset > file_size)
diff --git a/bmc/firmware-handler/data_handler.hpp b/bmc/firmware-handler/data_handler.hpp
index 162347c..5548f95 100644
--- a/bmc/firmware-handler/data_handler.hpp
+++ b/bmc/firmware-handler/data_handler.hpp
@@ -62,8 +62,7 @@
 
     DataHandlerPack(std::uint16_t bitmask,
                     std::unique_ptr<DataInterface> handler) :
-        bitmask(bitmask),
-        handler(std::move(handler))
+        bitmask(bitmask), handler(std::move(handler))
     {}
 
     /* Don't allow copying, assignment or move assignment, only moving. */
diff --git a/bmc/firmware-handler/firmware_handler.cpp b/bmc/firmware-handler/firmware_handler.cpp
index 3d9b3fd..116bc07 100644
--- a/bmc/firmware-handler/firmware_handler.cpp
+++ b/bmc/firmware-handler/firmware_handler.cpp
@@ -57,18 +57,19 @@
 
     std::vector<std::string> blobs;
     blobs.reserve(firmwares.size());
-    std::for_each(
-        firmwares.begin(), firmwares.end(),
-        [&blobs](const auto& blob) { blobs.emplace_back(blob.blobName); });
+    std::for_each(firmwares.begin(), firmwares.end(),
+                  [&blobs](const auto& blob) {
+                      blobs.emplace_back(blob.blobName);
+                  });
 
     if (0 == std::count(blobs.begin(), blobs.end(), hashBlobId))
     {
         return nullptr;
     }
 
-    return std::make_unique<FirmwareBlobHandler>(std::move(firmwares), blobs,
-                                                 std::move(transports),
-                                                 std::move(actionPacks));
+    return std::make_unique<FirmwareBlobHandler>(
+        std::move(firmwares), blobs, std::move(transports),
+        std::move(actionPacks));
 }
 
 /* Check if the path is in our supported list (or active list). */
@@ -421,8 +422,8 @@
     /* How are they expecting to copy this data? */
     auto d = std::find_if(transports.begin(), transports.end(),
                           [&transportFlag](const auto& iter) {
-        return (iter.bitmask == transportFlag);
-    });
+                              return (iter.bitmask == transportFlag);
+                          });
     if (d == transports.end())
     {
         return false;
diff --git a/bmc/firmware-handler/firmware_handler.hpp b/bmc/firmware-handler/firmware_handler.hpp
index 505f1a7..1a45328 100644
--- a/bmc/firmware-handler/firmware_handler.hpp
+++ b/bmc/firmware-handler/firmware_handler.hpp
@@ -123,11 +123,11 @@
                         const std::vector<std::string>& blobs,
                         std::vector<DataHandlerPack>&& transports,
                         ActionMap&& actionPacks) :
-        handlers(std::move(firmwares)),
-        blobIDs(blobs), transports(std::move(transports)),
-        activeImage(activeImageBlobId), activeHash(activeHashBlobId),
-        verifyImage(verifyBlobId), updateImage(updateBlobId), lookup(),
-        state(UpdateState::notYetStarted), actionPacks(std::move(actionPacks))
+        handlers(std::move(firmwares)), blobIDs(blobs),
+        transports(std::move(transports)), activeImage(activeImageBlobId),
+        activeHash(activeHashBlobId), verifyImage(verifyBlobId),
+        updateImage(updateBlobId), lookup(), state(UpdateState::notYetStarted),
+        actionPacks(std::move(actionPacks))
     {}
     ~FirmwareBlobHandler() = default;
     FirmwareBlobHandler(const FirmwareBlobHandler&) = delete;
diff --git a/bmc/firmware-handler/firmware_handlers_builder.cpp b/bmc/firmware-handler/firmware_handlers_builder.cpp
index 13bfd69..c803997 100644
--- a/bmc/firmware-handler/firmware_handlers_builder.cpp
+++ b/bmc/firmware-handler/firmware_handlers_builder.cpp
@@ -49,9 +49,9 @@
             /* name must be: /flash/... */
             if (!std::regex_match(output.blobId, std::regex("^\\/flash\\/.+")))
             {
-                throw std::runtime_error("Invalid blob name: '" +
-                                         output.blobId +
-                                         "' must start with /flash/");
+                throw std::runtime_error(
+                    "Invalid blob name: '" + output.blobId +
+                    "' must start with /flash/");
             }
 
             /* handler is required. */
@@ -64,8 +64,8 @@
             }
             else
             {
-                throw std::runtime_error("Invalid handler type: " +
-                                         handlerType);
+                throw std::runtime_error(
+                    "Invalid handler type: " + handlerType);
             }
 
             /* actions are required (presently). */
@@ -85,8 +85,8 @@
             }
             else
             {
-                throw std::runtime_error("Invalid preparation type: " +
-                                         prepareType);
+                throw std::runtime_error(
+                    "Invalid preparation type: " + prepareType);
             }
 
             const auto& verify = a.at("verification");
@@ -105,8 +105,8 @@
             }
             else
             {
-                throw std::runtime_error("Invalid verification type:" +
-                                         verifyType);
+                throw std::runtime_error(
+                    "Invalid verification type:" + verifyType);
             }
 
             const auto& update = a.at("update");
diff --git a/bmc/firmware-handler/lpc_aspeed.cpp b/bmc/firmware-handler/lpc_aspeed.cpp
index 047f87b..888e0af 100644
--- a/bmc/firmware-handler/lpc_aspeed.cpp
+++ b/bmc/firmware-handler/lpc_aspeed.cpp
@@ -35,9 +35,8 @@
 
 const std::string LpcMapperAspeed::lpcControlPath = "/dev/aspeed-lpc-ctrl";
 
-std::unique_ptr<HardwareMapperInterface>
-    LpcMapperAspeed::createAspeedMapper(std::uint32_t regionAddress,
-                                        std::size_t regionSize)
+std::unique_ptr<HardwareMapperInterface> LpcMapperAspeed::createAspeedMapper(
+    std::uint32_t regionAddress, std::size_t regionSize)
 {
     /* NOTE: considered using a joint factory to create one or the other, for
      * now, separate factories.
diff --git a/bmc/firmware-handler/lpc_aspeed.hpp b/bmc/firmware-handler/lpc_aspeed.hpp
index ac87c22..1a547c9 100644
--- a/bmc/firmware-handler/lpc_aspeed.hpp
+++ b/bmc/firmware-handler/lpc_aspeed.hpp
@@ -23,8 +23,7 @@
      */
     LpcMapperAspeed(std::uint32_t regionAddress, std::size_t regionSize,
                     const internal::Sys* sys = &internal::sys_impl) :
-        regionAddress(regionAddress),
-        regionSize(regionSize), sys(sys){};
+        regionAddress(regionAddress), regionSize(regionSize), sys(sys) {};
 
     LpcMapperAspeed(const LpcMapperAspeed&) = delete;
     LpcMapperAspeed& operator=(const LpcMapperAspeed&) = delete;
diff --git a/bmc/firmware-handler/lpc_nuvoton.cpp b/bmc/firmware-handler/lpc_nuvoton.cpp
index eaa316f..dcf9eaa 100644
--- a/bmc/firmware-handler/lpc_nuvoton.cpp
+++ b/bmc/firmware-handler/lpc_nuvoton.cpp
@@ -36,9 +36,8 @@
 using std::uint32_t;
 using std::uint8_t;
 
-std::unique_ptr<HardwareMapperInterface>
-    LpcMapperNuvoton::createNuvotonMapper(std::uint32_t regionAddress,
-                                          std::uint32_t regionSize)
+std::unique_ptr<HardwareMapperInterface> LpcMapperNuvoton::createNuvotonMapper(
+    std::uint32_t regionAddress, std::uint32_t regionSize)
 {
     /* NOTE: Considered making one factory for both types. */
     return std::make_unique<LpcMapperNuvoton>(regionAddress, regionSize);
@@ -98,8 +97,8 @@
  *   - WindowOffset = 4 and WindowSize = len - 4 if (addr & 0x7) == 0
  *   - WindowSize = 0 means that the region cannot be mapped otherwise
  */
-WindowMapResult LpcMapperNuvoton::mapWindow(std::uint32_t address,
-                                            std::uint32_t length)
+WindowMapResult
+    LpcMapperNuvoton::mapWindow(std::uint32_t address, std::uint32_t length)
 {
     WindowMapResult result = {};
 
diff --git a/bmc/firmware-handler/lpc_nuvoton.hpp b/bmc/firmware-handler/lpc_nuvoton.hpp
index c66653b..9aa5b8b 100644
--- a/bmc/firmware-handler/lpc_nuvoton.hpp
+++ b/bmc/firmware-handler/lpc_nuvoton.hpp
@@ -14,9 +14,8 @@
 class LpcMapperNuvoton : public HardwareMapperInterface
 {
   public:
-    static std::unique_ptr<HardwareMapperInterface>
-        createNuvotonMapper(std::uint32_t regionAddress,
-                            std::uint32_t regionSize);
+    static std::unique_ptr<HardwareMapperInterface> createNuvotonMapper(
+        std::uint32_t regionAddress, std::uint32_t regionSize);
 
     /**
      * Create an LpcMapper for Nuvoton.
@@ -28,8 +27,7 @@
      */
     LpcMapperNuvoton(std::uint32_t regionAddress, std::uint32_t regionSize,
                      const internal::Sys* sys = &internal::sys_impl) :
-        regionAddress(regionAddress),
-        memoryRegionSize(regionSize), sys(sys){};
+        regionAddress(regionAddress), memoryRegionSize(regionSize), sys(sys) {};
 
     /** Attempt to map the window for copying bytes, after mapWindow is called.
      * throws MapperException
diff --git a/bmc/firmware-handler/pci_handler.hpp b/bmc/firmware-handler/pci_handler.hpp
index 9b2c5b6..848760c 100644
--- a/bmc/firmware-handler/pci_handler.hpp
+++ b/bmc/firmware-handler/pci_handler.hpp
@@ -20,8 +20,7 @@
   public:
     PciDataHandler(std::uint32_t regionAddress, std::size_t regionSize,
                    const internal::Sys* sys = &internal::sys_impl) :
-        regionAddress(regionAddress),
-        memoryRegionSize(regionSize), sys(sys){};
+        regionAddress(regionAddress), memoryRegionSize(regionSize), sys(sys) {};
 
     bool open() override;
     bool close() override;
diff --git a/bmc/firmware-handler/test/firmware_state_verificationstarted_unittest.cpp b/bmc/firmware-handler/test/firmware_state_verificationstarted_unittest.cpp
index 4f69c89..ab2de9e 100644
--- a/bmc/firmware-handler/test/firmware_state_verificationstarted_unittest.cpp
+++ b/bmc/firmware-handler/test/firmware_state_verificationstarted_unittest.cpp
@@ -52,9 +52,9 @@
     getToVerificationStarted(staticLayoutBlobId);
 
     auto blobs = handler->getBlobIds();
-    EXPECT_THAT(
-        blobs, UnorderedElementsAreArray({activeImageBlobId, staticLayoutBlobId,
-                                          hashBlobId, verifyBlobId}));
+    EXPECT_THAT(blobs, UnorderedElementsAreArray(
+                           {activeImageBlobId, staticLayoutBlobId, hashBlobId,
+                            verifyBlobId}));
 
     for (const auto& blob : blobs)
     {
diff --git a/bmc/general_systemd.cpp b/bmc/general_systemd.cpp
index 02c3aea..ce16d14 100644
--- a/bmc/general_systemd.cpp
+++ b/bmc/general_systemd.cpp
@@ -141,8 +141,8 @@
                  job->c_str(), result.c_str());
     jobMonitor = std::nullopt;
     job = std::nullopt;
-    currentStatus = result == "done" ? ActionStatus::success
-                                     : ActionStatus::failed;
+    currentStatus =
+        result == "done" ? ActionStatus::success : ActionStatus::failed;
 
     if (cb)
     {
diff --git a/bmc/general_systemd.hpp b/bmc/general_systemd.hpp
index 4df4747..48e5177 100644
--- a/bmc/general_systemd.hpp
+++ b/bmc/general_systemd.hpp
@@ -20,8 +20,7 @@
 
     SystemdNoFile(sdbusplus::bus_t&& bus, const std::string& service,
                   const std::string& mode) :
-        bus(std::move(bus)),
-        triggerService(service), mode(mode)
+        bus(std::move(bus)), triggerService(service), mode(mode)
     {}
 
     SystemdNoFile(const SystemdNoFile&) = delete;
@@ -66,15 +65,13 @@
      * @param[in] mode - the job-mode when starting the systemd Unit.
      */
     static std::unique_ptr<TriggerableActionInterface>
-        CreateSystemdWithStatusFile(sdbusplus::bus_t&& bus,
-                                    const std::string& path,
-                                    const std::string& service,
-                                    const std::string& mode);
+        CreateSystemdWithStatusFile(
+            sdbusplus::bus_t&& bus, const std::string& path,
+            const std::string& service, const std::string& mode);
 
     SystemdWithStatusFile(sdbusplus::bus_t&& bus, const std::string& path,
                           const std::string& service, const std::string& mode) :
-        SystemdNoFile(std::move(bus), service, mode),
-        checkPath(path)
+        SystemdNoFile(std::move(bus), service, mode), checkPath(path)
     {}
 
     bool trigger() override;
diff --git a/bmc/image_handler.hpp b/bmc/image_handler.hpp
index 4d5b475..59944c6 100644
--- a/bmc/image_handler.hpp
+++ b/bmc/image_handler.hpp
@@ -66,8 +66,7 @@
   public:
     HandlerPack(const std::string& name,
                 std::unique_ptr<ImageHandlerInterface> handler) :
-        blobName(name),
-        handler(std::move(handler))
+        blobName(name), handler(std::move(handler))
     {}
 
     HandlerPack() = default;
diff --git a/bmc/log-handler/log_handler.cpp b/bmc/log-handler/log_handler.cpp
index 9a0d296..de91ae4 100644
--- a/bmc/log-handler/log_handler.cpp
+++ b/bmc/log-handler/log_handler.cpp
@@ -36,41 +36,44 @@
         info->handler = std::move(config.handler);
         info->actions->onOpen->setCallback(
             [infoP = info.get()](TriggerableActionInterface& tai) {
-            auto data = std::make_shared<std::optional<std::vector<uint8_t>>>();
-            do
-            {
-                if (tai.status() != ActionStatus::success)
+                auto data =
+                    std::make_shared<std::optional<std::vector<uint8_t>>>();
+                do
                 {
-                    fprintf(stderr,
-                            "LogBlobHandler: Log file unit failed for %s\n",
-                            infoP->blobId.c_str());
-                    continue;
-                }
-                if (!infoP->handler->open("", std::ios::in))
-                {
-                    fprintf(stderr,
+                    if (tai.status() != ActionStatus::success)
+                    {
+                        fprintf(stderr,
+                                "LogBlobHandler: Log file unit failed for %s\n",
+                                infoP->blobId.c_str());
+                        continue;
+                    }
+                    if (!infoP->handler->open("", std::ios::in))
+                    {
+                        fprintf(
+                            stderr,
                             "LogBlobHandler: Opening log file failed for %s\n",
                             infoP->blobId.c_str());
-                    continue;
-                }
-                auto d = infoP->handler->read(
-                    0, std::numeric_limits<uint32_t>::max());
-                infoP->handler->close();
-                if (!d)
-                {
-                    fprintf(stderr,
+                        continue;
+                    }
+                    auto d = infoP->handler->read(
+                        0, std::numeric_limits<uint32_t>::max());
+                    infoP->handler->close();
+                    if (!d)
+                    {
+                        fprintf(
+                            stderr,
                             "LogBlobHandler: Reading log file failed for %s\n",
                             infoP->blobId.c_str());
-                    continue;
+                        continue;
+                    }
+                    *data = std::move(d);
+                } while (false);
+                for (auto sessionP : infoP->sessionsToUpdate)
+                {
+                    sessionP->data = data;
                 }
-                *data = std::move(d);
-            } while (false);
-            for (auto sessionP : infoP->sessionsToUpdate)
-            {
-                sessionP->data = data;
-            }
-            infoP->sessionsToUpdate.clear();
-        });
+                infoP->sessionsToUpdate.clear();
+            });
         if (!blobInfoMap.try_emplace(info->blobId, std::move(info)).second)
         {
             fprintf(stderr,
diff --git a/bmc/log-handler/log_handlers_builder.cpp b/bmc/log-handler/log_handlers_builder.cpp
index d9c7fb2..fe60cce 100644
--- a/bmc/log-handler/log_handlers_builder.cpp
+++ b/bmc/log-handler/log_handlers_builder.cpp
@@ -64,8 +64,8 @@
             }
             else
             {
-                throw std::runtime_error("Invalid handler type: " +
-                                         handlerType);
+                throw std::runtime_error(
+                    "Invalid handler type: " + handlerType);
             }
 
             /* actions are required (presently). */
@@ -85,8 +85,8 @@
             }
             else
             {
-                throw std::runtime_error("Invalid preparation type: " +
-                                         onOpenType);
+                throw std::runtime_error(
+                    "Invalid preparation type: " + onOpenType);
             }
 
             const auto& onDelete = a.at("delete");
@@ -101,8 +101,8 @@
             }
             else
             {
-                throw std::runtime_error("Invalid preparation type: " +
-                                         onDeleteType);
+                throw std::runtime_error(
+                    "Invalid preparation type: " + onDeleteType);
             }
 
             output.actions = std::move(pack);
diff --git a/bmc/version-handler/test/version_mock.hpp b/bmc/version-handler/test/version_mock.hpp
index d8035a5..71fabaf 100644
--- a/bmc/version-handler/test/version_mock.hpp
+++ b/bmc/version-handler/test/version_mock.hpp
@@ -9,10 +9,9 @@
 namespace ipmi_flash
 {
 
-static HandlerConfig<VersionBlobHandler::ActionPack>
-    createMockVersionConfig(const std::string& id,
-                            ImageHandlerMock** im = nullptr,
-                            TriggerMock** tm = nullptr)
+static HandlerConfig<VersionBlobHandler::ActionPack> createMockVersionConfig(
+    const std::string& id, ImageHandlerMock** im = nullptr,
+    TriggerMock** tm = nullptr)
 {
     HandlerConfig<VersionBlobHandler::ActionPack> ret;
     ret.blobId = id;
diff --git a/bmc/version-handler/version_handler.cpp b/bmc/version-handler/version_handler.cpp
index f26884b..5b285f8 100644
--- a/bmc/version-handler/version_handler.cpp
+++ b/bmc/version-handler/version_handler.cpp
@@ -23,38 +23,39 @@
         info->handler = std::move(config.handler);
         info->actions->onOpen->setCallback(
             [infoP = info.get()](TriggerableActionInterface& tai) {
-            auto data = std::make_shared<std::optional<std::vector<uint8_t>>>();
-            do
-            {
-                if (tai.status() != ActionStatus::success)
+                auto data =
+                    std::make_shared<std::optional<std::vector<uint8_t>>>();
+                do
                 {
-                    fprintf(stderr, "Version file unit failed for %s\n",
-                            infoP->blobId.c_str());
-                    continue;
-                }
-                if (!infoP->handler->open("", std::ios::in))
+                    if (tai.status() != ActionStatus::success)
+                    {
+                        fprintf(stderr, "Version file unit failed for %s\n",
+                                infoP->blobId.c_str());
+                        continue;
+                    }
+                    if (!infoP->handler->open("", std::ios::in))
+                    {
+                        fprintf(stderr, "Opening version file failed for %s\n",
+                                infoP->blobId.c_str());
+                        continue;
+                    }
+                    auto d = infoP->handler->read(
+                        0, std::numeric_limits<uint32_t>::max());
+                    infoP->handler->close();
+                    if (!d)
+                    {
+                        fprintf(stderr, "Reading version file failed for %s\n",
+                                infoP->blobId.c_str());
+                        continue;
+                    }
+                    *data = std::move(d);
+                } while (false);
+                for (auto sessionP : infoP->sessionsToUpdate)
                 {
-                    fprintf(stderr, "Opening version file failed for %s\n",
-                            infoP->blobId.c_str());
-                    continue;
+                    sessionP->data = data;
                 }
-                auto d = infoP->handler->read(
-                    0, std::numeric_limits<uint32_t>::max());
-                infoP->handler->close();
-                if (!d)
-                {
-                    fprintf(stderr, "Reading version file failed for %s\n",
-                            infoP->blobId.c_str());
-                    continue;
-                }
-                *data = std::move(d);
-            } while (false);
-            for (auto sessionP : infoP->sessionsToUpdate)
-            {
-                sessionP->data = data;
-            }
-            infoP->sessionsToUpdate.clear();
-        });
+                infoP->sessionsToUpdate.clear();
+            });
         if (!blobInfoMap.try_emplace(info->blobId, std::move(info)).second)
         {
             fprintf(stderr, "Ignoring duplicate config for %s\n",
diff --git a/bmc/version-handler/version_handlers_builder.cpp b/bmc/version-handler/version_handlers_builder.cpp
index 044f4e3..d0b7360 100644
--- a/bmc/version-handler/version_handlers_builder.cpp
+++ b/bmc/version-handler/version_handlers_builder.cpp
@@ -75,8 +75,8 @@
             }
             else
             {
-                throw std::runtime_error("Invalid handler type: " +
-                                         handlerType);
+                throw std::runtime_error(
+                    "Invalid handler type: " + handlerType);
             }
 
             /* actions are required (presently). */
@@ -96,8 +96,8 @@
             }
             else
             {
-                throw std::runtime_error("Invalid preparation type: " +
-                                         onOpenType);
+                throw std::runtime_error(
+                    "Invalid preparation type: " + onOpenType);
             }
 
             output.actions = std::move(pack);