Kea 2.0.2
translator_database.cc
Go to the documentation of this file.
1// Copyright (C) 2018-2021 Internet Systems Consortium, Inc. ("ISC")
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7#include <config.h>
8
10#include <yang/adaptor.h>
11#include <yang/yang_models.h>
12#include <sstream>
13
14using namespace std;
15using namespace isc::data;
16using namespace sysrepo;
17
18namespace isc {
19namespace yang {
20
21TranslatorDatabase::TranslatorDatabase(S_Session session, const string& model)
22 : TranslatorBasic(session, model) {
23}
24
26}
27
29TranslatorDatabase::getDatabase(const string& xpath) {
30 try {
31 if ((model_ == KEA_DHCP4_SERVER) ||
32 (model_ == KEA_DHCP6_SERVER)) {
33 return (getDatabaseKea(xpath));
34 }
35 } catch (const sysrepo_exception& ex) {
37 "sysrepo error getting database access at '" << xpath
38 << "': " << ex.what());
39 }
41 "getDatabase not implemented for the model: " << model_);
42}
43
46 ConstElementPtr type = getItem(xpath + "/database-type");
47 if (!type) {
48 return (ElementPtr());
49 }
50 ElementPtr result = Element::createMap();
51 result->set("type", type);
52 ConstElementPtr user = getItem(xpath + "/user");
53 if (user) {
54 result->set("user", user);
55 }
56 ConstElementPtr password = getItem(xpath + "/password");
57 if (password) {
58 result->set("password", password);
59 }
60 ConstElementPtr host = getItem(xpath + "/host");
61 if (host) {
62 result->set("host", host);
63 }
64 ConstElementPtr name = getItem(xpath + "/name");
65 if (name) {
66 result->set("name", name);
67 }
68 ConstElementPtr persist = getItem(xpath + "/persist");
69 if (persist) {
70 result->set("persist", persist);
71 }
72 ConstElementPtr port = getItem(xpath + "/port");
73 if (port) {
74 result->set("port", port);
75 }
76 ConstElementPtr lfc_interval = getItem(xpath + "/lfc-interval");
77 if (lfc_interval) {
78 result->set("lfc-interval", lfc_interval);
79 }
80 ConstElementPtr readonly = getItem(xpath + "/readonly");
81 if (readonly) {
82 result->set("readonly", readonly);
83 }
84 ConstElementPtr connect_timeout = getItem(xpath + "/connect-timeout");
85 if (connect_timeout) {
86 result->set("connect-timeout", connect_timeout);
87 }
88 ConstElementPtr contact_points = getItem(xpath + "/contact-points");
89 if (contact_points) {
90 result->set("contact-points", contact_points);
91 }
92 ConstElementPtr keyspace = getItem(xpath + "/keyspace");
93 if (keyspace) {
94 result->set("keyspace", keyspace);
95 }
96 ConstElementPtr max_reconnect = getItem(xpath + "/max-reconnect-tries");
97 if (max_reconnect) {
98 result->set("max-reconnect-tries", max_reconnect);
99 }
100 ConstElementPtr reconnect_time = getItem(xpath + "/reconnect-wait-time");
101 if (reconnect_time) {
102 result->set("reconnect-wait-time", reconnect_time);
103 }
104 ConstElementPtr request_timeout = getItem(xpath + "/request-timeout");
105 if (request_timeout) {
106 result->set("request-timeout", request_timeout);
107 }
108 ConstElementPtr keepalive = getItem(xpath + "/tcp-keepalive");
109 if (keepalive) {
110 result->set("tcp-keepalive", keepalive);
111 }
112 ConstElementPtr nodelay = getItem(xpath + "/tcp-nodelay");
113 if (nodelay) {
114 result->set("tcp-nodelay", nodelay);
115 }
116 ConstElementPtr consistency = getItem(xpath + "/consistency");
117 if (consistency) {
118 result->set("consistency", consistency);
119 }
120 ConstElementPtr serial_consistency = getItem(xpath + "/serial-consistency");
121 if (serial_consistency) {
122 result->set("serial-consistency", serial_consistency);
123 }
124 ConstElementPtr max_row_errors = getItem(xpath + "/max-row-errors");
125 if (max_row_errors) {
126 result->set("max-row-errors", max_row_errors);
127 }
128 ConstElementPtr context = getItem(xpath + "/user-context");
129 if (context) {
130 result->set("user-context", Element::fromJSON(context->stringValue()));
131 }
132 return (result);
133}
134
135void
137 ConstElementPtr elem,
138 bool skip) {
139 try {
140 if ((model_ == KEA_DHCP4_SERVER) ||
141 (model_ == KEA_DHCP6_SERVER)) {
142 setDatabaseKea(xpath, elem, skip);
143 } else {
145 "setDatabase not implemented for the model: " << model_);
146 }
147 } catch (const sysrepo_exception& ex) {
149 "sysrepo error setting database access '" << elem->str()
150 << "' at '" << xpath << "': " << ex.what());
151 }
152}
153
154void
156 ConstElementPtr elem,
157 bool skip) {
158 if (!elem) {
159 delItem(xpath);
160 return;
161 }
162 if (!skip) {
163 ConstElementPtr type = elem->get("type");
164 if (!type) {
165 isc_throw(BadValue, "setDatabase requires database type: "
166 << elem->str());
167 }
168 setItem(xpath + "/database-type", type, SR_STRING_T);
169 }
170 ConstElementPtr user = elem->get("user");
171 if (user) {
172 setItem(xpath + "/user", user, SR_STRING_T);
173 }
174 ConstElementPtr password = elem->get("password");
175 if (password) {
176 setItem(xpath + "/password", password, SR_STRING_T);
177 }
178 ConstElementPtr host = elem->get("host");
179 if (host) {
180 setItem(xpath + "/host", host, SR_STRING_T);
181 }
182 ConstElementPtr name = elem->get("name");
183 if (name) {
184 setItem(xpath + "/name", name, SR_STRING_T);
185 }
186 ConstElementPtr persist = elem->get("persist");
187 if (persist) {
188 setItem(xpath + "/persist", persist, SR_BOOL_T);
189 }
190 ConstElementPtr port = elem->get("port");
191 if (port) {
192 setItem(xpath + "/port", port, SR_UINT16_T);
193 }
194 ConstElementPtr lfc_interval = elem->get("lfc-interval");
195 if (lfc_interval) {
196 setItem(xpath + "/lfc-interval", lfc_interval, SR_UINT32_T);
197 }
198 ConstElementPtr readonly = elem->get("readonly");
199 if (readonly) {
200 setItem(xpath + "/readonly", readonly, SR_BOOL_T);
201 }
202 ConstElementPtr connect_timeout = elem->get("connect-timeout");
203 if (connect_timeout) {
204 setItem(xpath + "/connect-timeout", connect_timeout, SR_UINT32_T);
205 }
206 ConstElementPtr contact_points = elem->get("contact-points");
207 if (contact_points) {
208 setItem(xpath + "/contact-points", contact_points, SR_STRING_T);
209 }
210 ConstElementPtr keyspace = elem->get("keyspace");
211 if (keyspace) {
212 setItem(xpath + "/keyspace", keyspace, SR_STRING_T);
213 }
214 ConstElementPtr max_reconnect = elem->get("max-reconnect-tries");
215 if (max_reconnect) {
216 setItem(xpath + "/max-reconnect-tries", max_reconnect, SR_UINT32_T);
217 }
218 ConstElementPtr reconnect_wait = elem->get("reconnect-wait-time");
219 if (reconnect_wait) {
220 setItem(xpath + "/reconnect-wait-time", reconnect_wait, SR_UINT32_T);
221 }
222 ConstElementPtr request_timeout = elem->get("request-timeout");
223 if (request_timeout) {
224 setItem(xpath + "/request-timeout", request_timeout, SR_UINT32_T);
225 }
226 ConstElementPtr keepalive = elem->get("tcp-keepalive");
227 if (keepalive) {
228 setItem(xpath + "/tcp-keepalive", keepalive, SR_UINT32_T);
229 }
230 ConstElementPtr nodelay = elem->get("tcp-nodelay");
231 if (nodelay) {
232 setItem(xpath + "/tcp-nodelay", nodelay, SR_BOOL_T);
233 }
234 ConstElementPtr consistency = elem->get("consistency");
235 if (consistency) {
236 setItem(xpath + "/consistency", consistency, SR_STRING_T);
237 }
238 ConstElementPtr serial_consistency = elem->get("serial-consistency");
239 if (serial_consistency) {
240 setItem(xpath + "/serial-consistency", serial_consistency, SR_STRING_T);
241 }
242 ConstElementPtr max_row_errors = elem->get("max-row-errors");
243 if (max_row_errors) {
244 setItem(xpath + "/max-row-errors", max_row_errors, SR_UINT32_T);
245 }
246 ConstElementPtr context = Adaptor::getContext(elem);
247 if (context) {
248 setItem(xpath + "/user-context", Element::create(context->str()),
249 SR_STRING_T);
250 }
251}
252
254 const string& model)
255 : TranslatorBasic(session, model),
256 TranslatorDatabase(session, model) {
257}
258
260}
261
264 try {
265 if ((model_ == KEA_DHCP4_SERVER) ||
266 (model_ == KEA_DHCP6_SERVER)) {
267 return (getDatabasesKea(xpath));
268 }
269 } catch (const sysrepo_exception& ex) {
271 "sysrepo error getting database accesses at '" << xpath
272 << "': " << ex.what());
273 }
275 "getDatabases not implemented for the model: " << model_);
276}
277
280 return getList<TranslatorDatabase>(xpath, *this,
282}
283
284void
286 try {
287 if ((model_ == KEA_DHCP4_SERVER) ||
288 (model_ == KEA_DHCP6_SERVER)) {
289 setDatabasesKea(xpath, elem);
290 } else {
292 "setDatabases not implemented for the model: "
293 << model_);
294 }
295 } catch (const sysrepo_exception& ex) {
297 "sysrepo error setting database accesses '" << elem->str()
298 << "' at '" << xpath << "': " << ex.what());
299 }
300}
301
302void
304 ConstElementPtr elem) {
305 if (!elem) {
306 delItem(xpath);
307 return;
308 }
309 for (size_t i = 0; i < elem->size(); ++i) {
310 ConstElementPtr database = elem->get(i);
311 if (!database->contains("type")) {
312 isc_throw(BadValue, "database without type: " << database->str());
313 }
314 string type = database->get("type")->stringValue();
315 ostringstream key;
316 key << xpath << "[database-type='" << type << "']";
317 setDatabase(key.str(), database, true);
318 }
319}
320
321} // namespace yang
322} // namespace isc
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
A generic exception that is thrown when a function is not implemented.
static isc::data::ConstElementPtr getContext(isc::data::ConstElementPtr parent)
Get user context.
Definition: adaptor.cc:27
Between YANG and JSON translator class for basic values.
Definition: translator.h:19
isc::data::ElementPtr getItem(const std::string &xpath)
Get and translate basic value from YANG to JSON.
Definition: translator.cc:105
std::string model_
The model.
Definition: translator.h:159
void delItem(const std::string &xpath)
Delete basic value from YANG.
Definition: translator.cc:284
void setItem(const std::string &xpath, isc::data::ConstElementPtr elem, sr_type_t type)
Translate and set basic value from JSON to YANG.
Definition: translator.cc:260
Database access translation between YANG and JSON.
isc::data::ElementPtr getDatabaseKea(const std::string &xpath)
getDatabase JSON for kea-dhcp[46]-server models.
void setDatabase(const std::string &xpath, isc::data::ConstElementPtr elem, bool skip=false)
Translate and set database access from JSON to YANG.
TranslatorDatabase(sysrepo::S_Session session, const std::string &model)
Constructor.
virtual ~TranslatorDatabase()
Destructor.
isc::data::ElementPtr getDatabase(const std::string &xpath)
Get and translate a database access from YANG to JSON.
void setDatabaseKea(const std::string &xpath, isc::data::ConstElementPtr elem, bool skip)
setDatabase for kea-dhcp[46]-server models.
void setDatabasesKea(const std::string &xpath, isc::data::ConstElementPtr elem)
setDatabases for kea-dhcp[46]-server models.
void setDatabases(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set database accesses from JSON to YANG.
isc::data::ConstElementPtr getDatabases(const std::string &xpath)
Get and translate database accesses from YANG to JSON.
TranslatorDatabases(sysrepo::S_Session session, const std::string &model)
Constructor.
isc::data::ElementPtr getDatabasesKea(const std::string &xpath)
getDatabases JSON for kea-dhcp[46]-server models.
virtual ~TranslatorDatabases()
Destructor.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
boost::shared_ptr< const Element > ConstElementPtr
Definition: data.h:27
boost::shared_ptr< Element > ElementPtr
Definition: data.h:24
Defines the logger used by the top-level component of kea-lfc.