begin pgsql backend

conf/pdns-slave.json.default

 
   "hosts-file":       "/etc/pdns-slave/hosts.json",
 
+  "db-type":          "pgsql",
+
   "master-host":      "ns.example.com",
   "master-user":      "master-user",
   "master-password":  "master-password",

src/Business/PdnsSlave.cpp

 
 #include <fstream>
 #include <DataAccess/MySql.h>
+#include <DataAccess/PgSql.h>
 #include "DataAccess/PdnsSlaveConfig.h"
 #include "DataAccess/HostsConfig.h"
 #include "PdnsSlave.h"
     _dhcpdFilePath = conf.getDhcpdFilePath();
     _dhcpdTemplatePath = conf.getDhcpdTemplatePath();
     _hostsPath = conf.getHostsPath();
+    _dbType = conf.getDbType();
     _masterConfig = conf.getMasterConfig();
     _slaveConfig = conf.getSlaveConfig();
 
 
 BResult PdnsSlave::overridePdns()
 {
-    MySql mysql(_masterConfig, _slaveConfig);
-    auto res = mysql.dump();
+    AbstractSql* sqlDb = 0;
+    if (_dbType == "mysql") {
+        sqlDb = new MySql(_masterConfig, _slaveConfig);
+    }
+    else if (_dbType == "pgsql") {
+        sqlDb = new PgSql(_masterConfig, _slaveConfig);
+    }
+    else {
+        return BResult().error("Invalid database type " + _dbType);
+    }
+    auto res = sqlDb->dump();
     if (!res)
         return res;
-    if (!(res = mysql.insert()))
+    if (!(res = sqlDb->insert()))
         return res;
     std::string sql;
     for (auto a : _actions)
         sql += a->getSqlQuery();
-    return mysql.override(sql);
+    res = sqlDb->override(sql);
+    delete sqlDb;
+    return res;
 }
 
 BResult PdnsSlave::overrideDhcp()

src/Business/PdnsSlave.h

 
     std::string _hostsPath;
 
+    std::string _dbType;
+
     SqlConfiguration _masterConfig;
 
     SqlConfiguration _slaveConfig;

src/CMakeLists.txt

   DBO/Actions/ActionDelDomain.h
   DBO/Actions/ActionAddDomain.cpp
   DBO/Actions/ActionAddDomain.h
-        DataAccess/AbstractSql.cpp DataAccess/AbstractSql.h)
+        DataAccess/AbstractSql.cpp DataAccess/AbstractSql.h DataAccess/PgSql.cpp DataAccess/PgSql.h)
 set(LIBS ${LIBS} jsoncpp)
 add_executable(pdns-slave ${SOURCE_FILES})
 target_link_libraries(pdns-slave ${LIBS})

src/DBO/Actions/ActionAddDomain.cpp

     _ttl = ttl;
 }
 
