cron job load and store events

src/cronjobs.cpp

@@ -1,16 +1,91 @@
 #include <cronjobs.h>
 #include <chrono>
+#include <fsmount.h>
 
 #define STACK_DEPTH 4096
 #define PRIORITY 3
 
-const bool Cron::loadEvents(fs::File &file)
+const bool Cron::loadEvents()
 {
+    FSmount fs;
+    File cronFile = FFat.open("/cronjobs.json", FILE_READ, false);
+    if (!cronFile)
+    {
+        LOG_ERROR("Cron failed to open cronjobs.json");
+        return false;
+    }
+    ArduinoJson::JsonDocument cronFileContent;
+    if (ArduinoJson::deserializeJson(cronFileContent, cronFile) != ArduinoJson::DeserializationError::Ok)
+    {
+        LOG_ERROR("Cron unable to deserialize cronjobs.json");
+        return false;
+    }
+
+    std::string buf;
+    ArduinoJson::serializeJsonPretty(cronFileContent, buf);
+    LOG_INFO("Cron loadEvents loaded cronjobs.json\n", buf.c_str());
+
+    ArduinoJson::JsonArray cronjobList = cronFileContent.as<JsonArray>();
+    LOG_INFO("Cron loadEvents loaded [", cronjobList.size(), "] events");
+    for (const auto &job : cronjobList)
+    {
+        const auto &eventName = job["name"].as<std::string>();
+        const auto &cronExpr = job["cronExpr"].as<std::string>();
+        ArduinoJson::JsonDocument action(job["action"]);
+        if (!addEvent(eventName, cronExpr, action))
+            LOG_ERROR("Cron failed to load event [", eventName.c_str(), "]");
+        else
+            LOG_INFO("Cron loaded event [", eventName.c_str(), "]");
+        delay(10);
+    }
+    cronFile.close();
+    return true;
+}
+
+const bool Cron::storeEvents()
+{
+    FSmount fs;
+    std::lock_guard<std::mutex> lock(m_mutex);
+    File cronFile = FFat.open("/cronjobs.json", FILE_WRITE, true);
+    if (!cronFile)
+    {
+        LOG_ERROR("Cron failed to open cronjobs.json");
+        return false;
+    }
+
+    ArduinoJson::JsonDocument cronFileContent;
+    ArduinoJson::JsonArray cronFileArray = cronFileContent.to<JsonArray>();
+
+    for (const auto &job : m_cronMap) // convert cron events map to json file
+    {
+        const auto &eventName = job.first;
+        const auto &params = job.second;
+
+        const auto &cmd = std::get<0>(params);
+        const auto &cronExpr = std::get<1>(params);
+        const auto &cmdParams = std::get<3>(params);
+
+        ArduinoJson::JsonDocument thisJob;
+        thisJob["name"] = eventName;
+        thisJob["cronExpr"] = cron::to_cronstr(cronExpr); 
+        thisJob["action"]["cmd"] = cmd;
+        thisJob["action"]["params"] = cmdParams;
+
+        cronFileArray.add(thisJob);
+    }
+
+    std::string buf;
+    ArduinoJson::serializeJsonPretty(cronFileContent, buf);
+    LOG_INFO("Cron storeEvents generated cronjobs.json\n", buf.c_str());
+
+    ArduinoJson::serializeJson(cronFileContent, cronFile);
+    cronFile.close();
     return true;
 }
 
 const bool Cron::addEvent(const std::string &name, const std::string &expr, const ArduinoJson::JsonDocument action)
 {
+    std::lock_guard<std::mutex> lock(m_mutex);
     if (m_cronMap.contains(name))
     {
         LOG_ERROR("Cron event [", name.c_str(), "] already scheduled");
@@ -41,7 +116,7 @@ const bool Cron::addEvent(const std::string &name, const std::string &expr, cons
         std::tm nowTm = drivers::PCF85063::datetime2tm(now);
         auto next = cron::cron_next(eventExpr, nowTm);
         JsonDocument act(params);
-        LOG_INFO("Cron adding  event [", name.c_str(), "] next execution [", drivers::PCF85063::tm2str(next).c_str(), "]");
+        LOG_INFO("Cron adding event [", name.c_str(), "] next execution [", drivers::PCF85063::tm2str(next).c_str(), "]");
         m_cronMap[name] = std::make_tuple(cmd, eventExpr, next, act);
     }
     catch (cron::bad_cronexpr const &ex)
@@ -54,6 +129,7 @@ const bool Cron::addEvent(const std::string &name, const std::string &expr, cons
 
 const bool Cron::getEvent(const std::string &name, CronEvent &event)
 {
+    std::lock_guard<std::mutex> lock(m_mutex);
     if (!m_cronMap.contains(name))
     {
         LOG_ERROR("Cron event [", name.c_str(), "] does not exist");
@@ -66,6 +142,7 @@ const bool Cron::getEvent(const std::string &name, CronEvent &event)
 
 const bool Cron::delEvent(const std::string &name)
 {
+    std::lock_guard<std::mutex> lock(m_mutex);
     if (!m_cronMap.contains(name))
     {
         LOG_WARN("Cron event [", name.c_str(), "] does not exist");
@@ -78,7 +155,7 @@ const bool Cron::delEvent(const std::string &name)
 
 void cronLoop(void *dev)
 {
-    auto &cron = Cron::getInstance(*(devices_t*)dev);
+    auto &cron = Cron::getInstance(*(devices_t *)dev);
     while (true)
     {
         cron.processEvents();
@@ -107,6 +184,7 @@ void Cron::stopCron()
 
 const bool Cron::processEvents()
 {
+    std::lock_guard<std::mutex> lock(m_mutex);
     LOG_DEBUG("Cron processEvents [", m_cronMap.size(), "]");
 
     drivers::PCF85063::datetime_t now;
@@ -126,7 +204,7 @@ const bool Cron::processEvents()
         auto &cmd = std::get<0>(eventAction);
         auto &cronexrp = std::get<1>(eventAction);
         auto &next = std::get<2>(eventAction);
-        auto &params = std::get<3>(eventAction);
+        auto &cmdParams = std::get<3>(eventAction);
 
         const auto nowPoint = std::chrono::system_clock::from_time_t(std::mktime(&nowTm));
         const auto nextEventPoint = std::chrono::system_clock::from_time_t(std::mktime(&next));
@@ -139,7 +217,7 @@ const bool Cron::processEvents()
             next = cron::cron_next(cronexrp, nowTm); // update next execution time only if event was executed
                                                      // otherwise time tracking is lost
             LOG_INFO("Cron running event [", eventName.c_str(), "] next execution time [", drivers::PCF85063::tm2str(next).c_str(), "]");
-            commands::commandMap.at(cmd)(m_dev, params); // here the magic happens
+            commands::commandMap.at(cmd)(m_dev, cmdParams); // here the magic happens
         }
     }
     return true;