use Result class; begin hosts parse

src/Business/PdnsSlave.cpp

 {
 }
 
-bool PdnsSlave::readConfig()
+BResult PdnsSlave::readConfig()
 {
     PdnsSlaveConfig conf(_filePath);
-    if (!conf.readConfig())
-        return false;
+    BResult res;
+    if (!(res = conf.readConfig()))
+        return res;
 
     _dhcpdFilePath = conf.getDhcpdFilePath();
     _dhcpdTemplatePath = conf.getDhcpdTemplatePath();
     return true;
 }
 
-bool PdnsSlave::readDhcpdTemplate()
+BResult PdnsSlave::readDhcpdTemplate()
 {
     std::ifstream dhcpTemplate(_dhcpdTemplatePath);
     if (!dhcpTemplate)
-        return false;
+        return BResult().error("Could not open file");
     while (!dhcpTemplate.eof())
     {
         std::string line;

src/Business/PdnsSlave.h

 public:
     PdnsSlave(const std::string& filePath);
 
-    bool readConfig();
+    BResult readConfig();
 
-    bool readDhcpdTemplate();
+    BResult readDhcpdTemplate();
 
 private:
     std::string _filePath;

src/CMakeLists.txt

   DBO/SqlConfiguration.h
   DataAccess/PdnsSlaveConfig.cpp
   DataAccess/PdnsSlaveConfig.h
+  DataAccess/HostsConfig.cpp
+  DataAccess/HostsConfig.h
+  DBO/Actions/Action.cpp
+  DBO/Actions/Action.h
+  DBO/Result.hxx
+  DBO/Result.h
   )
 set(LIBS ${LIBS} jsoncpp)
-add_executable(pdns-slave ${SOURCE_FILES} DataAccess/HostsConfig.cpp DataAccess/HostsConfig.h)
+add_executable(pdns-slave ${SOURCE_FILES} DBO/Actions/ActionDelHost.cpp DBO/Actions/ActionDelHost.h DBO/Actions/ActionAddHost.cpp DBO/Actions/ActionAddHost.h)
 target_link_libraries(pdns-slave ${LIBS})

src/DataAccess/HostsConfig.cpp

 
 #include <json/json.h>
 #include <fstream>
+#include <memory>
+#include <DBO/Actions/Action.h>
+#include <DBO/Actions/ActionAddHost.h>
+#include <DBO/Actions/ActionDelHost.h>
 #include "HostsConfig.h"
 
+#define SET_VALUE(VALUE, METHOD, TYPE) do {             \
+    if (action)                                         \
+    {                                                   \
+        auto v = readValue(act, defaults, VALUE);       \
+        if (!v || !v.is##TYPE())                        \
+        {                                               \
+            action = nullptr;                           \
+        }                                               \
+        else                                            \
+        {                                               \
+            action->METHOD(v.as##TYPE());               \
+        }                                               \
+    }                                                   \
+    } while (0)
+
+#define SET_VALUE_STRING(VALUE, METHOD) SET_VALUE(VALUE, METHOD, String)
+
+#define SET_VALUE_BOOL(VALUE, METHOD) SET_VALUE(VALUE, METHOD, Bool)
+
 HostsConfig::HostsConfig(const std::string &filePath)
     : _filePath(filePath)
 {
 }
 
-bool HostsConfig::readConfig()
+BResult HostsConfig::readConfig()
 {
+    BResult res;
     std::ifstream file(_filePath);
     if (!file)
-        return false;
+        return res.error("Could not open file");
     Json::Value root;
     try
     {
     catch (...)
     {
         file.close();
-        return false;
+        return res.error("Could not parse JSON");
     }
     auto defaults = root["defaults"];
     auto actions = root["actions"];
     for (Json::ArrayIndex i = 0; i < actions.size(); ++i)
     {
-        auto action = actions[i];
-        auto action_type = readValue(action, defaults, "action");
+        auto act = actions[i];
+        auto action_type = readValue(act, defaults, "action");
+        if (!action_type)
+            res.addWarning("Could no find action value for item " + i);
+        else
+        {
+            auto action_str = action_type.asString();
+            std::shared_ptr<Action> actionAbs = nullptr;
+            if (action_str == "add_domain")
+            {
+
+            }
+            else if (action_str == "del_domain")
+            {
+
+            }
+            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;
+            }
+            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);
+            }
+            else
+                res.addWarning("Errors occured while processing item " + i);
+        }
     }
     return true;
 }

src/DataAccess/HostsConfig.h

 #define PDNS_SLAVE_HOSTSCONFIG_H
 
 # include <string>
