save database to file during server stop + some refactoring

Author: kolomenkin

BackgroundWorker.cpp

@@ -40,18 +40,8 @@ void BackgroundWorker::run(const DataEngine& engine, const std::string& database
         {
             const auto saveSecondsElapsed = std::chrono::duration_cast<std::chrono::seconds>(saveTime - lastSaveTime);
             LOG_INFO << "BackgroundWorker: save data to file after " << saveSecondsElapsed.count() << " seconds" << std::endl;
-
-            DataSerializer::Document document;
-
-            const std::function<DataEngine::EnumerateVisitorProc> visitor =
-                [&document](const std::string_view name, const std::string_view value)
-            {
-                document.add(name, value);
-                return;
-            };
-            engine.enumerate(visitor);
-
-            DataSerializer::save(databaseFilename, document);
+            const size_t savedRecordCount = store_data(engine, databaseFilename);
+            LOG_INFO << "BackgroundWorker: saved " << savedRecordCount << " DB records to file " << databaseFilename << std::endl;
             lastSaveTime = saveTime;
         }
 
@@ -84,3 +74,48 @@ void BackgroundWorker::stop_notify()
 
     LOG_INFO << "BackgroundWorker: stop_notify: end" << std::endl;
 }
+
+size_t BackgroundWorker::initial_load_data(DataEngine& engine, const std::string& databaseFilename)
+{
+    size_t recordCount = 0;
+    auto loadVisitor = [&engine, &recordCount](const std::string_view name, const std::string_view value)
+    {
+        engine.initial_set(name, value);
+        ++recordCount;
+        return;
+    };
+
+    const bool ok = DataSerializer::load(databaseFilename, loadVisitor);
+    if (!ok)
+    {
+        LOG_ERROR << "DataSerializer::load() failed" << std::endl;
+        return recordCount;
+    }
+
+    return recordCount;
+}
+
+size_t BackgroundWorker::store_data(const DataEngine& engine, const std::string& databaseFilename)
+{
+    size_t recordCount = 0;
+    DataSerializer::Document document;
+
+    const std::function<DataEngine::EnumerateVisitorProc> visitor =
+        [&document, &recordCount](const std::string_view name, const std::string_view value)
+    {
+        document.add(name, value);
+        ++recordCount;
+        return;
+    };
+
+    engine.enumerate(visitor);
+
+    const bool ok = DataSerializer::save(databaseFilename, document);
+    if (!ok)
+    {
+        LOG_ERROR << "DataSerializer::save() failed" << std::endl;
+        return recordCount;
+    }
+
+    return recordCount;
+}

BackgroundWorker.h

@@ -15,6 +15,10 @@ class BackgroundWorker
 
     void stop_notify();
 
+public:
+    static size_t initial_load_data(DataEngine& engine, const std::string& databaseFilename);
+    static size_t store_data(const DataEngine& engine, const std::string& databaseFilename);
+
 protected:
     std::mutex              m_protect;
     std::condition_variable m_conditional;

main.cpp

@@ -1,6 +1,5 @@
 #include "BackgroundWorker.h"
 #include "DataEngine.h"
-#include "DataSerializer.h"
 #include "HttpServer.h"
 #include "Logger.h"
 
@@ -11,7 +10,7 @@
 #include <thread>
 
 
-int main(const int argc, const char * const * const argv)
+int main(const int argc, const char* const* const argv)
 {
     LOG_INFO << "main: begin" << std::endl;
     const std::string arg1 = argc > 1 ? argv[1] : "";
@@ -30,36 +29,33 @@ int main(const int argc, const char * const * const argv)
     DataEngine engine;
 
     LOG_INFO << "main: load data" << std::endl;
+    const size_t loadedRecordCount = BackgroundWorker::initial_load_data(engine, databaseFilename);
+    LOG_INFO << "main: loaded " << loadedRecordCount << " DB records from file " << databaseFilename << std::endl;
 
     {
-        size_t recordCount = 0;
-        auto loadVisitor = [&engine, &recordCount](const std::string_view name, const std::string_view value)
+        BackgroundWorker worker;
+
+        auto backgroundWorkerProc = [&worker, &engine, &databaseFilename]()
         {
-            engine.initial_set(name, value);
-            ++recordCount;
+            worker.run(engine, databaseFilename);
         };
-        DataSerializer::load(databaseFilename, loadVisitor);
-        LOG_INFO << "main: loaded " << recordCount << " DB records from file " << databaseFilename << std::endl;
-    }
 
-    BackgroundWorker worker;
+        auto backgroundWorkerFuture = std::async(std::launch::async, backgroundWorkerProc);
 
-    auto backgroundWorkerProc = [&worker, &engine, &databaseFilename]()
-    {
-        worker.run(engine, databaseFilename);
-    };
+        LOG_INFO << "main: listening connections: begin" << std::endl;
 
-    auto backgroundWorkerFuture = std::async(std::launch::async, backgroundWorkerProc);
+        HttpServer server;
+        server.run(listenHost, listenPort, engine, logEachRequest);
 
-    LOG_INFO << "main: listening connections: begin" << std::endl;
+        LOG_INFO << "main: listening connections: end" << std::endl;
 
-    HttpServer server;
-    server.run(listenHost, listenPort, engine, logEachRequest);
-
-    LOG_INFO << "main: listening connections: end" << std::endl;
+        worker.stop_notify();
+        backgroundWorkerFuture.wait();
+    }
 
-    worker.stop_notify();
-    backgroundWorkerFuture.wait();
+    LOG_INFO << "main: save data to file before process exit" << std::endl;
+    const size_t savedRecordCount = BackgroundWorker::store_data(engine, databaseFilename);
+    LOG_INFO << "main: saved " << savedRecordCount << " DB records to file " << databaseFilename << std::endl;
 
     LOG_INFO << "main: end" << std::endl;