blob: 3af5f7975c672cf9b8c9161474be21c437167ab2 [file] [log] [blame]
Václav Kubernát80aacc02018-08-22 17:41:54 +02001/*
2 * Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
3 * Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
4 *
5 * Written by Václav Kubernát <kubervac@fit.cvut.cz>
6 *
7*/
8
Václav Kubernátab612e92019-11-26 19:51:31 +01009#include <libyang/Tree_Data.hpp>
10#include <libyang/Tree_Schema.hpp>
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020011#include <sysrepo-cpp/Session.hpp>
Václav Kubernátab612e92019-11-26 19:51:31 +010012#include "libyang_utils.hpp"
Václav Kubernát80aacc02018-08-22 17:41:54 +020013#include "sysrepo_access.hpp"
Jan Kundrát6ee84792020-01-24 01:43:36 +010014#include "utils.hpp"
Václav Kubernáta6c5fff2018-09-07 15:16:25 +020015#include "yang_schema.hpp"
Václav Kubernát80aacc02018-08-22 17:41:54 +020016
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020017leaf_data_ leafValueFromVal(const sysrepo::S_Val& value)
Václav Kubernátc89736b2018-08-30 16:14:05 +020018{
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020019 using namespace std::string_literals;
Václav Kubernátc89736b2018-08-30 16:14:05 +020020 switch (value->type()) {
Ivona Oboňová88c78ca2019-07-02 18:40:07 +020021 case SR_INT8_T:
22 return value->data()->get_int8();
23 case SR_UINT8_T:
24 return value->data()->get_uint8();
25 case SR_INT16_T:
26 return value->data()->get_int16();
27 case SR_UINT16_T:
28 return value->data()->get_uint16();
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020029 case SR_INT32_T:
30 return value->data()->get_int32();
31 case SR_UINT32_T:
32 return value->data()->get_uint32();
Ivona Oboňová88c78ca2019-07-02 18:40:07 +020033 case SR_INT64_T:
34 return value->data()->get_int64();
35 case SR_UINT64_T:
36 return value->data()->get_uint64();
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020037 case SR_BOOL_T:
38 return value->data()->get_bool();
39 case SR_STRING_T:
40 return std::string(value->data()->get_string());
41 case SR_ENUM_T:
Václav Kubernát152ce222019-12-19 12:23:32 +010042 return enum_{std::string(value->data()->get_enum())};
Jan Kundrát0d8abd12020-05-07 02:00:14 +020043 case SR_IDENTITYREF_T:
44 {
45 auto pair = splitModuleNode(value->data()->get_identityref());
46 return identityRef_{*pair.first, pair.second};
47 }
Jan Kundrát68985442020-05-07 02:15:34 +020048 case SR_BINARY_T:
49 return binary_{value->data()->get_binary()};
Jan Kundrát379bb572020-05-07 03:23:13 +020050 case SR_LEAF_EMPTY_T:
51 return empty_{};
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020052 case SR_DECIMAL64_T:
53 return value->data()->get_decimal64();
54 case SR_CONTAINER_T:
Václav Kubernát144729d2020-01-08 15:20:35 +010055 return special_{SpecialValue::Container};
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020056 case SR_CONTAINER_PRESENCE_T:
Václav Kubernát144729d2020-01-08 15:20:35 +010057 return special_{SpecialValue::PresenceContainer};
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020058 case SR_LIST_T:
Václav Kubernát144729d2020-01-08 15:20:35 +010059 return special_{SpecialValue::List};
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020060 default: // TODO: implement all types
61 return value->val_to_string();
Václav Kubernátc89736b2018-08-30 16:14:05 +020062 }
63}
Václav Kubernát80aacc02018-08-22 17:41:54 +020064
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020065struct valFromValue : boost::static_visitor<sysrepo::S_Val> {
66 sysrepo::S_Val operator()(const enum_& value) const
Václav Kubernát80aacc02018-08-22 17:41:54 +020067 {
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020068 return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_ENUM_T);
Václav Kubernát80aacc02018-08-22 17:41:54 +020069 }
70
Václav Kubernátab538992019-03-06 15:30:50 +010071 sysrepo::S_Val operator()(const binary_& value) const
72 {
73 return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_BINARY_T);
74 }
75
Jan Kundrát379bb572020-05-07 03:23:13 +020076 sysrepo::S_Val operator()(const empty_) const
77 {
78 return std::make_shared<sysrepo::Val>(nullptr, SR_LEAF_EMPTY_T);
79 }
80
Václav Kubernáteeb38842019-03-20 19:46:05 +010081 sysrepo::S_Val operator()(const identityRef_& value) const
82 {
Jan Kundrát0d8abd12020-05-07 02:00:14 +020083 auto res = value.m_prefix ? (value.m_prefix.value().m_name + ":" + value.m_value) : value.m_value;
Václav Kubernáteeb38842019-03-20 19:46:05 +010084 return std::make_shared<sysrepo::Val>(res.c_str(), SR_IDENTITYREF_T);
85 }
86
Václav Kubernát144729d2020-01-08 15:20:35 +010087 sysrepo::S_Val operator()(const special_& value) const
88 {
89 throw std::runtime_error("Tried constructing S_Val from a " + specialValueToString(value));
90 }
91
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020092 sysrepo::S_Val operator()(const std::string& value) const
Václav Kubernát80aacc02018-08-22 17:41:54 +020093 {
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020094 return std::make_shared<sysrepo::Val>(value.c_str());
Václav Kubernát80aacc02018-08-22 17:41:54 +020095 }
96
Jan Kundrátbd178362019-02-05 19:00:04 +010097 template <typename T>
98 sysrepo::S_Val operator()(const T& value) const
Václav Kubernát80aacc02018-08-22 17:41:54 +020099 {
Jan Kundrát68d4a2c2018-10-01 17:17:09 +0200100 return std::make_shared<sysrepo::Val>(value);
Václav Kubernát80aacc02018-08-22 17:41:54 +0200101 }
102};
103
Jan Kundrát6ee84792020-01-24 01:43:36 +0100104struct updateSrValFromValue : boost::static_visitor<void> {
105 std::string xpath;
106 sysrepo::S_Val v;
107 updateSrValFromValue(const std::string& xpath, sysrepo::S_Val v)
108 : xpath(xpath)
109 , v(v)
110 {
111 }
112
113 void operator()(const enum_& value) const
114 {
115 v->set(xpath.c_str(), value.m_value.c_str(), SR_ENUM_T);
116 }
117
118 void operator()(const binary_& value) const
119 {
120 v->set(xpath.c_str(), value.m_value.c_str(), SR_BINARY_T);
121 }
122
Jan Kundrát379bb572020-05-07 03:23:13 +0200123 void operator()(const empty_) const
124 {
125 v->set(xpath.c_str(), nullptr, SR_LEAF_EMPTY_T);
126 }
127
Jan Kundrát6ee84792020-01-24 01:43:36 +0100128 void operator()(const identityRef_& value) const
129 {
130 v->set(xpath.c_str(), (value.m_prefix.value().m_name + ":" + value.m_value).c_str(), SR_IDENTITYREF_T);
131 }
132
133 void operator()(const special_& value) const
134 {
135 throw std::runtime_error("Tried constructing S_Val from a " + specialValueToString(value));
136 }
137
138 void operator()(const std::string& value) const
139 {
140 v->set(xpath.c_str(), value.c_str(), SR_STRING_T);
141 }
142
143 template <typename T>
144 void operator()(const T value) const
145 {
146 v->set(xpath.c_str(), value);
147 }
148};
149
Václav Kubernát812ee282018-08-30 17:10:03 +0200150SysrepoAccess::~SysrepoAccess() = default;
Václav Kubernát80aacc02018-08-22 17:41:54 +0200151
Václav Kubernát715c85c2020-04-14 01:46:08 +0200152sr_datastore_t toSrDatastore(Datastore datastore)
153{
154 switch (datastore) {
155 case Datastore::Running:
156 return SR_DS_RUNNING;
157 case Datastore::Startup:
158 return SR_DS_STARTUP;
159 }
160 __builtin_unreachable();
161}
162
163SysrepoAccess::SysrepoAccess(const std::string& appname, const Datastore datastore)
Jan Kundrát68d4a2c2018-10-01 17:17:09 +0200164 : m_connection(new sysrepo::Connection(appname.c_str()))
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200165 , m_schema(new YangSchema())
Václav Kubernát80aacc02018-08-22 17:41:54 +0200166{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200167 try {
Václav Kubernát715c85c2020-04-14 01:46:08 +0200168 m_session = std::make_shared<sysrepo::Session>(m_connection, toSrDatastore(datastore));
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200169 } catch (sysrepo::sysrepo_exception& ex) {
170 reportErrors();
171 }
Václav Kubernátb52dc252019-12-04 13:03:39 +0100172
173 // If fetching a submodule, sysrepo::Session::get_schema will determine the revision from the main module.
174 // That's why submoduleRevision is ignored.
175 m_schema->registerModuleCallback([this](const char* moduleName, const char* revision, const char* submodule, [[maybe_unused]] const char* submoduleRevision) {
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200176 return fetchSchema(moduleName, revision, submodule);
177 });
178
Václav Kubernátbf9c6112019-11-04 16:03:35 +0100179 for (const auto& it : listSchemas()) {
180 if (it->implemented()) {
181 m_schema->loadModule(it->module_name());
182 for (unsigned int i = 0; i < it->enabled_feature_cnt(); i++) {
183 m_schema->enableFeature(it->module_name(), it->enabled_features(i));
184 }
185 }
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200186 }
Václav Kubernát80aacc02018-08-22 17:41:54 +0200187}
188
Jan Kundrátb331b552020-01-23 15:25:29 +0100189DatastoreAccess::Tree SysrepoAccess::getItems(const std::string& path)
Václav Kubernát80aacc02018-08-22 17:41:54 +0200190{
Václav Kubernátb6ff0b62018-08-30 16:14:53 +0200191 using namespace std::string_literals;
Jan Kundrátb331b552020-01-23 15:25:29 +0100192 Tree res;
Václav Kubernát80aacc02018-08-22 17:41:54 +0200193
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200194 auto fillMap = [this, &res](auto items) {
Václav Kubernátb6ff0b62018-08-30 16:14:53 +0200195 if (!items)
196 return;
197 for (unsigned int i = 0; i < items->val_cnt(); i++) {
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200198 auto value = leafValueFromVal(items->val(i));
199 if (m_schema->isLeafList(items->val(i)->xpath())) {
Václav Kubernátcf9224f2020-06-02 09:55:29 +0200200 res.push_back({items->val(i)->xpath(), special_{SpecialValue::LeafList}});
201 std::string leafListPath = items->val(i)->xpath();
202 while (i < items->val_cnt() && leafListPath == items->val(i)->xpath()) {
203 auto leafListValue = leafDataToString(leafValueFromVal(items->val(i)));
204 res.push_back({items->val(i)->xpath() + "[.="s + escapeListKeyString(leafListValue) + "]", leafListValue});
205 i++;
206 }
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200207 } else {
Václav Kubernátcf9224f2020-06-02 09:55:29 +0200208 res.push_back({items->val(i)->xpath(), value});
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200209 }
Václav Kubernátb6ff0b62018-08-30 16:14:53 +0200210 }
211 };
Václav Kubernátc89736b2018-08-30 16:14:05 +0200212
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200213 try {
214 if (path == "/") {
215 // Sysrepo doesn't have a root node ("/"), so we take all top-level nodes from all schemas
216 auto schemas = m_session->list_schemas();
217 for (unsigned int i = 0; i < schemas->schema_cnt(); i++) {
218 fillMap(m_session->get_items(("/"s + schemas->schema(i)->module_name() + ":*//.").c_str()));
219 }
220 } else {
221 fillMap(m_session->get_items((path + "//.").c_str()));
Václav Kubernátb6ff0b62018-08-30 16:14:53 +0200222 }
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200223 } catch (sysrepo::sysrepo_exception& ex) {
224 reportErrors();
Václav Kubernátc89736b2018-08-30 16:14:05 +0200225 }
Václav Kubernát80aacc02018-08-22 17:41:54 +0200226 return res;
227}
228
229void SysrepoAccess::setLeaf(const std::string& path, leaf_data_ value)
230{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200231 try {
232 m_session->set_item(path.c_str(), boost::apply_visitor(valFromValue(), value));
233 } catch (sysrepo::sysrepo_exception& ex) {
234 reportErrors();
235 }
Václav Kubernát80aacc02018-08-22 17:41:54 +0200236}
237
238void SysrepoAccess::createPresenceContainer(const std::string& path)
239{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200240 try {
241 m_session->set_item(path.c_str());
242 } catch (sysrepo::sysrepo_exception& ex) {
243 reportErrors();
244 }
Václav Kubernát80aacc02018-08-22 17:41:54 +0200245}
246
247void SysrepoAccess::deletePresenceContainer(const std::string& path)
248{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200249 try {
250 m_session->delete_item(path.c_str());
251 } catch (sysrepo::sysrepo_exception& ex) {
252 reportErrors();
253 }
Václav Kubernát80aacc02018-08-22 17:41:54 +0200254}
Václav Kubernát812ee282018-08-30 17:10:03 +0200255
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200256void SysrepoAccess::createLeafListInstance(const std::string& path)
257{
258 try {
259 m_session->set_item(path.c_str());
260 } catch (sysrepo::sysrepo_exception& ex) {
261 reportErrors();
262 }
263}
264
265void SysrepoAccess::deleteLeafListInstance(const std::string& path)
266{
267 try {
268 m_session->delete_item(path.c_str());
269 } catch (sysrepo::sysrepo_exception& ex) {
270 reportErrors();
271 }
272}
273
Václav Kubernátf5f64f02019-03-19 17:15:47 +0100274void SysrepoAccess::createListInstance(const std::string& path)
275{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200276 try {
277 m_session->set_item(path.c_str());
278 } catch (sysrepo::sysrepo_exception& ex) {
279 reportErrors();
280 }
Václav Kubernátf5f64f02019-03-19 17:15:47 +0100281}
282
283void SysrepoAccess::deleteListInstance(const std::string& path)
284{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200285 try {
286 m_session->delete_item(path.c_str());
287 } catch (sysrepo::sysrepo_exception& ex) {
288 reportErrors();
289 }
Václav Kubernátf5f64f02019-03-19 17:15:47 +0100290}
291
Václav Kubernát812ee282018-08-30 17:10:03 +0200292void SysrepoAccess::commitChanges()
293{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200294 try {
295 m_session->commit();
296 } catch (sysrepo::sysrepo_exception& ex) {
297 reportErrors();
298 }
Václav Kubernát812ee282018-08-30 17:10:03 +0200299}
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200300
Václav Kubernát6d791432018-10-25 16:00:35 +0200301void SysrepoAccess::discardChanges()
302{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200303 try {
304 m_session->discard_changes();
305 } catch (sysrepo::sysrepo_exception& ex) {
306 reportErrors();
307 }
Václav Kubernát6d791432018-10-25 16:00:35 +0200308}
309
Jan Kundrát6ee84792020-01-24 01:43:36 +0100310DatastoreAccess::Tree SysrepoAccess::executeRpc(const std::string &path, const Tree &input)
311{
312 auto srInput = std::make_shared<sysrepo::Vals>(input.size());
313 {
314 size_t i = 0;
315 for (const auto& [k, v] : input) {
316 boost::apply_visitor(updateSrValFromValue(joinPaths(path, k), srInput->val(i)), v);
317 ++i;
318 }
319 }
320 auto output = m_session->rpc_send(path.c_str(), srInput);
321 Tree res;
322 for (size_t i = 0; i < output->val_cnt(); ++i) {
323 const auto& v = output->val(i);
Václav Kubernátcf9224f2020-06-02 09:55:29 +0200324 res.push_back({std::string(v->xpath()).substr(joinPaths(path, "/").size()), leafValueFromVal(v)});
Jan Kundrát6ee84792020-01-24 01:43:36 +0100325 }
326 return res;
327}
328
Václav Kubernát7160a132020-04-03 02:11:01 +0200329void SysrepoAccess::copyConfig(const Datastore source, const Datastore destination)
330{
331 m_session->copy_config(nullptr, toSrDatastore(source), toSrDatastore(destination));
332 if (destination == Datastore::Running) {
333 m_session->refresh();
334 }
335}
336
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200337std::string SysrepoAccess::fetchSchema(const char* module, const char* revision, const char* submodule)
338{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200339 std::string schema;
340 try {
Václav Kubernátb52dc252019-12-04 13:03:39 +0100341 schema = m_session->get_schema(module, revision, submodule, SR_SCHEMA_YANG);
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200342 } catch (sysrepo::sysrepo_exception& ex) {
343 reportErrors();
344 }
345
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200346 if (schema.empty())
347 throw std::runtime_error(std::string("Module ") + module + " not available");
348
349 return schema;
350}
351
Václav Kubernátbf9c6112019-11-04 16:03:35 +0100352std::vector<std::shared_ptr<sysrepo::Yang_Schema>> SysrepoAccess::listSchemas()
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200353{
Václav Kubernátbf9c6112019-11-04 16:03:35 +0100354 std::vector<sysrepo::S_Yang_Schema> res;
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200355 std::shared_ptr<sysrepo::Yang_Schemas> schemas;
356 try {
357 schemas = m_session->list_schemas();
358 } catch (sysrepo::sysrepo_exception& ex) {
359 reportErrors();
360 }
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200361 for (unsigned int i = 0; i < schemas->schema_cnt(); i++) {
362 auto schema = schemas->schema(i);
Václav Kubernátbf9c6112019-11-04 16:03:35 +0100363 res.push_back(schema);
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200364 }
365 return res;
366}
367
368std::shared_ptr<Schema> SysrepoAccess::schema()
369{
370 return m_schema;
371}
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200372
373[[noreturn]] void SysrepoAccess::reportErrors()
374{
375 // I only use get_last_errors to get error info, since the error code from
376 // sysrepo_exception doesn't really give any meaningful information. For
377 // example an "invalid argument" error could mean a node isn't enabled, or
378 // it could mean something totally different and there is no documentation
379 // for that, so it's better to just use the message sysrepo gives me.
380 auto srErrors = m_session->get_last_errors();
381 std::vector<DatastoreError> res;
382
383 for (size_t i = 0; i < srErrors->error_cnt(); i++) {
384 auto error = srErrors->error(i);
385 res.emplace_back(error->message(), error->xpath() ? std::optional<std::string>{error->xpath()} : std::nullopt);
386 }
387
388 throw DatastoreException(res);
389}
Václav Kubernátab612e92019-11-26 19:51:31 +0100390
391std::vector<ListInstance> SysrepoAccess::listInstances(const std::string& path)
392{
393 std::vector<ListInstance> res;
394 auto lists = getItems(path);
395
396 decltype(lists) instances;
397 auto wantedTree = *(m_schema->dataNodeFromPath(path)->find_path(path.c_str())->data().begin());
398 std::copy_if(lists.begin(), lists.end(), std::inserter(instances, instances.end()), [this, pathToCheck=wantedTree->schema()->path()](const auto& item) {
399 // This filters out non-instances.
400 if (item.second.type() != typeid(special_) || boost::get<special_>(item.second).m_value != SpecialValue::List) {
401 return false;
402 }
403
404 // Now, getItems is recursive: it gives everything including nested lists. So I try create a tree from the instance...
405 auto instanceTree = *(m_schema->dataNodeFromPath(item.first)->find_path(item.first.c_str())->data().begin());
406 // And then check if its schema path matches the list we actually want. This filters out lists which are not the ones I requested.
407 return instanceTree->schema()->path() == pathToCheck;
408 });
409
410 // If there are no instances, then just return
411 if (instances.empty()) {
412 return res;
413 }
414
415 // I need to find out which keys does the list have. To do that, I create a
416 // tree from the first instance. This is gives me some top level node,
417 // which will be our list in case out list is a top-level node. In case it
418 // isn't, we have call find_path on the top level node. After that, I just
419 // retrieve the keys.
420 auto topLevelTree = m_schema->dataNodeFromPath(instances.begin()->first);
421 auto list = *(topLevelTree->find_path(path.c_str())->data().begin());
422 auto keys = libyang::Schema_Node_List{list->schema()}.keys();
423
424 // Creating a full tree at the same time from the values sysrepo gives me
425 // would be a pain (and after sysrepo switches to libyang meaningless), so
426 // I just use this algorithm to create data nodes one by one and get the
427 // key values from them.
428 for (const auto& instance : instances) {
429 auto wantedList = *(m_schema->dataNodeFromPath(instance.first)->find_path(path.c_str())->data().begin());
430 ListInstance instanceRes;
431 for (const auto& key : keys) {
432 auto vec = wantedList->find_path(key->name())->data();
433 auto leaf = libyang::Data_Node_Leaf_List{*(vec.begin())};
434 instanceRes.emplace(key->name(), leafValueFromValue(leaf.value(), leaf.leaf_type()->base()));
435 }
436 res.push_back(instanceRes);
437 }
438
439 return res;
440}