read hosts conf

src/Business/PdnsSlave.cpp

 
 #include <fstream>
 #include "DataAccess/PdnsSlaveConfig.h"
+#include "DataAccess/HostsConfig.h"
 #include "PdnsSlave.h"
 
 PdnsSlave::PdnsSlave(const std::string &filePath)
     dhcpTemplate.close();
     return true;
 }
+
+Result<Actions> PdnsSlave::readHosts()
+{
+    HostsConfig conf(_hostsPath);
+    auto res = conf.readConfig();
+    if (!res)
+        return res;
+    _actions = res.getData();
+    return res;
+}

src/Business/PdnsSlave.h

 #define PDNS_SLAVE_PDNSSLAVE_H
 
 # include <string>
+# include <memory>
 # include "DBO/SqlConfiguration.h"
+# include "DBO/Actions/Action.h"
 
 class PdnsSlave
 {
 
     BResult readDhcpdTemplate();
 
+    Result<Actions> readHosts();
+
 private:
     std::string _filePath;
 
     SqlConfiguration _slaveConfig;
 
     std::string _dhcpdTemplateContent;
+
+    Actions _actions;
 };
 
 

src/CMakeLists.txt

   Interface/MainClass.h
   Interface/CommandLineParser.cpp
   Interface/CommandLineParser.h
-  DBO/CommandLineOption.cpp
-  DBO/CommandLineOption.h
   Business/PdnsSlave.cpp
   Business/PdnsSlave.h
-  DBO/SqlConfiguration.cpp
-  DBO/SqlConfiguration.h
   DataAccess/PdnsSlaveConfig.cpp
   DataAccess/PdnsSlaveConfig.h
   DataAccess/HostsConfig.cpp
   DataAccess/HostsConfig.h
-  DBO/Actions/Action.cpp
-  DBO/Actions/Action.h
+  DBO/CommandLineOption.cpp
+  DBO/CommandLineOption.h
+  DBO/SqlConfiguration.cpp
+  DBO/SqlConfiguration.h
   DBO/Result.hxx
   DBO/Result.h
+  DBO/Actions/Action.cpp
+  DBO/Actions/Action.h
+  DBO/Actions/ActionDelHost.cpp
+  DBO/Actions/ActionDelHost.h
+  DBO/Actions/ActionAddHost.cpp
+  DBO/Actions/ActionAddHost.h
+  DBO/Actions/ActionDelDomain.cpp
+  DBO/Actions/ActionDelDomain.h
+  DBO/Actions/ActionAddDomain.cpp
+  DBO/Actions/ActionAddDomain.h
   )
 set(LIBS ${LIBS} jsoncpp)
-add_executable(pdns-slave ${SOURCE_FILES} DBO/Actions/ActionDelHost.cpp DBO/Actions/ActionDelHost.h DBO/Actions/ActionAddHost.cpp DBO/Actions/ActionAddHost.h)
+add_executable(pdns-slave ${SOURCE_FILES})
 target_link_libraries(pdns-slave ${LIBS})

src/DataAccess/HostsConfig.cpp

 #include <DBO/Actions/Action.h>
 #include <DBO/Actions/ActionAddHost.h>
 #include <DBO/Actions/ActionDelHost.h>
+#include <DBO/Actions/ActionAddDomain.h>
+#include <DBO/Actions/ActionDelDomain.h>
 #include "HostsConfig.h"
 
 #define SET_VALUE(VALUE, METHOD, TYPE) do {             \
         auto v = readValue(act, defaults, VALUE);       \
         if (!v || !v.is##TYPE())                        \
         {                                               \
+            res.addWarning("Could not find value "      \
+                VALUE " for item " + i);                \
             action = nullptr;                           \
         }                                               \
         else                                            \
 {
 }
 
-BResult HostsConfig::readConfig()
+Result<Actions> HostsConfig::readConfig()
 {
-    BResult res;
+    Result<Actions> res;
     std::ifstream file(_filePath);
     if (!file)
         return res.error("Could not open file");
         return res.error("Could not parse JSON");
     }
     auto defaults = root["defaults"];
-    auto actions = root["actions"];
-    for (Json::ArrayIndex i = 0; i < actions.size(); ++i)
+    if (!defaults || !defaults.isObject())
+        return res.error("Could not find defaults object");
+    auto acts = root["actions"];
+    if (!acts || !acts.isArray())
+        return res.error("Could not find actions array");
+    std::vector<std::shared_ptr<Action>> actions;
+    for (Json::ArrayIndex i = 0; i < acts.size(); ++i)
     {
-        auto act = actions[i];
+        auto act = acts[i];
         auto action_type = readValue(act, defaults, "action");
-        if (!action_type)
-            res.addWarning("Could no find action value for item " + i);
+        if (!action_type || !action_type.isString())
+            res.addWarning("Could not find action value for item " + std::to_string(i));
         else
         {
             auto action_str = action_type.asString();
-            std::shared_ptr<Action> actionAbs = nullptr;
             if (action_str == "add_domain")
             {
-
+                auto del = readDelDomain(act, defaults, i, res);
+                auto add = readAddDomain(act, defaults, i, res);
+                if (del && add)
+                {
+                    actions.push_back(del);
+                    actions.push_back(add);
+                }
             }
             else if (action_str == "del_domain")
             {
-
+                auto del = readDelDomain(act, defaults, i, res);
+                if (del)
+                    actions.push_back(del);
             }
             else if (action_str == "add_host")
             {
-                auto action = std::make_shared<ActionAddHost>();
-                SET_VALUE_STRING("host", setHost);
-                SET_VALUE_STRING("record_value", setRecordValue);
-                SET_VALUE_STRING("record_type", setRecordType);
-                actionAbs = action;
+                auto del = readDelHost(act, defaults, i, res);
+                auto add = readAddHost(act, defaults, i, res);
+                if (del && add)
+                {
+                    actions.push_back(del);
+                    actions.push_back(add);
+                }
             }
             else if (action_str == "del_host")
             {
-                auto action = std::make_shared<ActionDelHost>();
-                SET_VALUE_STRING("host", setHost);
-                actionAbs = action;
-            }
-            else
-                res.addWarning("Unkown action " + action_str);
-            if (actionAbs)
-            {
-                auto action = actionAbs;
-                SET_VALUE_STRING("domain", setDomain);
+                auto del = readDelHost(act, defaults, i, res);
+                if (del)
+                    actions.push_back(del);
             }
             else
-                res.addWarning("Errors occured while processing item " + i);
+                res.addWarning("Unknown action " + action_str);
         }
     }
-    return true;
+    return res.ok(actions);
 }
 
