blob: 4ed29aed07b87e02af8a097cd441a6b1bd9b7197 [file] [log] [blame]
Václav Kubernátc31bd602019-03-07 11:44:48 +01001/*
2 * Copyright (C) 2019 CESNET, https://photonics.cesnet.cz/
3 *
4 * Written by Václav Kubernát <kubernat@cesnet.cz>
5 *
6*/
7
8#include <libyang/Libyang.hpp>
9#include <libyang/Tree_Data.hpp>
Václav Kubernát02a71152020-01-21 14:52:51 +010010#include "libyang_utils.hpp"
Václav Kubernát26b56082020-02-03 18:28:56 +010011#include "netconf-client.hpp"
Václav Kubernátc31bd602019-03-07 11:44:48 +010012#include "netconf_access.hpp"
13#include "utils.hpp"
14#include "yang_schema.hpp"
15
Jan Kundrát8f63fb72020-01-24 01:40:01 +010016
Václav Kubernátc31bd602019-03-07 11:44:48 +010017NetconfAccess::~NetconfAccess() = default;
18
Václav Kubernátd6282912020-06-23 14:49:34 +020019DatastoreAccess::Tree NetconfAccess::getItems(const std::string& path) const
Václav Kubernátc31bd602019-03-07 11:44:48 +010020{
Jan Kundrátb331b552020-01-23 15:25:29 +010021 Tree res;
Jan Kundrátb091dd42020-01-30 09:28:28 +010022 auto config = m_session->get((path != "/") ? std::optional{path} : std::nullopt);
Václav Kubernát9456b5c2019-10-02 21:14:52 +020023
24 if (config) {
Václav Kubernátdaf40312020-06-19 11:34:55 +020025 lyNodesToTree(res, config->tree_for());
Václav Kubernátc31bd602019-03-07 11:44:48 +010026 }
Václav Kubernátc31bd602019-03-07 11:44:48 +010027 return res;
28}
29
Václav Kubernátc31bd602019-03-07 11:44:48 +010030NetconfAccess::NetconfAccess(const std::string& hostname, uint16_t port, const std::string& user, const std::string& pubKey, const std::string& privKey)
Václav Kubernát1d50a5b2020-02-03 16:44:22 +010031 : m_session(libnetconf::client::Session::connectPubkey(hostname, port, user, pubKey, privKey))
32 , m_schema(std::make_shared<YangSchema>(m_session->libyangContext()))
Václav Kubernátc31bd602019-03-07 11:44:48 +010033{
Václav Kubernátc31bd602019-03-07 11:44:48 +010034}
35
Václav Kubernát7a9463f2020-10-30 08:57:59 +010036NetconfAccess::NetconfAccess(const int source, const int sink)
37 : m_session(libnetconf::client::Session::connectFd(source, sink))
38 , m_schema(std::make_shared<YangSchema>(m_session->libyangContext()))
39{
40}
41
Jan Kundrátdab815e2020-01-22 19:44:11 +010042NetconfAccess::NetconfAccess(std::unique_ptr<libnetconf::client::Session>&& session)
43 : m_session(std::move(session))
Václav Kubernát1d50a5b2020-02-03 16:44:22 +010044 , m_schema(std::make_shared<YangSchema>(m_session->libyangContext()))
Jan Kundrátdab815e2020-01-22 19:44:11 +010045{
Jan Kundrátdab815e2020-01-22 19:44:11 +010046}
47
Václav Kubernátc31bd602019-03-07 11:44:48 +010048NetconfAccess::NetconfAccess(const std::string& socketPath)
Václav Kubernát1d50a5b2020-02-03 16:44:22 +010049 : m_session(libnetconf::client::Session::connectSocket(socketPath))
50 , m_schema(std::make_shared<YangSchema>(m_session->libyangContext()))
Václav Kubernátc31bd602019-03-07 11:44:48 +010051{
Václav Kubernátc31bd602019-03-07 11:44:48 +010052}
53
Václav Kubernáte2e15ee2020-02-05 17:38:13 +010054void NetconfAccess::setNcLogLevel(NC_VERB_LEVEL level)
55{
56 libnetconf::client::setLogLevel(level);
57}
58
59void NetconfAccess::setNcLogCallback(const LogCb& callback)
60{
61 libnetconf::client::setLogCallback(callback);
62}
63
Václav Kubernátc31bd602019-03-07 11:44:48 +010064void NetconfAccess::setLeaf(const std::string& path, leaf_data_ value)
65{
Jan Kundrát379bb572020-05-07 03:23:13 +020066 auto lyValue = value.type() == typeid(empty_) ? std::nullopt : std::optional(leafDataToString(value));
67 auto node = m_schema->dataNodeFromPath(path, lyValue);
Václav Kubernátc31bd602019-03-07 11:44:48 +010068 doEditFromDataNode(node);
69}
70
Jan Kundrátcbf288b2020-06-18 20:44:39 +020071void NetconfAccess::createItem(const std::string& path)
Václav Kubernátc31bd602019-03-07 11:44:48 +010072{
73 auto node = m_schema->dataNodeFromPath(path);
74 doEditFromDataNode(node);
75}
76
Jan Kundrátcbf288b2020-06-18 20:44:39 +020077void NetconfAccess::deleteItem(const std::string& path)
Václav Kubernátc31bd602019-03-07 11:44:48 +010078{
79 auto node = m_schema->dataNodeFromPath(path);
Václav Kubernátda8e4b92020-02-04 11:56:30 +010080 auto container = *(node->find_path(path.c_str())->data().begin());
81 container->insert_attr(m_schema->getYangModule("ietf-netconf"), "operation", "delete");
Václav Kubernátc31bd602019-03-07 11:44:48 +010082 doEditFromDataNode(node);
83}
84
Václav Kubernátbf65dd72020-05-28 02:32:31 +020085struct impl_toYangInsert {
86 std::string operator()(yang::move::Absolute& absolute)
87 {
88 return absolute == yang::move::Absolute::Begin ? "first" : "last";
89 }
90 std::string operator()(yang::move::Relative& relative)
91 {
92 return relative.m_position == yang::move::Relative::Position::After ? "after" : "before";
93 }
94};
95
96std::string toYangInsert(std::variant<yang::move::Absolute, yang::move::Relative> move)
97{
98 return std::visit(impl_toYangInsert{}, move);
99}
100
101void NetconfAccess::moveItem(const std::string& source, std::variant<yang::move::Absolute, yang::move::Relative> move)
102{
103 auto node = m_schema->dataNodeFromPath(source);
104 auto sourceNode = *(node->find_path(source.c_str())->data().begin());
105 auto yangModule = m_schema->getYangModule("yang");
106 sourceNode->insert_attr(yangModule, "insert", toYangInsert(move).c_str());
107
108 if (std::holds_alternative<yang::move::Relative>(move)) {
109 auto relative = std::get<yang::move::Relative>(move);
110 if (m_schema->nodeType(source) == yang::NodeTypes::LeafList) {
111 sourceNode->insert_attr(yangModule, "value", leafDataToString(relative.m_path.at(".")).c_str());
112 } else {
Václav Kubernát2c4778b2020-06-18 11:55:20 +0200113 sourceNode->insert_attr(yangModule, "key", instanceToString(relative.m_path, node->node_module()->name()).c_str());
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200114 }
115 }
116 doEditFromDataNode(sourceNode);
117}
118
Václav Kubernátc31bd602019-03-07 11:44:48 +0100119void NetconfAccess::doEditFromDataNode(std::shared_ptr<libyang::Data_Node> dataNode)
120{
121 auto data = dataNode->print_mem(LYD_XML, 0);
122 m_session->editConfig(NC_DATASTORE_CANDIDATE, NC_RPC_EDIT_DFLTOP_MERGE, NC_RPC_EDIT_TESTOPT_TESTSET, NC_RPC_EDIT_ERROPT_STOP, data);
123}
124
125void NetconfAccess::commitChanges()
126{
127 m_session->commit();
128}
129
130void NetconfAccess::discardChanges()
131{
132 m_session->discard();
133}
134
Václav Kubernátb3960f82020-12-01 03:21:48 +0100135DatastoreAccess::Tree NetconfAccess::execute(const std::string& path, const Tree& input)
Jan Kundrát6ee84792020-01-24 01:43:36 +0100136{
137 auto root = m_schema->dataNodeFromPath(path);
138 for (const auto& [k, v] : input) {
139 auto node = m_schema->dataNodeFromPath(joinPaths(path, k), leafDataToString(v));
140 root->merge(node, 0);
141 }
142 auto data = root->print_mem(LYD_XML, 0);
143
144 Tree res;
Václav Kubernáta8789602020-07-20 15:18:19 +0200145 auto output = m_session->rpc_or_action(data);
Jan Kundrát6ee84792020-01-24 01:43:36 +0100146 if (output) {
Václav Kubernátdaf40312020-06-19 11:34:55 +0200147 lyNodesToTree(res, output->tree_for(), joinPaths(path, "/"));
Jan Kundrát6ee84792020-01-24 01:43:36 +0100148 }
149 return res;
150}
151
Václav Kubernát7160a132020-04-03 02:11:01 +0200152NC_DATASTORE toNcDatastore(Datastore datastore)
153{
154 switch (datastore) {
155 case Datastore::Running:
156 return NC_DATASTORE_RUNNING;
157 case Datastore::Startup:
158 return NC_DATASTORE_STARTUP;
159 }
160 __builtin_unreachable();
161}
162
163void NetconfAccess::copyConfig(const Datastore source, const Datastore destination)
164{
165 m_session->copyConfig(toNcDatastore(source), toNcDatastore(destination));
166}
167
Václav Kubernátb52dc252019-12-04 13:03:39 +0100168std::string NetconfAccess::fetchSchema(const std::string_view module, const
169 std::optional<std::string_view> revision, const
170 std::optional<std::string_view> submodule, const
171 std::optional<std::string_view> submoduleRevision)
Václav Kubernátc31bd602019-03-07 11:44:48 +0100172{
Václav Kubernátb52dc252019-12-04 13:03:39 +0100173 if (submodule) {
174 return m_session->getSchema(*submodule, submoduleRevision);
175 }
Václav Kubernátc31bd602019-03-07 11:44:48 +0100176 return m_session->getSchema(module, revision);
177}
178
179std::vector<std::string> NetconfAccess::listImplementedSchemas()
180{
181 auto data = m_session->get("/ietf-netconf-monitoring:netconf-state/schemas");
182 auto set = data->find_path("/ietf-netconf-monitoring:netconf-state/schemas/schema/identifier");
183
184 std::vector<std::string> res;
185 for (auto it : set->data()) {
186 if (it->schema()->nodetype() == LYS_LEAF) {
187 libyang::Data_Node_Leaf_List leaf(it);
Václav Kubernátfaacd022020-07-08 16:44:38 +0200188 res.emplace_back(leaf.value_str());
Václav Kubernátc31bd602019-03-07 11:44:48 +0100189 }
190 }
191 return res;
192}
193
194std::shared_ptr<Schema> NetconfAccess::schema()
195{
196 return m_schema;
197}
Václav Kubernátab612e92019-11-26 19:51:31 +0100198
199std::vector<ListInstance> NetconfAccess::listInstances(const std::string& path)
200{
201 std::vector<ListInstance> res;
202 auto list = m_schema->dataNodeFromPath(path);
203
204 // This inserts selection nodes - I only want keys not other data
205 // To get the keys, I have to call find_path here - otherwise I would get keys of a top-level node (which might not even be a list)
206 auto keys = libyang::Schema_Node_List{(*(list->find_path(path.c_str())->data().begin()))->schema()}.keys();
207 for (const auto& keyLeaf : keys) {
208 // Have to call find_path here - otherwise I'll have the list, not the leaf inside it
209 auto selectionLeaf = *(m_schema->dataNodeFromPath(keyLeaf->path())->find_path(keyLeaf->path().c_str())->data().begin());
210 auto actualList = *(list->find_path(path.c_str())->data().begin());
211 actualList->insert(selectionLeaf);
212 }
213
Jan Kundrátbb525b42020-02-04 11:56:59 +0100214 auto instances = m_session->get(list->print_mem(LYD_XML, 0));
Václav Kubernátab612e92019-11-26 19:51:31 +0100215
Václav Kubernát45e55462020-02-04 11:19:32 +0100216 if (!instances) {
217 return res;
218 }
Václav Kubernátab612e92019-11-26 19:51:31 +0100219
220 for (const auto& instance : instances->find_path(path.c_str())->data()) {
221 ListInstance instanceRes;
222
223 // I take the first child here, because the first element (the parent of the child()) will be the list
224 for (const auto& keyLeaf : instance->child()->tree_for()) {
Václav Kubernát2e4cafe2020-11-05 01:53:21 +0100225 auto leafData = std::make_shared<libyang::Data_Node_Leaf_List>(keyLeaf);
Václav Kubernátb4e5b182020-11-16 19:55:09 +0100226 instanceRes.insert({leafData->schema()->name(), leafValueFromNode(leafData)});
Václav Kubernátab612e92019-11-26 19:51:31 +0100227 }
Václav Kubernátfaacd022020-07-08 16:44:38 +0200228 res.emplace_back(instanceRes);
Václav Kubernátab612e92019-11-26 19:51:31 +0100229 }
230
231 return res;
232}
Václav Kubernát70d7f7a2020-06-23 14:40:40 +0200233
234std::string NetconfAccess::dump(const DataFormat format) const
235{
236 auto config = m_session->get();
237 if (!config) {
238 return "";
239 }
240 return config->print_mem(format == DataFormat::Xml ? LYD_XML : LYD_JSON, LYP_WITHSIBLINGS | LYP_FORMAT);
241}