-const std::string ActionAddDomain::getSql() const //ns.rthoni.com rthoni.hotmail.fr 2015080600 28800 7200 604800 86400
+const std::string ActionAddDomain::getSql() const
 {
     auto soa = _soaNs + " " + _soaMail + " " + std::to_string(time(nullptr)) + " " + std::to_string(_soaRefresh)
              + " " + std::to_string(_soaRetry)+ " " + std::to_string(_soaExpire) + " " + std::to_string(_soaTtl);

src/DataAccess/AbstractSql.cpp

+//
+// Created by robin on 4/6/16.
+//
+
+#include "AbstractSql.h"
+
+AbstractSql::~AbstractSql()
+{
+}
+
+AbstractSql::AbstractSql(const SqlConfiguration &masterConfig, const SqlConfiguration &slaveConfig)
+        : _masterConfig(masterConfig)
+        , _slaveConfig(slaveConfig)
+{
+}

src/DataAccess/AbstractSql.h

+//
+// Created by robin on 4/6/16.
+//
+
+#ifndef PDNS_SLAVE_ABSTRACTSQL_H
+#define PDNS_SLAVE_ABSTRACTSQL_H
+
+#include <DBO/Result.h>
+#include <DBO/SqlConfiguration.h>
+#include "DBO/Result.h"
+
+class AbstractSql
+{
+public:
+    AbstractSql(const SqlConfiguration& masterConfig, const SqlConfiguration& slaveConfig);
+    virtual ~AbstractSql();
+
+    virtual BResult dump() = 0;
+
+    virtual BResult insert() = 0;
+
+    virtual BResult override(const std::string& sql) = 0;
+
+protected:
+    SqlConfiguration _masterConfig;
+
+    SqlConfiguration _slaveConfig;
+};
+
+
+#endif //PDNS_SLAVE_ABSTRACTSQL_H

src/DataAccess/MySql.cpp

 #define tmpTemplate "/tmp/pdns-slave.XXXXXX"
 
 MySql::MySql(const SqlConfiguration &masterConfig, const SqlConfiguration &slaveConfig)
-    : _masterConfig(masterConfig)
-    , _slaveConfig(slaveConfig)
+    : AbstractSql(masterConfig, slaveConfig)
 {
 }
 
 MySql::~MySql()
 {
-    clean();
+    if (!_dumpFilePath.empty())
+    {
+        unlink(_dumpFilePath.c_str());
+        _dumpFilePath = "";
+    }
+    if (!_overrideFilePath.empty())
+    {
+        unlink(_overrideFilePath.c_str());
+        _overrideFilePath = "";
+    }
 }
 
 BResult MySql::dump()
     return std::string(tmp);
 }
 
