blob: 6176f67479a5d9f4dd06fbab71be972c7fdeb3d0 [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át19097f32020-10-05 10:08:29 +02009#include <experimental/iterator>
Václav Kubernátab612e92019-11-26 19:51:31 +010010#include <libyang/Tree_Data.hpp>
11#include <libyang/Tree_Schema.hpp>
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020012#include <sysrepo-cpp/Session.hpp>
Václav Kubernát19097f32020-10-05 10:08:29 +020013#include <sstream>
Václav Kubernátab612e92019-11-26 19:51:31 +010014#include "libyang_utils.hpp"
Václav Kubernát80aacc02018-08-22 17:41:54 +020015#include "sysrepo_access.hpp"
Jan Kundrát6ee84792020-01-24 01:43:36 +010016#include "utils.hpp"
Václav Kubernáta6c5fff2018-09-07 15:16:25 +020017#include "yang_schema.hpp"
Václav Kubernát80aacc02018-08-22 17:41:54 +020018
Václav Kubernát654303f2020-07-31 13:16:54 +020019const auto OPERATION_TIMEOUT_MS = 1000;
20
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020021leaf_data_ leafValueFromVal(const sysrepo::S_Val& value)
Václav Kubernátc89736b2018-08-30 16:14:05 +020022{
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020023 using namespace std::string_literals;
Václav Kubernátc89736b2018-08-30 16:14:05 +020024 switch (value->type()) {
Ivona Oboňová88c78ca2019-07-02 18:40:07 +020025 case SR_INT8_T:
26 return value->data()->get_int8();
27 case SR_UINT8_T:
28 return value->data()->get_uint8();
29 case SR_INT16_T:
30 return value->data()->get_int16();
31 case SR_UINT16_T:
32 return value->data()->get_uint16();
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020033 case SR_INT32_T:
34 return value->data()->get_int32();
35 case SR_UINT32_T:
36 return value->data()->get_uint32();
Ivona Oboňová88c78ca2019-07-02 18:40:07 +020037 case SR_INT64_T:
38 return value->data()->get_int64();
39 case SR_UINT64_T:
40 return value->data()->get_uint64();
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020041 case SR_BOOL_T:
42 return value->data()->get_bool();
43 case SR_STRING_T:
44 return std::string(value->data()->get_string());
45 case SR_ENUM_T:
Václav Kubernát152ce222019-12-19 12:23:32 +010046 return enum_{std::string(value->data()->get_enum())};
Jan Kundrát0d8abd12020-05-07 02:00:14 +020047 case SR_IDENTITYREF_T:
48 {
49 auto pair = splitModuleNode(value->data()->get_identityref());
50 return identityRef_{*pair.first, pair.second};
51 }
Jan Kundrát68985442020-05-07 02:15:34 +020052 case SR_BINARY_T:
53 return binary_{value->data()->get_binary()};
Jan Kundrát379bb572020-05-07 03:23:13 +020054 case SR_LEAF_EMPTY_T:
55 return empty_{};
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020056 case SR_DECIMAL64_T:
57 return value->data()->get_decimal64();
58 case SR_CONTAINER_T:
Václav Kubernát144729d2020-01-08 15:20:35 +010059 return special_{SpecialValue::Container};
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020060 case SR_CONTAINER_PRESENCE_T:
Václav Kubernát144729d2020-01-08 15:20:35 +010061 return special_{SpecialValue::PresenceContainer};
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020062 case SR_LIST_T:
Václav Kubernát144729d2020-01-08 15:20:35 +010063 return special_{SpecialValue::List};
Václav Kubernát19097f32020-10-05 10:08:29 +020064 case SR_BITS_T:
65 {
66 bits_ res;
67 std::istringstream ss(value->data()->get_bits());
68 while (!ss.eof()) {
69 std::string bit;
70 ss >> bit;
Václav Kubernát909d9662020-10-30 00:06:34 +010071 res.m_bits.push_back(bit);
Václav Kubernát19097f32020-10-05 10:08:29 +020072 }
73 return res;
74
75 }
Václav Kubernátb6ff0b62018-08-30 16:14:53 +020076 default: // TODO: implement all types
77 return value->val_to_string();
Václav Kubernátc89736b2018-08-30 16:14:05 +020078 }
79}
Václav Kubernát80aacc02018-08-22 17:41:54 +020080
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020081struct valFromValue : boost::static_visitor<sysrepo::S_Val> {
82 sysrepo::S_Val operator()(const enum_& value) const
Václav Kubernát80aacc02018-08-22 17:41:54 +020083 {
Jan Kundrát68d4a2c2018-10-01 17:17:09 +020084 return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_ENUM_T);
Václav Kubernát80aacc02018-08-22 17:41:54 +020085 }
86
Václav Kubernátab538992019-03-06 15:30:50 +010087 sysrepo::S_Val operator()(const binary_& value) const
88 {
89 return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_BINARY_T);
90 }
91
Jan Kundrát379bb572020-05-07 03:23:13 +020092 sysrepo::S_Val operator()(const empty_) const
93 {
94 return std::make_shared<sysrepo::Val>(nullptr, SR_LEAF_EMPTY_T);
95 }
96
Václav Kubernáteeb38842019-03-20 19:46:05 +010097 sysrepo::S_Val operator()(const identityRef_& value) const
98 {
Jan Kundrát0d8abd12020-05-07 02:00:14 +020099 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 +0100100 return std::make_shared<sysrepo::Val>(res.c_str(), SR_IDENTITYREF_T);
101 }
102
Václav Kubernát144729d2020-01-08 15:20:35 +0100103 sysrepo::S_Val operator()(const special_& value) const
104 {
105 throw std::runtime_error("Tried constructing S_Val from a " + specialValueToString(value));
106 }
107
Jan Kundrát68d4a2c2018-10-01 17:17:09 +0200108 sysrepo::S_Val operator()(const std::string& value) const
Václav Kubernát80aacc02018-08-22 17:41:54 +0200109 {
Jan Kundrát68d4a2c2018-10-01 17:17:09 +0200110 return std::make_shared<sysrepo::Val>(value.c_str());
Václav Kubernát80aacc02018-08-22 17:41:54 +0200111 }
112
Václav Kubernát19097f32020-10-05 10:08:29 +0200113 sysrepo::S_Val operator()(const bits_& value) const
114 {
115 std::stringstream ss;
116 std::copy(value.m_bits.begin(), value.m_bits.end(), std::experimental::make_ostream_joiner(ss, " "));
117 return std::make_shared<sysrepo::Val>(ss.str().c_str(), SR_BITS_T);
118 }
119
Jan Kundrátbd178362019-02-05 19:00:04 +0100120 template <typename T>
121 sysrepo::S_Val operator()(const T& value) const
Václav Kubernát80aacc02018-08-22 17:41:54 +0200122 {
Jan Kundrát68d4a2c2018-10-01 17:17:09 +0200123 return std::make_shared<sysrepo::Val>(value);
Václav Kubernát80aacc02018-08-22 17:41:54 +0200124 }
125};
126
Jan Kundrát6ee84792020-01-24 01:43:36 +0100127struct updateSrValFromValue : boost::static_visitor<void> {
128 std::string xpath;
129 sysrepo::S_Val v;
130 updateSrValFromValue(const std::string& xpath, sysrepo::S_Val v)
131 : xpath(xpath)
132 , v(v)
133 {
134 }
135
136 void operator()(const enum_& value) const
137 {
138 v->set(xpath.c_str(), value.m_value.c_str(), SR_ENUM_T);
139 }
140
141 void operator()(const binary_& value) const
142 {
143 v->set(xpath.c_str(), value.m_value.c_str(), SR_BINARY_T);
144 }
145
Jan Kundrát379bb572020-05-07 03:23:13 +0200146 void operator()(const empty_) const
147 {
148 v->set(xpath.c_str(), nullptr, SR_LEAF_EMPTY_T);
149 }
150
Jan Kundrát6ee84792020-01-24 01:43:36 +0100151 void operator()(const identityRef_& value) const
152 {
153 v->set(xpath.c_str(), (value.m_prefix.value().m_name + ":" + value.m_value).c_str(), SR_IDENTITYREF_T);
154 }
155
156 void operator()(const special_& value) const
157 {
Václav Kubernáte7248b22020-06-26 15:38:59 +0200158 switch (value.m_value) {
159 case SpecialValue::PresenceContainer:
160 v->set(xpath.c_str(), nullptr, SR_CONTAINER_PRESENCE_T);
161 break;
162 case SpecialValue::List:
163 v->set(xpath.c_str(), nullptr, SR_LIST_T);
164 break;
165 default:
166 throw std::runtime_error("Tried constructing S_Val from a " + specialValueToString(value));
167 }
Jan Kundrát6ee84792020-01-24 01:43:36 +0100168 }
169
Václav Kubernát19097f32020-10-05 10:08:29 +0200170 auto operator()(const bits_& value) const
171 {
172 std::stringstream ss;
173 std::copy(value.m_bits.begin(), value.m_bits.end(), std::experimental::make_ostream_joiner(ss, " "));
174 v->set(xpath.c_str(), ss.str().c_str(), SR_BITS_T);
175 }
176
Jan Kundrát6ee84792020-01-24 01:43:36 +0100177 void operator()(const std::string& value) const
178 {
179 v->set(xpath.c_str(), value.c_str(), SR_STRING_T);
180 }
181
182 template <typename T>
183 void operator()(const T value) const
184 {
185 v->set(xpath.c_str(), value);
186 }
187};
188
Václav Kubernát812ee282018-08-30 17:10:03 +0200189SysrepoAccess::~SysrepoAccess() = default;
Václav Kubernát80aacc02018-08-22 17:41:54 +0200190
Václav Kubernát715c85c2020-04-14 01:46:08 +0200191sr_datastore_t toSrDatastore(Datastore datastore)
192{
193 switch (datastore) {
194 case Datastore::Running:
195 return SR_DS_RUNNING;
196 case Datastore::Startup:
197 return SR_DS_STARTUP;
198 }
199 __builtin_unreachable();
200}
201
Václav Kubernát654303f2020-07-31 13:16:54 +0200202SysrepoAccess::SysrepoAccess(const Datastore datastore)
203 : m_connection(std::make_shared<sysrepo::Connection>())
204 , m_session(std::make_shared<sysrepo::Session>(m_connection))
205 , m_schema(std::make_shared<YangSchema>(m_session->get_context()))
Václav Kubernát80aacc02018-08-22 17:41:54 +0200206{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200207 try {
Václav Kubernát715c85c2020-04-14 01:46:08 +0200208 m_session = std::make_shared<sysrepo::Session>(m_connection, toSrDatastore(datastore));
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200209 } catch (sysrepo::sysrepo_exception& ex) {
210 reportErrors();
211 }
Václav Kubernát80aacc02018-08-22 17:41:54 +0200212}
213
Václav Kubernátd6282912020-06-23 14:49:34 +0200214DatastoreAccess::Tree SysrepoAccess::getItems(const std::string& path) const
Václav Kubernát80aacc02018-08-22 17:41:54 +0200215{
Václav Kubernátb6ff0b62018-08-30 16:14:53 +0200216 using namespace std::string_literals;
Jan Kundrátb331b552020-01-23 15:25:29 +0100217 Tree res;
Václav Kubernát80aacc02018-08-22 17:41:54 +0200218
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200219 try {
Václav Kubernát654303f2020-07-31 13:16:54 +0200220 auto oldDs = m_session->session_get_ds();
221 m_session->session_switch_ds(SR_DS_OPERATIONAL);
222 auto config = m_session->get_data(((path == "/") ? "/*" : path + "//.").c_str());
223 m_session->session_switch_ds(oldDs);
224 if (config) {
225 lyNodesToTree(res, config->tree_for());
Václav Kubernátb6ff0b62018-08-30 16:14:53 +0200226 }
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200227 } catch (sysrepo::sysrepo_exception& ex) {
228 reportErrors();
Václav Kubernátc89736b2018-08-30 16:14:05 +0200229 }
Václav Kubernát80aacc02018-08-22 17:41:54 +0200230 return res;
231}
232
233void SysrepoAccess::setLeaf(const std::string& path, leaf_data_ value)
234{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200235 try {
236 m_session->set_item(path.c_str(), boost::apply_visitor(valFromValue(), value));
237 } catch (sysrepo::sysrepo_exception& ex) {
238 reportErrors();
239 }
Václav Kubernát80aacc02018-08-22 17:41:54 +0200240}
241
Jan Kundrátcbf288b2020-06-18 20:44:39 +0200242void SysrepoAccess::createItem(const std::string& path)
Václav Kubernát80aacc02018-08-22 17:41:54 +0200243{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200244 try {
245 m_session->set_item(path.c_str());
246 } catch (sysrepo::sysrepo_exception& ex) {
247 reportErrors();
248 }
Václav Kubernát80aacc02018-08-22 17:41:54 +0200249}
250
Jan Kundrátcbf288b2020-06-18 20:44:39 +0200251void SysrepoAccess::deleteItem(const std::string& path)
Václav Kubernátf5f64f02019-03-19 17:15:47 +0100252{
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200253 try {
Václav Kubernát654303f2020-07-31 13:16:54 +0200254 // Have to use SR_EDIT_ISOLATE, because deleting something that's been set without committing is not supported
255 // https://github.com/sysrepo/sysrepo/issues/1967#issuecomment-625085090
256 m_session->delete_item(path.c_str(), SR_EDIT_ISOLATE);
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200257 } catch (sysrepo::sysrepo_exception& ex) {
258 reportErrors();
259 }
Václav Kubernátf5f64f02019-03-19 17:15:47 +0100260}
261
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200262struct impl_toSrMoveOp {
263 sr_move_position_t operator()(yang::move::Absolute& absolute)
264 {
265 return absolute == yang::move::Absolute::Begin ? SR_MOVE_FIRST : SR_MOVE_LAST;
266 }
267 sr_move_position_t operator()(yang::move::Relative& relative)
268 {
269 return relative.m_position == yang::move::Relative::Position::After ? SR_MOVE_AFTER : SR_MOVE_BEFORE;
270 }
271};
272
273sr_move_position_t toSrMoveOp(std::variant<yang::move::Absolute, yang::move::Relative> move)
274{
275 return std::visit(impl_toSrMoveOp{}, move);
276}
277
278void SysrepoAccess::moveItem(const std::string& source, std::variant<yang::move::Absolute, yang::move::Relative> move)
279{
Václav Kubernát654303f2020-07-31 13:16:54 +0200280 std::string destination;
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200281 if (std::holds_alternative<yang::move::Relative>(move)) {
282 auto relative = std::get<yang::move::Relative>(move);
283 if (m_schema->nodeType(source) == yang::NodeTypes::LeafList) {
Václav Kubernát654303f2020-07-31 13:16:54 +0200284 destination = leafDataToString(relative.m_path.at("."));
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200285 } else {
Václav Kubernát654303f2020-07-31 13:16:54 +0200286 destination = instanceToString(relative.m_path);
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200287 }
288 }
Václav Kubernát654303f2020-07-31 13:16:54 +0200289 m_session->move_item(source.c_str(), toSrMoveOp(move), destination.c_str(), destination.c_str());
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200290}
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 {
Václav Kubernát654303f2020-07-31 13:16:54 +0200295 m_session->apply_changes(OPERATION_TIMEOUT_MS, 1);
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200296 } 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
Václav Kubernáta8789602020-07-20 15:18:19 +0200310namespace {
311std::shared_ptr<sysrepo::Vals> toSrVals(const std::string& path, const DatastoreAccess::Tree& input)
Jan Kundrát6ee84792020-01-24 01:43:36 +0100312{
Václav Kubernáta8789602020-07-20 15:18:19 +0200313 auto res = std::make_shared<sysrepo::Vals>(input.size());
Jan Kundrát6ee84792020-01-24 01:43:36 +0100314 {
315 size_t i = 0;
316 for (const auto& [k, v] : input) {
Václav Kubernáta8789602020-07-20 15:18:19 +0200317 boost::apply_visitor(updateSrValFromValue(joinPaths(path, k), res->val(i)), v);
Jan Kundrát6ee84792020-01-24 01:43:36 +0100318 ++i;
319 }
320 }
Václav Kubernáta8789602020-07-20 15:18:19 +0200321 return res;
322}
323
324DatastoreAccess::Tree toTree(const std::string& path, const std::shared_ptr<sysrepo::Vals>& output)
325{
326 DatastoreAccess::Tree res;
Jan Kundrát6ee84792020-01-24 01:43:36 +0100327 for (size_t i = 0; i < output->val_cnt(); ++i) {
328 const auto& v = output->val(i);
Václav Kubernátfaacd022020-07-08 16:44:38 +0200329 res.emplace_back(std::string(v->xpath()).substr(joinPaths(path, "/").size()), leafValueFromVal(v));
Jan Kundrát6ee84792020-01-24 01:43:36 +0100330 }
331 return res;
332}
Václav Kubernáta8789602020-07-20 15:18:19 +0200333}
334
Václav Kubernát654303f2020-07-31 13:16:54 +0200335// TODO: merge this with executeAction
Václav Kubernáta8789602020-07-20 15:18:19 +0200336DatastoreAccess::Tree SysrepoAccess::executeRpc(const std::string &path, const Tree &input)
337{
338 auto srInput = toSrVals(path, input);
339 auto output = m_session->rpc_send(path.c_str(), srInput);
340 return toTree(path, output);
341}
342
343DatastoreAccess::Tree SysrepoAccess::executeAction(const std::string& path, const Tree& input)
344{
345 auto srInput = toSrVals(path, input);
Václav Kubernát654303f2020-07-31 13:16:54 +0200346 auto output = m_session->rpc_send(path.c_str(), srInput);
Václav Kubernáta8789602020-07-20 15:18:19 +0200347 return toTree(path, output);
348}
Jan Kundrát6ee84792020-01-24 01:43:36 +0100349
Václav Kubernát7160a132020-04-03 02:11:01 +0200350void SysrepoAccess::copyConfig(const Datastore source, const Datastore destination)
351{
Václav Kubernát654303f2020-07-31 13:16:54 +0200352 auto oldDs = m_session->session_get_ds();
353 m_session->session_switch_ds(toSrDatastore(destination));
354 m_session->copy_config(toSrDatastore(source), nullptr, OPERATION_TIMEOUT_MS, 1);
355 m_session->session_switch_ds(oldDs);
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200356}
357
358std::shared_ptr<Schema> SysrepoAccess::schema()
359{
360 return m_schema;
361}
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200362
Václav Kubernátd6282912020-06-23 14:49:34 +0200363[[noreturn]] void SysrepoAccess::reportErrors() const
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200364{
Václav Kubernát654303f2020-07-31 13:16:54 +0200365 // I only use get_error to get error info, since the error code from
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200366 // sysrepo_exception doesn't really give any meaningful information. For
367 // example an "invalid argument" error could mean a node isn't enabled, or
368 // it could mean something totally different and there is no documentation
369 // for that, so it's better to just use the message sysrepo gives me.
Václav Kubernát654303f2020-07-31 13:16:54 +0200370 auto srErrors = m_session->get_error();
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200371 std::vector<DatastoreError> res;
372
373 for (size_t i = 0; i < srErrors->error_cnt(); i++) {
Václav Kubernát654303f2020-07-31 13:16:54 +0200374 res.emplace_back(srErrors->message(i), srErrors->xpath(i) ? std::optional<std::string>{srErrors->xpath(i)} : std::nullopt);
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200375 }
376
377 throw DatastoreException(res);
378}
Václav Kubernátab612e92019-11-26 19:51:31 +0100379
380std::vector<ListInstance> SysrepoAccess::listInstances(const std::string& path)
381{
382 std::vector<ListInstance> res;
383 auto lists = getItems(path);
384
385 decltype(lists) instances;
386 auto wantedTree = *(m_schema->dataNodeFromPath(path)->find_path(path.c_str())->data().begin());
387 std::copy_if(lists.begin(), lists.end(), std::inserter(instances, instances.end()), [this, pathToCheck=wantedTree->schema()->path()](const auto& item) {
388 // This filters out non-instances.
389 if (item.second.type() != typeid(special_) || boost::get<special_>(item.second).m_value != SpecialValue::List) {
390 return false;
391 }
392
393 // Now, getItems is recursive: it gives everything including nested lists. So I try create a tree from the instance...
394 auto instanceTree = *(m_schema->dataNodeFromPath(item.first)->find_path(item.first.c_str())->data().begin());
395 // And then check if its schema path matches the list we actually want. This filters out lists which are not the ones I requested.
396 return instanceTree->schema()->path() == pathToCheck;
397 });
398
399 // If there are no instances, then just return
400 if (instances.empty()) {
401 return res;
402 }
403
404 // I need to find out which keys does the list have. To do that, I create a
405 // tree from the first instance. This is gives me some top level node,
406 // which will be our list in case out list is a top-level node. In case it
407 // isn't, we have call find_path on the top level node. After that, I just
408 // retrieve the keys.
409 auto topLevelTree = m_schema->dataNodeFromPath(instances.begin()->first);
410 auto list = *(topLevelTree->find_path(path.c_str())->data().begin());
411 auto keys = libyang::Schema_Node_List{list->schema()}.keys();
412
413 // Creating a full tree at the same time from the values sysrepo gives me
414 // would be a pain (and after sysrepo switches to libyang meaningless), so
415 // I just use this algorithm to create data nodes one by one and get the
416 // key values from them.
417 for (const auto& instance : instances) {
418 auto wantedList = *(m_schema->dataNodeFromPath(instance.first)->find_path(path.c_str())->data().begin());
419 ListInstance instanceRes;
420 for (const auto& key : keys) {
421 auto vec = wantedList->find_path(key->name())->data();
422 auto leaf = libyang::Data_Node_Leaf_List{*(vec.begin())};
423 instanceRes.emplace(key->name(), leafValueFromValue(leaf.value(), leaf.leaf_type()->base()));
424 }
Václav Kubernátfaacd022020-07-08 16:44:38 +0200425 res.emplace_back(instanceRes);
Václav Kubernátab612e92019-11-26 19:51:31 +0100426 }
427
428 return res;
429}
Václav Kubernát70d7f7a2020-06-23 14:40:40 +0200430
431std::string SysrepoAccess::dump(const DataFormat format) const
432{
Václav Kubernát654303f2020-07-31 13:16:54 +0200433 auto root = m_session->get_data("/*");
Václav Kubernát70d7f7a2020-06-23 14:40:40 +0200434 return root->print_mem(format == DataFormat::Xml ? LYD_XML : LYD_JSON, LYP_WITHSIBLINGS | LYP_FORMAT);
435}