Kea 2.0.0
translator_shared_network.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
22 const string& model)
23 : TranslatorBasic(session, model),
24 TranslatorOptionData(session, model),
25 TranslatorOptionDataList(session, model),
26 TranslatorPool(session, model),
27 TranslatorPools(session, model),
28 TranslatorPdPool(session, model),
29 TranslatorPdPools(session, model),
30 TranslatorHost(session, model),
31 TranslatorHosts(session, model),
32 TranslatorSubnet(session, model),
33 TranslatorSubnets(session, model) {
34}
35
37}
38
41 try {
42 if (model_ == KEA_DHCP4_SERVER) {
43 return (getSharedNetworkKea(xpath, "subnet4"));
44 } else if (model_ == KEA_DHCP6_SERVER) {
45 return (getSharedNetworkKea(xpath, "subnet6"));
46 }
47 } catch (const sysrepo_exception& ex) {
49 "sysrepo error getting shared network at '" << xpath
50 << "': " << ex.what());
51 }
53 "getSharedNetwork not implemented for the model: " << model_);
54}
55
58 const std::string& subsel) {
59 ElementPtr result = Element::createMap();
60 ConstElementPtr name = getItem(xpath + "/name");
61 if (!name) {
62 // Can't happen as the name is the key.
63 isc_throw(Unexpected, "getSharedNetworkKea requires name: " << xpath);
64 }
65 result->set("name", name);
66 ConstElementPtr subnets = getSubnets(xpath);
67 if (subnets && (subnets->size() > 0)) {
68 result->set(subsel, subnets);
69 }
70 if (subsel == "subnet6") {
71 ConstElementPtr preferred = getItem(xpath + "/preferred-lifetime");
72 if (preferred) {
73 result->set("preferred-lifetime", preferred);
74 }
75 ConstElementPtr min_pref = getItem(xpath + "/min-preferred-lifetime");
76 if (min_pref) {
77 result->set("min-preferred-lifetime", min_pref);
78 }
79 ConstElementPtr max_pref = getItem(xpath + "/max-preferred-lifetime");
80 if (max_pref) {
81 result->set("max-preferred-lifetime", max_pref);
82 }
83 }
84 ConstElementPtr valid = getItem(xpath + "/valid-lifetime");
85 if (valid) {
86 result->set("valid-lifetime", valid);
87 }
88 ConstElementPtr min_valid = getItem(xpath + "/min-valid-lifetime");
89 if (min_valid) {
90 result->set("min-valid-lifetime", min_valid);
91 }
92 ConstElementPtr max_valid = getItem(xpath + "/max-valid-lifetime");
93 if (max_valid) {
94 result->set("max-valid-lifetime", max_valid);
95 }
96 ConstElementPtr renew = getItem(xpath + "/renew-timer");
97 if (renew) {
98 result->set("renew-timer", renew);
99 }
100 ConstElementPtr rebind = getItem(xpath + "/rebind-timer");
101 if (rebind) {
102 result->set("rebind-timer", rebind);
103 }
104 ConstElementPtr calculate = getItem(xpath + "/calculate-tee-times");
105 if (calculate) {
106 result->set("calculate-tee-times", calculate);
107 }
108 ConstElementPtr t1_percent = getItem(xpath + "/t1-percent");
109 if (t1_percent) {
110 result->set("t1-percent", t1_percent);
111 }
112 ConstElementPtr t2_percent = getItem(xpath + "/t2-percent");
113 if (t2_percent) {
114 result->set("t2-percent", t2_percent);
115 }
116 ConstElementPtr options = getOptionDataList(xpath);
117 if (options && (options->size() > 0)) {
118 result->set("option-data", options);
119 }
120 ConstElementPtr interface = getItem(xpath + "/interface");
121 if (interface) {
122 result->set("interface", interface);
123 }
124 if (subsel == "subnet6") {
125 ConstElementPtr interface_id = getItem(xpath + "/interface-id");
126 if (interface_id) {
127 result->set("interface-id", interface_id);
128 }
129 ConstElementPtr rapid_commit = getItem(xpath + "/rapid-commit");
130 if (rapid_commit) {
131 result->set("rapid-commit", rapid_commit);
132 }
133 }
134 ConstElementPtr guard = getItem(xpath + "/client-class");
135 if (guard) {
136 result->set("client-class", guard);
137 }
138 ConstElementPtr required = getItems(xpath + "/require-client-classes");
139 if (required && (required->size() > 0)) {
140 result->set("require-client-classes", required);
141 }
142 ConstElementPtr mode = getItem(xpath + "/reservation-mode");
143 if (mode) {
144 result->set("reservation-mode", mode);
145 }
146 ConstElementPtr relay = getItems(xpath + "/relay/ip-addresses");
147 if (relay && (relay->size() > 0)) {
148 ElementPtr relay_map = Element::createMap();
149 relay_map->set("ip-addresses", relay);
150 result->set("relay", relay_map);
151 }
152 if (subsel == "subnet4") {
153 ConstElementPtr match = getItem(xpath + "/match-client-id");
154 if (match) {
155 result->set("match-client-id", match);
156 }
157 ConstElementPtr auth = getItem(xpath + "/authoritative");
158 if (auth) {
159 result->set("authoritative", auth);
160 }
161 ConstElementPtr next = getItem(xpath + "/next-server");
162 if (next) {
163 result->set("next-server", next);
164 }
165 ConstElementPtr hostname = getItem(xpath + "/server-hostname");
166 if (hostname) {
167 result->set("server-hostname", hostname);
168 }
169 ConstElementPtr boot = getItem(xpath + "/boot-file-name");
170 if (boot) {
171 result->set("boot-file-name", boot);
172 }
173 }
174 ConstElementPtr context = getItem(xpath + "/user-context");
175 if (context) {
176 result->set("user-context", Element::fromJSON(context->stringValue()));
177 }
178 return (result);
179}
180
181void
183 ConstElementPtr elem) {
184 try {
185 if (model_ == KEA_DHCP4_SERVER) {
186 setSharedNetworkKea(xpath, elem, "subnet4");
187 } else if (model_ == KEA_DHCP6_SERVER) {
188 setSharedNetworkKea(xpath, elem, "subnet6");
189 } else {
191 "setSharedNetwork not implemented for the model: "
192 << model_);
193 }
194 } catch (const sysrepo_exception& ex) {
196 "sysrepo error setting shared network '" << elem->str()
197 << "' at '" << xpath << "': " << ex.what());
198 }
199}
200
201void
203 ConstElementPtr elem,
204 const std::string& subsel) {
205 // Skip name which is the key.
206 ConstElementPtr subnets = elem->get(subsel);
207 if (subnets && (subnets->size() > 0)) {
208 setSubnets(xpath, subnets);
209 }
210 if (subsel == "subnet6") {
211 ConstElementPtr preferred = elem->get("preferred-lifetime");
212 if (preferred) {
213 setItem(xpath + "/preferred-lifetime", preferred, SR_UINT32_T);
214 }
215 ConstElementPtr min_pref = elem->get("min-preferred-lifetime");
216 if (min_pref) {
217 setItem(xpath + "/min-preferred-lifetime", min_pref, SR_UINT32_T);
218 }
219 ConstElementPtr max_pref = elem->get("max-preferred-lifetime");
220 if (max_pref) {
221 setItem(xpath + "/max-preferred-lifetime", max_pref, SR_UINT32_T);
222 }
223 }
224 ConstElementPtr valid = elem->get("valid-lifetime");
225 if (valid) {
226 setItem(xpath + "/valid-lifetime", valid, SR_UINT32_T);
227 }
228 ConstElementPtr min_valid = elem->get("min-valid-lifetime");
229 if (min_valid) {
230 setItem(xpath + "/min-valid-lifetime", min_valid, SR_UINT32_T);
231 }
232 ConstElementPtr max_valid = elem->get("max-valid-lifetime");
233 if (max_valid) {
234 setItem(xpath + "/max-valid-lifetime", max_valid, SR_UINT32_T);
235 }
236 ConstElementPtr renew = elem->get("renew-timer");
237 if (renew) {
238 setItem(xpath + "/renew-timer", renew, SR_UINT32_T);
239 }
240 ConstElementPtr rebind = elem->get("rebind-timer");
241 if (rebind) {
242 setItem(xpath + "/rebind-timer", rebind, SR_UINT32_T);
243 }
244 ConstElementPtr calculate = elem->get("calculate-tee-times");
245 if (calculate) {
246 setItem(xpath + "/calculate-tee-times", calculate, SR_BOOL_T);
247 }
248 ConstElementPtr t1_percent = elem->get("t1-percent");
249 if (t1_percent) {
250 setItem(xpath + "/t1-percent", t1_percent, SR_DECIMAL64_T);
251 }
252 ConstElementPtr t2_percent = elem->get("t2-percent");
253 if (t2_percent) {
254 setItem(xpath + "/t2-percent", t2_percent, SR_DECIMAL64_T);
255 }
256 ConstElementPtr options = elem->get("option-data");
257 if (options && (options->size() > 0)) {
258 setOptionDataList(xpath, options);
259 }
260 ConstElementPtr interface = elem->get("interface");
261 if (interface) {
262 setItem(xpath + "/interface", interface, SR_STRING_T);
263 }
264 if (subsel == "subnet6") {
265 ConstElementPtr interface_id = elem->get("interface-id");
266 if (interface_id) {
267 setItem(xpath + "/interface-id", interface_id, SR_STRING_T);
268 }
269 ConstElementPtr rapid_commit = elem->get("rapid-commit");
270 if (rapid_commit) {
271 setItem(xpath + "/rapid-commit", rapid_commit, SR_BOOL_T);
272 }
273 }
274 ConstElementPtr guard = elem->get("client-class");
275 if (guard) {
276 setItem(xpath + "/client-class", guard, SR_STRING_T);
277 }
278 ConstElementPtr required = elem->get("require-client-classes");
279 if (required && (required->size() > 0)) {
280 for (ConstElementPtr rclass : required->listValue()) {
281 setItem(xpath + "/require-client-classes", rclass, SR_STRING_T);
282 }
283 }
284 ConstElementPtr mode = elem->get("reservation-mode");
285 if (mode) {
286 setItem(xpath + "/reservation-mode", mode, SR_ENUM_T);
287 }
288 ConstElementPtr relay = elem->get("relay");
289 if (relay) {
290 ConstElementPtr address = relay->get("ip-address");
291 ConstElementPtr addresses = relay->get("ip-addresses");
292 if (address) {
293 setItem(xpath + "/relay/ip-addresses", address, SR_STRING_T);
294 } else if (addresses && (addresses->size() > 0)) {
295 for (ConstElementPtr addr : addresses->listValue()) {
296 setItem(xpath + "/relay/ip-addresses", addr, SR_STRING_T);
297 }
298 }
299 }
300 if (subsel == "subnet4") {
301 ConstElementPtr match = elem->get("match-client-id");
302 if (match) {
303 setItem(xpath + "/match-client-id", match, SR_BOOL_T);
304 }
305 ConstElementPtr auth = elem->get("authoritative");
306 if (auth) {
307 setItem(xpath + "/authoritative", auth, SR_BOOL_T);
308 }
309 ConstElementPtr next = elem->get("next-server");
310 if (next) {
311 setItem(xpath + "/next-server", next, SR_STRING_T);
312 }
313 ConstElementPtr hostname = elem->get("server-hostname");
314 if (hostname) {
315 setItem(xpath + "/server-hostname", hostname, SR_STRING_T);
316 }
317 ConstElementPtr boot = elem->get("boot-file-name");
318 if (boot) {
319 setItem(xpath + "/boot-file-name", boot, SR_STRING_T);
320 }
321 }
322 ConstElementPtr context = Adaptor::getContext(elem);
323 if (context) {
324 ConstElementPtr repr = Element::create(context->str());
325 setItem(xpath + "/user-context", repr, SR_STRING_T);
326 }
327}
328
330 const string& model)
331 : TranslatorBasic(session, model),
332 TranslatorOptionData(session, model),
333 TranslatorOptionDataList(session, model),
334 TranslatorPool(session, model),
335 TranslatorPools(session, model),
336 TranslatorPdPool(session, model),
337 TranslatorPdPools(session, model),
338 TranslatorHost(session, model),
339 TranslatorHosts(session, model),
340 TranslatorSubnet(session, model),
341 TranslatorSubnets(session, model),
342 TranslatorSharedNetwork(session, model) {
343}
344
346}
347
350 return getList<TranslatorSharedNetwork>(xpath + "/shared-network", *this,
352}
353
354void
356 ConstElementPtr elem) {
357 try {
358 if ((model_ == KEA_DHCP4_SERVER) ||
359 (model_ == KEA_DHCP6_SERVER)) {
360 setSharedNetworksKea(xpath, elem);
361 } else {
363 "setSharedNetworks not implemented for the model: "
364 << model_);
365 }
366 } catch (const sysrepo_exception& ex) {
368 "sysrepo error setting shared networks '" << elem->str()
369 << "' at '" << xpath << "': " << ex.what());
370 }
371}
372
373void
375 ConstElementPtr elem) {
376 for (size_t i = 0; i < elem->size(); ++i) {
377 ConstElementPtr network = elem->get(i);
378 if (!network->contains("name")) {
379 isc_throw(BadValue, "setSharedNetworksKea requires name: "
380 << network->str());
381 }
382 string name = network->get("name")->stringValue();
383 ostringstream key;
384 key<< xpath << "/shared-network[name='" << name << "']";
385 setSharedNetwork(key.str(), network);
386 }
387}
388
389} // namespace yang
390} // 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.
A generic exception that is thrown when an unexpected error condition occurs.
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 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
isc::data::ElementPtr getItems(const std::string &xpath)
Get and translate a list of basic values from YANG to JSON.
Definition: translator.cc:124
Translation between YANG and JSON for a single host reservation.
A translator class for converting host reservations list between YANG and JSON.
A translator class for converting an option data list between YANG and JSON.
isc::data::ConstElementPtr getOptionDataList(const std::string &xpath)
Get and translate option data list from YANG to JSON.
void setOptionDataList(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set option data list from JSON to YANG.
Option data translation between YANG and JSON.
Prefix delegation pool translation between YANG and JSON.
A translator class for converting a pd-pool list between YANG and JSON.
A translator class for converting a pool between YANG and JSON.
A translator class for converting pools between YANG and JSON.
Shared network translation between YANG and JSON.
isc::data::ElementPtr getSharedNetworkKea(const std::string &xpath, const std::string &subsel)
getSharedNetwork for kea-dhcp4-server and kea-dhcp6-server models
TranslatorSharedNetwork(sysrepo::S_Session session, const std::string &model)
Constructor.
void setSharedNetworkKea(const std::string &xpath, isc::data::ConstElementPtr elem, const std::string &subsel)
setSharedNetwork for kea-dhcp4-server and kea-dhcp6-server models
void setSharedNetwork(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set shared network from JSON to YANG.
isc::data::ElementPtr getSharedNetwork(const std::string &xpath)
Get and translate a shared network from YANG to JSON.
isc::data::ElementPtr getSharedNetworks(const std::string &xpath)
Get and translate shared networks from YANG to JSON.
void setSharedNetworksKea(const std::string &xpath, isc::data::ConstElementPtr elem)
setSharedNetworks for kea-dhcp4-server and kea-dhcp6-server
TranslatorSharedNetworks(sysrepo::S_Session session, const std::string &model)
Constructor.
void setSharedNetworks(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set shared networks from JSON to YANG.
Subnet (aka network range) translation between YANG and JSON.
A translator class for converting a subnet list between YANG and JSON.
void setSubnets(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set subnets from JSON to YANG.
isc::data::ElementPtr getSubnets(const std::string &xpath)
Get and translate subnets from YANG to JSON.
#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.