-void MySql::clean()
-{
-    if (!_dumpFilePath.empty())
-    {
-        unlink(_dumpFilePath.c_str());
-        _dumpFilePath = "";
-    }
-    if (!_overrideFilePath.empty())
-    {
-        unlink(_overrideFilePath.c_str());
-        _overrideFilePath = "";
-    }
-}
-
 BResult MySql::insert()
 {
     return insertSlave(_dumpFilePath);

src/DataAccess/MySql.h

 #ifndef PDNS_SLAVE_MYSQL_H
 #define PDNS_SLAVE_MYSQL_H
 
-#include <DBO/Result.h>
-#include <DBO/SqlConfiguration.h>
-# include "DBO/Result.h"
+#include "AbstractSql.h"
 
-class MySql
+class MySql : public AbstractSql
 {
 public:
     MySql(const SqlConfiguration& masterConfig, const SqlConfiguration& slaveConfig);
-    virtual ~MySql();
+    ~MySql();
 
     BResult dump();
 
 
     BResult override(const std::string& sql);
 
-    void clean();
-
 private:
     const std::string getTempFile();
 
     BResult insertSlave(const std::string& file);
 
-    SqlConfiguration _masterConfig;
-
-    SqlConfiguration _slaveConfig;
-
     std::string _dumpFilePath;
 
     std::string _overrideFilePath;

src/DataAccess/PdnsSlaveConfig.cpp

         return res;
     if (!(res = readString(root, "hosts-file", _hostsPath)))
         return res;
+    if (!(res = readString(root, "db-type", _dbType)))
+        return res;
+    if (_dbType != "mysql" && _dbType != "pgsql")
+    {
+        return BResult().error("Invalid database type " + _dbType);
+    }
     if (!(res = readSqlConfiguration(root, "master", _masterConfig)))
         return res;
     if (!(res = readSqlConfiguration(root, "slave", _slaveConfig)))
 const SqlConfiguration &PdnsSlaveConfig::getSlaveConfig() const
 {
     return _slaveConfig;
-}
+}
+
+const std::string &PdnsSlaveConfig::getDbType() const
+{
+    return _dbType;
+}

src/DataAccess/PdnsSlaveConfig.h

 
     const std::string &getHostsPath() const;
 
+    const std::string &getDbType() const;
+
     const SqlConfiguration &getMasterConfig() const;
 
     const SqlConfiguration &getSlaveConfig() const;
 
     std::string _hostsPath;
 
+    std::string _dbType;
+
     SqlConfiguration _masterConfig;
 
     SqlConfiguration _slaveConfig;

src/DataAccess/PgSql.cpp

+//
+// Created by robin on 4/6/16.
+//
+
+#include <fstream>
+#include <string.h>
+#include <unistd.h>
+#include "PgSql.h"
+
+#define tmpTemplate "/tmp/pdns-slave.XXXXXX"
+
+PgSql::PgSql(const SqlConfiguration &masterConfig, const SqlConfiguration &slaveConfig)
+        : AbstractSql(masterConfig, slaveConfig)
+{
+}
+
+PgSql::~PgSql()
+{
+    if (!_dumpFilePath.empty())
+    {
+        unlink(_dumpFilePath.c_str());
+        _dumpFilePath = "";
+    }
+    if (!_overrideFilePath.empty())
+    {
+        unlink(_overrideFilePath.c_str());
+        _overrideFilePath = "";
+    }
+}
+
+BResult PgSql::dump()
+{
+    BResult res;
+    _dumpFilePath = getTempFile();
+    auto command = std::string("PGPASSWORD='" + _masterConfig.getPassword() + "' "
+                               + "pg_dump -h '" + _masterConfig.getHost() + "' "
+                               + "-U '" + _masterConfig.getUser() + "' "
+                               + "-w -c -x -O '" + _masterConfig.getDatabase() + "' "
+                               + "> '" + _dumpFilePath + "'");
+    std::cout << command << std::endl;
+    int status = system(command.c_str());
+    if (status == 0)
+        return res.ok(true);
+    return res.error("pg_dump exited with code " + std::to_string(status));
+}
+
+const std::string PgSql::getTempFile()
+{
+    char tmp[sizeof(tmpTemplate)];
+    strcpy(tmp, tmpTemplate);
+    mkstemp(tmp);
+    return std::string(tmp);
+}
+
+BResult PgSql::insert()
+{
+    return insertSlave(_dumpFilePath);
+}
+
+BResult PgSql::override(const std::string &sql)
+{
+    _overrideFilePath = getTempFile();
+    std::ofstream file(_overrideFilePath);
+    if (!file)
+        return BResult().error("Could not open temp file " + _overrideFilePath);
+    file << sql;
+    file.close();
+    return insertSlave(_overrideFilePath);
+}
+
+BResult PgSql::insertSlave(const std::string &file)
+{
+    BResult res;
+    auto command = std::string("cat '" + file + "' | PGPASSWORD='" + _slaveConfig.getPassword() + "' "
+                               + "psql -h '" + _slaveConfig.getHost() + "' "
+                               + "-U '" + _slaveConfig.getUser() + "' "
+                               + "-w -d '" + _slaveConfig.getDatabase() + "' > /dev/null");
+    std::cout << command << std::endl;
+    int status = system(command.c_str());
+    if (status == 0)
+        return res.ok(true);
+    return res.error("psql exited with code " + std::to_string(status));
+}

src/DataAccess/PgSql.h

+//
+// Created by robin on 4/6/16.
+//
+
+#ifndef PDNS_SLAVE_PGSQL_H
+#define PDNS_SLAVE_PGSQL_H
+
+#include "AbstractSql.h"
+
+class PgSql : public AbstractSql
+{
+public:
+    PgSql(const SqlConfiguration& masterConfig, const SqlConfiguration& slaveConfig);
+    ~PgSql();
+
+    BResult dump();
+
+    BResult insert();
+
+    BResult override(const std::string& sql);
+
+private:
+    const std::string getTempFile();
+
+    BResult insertSlave(const std::string& file);
+
+    std::string _dumpFilePath;
+
+    std::string _overrideFilePath;
+};
+
+
+#endif //PDNS_SLAVE_PGSQL_H