Kea 2.0.1
translator_class.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
21TranslatorClass::TranslatorClass(S_Session session, const string& model)
22 : TranslatorBasic(session, model),
23 TranslatorOptionData(session, model),
24 TranslatorOptionDataList(session, model),
25 TranslatorOptionDef(session, model),
26 TranslatorOptionDefList(session, model) {
27}
28
30}
31
33TranslatorClass::getClass(const string& xpath) {
34 try {
35 if ((model_ == KEA_DHCP4_SERVER) ||
36 (model_ == KEA_DHCP6_SERVER)) {
37 return (getClassKea(xpath));
38 }
39 } catch (const sysrepo_exception& ex) {
41 "sysrepo error getting client class at '" << xpath
42 << "': " << ex.what());
43 }
45 "getClass not implemented for the model: " << model_);
46}
47
49TranslatorClass::getClassKea(const string& xpath) {
50 ConstElementPtr name = getItem(xpath + "/name");
51 if (!name) {
52 // Can't happen as the name is the key.
53 isc_throw(Unexpected, "getClassKea requires name: " << xpath);
54 }
55 ElementPtr result = Element::createMap();
56 result->set("name", name);
57 ConstElementPtr test = getItem(xpath + "/test");
58 if (test) {
59 result->set("test", test);
60 }
61 ConstElementPtr required = getItem(xpath + "/only-if-required");
62 if (required) {
63 result->set("only-if-required", required);
64 }
65 ConstElementPtr options = getOptionDataList(xpath);
66 if (options && (options->size() > 0)) {
67 result->set("option-data", options);
68 }
69 if (model_ == KEA_DHCP4_SERVER) {
71 if (defs && (defs->size() > 0)) {
72 result->set("option-def", defs);
73 }
74 ConstElementPtr next = getItem(xpath + "/next-server");
75 if (next) {
76 result->set("next-server", next);
77 }
78 ConstElementPtr hostname = getItem(xpath + "/server-hostname");
79 if (hostname) {
80 result->set("server-hostname", hostname);
81 }
82 ConstElementPtr boot = getItem(xpath + "/boot-file-name");
83 if (boot) {
84 result->set("boot-file-name", boot);
85 }
86 }
87 ConstElementPtr context = getItem(xpath + "/user-context");
88 if (context) {
89 result->set("user-context", Element::fromJSON(context->stringValue()));
90 }
91 return (result);
92}
93
94void
95TranslatorClass::setClass(const string& xpath, ConstElementPtr elem) {
96 try {
97 if ((model_ == KEA_DHCP4_SERVER) ||
98 (model_ == KEA_DHCP6_SERVER)) {
99 setClassKea(xpath, elem);
100 } else {
102 "setClass not implemented for the model: " << model_);
103 }
104 } catch (const sysrepo_exception& ex) {
106 "sysrepo error setting client class '" << elem->str()
107 << "' at '" << xpath << "': " << ex.what());
108 }
109}
110
111void
113 bool created = false;
114 // Skip key name.
115 ConstElementPtr test = elem->get("test");
116 if (test) {
117 setItem(xpath + "/test", test, SR_STRING_T);
118 created = true;
119 }
120 ConstElementPtr required = elem->get("only-if-required");
121 if (required) {
122 setItem(xpath + "/only-if-required", required, SR_BOOL_T);
123 created = true;
124 }
125 ConstElementPtr options = elem->get("option-data");
126 if (options) {
127 setOptionDataList(xpath, options);
128 created = true;
129 }
130 if (model_ == KEA_DHCP4_SERVER) {
131 ConstElementPtr defs = elem->get("option-def");
132 if (defs) {
133 setOptionDefList(xpath, defs);
134 created = true;
135 }
136 ConstElementPtr next = elem->get("next-server");
137 if (next) {
138 setItem(xpath + "/next-server", next, SR_STRING_T);
139 created = true;
140 }
141 ConstElementPtr hostname = elem->get("server-hostname");
142 if (hostname) {
143 setItem(xpath + "/server-hostname", hostname, SR_STRING_T);
144 created = true;
145 }
146 ConstElementPtr boot = elem->get("boot-file-name");
147 if (boot) {
148 setItem(xpath + "/boot-file-name", boot, SR_STRING_T);
149 created = true;
150 }
151 }
152 ConstElementPtr context = Adaptor::getContext(elem);
153 if (context) {
154 setItem(xpath + "/user-context", Element::create(context->str()),
155 SR_STRING_T);
156 created = true;
157 }
158 // There is no mandatory fields outside the key so force creation.
159 if (!created) {
160 ConstElementPtr list = Element::createList();
161 setItem(xpath, list, SR_LIST_T);
162 }
163}
164
165TranslatorClasses::TranslatorClasses(S_Session session, const string& model)
166 : TranslatorBasic(session, model),
167 TranslatorOptionData(session, model),
168 TranslatorOptionDataList(session, model),
169 TranslatorOptionDef(session, model),
170 TranslatorOptionDefList(session, model),
171 TranslatorClass(session, model) {
172}
173
175}
176
178TranslatorClasses::getClasses(const string& xpath) {
179 try {
180 if ((model_ == KEA_DHCP4_SERVER) ||
181 (model_ == KEA_DHCP6_SERVER)) {
182 return (getClassesKea(xpath));
183 }
184 } catch (const sysrepo_exception& ex) {
186 "sysrepo error getting client classes at '" << xpath
187 << "': " << ex.what());
188 }
190 "getClasses not implemented for the model: " << model_);
191}
192
195 return getList<TranslatorClass>(xpath + "/client-class", *this,
197}
198
199void
201 try {
202 if ((model_ == KEA_DHCP4_SERVER) ||
203 (model_ == KEA_DHCP6_SERVER)) {
204 setClassesKea(xpath, elem);
205 } else {
207 "setClasses not implemented for the model: " << model_);
208 }
209 } catch (const sysrepo_exception& ex) {
211 "sysrepo error setting client classes '" << elem->str()
212 << "' at '" << xpath << "': " << ex.what());
213 }
214}
215
216void
218 for (size_t i = 0; i < elem->size(); ++i) {
219 ConstElementPtr cclass = elem->get(i);
220 if (!cclass->contains("name")) {
221 isc_throw(BadValue, "client class without name: " << elem->str());
222 }
223 string name = cclass->get("name")->stringValue();
224 ostringstream key;
225 key << xpath << "/client-class[name='" << name << "']";
226 setClass(key.str(), cclass);
227 }
228}
229
230} // namespace yang
231} // 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
Client class translation between YANG and JSON.
TranslatorClass(sysrepo::S_Session session, const std::string &model)
Constructor.
isc::data::ElementPtr getClass(const std::string &xpath)
Get and translate a client class from YANG to JSON.
virtual ~TranslatorClass()
Destructor.
void setClassKea(const std::string &xpath, isc::data::ConstElementPtr elem)
setClass for kea-dhcp[46].
void setClass(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set client class from JSON to YANG.
isc::data::ElementPtr getClassKea(const std::string &xpath)
getClass JSON for kea-dhcp[46].
TranslatorClasses(sysrepo::S_Session session, const std::string &model)
Constructor.
void setClassesKea(const std::string &xpath, isc::data::ConstElementPtr elem)
setClasses for kea-dhcp[46].
isc::data::ElementPtr getClassesKea(const std::string &xpath)
getClasses JSON for kea-dhcp[46].
isc::data::ConstElementPtr getClasses(const std::string &xpath)
Get and translate client classes from YANG to JSON.
void setClasses(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set client classes from JSON to YANG.
virtual ~TranslatorClasses()
Destructor.
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.
Currently supports kea-dhcp[46]-server models.
void setOptionDefList(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set option definition list from JSON to YANG.
isc::data::ConstElementPtr getOptionDefList(const std::string &xpath)
Get and translate option definition list from YANG to JSON.
Option definition translation between YANG and 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.