Adding upstream version 2.2.0.upstream/2.2.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 204 insertions, 0 deletions

diff --git a/src/lib/yang/translator_database.cc b/src/lib/yang/translator_database.cc
new file mode 100644
index 0000000..1536dd7
--- /dev/null
+++ b/src/lib/yang/translator_database.cc
@@ -0,0 +1,204 @@
+// Copyright (C) 2018-2022 Internet Systems Consortium, Inc. ("ISC")
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include <config.h>
+
+#include <yang/translator_database.h>
+#include <yang/adaptor.h>
+#include <yang/yang_models.h>
+#include <sstream>
+
+using namespace std;
+using namespace isc::data;
+using namespace sysrepo;
+
+namespace isc {
+namespace yang {
+
+TranslatorDatabase::TranslatorDatabase(S_Session session, const string& model)
+    : TranslatorBasic(session, model) {
+}
+
+TranslatorDatabase::~TranslatorDatabase() {
+}
+
+ElementPtr
+TranslatorDatabase::getDatabase(const string& xpath) {
+    try {
+        if ((model_ == KEA_DHCP4_SERVER) ||
+            (model_ == KEA_DHCP6_SERVER)) {
+            return (getDatabaseKea(xpath));
+        }
+    } catch (const sysrepo_exception& ex) {
+        isc_throw(SysrepoError,
+                  "sysrepo error getting database access at '" << xpath
+                  << "': " << ex.what());
+    }
+    isc_throw(NotImplemented,
+              "getDatabase not implemented for the model: " << model_);
+}
+
+ElementPtr
+TranslatorDatabase::getDatabaseKea(const string& xpath) {
+    ConstElementPtr type = getItem(xpath + "/database-type");
+    if (!type) {
+        return (ElementPtr());
+    }
+    ElementPtr result = Element::createMap();
+    result->set("type", type);
+    checkAndGetLeaf(result, xpath, "user");
+    checkAndGetLeaf(result, xpath, "password");
+    checkAndGetLeaf(result, xpath, "host");
+    checkAndGetLeaf(result, xpath, "name");
+    checkAndGetLeaf(result, xpath, "persist");
+    checkAndGetLeaf(result, xpath, "port");
+    checkAndGetLeaf(result, xpath, "lfc-interval");
+    checkAndGetLeaf(result, xpath, "readonly");
+    checkAndGetLeaf(result, xpath, "trust-anchor");
+    checkAndGetLeaf(result, xpath, "cert-file");
+    checkAndGetLeaf(result, xpath, "key-file");
+    checkAndGetLeaf(result, xpath, "cipher-list");
+    checkAndGetLeaf(result, xpath, "connect-timeout");
+    checkAndGetLeaf(result, xpath, "max-reconnect-tries");
+    checkAndGetLeaf(result, xpath, "reconnect-wait-time");
+    checkAndGetLeaf(result, xpath, "max-row-errors");
+    checkAndGetLeaf(result, xpath, "on-fail");
+    ConstElementPtr context = getItem(xpath + "/user-context");
+    if (context) {
+        result->set("user-context", Element::fromJSON(context->stringValue()));
+    }
+    return (result);
+}
+
+void
+TranslatorDatabase::setDatabase(const string& xpath,
+                                ConstElementPtr elem,
+                                bool skip) {
+    try {
+        if ((model_ == KEA_DHCP4_SERVER) ||
+            (model_ == KEA_DHCP6_SERVER)) {
+            setDatabaseKea(xpath, elem, skip);
+        } else {
+            isc_throw(NotImplemented,
+                      "setDatabase not implemented for the model: " << model_);
+        }
+    } catch (const sysrepo_exception& ex) {
+        isc_throw(SysrepoError,
+                  "sysrepo error setting database access '" << elem->str()
+                  << "' at '" << xpath << "': " << ex.what());
+    }
+}
+
+void
+TranslatorDatabase::setDatabaseKea(const string& xpath,
+                                   ConstElementPtr elem,
+                                   bool skip) {
+    if (!elem) {
+        delItem(xpath);
+        return;
+    }
+    if (!skip) {
+        ConstElementPtr type = elem->get("type");
+        if (!type) {
+            isc_throw(BadValue, "setDatabase requires database type: "
+                      << elem->str());
+        }
+        setItem(xpath + "/database-type", type, SR_STRING_T);
+    }
+    checkAndSetLeaf(elem, xpath, "user", SR_STRING_T);
+    checkAndSetLeaf(elem, xpath, "password", SR_STRING_T);
+    checkAndSetLeaf(elem, xpath, "host", SR_STRING_T);
+    checkAndSetLeaf(elem, xpath, "name", SR_STRING_T);
+    checkAndSetLeaf(elem, xpath, "persist", SR_BOOL_T);
+    checkAndSetLeaf(elem, xpath, "port", SR_UINT16_T);
+    checkAndSetLeaf(elem, xpath, "lfc-interval", SR_UINT32_T);
+    checkAndSetLeaf(elem, xpath, "readonly", SR_BOOL_T);
+    checkAndSetLeaf(elem, xpath, "trust-anchor", SR_STRING_T);
+    checkAndSetLeaf(elem, xpath, "cert-file", SR_STRING_T);
+    checkAndSetLeaf(elem, xpath, "key-file", SR_STRING_T);
+    checkAndSetLeaf(elem, xpath, "cipher-list", SR_STRING_T);
+    checkAndSetLeaf(elem, xpath, "connect-timeout", SR_UINT32_T);
+    checkAndSetLeaf(elem, xpath, "max-reconnect-tries", SR_UINT32_T);
+    checkAndSetLeaf(elem, xpath, "reconnect-wait-time", SR_UINT32_T);
+    checkAndSetLeaf(elem, xpath, "max-row-errors", SR_UINT32_T);
+    checkAndSetLeaf(elem, xpath, "on-fail", SR_STRING_T);
+    ConstElementPtr context = Adaptor::getContext(elem);
+    if (context) {
+        setItem(xpath + "/user-context", Element::create(context->str()),
+                SR_STRING_T);
+    }
+}
+
+TranslatorDatabases::TranslatorDatabases(S_Session session,
+                                         const string& model)
+    : TranslatorBasic(session, model),
+      TranslatorDatabase(session, model) {
+}
+
+TranslatorDatabases::~TranslatorDatabases() {
+}
+
+ConstElementPtr
+TranslatorDatabases::getDatabases(const string& xpath) {
+    try {
+        if ((model_ == KEA_DHCP4_SERVER) ||
+            (model_ == KEA_DHCP6_SERVER)) {
+            return (getDatabasesKea(xpath));
+        }
+    } catch (const sysrepo_exception& ex) {
+        isc_throw(SysrepoError,
+                  "sysrepo error getting database accesses at '" << xpath
+                  << "': " << ex.what());
+    }
+    isc_throw(NotImplemented,
+              "getDatabases not implemented for the model: " << model_);
+}
+
+ElementPtr
+TranslatorDatabases::getDatabasesKea(const string& xpath) {
+    return getList<TranslatorDatabase>(xpath, *this,
+                                       &TranslatorDatabase::getDatabase);
+}
+
+void
+TranslatorDatabases::setDatabases(const string& xpath, ConstElementPtr elem) {
+    try {
+        if ((model_ == KEA_DHCP4_SERVER) ||
+            (model_ == KEA_DHCP6_SERVER)) {
+            setDatabasesKea(xpath, elem);
+        } else {
+            isc_throw(NotImplemented,
+                      "setDatabases not implemented for the model: "
+                      << model_);
+        }
+    } catch (const sysrepo_exception& ex) {
+        isc_throw(SysrepoError,
+                  "sysrepo error setting database accesses '" << elem->str()
+                  << "' at '" << xpath << "': " << ex.what());
+    }
+}
+
+void
+TranslatorDatabases::setDatabasesKea(const string& xpath,
+                                     ConstElementPtr elem) {
+    if (!elem) {
+        delItem(xpath);
+        return;
+    }
+    for (size_t i = 0; i < elem->size(); ++i) {
+        ConstElementPtr database = elem->get(i);
+        if (!database->contains("type")) {
+            isc_throw(BadValue, "database without type: " << database->str());
+        }
+        string type = database->get("type")->stringValue();
+        ostringstream key;
+        key << xpath << "[database-type='" << type << "']";
+        setDatabase(key.str(), database, true);
+    }
+}
+
+}  // namespace yang
+}  // namespace isc