blob: f6e0eeaaf0b03cf31de17b99d9e24957e911cbf9 [file] [log] [blame]
Václav Kubernát0d4db442018-07-18 17:18:43 +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
9#include <libyang/Libyang.hpp>
10#include <libyang/Tree_Schema.hpp>
11#include <string_view>
12#include "utils.hpp"
13#include "yang_schema.hpp"
14
15class YangLoadError : public std::runtime_error {
16public:
17 using std::runtime_error::runtime_error;
18 ~YangLoadError() override = default;
19};
20
21class UnsupportedYangTypeException : public std::runtime_error {
22public:
23 using std::runtime_error::runtime_error;
24 ~UnsupportedYangTypeException() override = default;
25};
26
27class InvalidSchemaQueryException : public std::runtime_error {
28public:
29 using std::runtime_error::runtime_error;
30 ~InvalidSchemaQueryException() override = default;
31};
32
Václav Kubernát2eaceb82018-10-08 19:56:30 +020033template <typename T>
34std::string pathToYangAbsSchemPath(const T& path)
Václav Kubernát0d4db442018-07-18 17:18:43 +020035{
36 std::string res = "/";
37 std::string currentModule;
38
39 for (const auto& it : path.m_nodes) {
40 const auto name = nodeToSchemaString(it);
41
42 if (it.m_suffix.type() == typeid(module_)) {
43 currentModule = name;
44 continue;
45 } else {
46 res += currentModule + ":";
47 res += name + "/";
48 }
49 }
50
51 return res;
52}
53
54YangSchema::YangSchema()
Václav Kubernáta6c5fff2018-09-07 15:16:25 +020055 : m_context(std::make_shared<libyang::Context>(nullptr, LY_CTX_DISABLE_SEARCHDIRS | LY_CTX_DISABLE_SEARCHDIR_CWD))
Václav Kubernát0d4db442018-07-18 17:18:43 +020056{
Václav Kubernát0d4db442018-07-18 17:18:43 +020057}
58
59YangSchema::~YangSchema() = default;
60
61void YangSchema::addSchemaString(const char* schema)
62{
63 if (!m_context->parse_module_mem(schema, LYS_IN_YANG)) {
64 throw YangLoadError("Couldn't load schema");
65 }
66}
67
68void YangSchema::addSchemaDirectory(const char* directoryName)
69{
70 if (m_context->set_searchdir(directoryName)) {
71 throw YangLoadError("Couldn't add schema search directory");
72 }
73}
74
75void YangSchema::addSchemaFile(const char* filename)
76{
77 if (!m_context->parse_module_path(filename, LYS_IN_YANG)) {
78 throw YangLoadError("Couldn't load schema");
79 }
80}
81
Václav Kubernát2eaceb82018-10-08 19:56:30 +020082bool YangSchema::isModule(const schemaPath_&, const std::string& name) const
Václav Kubernát0d4db442018-07-18 17:18:43 +020083{
84 const auto set = modules();
85 return set.find(name) != set.end();
86}
87
Václav Kubernát2eaceb82018-10-08 19:56:30 +020088bool YangSchema::isContainer(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +020089{
90 const auto schemaNode = getSchemaNode(location, node);
91 return schemaNode && schemaNode->nodetype() == LYS_CONTAINER;
92}
93
Václav Kubernát2eaceb82018-10-08 19:56:30 +020094bool YangSchema::isLeaf(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +020095{
96 const auto schemaNode = getSchemaNode(location, node);
97 return schemaNode && schemaNode->nodetype() == LYS_LEAF;
98}
99
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200100bool YangSchema::isList(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200101{
102 const auto schemaNode = getSchemaNode(location, node);
103 return schemaNode && schemaNode->nodetype() == LYS_LIST;
104}
105
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200106bool YangSchema::isPresenceContainer(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200107{
108 if (!isContainer(location, node))
109 return false;
Jan Kundrát4ed0e9f2018-08-23 16:56:58 +0200110 return libyang::Schema_Node_Container(getSchemaNode(location, node)).presence();
Václav Kubernát0d4db442018-07-18 17:18:43 +0200111}
112
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200113bool YangSchema::leafEnumHasValue(const schemaPath_& location, const ModuleNodePair& node, const std::string& value) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200114{
Václav Kubernát989b5de2019-02-20 16:28:35 +0100115 auto enums = enumValues(location, node);
116
117 return std::any_of(enums.begin(), enums.end(), [=](const auto& x) { return x == value; });
118}
119
120const std::set<std::string> YangSchema::enumValues(const schemaPath_& location, const ModuleNodePair& node) const
121{
Václav Kubernát0d4db442018-07-18 17:18:43 +0200122 if (!isLeaf(location, node) || leafType(location, node) != yang::LeafDataTypes::Enum)
Václav Kubernát989b5de2019-02-20 16:28:35 +0100123 return {};
Václav Kubernát0d4db442018-07-18 17:18:43 +0200124
Jan Kundrát4ed0e9f2018-08-23 16:56:58 +0200125 libyang::Schema_Node_Leaf leaf(getSchemaNode(location, node));
Václav Kubernát6a713d62018-10-03 18:47:34 +0200126 auto type = leaf.type();
127 auto enm = type->info()->enums()->enm();
128 // The enum can be a derived type and enm() only returns values,
129 // if that specific typedef changed the possible values. So we go
130 // up the hierarchy until we find a typedef that defined these values.
131 while (enm.empty()) {
132 type = type->der()->type();
133 enm = type->info()->enums()->enm();
134 }
Václav Kubernát0d4db442018-07-18 17:18:43 +0200135
Václav Kubernát989b5de2019-02-20 16:28:35 +0100136 std::set<std::string> enumSet;
137 std::transform(enm.begin(), enm.end(), std::inserter(enumSet, enumSet.end()), [](auto it) { return it->name(); });
138 return enumSet;
Václav Kubernát0d4db442018-07-18 17:18:43 +0200139}
140
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200141bool YangSchema::listHasKey(const schemaPath_& location, const ModuleNodePair& node, const std::string& key) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200142{
143 if (!isList(location, node))
144 return false;
145 const auto keys = listKeys(location, node);
146 return keys.find(key) != keys.end();
147}
148
149bool YangSchema::nodeExists(const std::string& location, const std::string& node) const
150{
151 const auto absPath = location + "/" + node;
152 const auto set = m_context->find_path(absPath.c_str());
153 return set->number() == 1;
154}
155
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200156libyang::S_Set YangSchema::getNodeSet(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200157{
158 std::string absPath = location.m_nodes.empty() ? "" : "/";
159 absPath += pathToAbsoluteSchemaString(location) + "/" + fullNodeName(location, node);
160 return m_context->find_path(absPath.c_str());
161}
162
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200163libyang::S_Schema_Node YangSchema::getSchemaNode(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200164{
165 const auto set = getNodeSet(location, node);
166 if (!set)
167 return nullptr;
Jan Kundrát4030b772018-08-23 15:54:56 +0200168 const auto& schemaSet = set->schema();
Václav Kubernát0d4db442018-07-18 17:18:43 +0200169 if (set->number() != 1)
170 return nullptr;
Jan Kundrát4030b772018-08-23 15:54:56 +0200171 return *schemaSet.begin();
Václav Kubernát0d4db442018-07-18 17:18:43 +0200172}
173
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200174const std::set<std::string> YangSchema::listKeys(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200175{
176 std::set<std::string> keys;
177 if (!isList(location, node))
178 return keys;
Jan Kundrát4ed0e9f2018-08-23 16:56:58 +0200179 libyang::Schema_Node_List list(getSchemaNode(location, node));
Jan Kundrát4030b772018-08-23 15:54:56 +0200180 const auto& keysVec = list.keys();
Václav Kubernát0d4db442018-07-18 17:18:43 +0200181
Jan Kundrát4030b772018-08-23 15:54:56 +0200182 std::transform(keysVec.begin(), keysVec.end(), std::inserter(keys, keys.begin()),
Václav Kubernát0d4db442018-07-18 17:18:43 +0200183 [] (const auto& it) {return it->name();});
184 return keys;
185}
186
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200187yang::LeafDataTypes YangSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200188{
189 using namespace std::string_literals;
190 if (!isLeaf(location, node))
191 throw InvalidSchemaQueryException(fullNodeName(location, node) + " is not a leaf");
192
Jan Kundrát4ed0e9f2018-08-23 16:56:58 +0200193 libyang::Schema_Node_Leaf leaf(getSchemaNode(location, node));
Václav Kubernát0d4db442018-07-18 17:18:43 +0200194 switch (leaf.type()->base()) {
195 case LY_TYPE_STRING:
196 return yang::LeafDataTypes::String;
197 case LY_TYPE_DEC64:
198 return yang::LeafDataTypes::Decimal;
199 case LY_TYPE_BOOL:
200 return yang::LeafDataTypes::Bool;
201 case LY_TYPE_INT32:
202 return yang::LeafDataTypes::Int;
203 case LY_TYPE_UINT32:
204 return yang::LeafDataTypes::Uint;
205 case LY_TYPE_ENUM:
206 return yang::LeafDataTypes::Enum;
Václav Kubernátab538992019-03-06 15:30:50 +0100207 case LY_TYPE_BINARY:
208 return yang::LeafDataTypes::Binary;
Václav Kubernát0d4db442018-07-18 17:18:43 +0200209 default:
210 throw UnsupportedYangTypeException("the type of "s + fullNodeName(location, node) + " is not supported");
211 }
212}
213
214std::set<std::string> YangSchema::modules() const
215{
Jan Kundrát4030b772018-08-23 15:54:56 +0200216 const auto& modules = m_context->get_module_iter();
Václav Kubernát0d4db442018-07-18 17:18:43 +0200217
218 std::set<std::string> res;
Jan Kundrát4030b772018-08-23 15:54:56 +0200219 std::transform(modules.begin(), modules.end(),
Václav Kubernát0d4db442018-07-18 17:18:43 +0200220 std::inserter(res, res.end()),
221 [] (const auto module) { return module->name(); });
222 return res;
223}
224
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200225std::set<std::string> YangSchema::childNodes(const schemaPath_& path, const Recursion recursion) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200226{
227 using namespace std::string_view_literals;
228 std::set<std::string> res;
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200229 std::vector<libyang::S_Schema_Node> nodes;
230
Václav Kubernát0d4db442018-07-18 17:18:43 +0200231 if (path.m_nodes.empty()) {
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200232 nodes = m_context->data_instantiables(0);
Václav Kubernát0d4db442018-07-18 17:18:43 +0200233 } else {
234 const auto absolutePath = "/" + pathToAbsoluteSchemaString(path);
235 const auto set = m_context->find_path(absolutePath.c_str());
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200236 const auto schemaSet = set->schema();
Jan Kundrát4030b772018-08-23 15:54:56 +0200237 for (auto it = (*schemaSet.begin())->child(); it; it = it->next()) {
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200238 nodes.push_back(it);
Václav Kubernát0d4db442018-07-18 17:18:43 +0200239 }
240 }
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200241
242 for (const auto node : nodes) {
243 if (node->module()->name() == "ietf-yang-library"sv)
Václav Kubernát89728d82018-09-13 16:28:28 +0200244 continue;
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200245 if (recursion == Recursion::Recursive) {
246 for (auto it : node->tree_dfs()) {
247 res.insert(it->path(LYS_PATH_FIRST_PREFIX));
248 }
249 } else {
Václav Kubernát4f77a252019-02-19 16:51:30 +0100250 std::string toInsert;
251 if (path.m_nodes.empty() || path.m_nodes.front().m_prefix.get().m_name != node->module()->name()) {
252 toInsert += node->module()->name();
253 toInsert += ":";
254 }
255 toInsert += node->name();
256 res.insert(toInsert);
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200257 }
258 }
259
Václav Kubernát0d4db442018-07-18 17:18:43 +0200260 return res;
261}
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200262
263void YangSchema::loadModule(const std::string& moduleName)
264{
265 m_context->load_module(moduleName.c_str());
266}
267
268void YangSchema::registerModuleCallback(const std::function<std::string(const char*, const char*, const char*)>& clb)
269{
270 auto lambda = [clb](const char* mod_name, const char* mod_revision, const char* submod_name, const char* submod_revision) {
271 (void)submod_revision;
272 auto moduleSource = clb(mod_name, mod_revision, submod_name);
273 if (moduleSource.empty()) {
274 return libyang::Context::mod_missing_cb_return{LYS_IN_YANG, nullptr};
275 }
276 return libyang::Context::mod_missing_cb_return{LYS_IN_YANG, strdup(moduleSource.c_str())};
277 };
278
279 auto deleter = [](void* data) {
280 free(data);
281 };
282 m_context->add_missing_module_callback(lambda, deleter);
283}