-Json::Value HostsConfig::readValue(const Json::Value &value, const Json::Value &defaults, const std::string &name)
+Json::Value HostsConfig::readValue(const Json::Value &value, const Json::Value &defaults, const std::string &name) const
 {
     auto v = value[name];
     if (!v)
         return defaults[name];
     return v;
 }
+
+std::shared_ptr<Action> HostsConfig::readAddHost(const Json::Value &act, const Json::Value &defaults,
+                                                 int i, Result<Actions>& res) const
+{
+    auto action = std::make_shared<ActionAddHost>();
+    SET_VALUE_STRING("domain", setDomain);
+    SET_VALUE_STRING("host", setHost);
+    SET_VALUE_STRING("record_value", setRecordValue);
+    SET_VALUE_STRING("record_type", setRecordType);
+    SET_VALUE_STRING("dhcp_mac", setDhcpMac);
+    SET_VALUE_STRING("reverse_domain", setReverseDomain);
+    SET_VALUE_BOOL("reverse_enabled", setReverseEnabled);
+    return action;
+}
+
+std::shared_ptr<Action> HostsConfig::readDelHost(const Json::Value &act, const Json::Value &defaults, int i,
+                                                 Result<Actions> &res) const
+{
+    auto action = std::make_shared<ActionDelHost>();
+    SET_VALUE_STRING("domain", setDomain);
+    SET_VALUE_STRING("host", setHost);
+    return action;
+}
+
+std::shared_ptr<Action> HostsConfig::readAddDomain(const Json::Value &act, const Json::Value &defaults, int i,
+                                                   Result<Actions> &res) const
+{
+    auto action = std::make_shared<ActionAddDomain>();
+    SET_VALUE_STRING("domain", setDomain);
+    return action;
+}
+
+std::shared_ptr<Action> HostsConfig::readDelDomain(const Json::Value &act, const Json::Value &defaults, int i,
+                                                   Result<Actions> &res) const
+{
+    auto action = std::make_shared<ActionDelDomain>();
+    SET_VALUE_STRING("domain", setDomain);
+    return action;
+}

src/DataAccess/HostsConfig.h

 #define PDNS_SLAVE_HOSTSCONFIG_H
 
 # include <string>
-# include <DBO/Result.h>
+# include "DBO/Result.h"
+# include "DBO/Actions/Action.h"
 
 class HostsConfig
 {
 public:
     HostsConfig(const std::string& filePath);
 
-    BResult readConfig();
+    Result<Actions> readConfig();
 
 private:
-    Json::Value readValue(const Json::Value &value, const Json::Value &defaults, const std::string& name);
+    Json::Value readValue(const Json::Value &value, const Json::Value &defaults, const std::string& name) const;
+
+    std::shared_ptr<Action> readAddHost(const Json::Value &act, const Json::Value &defaults,
+                                        int i, Result<Actions>& res) const;
+
+    std::shared_ptr<Action> readDelHost(const Json::Value &act, const Json::Value &defaults,
+                                        int i, Result<Actions>& res) const;
+
+    std::shared_ptr<Action> readAddDomain(const Json::Value &act, const Json::Value &defaults,
+                                        int i, Result<Actions>& res) const;
+
+    std::shared_ptr<Action> readDelDomain(const Json::Value &act, const Json::Value &defaults,
+                                        int i, Result<Actions>& res) const;
+
     std::string _filePath;
 };
 

src/Interface/MainClass.cpp

 
     PdnsSlave pdnsSlave(filePath);
     BResult res;
+    Result<Actions> res2;
+
+    std::cout << "Reading pdns-slave configuration" << std::endl;
     if (!(res = pdnsSlave.readConfig()))
     {
         std::cerr << "Failed to read pdns-slave configuration" << std::endl;
         res.print();
         return 1;
     }
+    res.print();
+
+    std::cout << "Reading dhcpd template" << std::endl;
     if (!(res = pdnsSlave.readDhcpdTemplate()))
     {
         std::cerr << "Failed to read dhcpd template" << std::endl;
         res.print();
         return 2;
     }
+    res.print();
+
+    std::cout << "Reading hosts configuration" << std::endl;
+    if (!(res2 = pdnsSlave.readHosts()))
+    {
+        std::cerr << "Failed to read hosts configuration" << std::endl;
+        res2.print();
+        return 3;
+    }
+    res2.print();
 
     return 0;
 }