+# include <DBO/Result.h>
 
 class HostsConfig
 {
 public:
     HostsConfig(const std::string& filePath);
 
-    bool readConfig();
+    BResult readConfig();
 
 private:
     Json::Value readValue(const Json::Value &value, const Json::Value &defaults, const std::string& name);

src/DataAccess/PdnsSlaveConfig.cpp

 {
 }
 
-bool PdnsSlaveConfig::readConfig()
+BResult PdnsSlaveConfig::readConfig()
 {
     std::ifstream file(_filePath);
     if (!file)
-        return false;
+        return BResult().error("Could not open file");
     Json::Value root;
     try
     {
     catch (...)
     {
         file.close();
-        return false;
+        return BResult().error("Could not parse JSON");
     }
-    if (!readString(root, "dhcpd-file", _dhcpdFilePath))
-        return false;
-    if (!readString(root, "dhcpd-template", _dhcpdTemplatePath))
-        return false;
-    if (!readString(root, "hosts-file", _hostsPath))
-        return false;
-    if (!readSqlConfiguration(root, "master", _masterConfig))
-        return false;
-    if (!readSqlConfiguration(root, "slave", _slaveConfig))
-        return false;
-
+    BResult res;
+    if (!(res = readString(root, "dhcpd-file", _dhcpdFilePath)))
+        return res;
+    if (!(res = readString(root, "dhcpd-template", _dhcpdTemplatePath)))
+        return res;
+    if (!(res = readString(root, "hosts-file", _hostsPath)))
+        return res;
+    if (!(res = readSqlConfiguration(root, "master", _masterConfig)))
+        return res;
+    if (!(res = readSqlConfiguration(root, "slave", _slaveConfig)))
+        return res;
     return true;
 }
 
-bool PdnsSlaveConfig::readSqlConfiguration(const Json::Value &value, const std::string &name, SqlConfiguration &sqlConfiguration)
+BResult PdnsSlaveConfig::readSqlConfiguration(const Json::Value &value, const std::string &name, SqlConfiguration &sqlConfiguration)
 {
     std::string str;
-    if (!readString(value, name + "-host", str))
-        return false;
+    BResult res;
+    if (!(res = readString(value, name + "-host", str)))
+        return res;
     sqlConfiguration.setHost(str);
 
-    if (!readString(value, name + "-user", str))
-        return false;
+    if (!(res = readString(value, name + "-user", str)))
+        return res;
     sqlConfiguration.setUser(str);
 
-    if (!readString(value, name + "-password", str))
-        return false;
+    if (!(res = readString(value, name + "-password", str)))
+        return res;
     sqlConfiguration.setPassword(str);
 
-    if (!readString(value, name + "-database", str))
-        return false;
+    if (!(res = readString(value, name + "-database", str)))
+        return res;
     sqlConfiguration.setDatabase(str);
 
     return true;
 }
 
-bool PdnsSlaveConfig::readString(const Json::Value &value, const std::string &name, std::string &dest)
+BResult PdnsSlaveConfig::readString(const Json::Value &value, const std::string &name, std::string &dest)
 {
     auto v = value[name];
     if (!v)
-        return false;
+        return BResult().error("Could not find value " + name);
     dest = v.asString();
     return true;
 }

src/DataAccess/PdnsSlaveConfig.h

 #define PDNS_SLAVE_PDNSSLAVECONFIG_H
 
 # include <string>
+# include "DBO/Result.h"
 # include "DBO/SqlConfiguration.h"
 
 namespace Json
 public:
     PdnsSlaveConfig(const std::string& filePath);
 
-    bool readConfig();
+    BResult readConfig();
 
     const std::string &getDhcpdFilePath() const;
 
     const SqlConfiguration &getSlaveConfig() const;
 
 private:
-    bool readString(const Json::Value& value, const std::string& name, std::string& dest);
+    BResult readString(const Json::Value& value, const std::string& name, std::string& dest);
 
-    bool readSqlConfiguration(const Json::Value &value, const std::string &name, SqlConfiguration& sqlConfiguration);
+    BResult readSqlConfiguration(const Json::Value &value, const std::string &name, SqlConfiguration& sqlConfiguration);
 
     std::string _filePath;
 

src/Interface/MainClass.cpp

 
 #include <iostream>
 #include <sysexits.h>
+#include <DBO/Result.h>
 #include "CommandLineParser.h"
 #include "Business/PdnsSlave.h"
 #include "MainClass.h"
     std::cout << "Using configuration file " << filePath << std::endl;
 
     PdnsSlave pdnsSlave(filePath);
-    if (!pdnsSlave.readConfig())
+    BResult res;
+    if (!(res = pdnsSlave.readConfig()))
     {
         std::cerr << "Failed to read pdns-slave configuration" << std::endl;
+        res.print();
         return 1;
     }
-    if (!pdnsSlave.readDhcpdTemplate())
+    if (!(res = pdnsSlave.readDhcpdTemplate()))
     {
         std::cerr << "Failed to read dhcpd template" << std::endl;
+        res.print();
         return 2;
     }