Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 1 | /* |
| 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> |
Václav Kubernát | c31bd60 | 2019-03-07 11:44:48 +0100 | [diff] [blame] | 10 | #include <libyang/Tree_Data.hpp> |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 11 | #include <libyang/Tree_Schema.hpp> |
| 12 | #include <string_view> |
Václav Kubernát | 26b5608 | 2020-02-03 18:28:56 +0100 | [diff] [blame] | 13 | #include "UniqueResource.hpp" |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 14 | #include "utils.hpp" |
| 15 | #include "yang_schema.hpp" |
| 16 | |
| 17 | class YangLoadError : public std::runtime_error { |
| 18 | public: |
| 19 | using std::runtime_error::runtime_error; |
| 20 | ~YangLoadError() override = default; |
| 21 | }; |
| 22 | |
| 23 | class UnsupportedYangTypeException : public std::runtime_error { |
| 24 | public: |
| 25 | using std::runtime_error::runtime_error; |
| 26 | ~UnsupportedYangTypeException() override = default; |
| 27 | }; |
| 28 | |
| 29 | class InvalidSchemaQueryException : public std::runtime_error { |
| 30 | public: |
| 31 | using std::runtime_error::runtime_error; |
| 32 | ~InvalidSchemaQueryException() override = default; |
| 33 | }; |
| 34 | |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 35 | YangSchema::YangSchema() |
Václav Kubernát | 51d0801 | 2020-06-08 15:20:12 +0200 | [diff] [blame] | 36 | : m_context(std::make_shared<libyang::Context>(nullptr, LY_CTX_DISABLE_SEARCHDIR_CWD)) |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 37 | { |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 38 | } |
| 39 | |
Václav Kubernát | 1d50a5b | 2020-02-03 16:44:22 +0100 | [diff] [blame] | 40 | YangSchema::YangSchema(std::shared_ptr<libyang::Context> lyCtx) |
| 41 | : m_context(lyCtx) |
| 42 | { |
| 43 | |
| 44 | } |
| 45 | |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 46 | YangSchema::~YangSchema() = default; |
| 47 | |
| 48 | void YangSchema::addSchemaString(const char* schema) |
| 49 | { |
| 50 | if (!m_context->parse_module_mem(schema, LYS_IN_YANG)) { |
| 51 | throw YangLoadError("Couldn't load schema"); |
| 52 | } |
| 53 | } |
| 54 | |
| 55 | void YangSchema::addSchemaDirectory(const char* directoryName) |
| 56 | { |
| 57 | if (m_context->set_searchdir(directoryName)) { |
| 58 | throw YangLoadError("Couldn't add schema search directory"); |
| 59 | } |
| 60 | } |
| 61 | |
| 62 | void YangSchema::addSchemaFile(const char* filename) |
| 63 | { |
| 64 | if (!m_context->parse_module_path(filename, LYS_IN_YANG)) { |
| 65 | throw YangLoadError("Couldn't load schema"); |
| 66 | } |
| 67 | } |
| 68 | |
Václav Kubernát | 75877de | 2019-11-20 17:43:02 +0100 | [diff] [blame] | 69 | bool YangSchema::isModule(const std::string& name) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 70 | { |
| 71 | const auto set = modules(); |
| 72 | return set.find(name) != set.end(); |
| 73 | } |
| 74 | |
Václav Kubernát | 2db124c | 2020-05-28 21:58:36 +0200 | [diff] [blame] | 75 | bool YangSchema::listHasKey(const schemaPath_& listPath, const std::string& key) const |
| 76 | { |
| 77 | const auto keys = listKeys(listPath); |
| 78 | return keys.find(key) != keys.end(); |
| 79 | } |
| 80 | |
Václav Kubernát | c386679 | 2020-02-20 14:12:56 +0100 | [diff] [blame] | 81 | bool YangSchema::leafIsKey(const std::string& leafPath) const |
| 82 | { |
| 83 | auto node = getSchemaNode(leafPath); |
| 84 | if (!node || node->nodetype() != LYS_LEAF) |
| 85 | return false; |
| 86 | |
| 87 | return libyang::Schema_Node_Leaf{node}.is_key().get(); |
| 88 | } |
| 89 | |
Václav Kubernát | 47a3f67 | 2019-11-08 15:42:43 +0100 | [diff] [blame] | 90 | libyang::S_Schema_Node YangSchema::impl_getSchemaNode(const std::string& node) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 91 | { |
Václav Kubernát | f2b91e0 | 2019-04-11 15:36:48 +0200 | [diff] [blame] | 92 | // If no node is found find_path prints an error message, so we have to |
| 93 | // disable logging |
| 94 | // https://github.com/CESNET/libyang/issues/753 |
| 95 | { |
| 96 | int oldOptions; |
| 97 | auto logBlocker = make_unique_resource( |
| 98 | [&oldOptions]() { |
| 99 | oldOptions = libyang::set_log_options(0); |
| 100 | }, |
| 101 | [&oldOptions]() { |
| 102 | libyang::set_log_options(oldOptions); |
| 103 | }); |
Václav Kubernát | 47a3f67 | 2019-11-08 15:42:43 +0100 | [diff] [blame] | 104 | return m_context->get_node(nullptr, node.c_str()); |
Václav Kubernát | f2b91e0 | 2019-04-11 15:36:48 +0200 | [diff] [blame] | 105 | } |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 106 | } |
| 107 | |
Václav Kubernát | 47a3f67 | 2019-11-08 15:42:43 +0100 | [diff] [blame] | 108 | |
| 109 | libyang::S_Schema_Node YangSchema::getSchemaNode(const std::string& node) const |
| 110 | { |
| 111 | return impl_getSchemaNode(node); |
| 112 | } |
| 113 | |
| 114 | libyang::S_Schema_Node YangSchema::getSchemaNode(const schemaPath_& location, const ModuleNodePair& node) const |
| 115 | { |
Václav Kubernát | efcac93 | 2020-01-10 15:26:32 +0100 | [diff] [blame] | 116 | std::string absPath = joinPaths(pathToSchemaString(location, Prefixes::Always), fullNodeName(location, node)); |
Václav Kubernát | 47a3f67 | 2019-11-08 15:42:43 +0100 | [diff] [blame] | 117 | |
| 118 | return impl_getSchemaNode(absPath); |
| 119 | } |
| 120 | |
Václav Kubernát | 2db124c | 2020-05-28 21:58:36 +0200 | [diff] [blame] | 121 | libyang::S_Schema_Node YangSchema::getSchemaNode(const schemaPath_& listPath) const |
| 122 | { |
| 123 | std::string absPath = pathToSchemaString(listPath, Prefixes::Always); |
| 124 | return impl_getSchemaNode(absPath); |
| 125 | } |
| 126 | |
Václav Kubernát | 912b949 | 2020-05-29 02:03:40 +0200 | [diff] [blame] | 127 | const std::set<std::string> YangSchema::listKeys(const schemaPath_& listPath) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 128 | { |
Václav Kubernát | 912b949 | 2020-05-29 02:03:40 +0200 | [diff] [blame] | 129 | auto node = getSchemaNode(listPath); |
| 130 | if (node->nodetype() != LYS_LIST) { |
| 131 | return {}; |
| 132 | } |
| 133 | |
| 134 | auto list = std::make_shared<libyang::Schema_Node_List>(node); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 135 | std::set<std::string> keys; |
Václav Kubernát | 2db124c | 2020-05-28 21:58:36 +0200 | [diff] [blame] | 136 | const auto& keysVec = list->keys(); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 137 | |
Václav Kubernát | 90de950 | 2019-11-20 17:19:44 +0100 | [diff] [blame] | 138 | std::transform(keysVec.begin(), keysVec.end(), std::inserter(keys, keys.begin()), [](const auto& it) { return it->name(); }); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 139 | return keys; |
| 140 | } |
| 141 | |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 142 | namespace { |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 143 | std::set<enum_> enumValues(const libyang::S_Type& typeArg) |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 144 | { |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 145 | auto type = typeArg; |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 146 | auto enm = type->info()->enums()->enm(); |
| 147 | // The enum can be a derived type and enm() only returns values, |
| 148 | // if that specific typedef changed the possible values. So we go |
| 149 | // up the hierarchy until we find a typedef that defined these values. |
| 150 | while (enm.empty()) { |
| 151 | type = type->der()->type(); |
| 152 | enm = type->info()->enums()->enm(); |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 153 | } |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 154 | |
| 155 | std::vector<libyang::S_Type_Enum> enabled; |
| 156 | std::copy_if(enm.begin(), enm.end(), std::back_inserter(enabled), [](const libyang::S_Type_Enum& it) { |
| 157 | auto iffeatures = it->iffeature(); |
| 158 | return std::all_of(iffeatures.begin(), iffeatures.end(), [](auto it) { return it->value(); }); |
| 159 | }); |
| 160 | |
| 161 | std::set<enum_> enumSet; |
| 162 | std::transform(enabled.begin(), enabled.end(), std::inserter(enumSet, enumSet.end()), [](auto it) { return enum_{it->name()}; }); |
| 163 | return enumSet; |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 164 | } |
| 165 | |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 166 | std::set<identityRef_> validIdentities(const libyang::S_Type& type) |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 167 | { |
| 168 | std::set<identityRef_> identSet; |
| 169 | |
| 170 | // auto topLevelModule = leaf->module(); |
| 171 | |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 172 | auto info = type->info(); |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 173 | for (auto base : info->ident()->ref()) { // Iterate over all bases |
| 174 | identSet.emplace(base->module()->name(), base->name()); |
| 175 | // Iterate over derived identities (this is recursive!) |
| 176 | for (auto derived : base->der()->schema()) { |
| 177 | identSet.emplace(derived->module()->name(), derived->name()); |
| 178 | } |
| 179 | } |
| 180 | |
| 181 | return identSet; |
| 182 | } |
| 183 | |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 184 | std::string leafrefPath(const libyang::S_Type& type) |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 185 | { |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 186 | return type->info()->lref()->target()->path(LYS_PATH_FIRST_PREFIX); |
Václav Kubernát | 3a99f00 | 2020-03-31 02:27:41 +0200 | [diff] [blame] | 187 | } |
| 188 | } |
| 189 | |
Václav Kubernát | 5b8a8f3 | 2020-05-20 00:57:22 +0200 | [diff] [blame] | 190 | template <typename NodeType> |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 191 | yang::TypeInfo YangSchema::impl_leafType(const libyang::S_Schema_Node& node) const |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 192 | { |
| 193 | using namespace std::string_literals; |
Václav Kubernát | 5b8a8f3 | 2020-05-20 00:57:22 +0200 | [diff] [blame] | 194 | auto leaf = std::make_shared<NodeType>(node); |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 195 | auto leafUnits = leaf->units(); |
| 196 | std::function<yang::TypeInfo(std::shared_ptr<libyang::Type>)> resolveType; |
| 197 | resolveType = [this, &resolveType, leaf, leafUnits] (std::shared_ptr<libyang::Type> type) -> yang::TypeInfo { |
| 198 | yang::LeafDataType resType; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 199 | switch (type->base()) { |
| 200 | case LY_TYPE_STRING: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 201 | resType.emplace<yang::String>(); |
| 202 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 203 | case LY_TYPE_DEC64: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 204 | resType.emplace<yang::Decimal>(); |
| 205 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 206 | case LY_TYPE_BOOL: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 207 | resType.emplace<yang::Bool>(); |
| 208 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 209 | case LY_TYPE_INT8: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 210 | resType.emplace<yang::Int8>(); |
| 211 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 212 | case LY_TYPE_INT16: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 213 | resType.emplace<yang::Int16>(); |
| 214 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 215 | case LY_TYPE_INT32: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 216 | resType.emplace<yang::Int32>(); |
| 217 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 218 | case LY_TYPE_INT64: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 219 | resType.emplace<yang::Int64>(); |
| 220 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 221 | case LY_TYPE_UINT8: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 222 | resType.emplace<yang::Uint8>(); |
| 223 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 224 | case LY_TYPE_UINT16: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 225 | resType.emplace<yang::Uint16>(); |
| 226 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 227 | case LY_TYPE_UINT32: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 228 | resType.emplace<yang::Uint32>(); |
| 229 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 230 | case LY_TYPE_UINT64: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 231 | resType.emplace<yang::Uint64>(); |
| 232 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 233 | case LY_TYPE_BINARY: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 234 | resType.emplace<yang::Binary>(); |
| 235 | break; |
Jan Kundrát | 379bb57 | 2020-05-07 03:23:13 +0200 | [diff] [blame] | 236 | case LY_TYPE_EMPTY: |
| 237 | resType.emplace<yang::Empty>(); |
| 238 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 239 | case LY_TYPE_ENUM: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 240 | resType.emplace<yang::Enum>(enumValues(type)); |
| 241 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 242 | case LY_TYPE_IDENT: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 243 | resType.emplace<yang::IdentityRef>(validIdentities(type)); |
| 244 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 245 | case LY_TYPE_LEAFREF: |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 246 | resType.emplace<yang::LeafRef>(::leafrefPath(type), std::make_unique<yang::TypeInfo>(leafType(::leafrefPath(type)))); |
| 247 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 248 | case LY_TYPE_UNION: |
| 249 | { |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 250 | auto resUnion = yang::Union{}; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 251 | for (auto unionType : type->info()->uni()->types()) { |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 252 | resUnion.m_unionTypes.push_back(resolveType(unionType)); |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 253 | } |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 254 | resType.emplace<yang::Union>(std::move(resUnion)); |
| 255 | break; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 256 | } |
| 257 | default: |
| 258 | using namespace std::string_literals; |
| 259 | throw UnsupportedYangTypeException("the type of "s + leaf->name() + " is not supported: " + std::to_string(leaf->type()->base())); |
| 260 | } |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 261 | |
| 262 | std::optional<std::string> resUnits; |
| 263 | |
| 264 | if (leafUnits) { |
| 265 | resUnits = leafUnits; |
| 266 | } else { |
| 267 | for (auto parentTypedef = type->der(); parentTypedef; parentTypedef = parentTypedef->type()->der()) { |
| 268 | auto units = parentTypedef->units(); |
| 269 | if (units) { |
| 270 | resUnits = units; |
| 271 | break; |
| 272 | } |
| 273 | } |
| 274 | } |
| 275 | |
| 276 | return yang::TypeInfo(resType, resUnits); |
| 277 | }; |
Václav Kubernát | 2984f44 | 2020-02-20 17:43:35 +0100 | [diff] [blame] | 278 | return resolveType(leaf->type()); |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 279 | } |
| 280 | |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 281 | yang::TypeInfo YangSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const |
Václav Kubernát | 9bf3685 | 2020-02-18 17:47:56 +0100 | [diff] [blame] | 282 | { |
Václav Kubernát | 5b8a8f3 | 2020-05-20 00:57:22 +0200 | [diff] [blame] | 283 | auto lyNode = getSchemaNode(location, node); |
| 284 | switch (lyNode->nodetype()) { |
| 285 | case LYS_LEAF: |
| 286 | return impl_leafType<libyang::Schema_Node_Leaf>(lyNode); |
| 287 | case LYS_LEAFLIST: |
| 288 | return impl_leafType<libyang::Schema_Node_Leaflist>(lyNode); |
| 289 | default: |
| 290 | throw std::logic_error("YangSchema::leafType: type must be leaf or leaflist"); |
| 291 | } |
Václav Kubernát | 9bf3685 | 2020-02-18 17:47:56 +0100 | [diff] [blame] | 292 | } |
| 293 | |
Václav Kubernát | 13b23d7 | 2020-04-16 21:49:51 +0200 | [diff] [blame] | 294 | yang::TypeInfo YangSchema::leafType(const std::string& path) const |
Václav Kubernát | 9bf3685 | 2020-02-18 17:47:56 +0100 | [diff] [blame] | 295 | { |
Václav Kubernát | 5b8a8f3 | 2020-05-20 00:57:22 +0200 | [diff] [blame] | 296 | auto lyNode = getSchemaNode(path); |
| 297 | switch (lyNode->nodetype()) { |
| 298 | case LYS_LEAF: |
| 299 | return impl_leafType<libyang::Schema_Node_Leaf>(lyNode); |
| 300 | case LYS_LEAFLIST: |
| 301 | return impl_leafType<libyang::Schema_Node_Leaflist>(lyNode); |
| 302 | default: |
| 303 | throw std::logic_error("YangSchema::leafType: type must be leaf or leaflist"); |
| 304 | } |
Václav Kubernát | 9bf3685 | 2020-02-18 17:47:56 +0100 | [diff] [blame] | 305 | } |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 306 | |
Václav Kubernát | 6fcd028 | 2020-02-21 16:33:08 +0100 | [diff] [blame] | 307 | std::optional<std::string> YangSchema::leafTypeName(const std::string& path) const |
| 308 | { |
| 309 | libyang::Schema_Node_Leaf leaf(getSchemaNode(path)); |
Václav Kubernát | 76ba4ec | 2020-05-18 13:26:56 +0200 | [diff] [blame] | 310 | return leaf.type()->der().get() && leaf.type()->der()->type()->der().get() ? std::optional{leaf.type()->der()->name()} : std::nullopt; |
Václav Kubernát | 6fcd028 | 2020-02-21 16:33:08 +0100 | [diff] [blame] | 311 | } |
| 312 | |
Václav Kubernát | bd5e3c2 | 2020-02-19 15:22:00 +0100 | [diff] [blame] | 313 | std::string YangSchema::leafrefPath(const std::string& leafrefPath) const |
| 314 | { |
| 315 | using namespace std::string_literals; |
| 316 | libyang::Schema_Node_Leaf leaf(getSchemaNode(leafrefPath)); |
| 317 | return leaf.type()->info()->lref()->target()->path(LYS_PATH_FIRST_PREFIX); |
| 318 | } |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 319 | |
| 320 | std::set<std::string> YangSchema::modules() const |
| 321 | { |
Jan Kundrát | 4030b77 | 2018-08-23 15:54:56 +0200 | [diff] [blame] | 322 | const auto& modules = m_context->get_module_iter(); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 323 | |
| 324 | std::set<std::string> res; |
Václav Kubernát | 90de950 | 2019-11-20 17:19:44 +0100 | [diff] [blame] | 325 | std::transform(modules.begin(), modules.end(), std::inserter(res, res.end()), [](const auto module) { return module->name(); }); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 326 | return res; |
| 327 | } |
| 328 | |
Václav Kubernát | 95b0887 | 2020-04-28 01:04:17 +0200 | [diff] [blame] | 329 | std::set<ModuleNodePair> YangSchema::availableNodes(const boost::variant<dataPath_, schemaPath_, module_>& path, const Recursion recursion) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 330 | { |
| 331 | using namespace std::string_view_literals; |
Václav Kubernát | 95b0887 | 2020-04-28 01:04:17 +0200 | [diff] [blame] | 332 | std::set<ModuleNodePair> res; |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 333 | std::vector<libyang::S_Schema_Node> nodes; |
Václav Kubernát | 3a823f4 | 2020-04-29 23:40:21 +0200 | [diff] [blame] | 334 | std::string topLevelModule; |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 335 | |
Václav Kubernát | 3a823f4 | 2020-04-29 23:40:21 +0200 | [diff] [blame] | 336 | if (path.type() == typeid(module_)) { |
| 337 | nodes = m_context->get_module(boost::get<module_>(path).m_name.c_str())->data_instantiables(0); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 338 | } else { |
Václav Kubernát | 3a823f4 | 2020-04-29 23:40:21 +0200 | [diff] [blame] | 339 | auto schemaPath = anyPathToSchemaPath(path); |
| 340 | if (schemaPath.m_nodes.empty()) { |
| 341 | nodes = m_context->data_instantiables(0); |
| 342 | } else { |
| 343 | const auto pathString = pathToSchemaString(schemaPath, Prefixes::Always); |
| 344 | const auto node = getSchemaNode(pathString); |
| 345 | nodes = node->child_instantiables(0); |
| 346 | topLevelModule = schemaPath.m_nodes.begin()->m_prefix->m_name; |
| 347 | } |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 348 | } |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 349 | |
Václav Kubernát | ef08574 | 2020-04-21 09:28:44 +0200 | [diff] [blame] | 350 | for (const auto& node : nodes) { |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 351 | if (node->module()->name() == "ietf-yang-library"sv) |
Václav Kubernát | 89728d8 | 2018-09-13 16:28:28 +0200 | [diff] [blame] | 352 | continue; |
Václav Kubernát | aaafeae | 2020-05-05 15:41:45 +0200 | [diff] [blame] | 353 | |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 354 | if (recursion == Recursion::Recursive) { |
| 355 | for (auto it : node->tree_dfs()) { |
Václav Kubernát | 95b0887 | 2020-04-28 01:04:17 +0200 | [diff] [blame] | 356 | res.insert(ModuleNodePair(boost::none, it->path(LYS_PATH_FIRST_PREFIX))); |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 357 | } |
| 358 | } else { |
Václav Kubernát | 95b0887 | 2020-04-28 01:04:17 +0200 | [diff] [blame] | 359 | ModuleNodePair toInsert; |
Václav Kubernát | 3a823f4 | 2020-04-29 23:40:21 +0200 | [diff] [blame] | 360 | if (topLevelModule.empty() || topLevelModule != node->module()->name()) { |
Václav Kubernát | 82d7463 | 2020-05-11 15:59:53 +0200 | [diff] [blame] | 361 | toInsert.first = node->module()->type() == 0 ? node->module()->name() : libyang::Submodule(node->module()).belongsto()->name(); |
Václav Kubernát | 4f77a25 | 2019-02-19 16:51:30 +0100 | [diff] [blame] | 362 | } |
Václav Kubernát | 95b0887 | 2020-04-28 01:04:17 +0200 | [diff] [blame] | 363 | toInsert.second = node->name(); |
Václav Kubernát | 4f77a25 | 2019-02-19 16:51:30 +0100 | [diff] [blame] | 364 | res.insert(toInsert); |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 365 | } |
| 366 | } |
| 367 | |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 368 | return res; |
| 369 | } |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 370 | |
| 371 | void YangSchema::loadModule(const std::string& moduleName) |
| 372 | { |
| 373 | m_context->load_module(moduleName.c_str()); |
| 374 | } |
| 375 | |
Václav Kubernát | bf9c611 | 2019-11-04 16:03:35 +0100 | [diff] [blame] | 376 | void YangSchema::enableFeature(const std::string& moduleName, const std::string& featureName) |
| 377 | { |
| 378 | m_context->get_module(moduleName.c_str())->feature_enable(featureName.c_str()); |
| 379 | } |
| 380 | |
Václav Kubernát | b52dc25 | 2019-12-04 13:03:39 +0100 | [diff] [blame] | 381 | void YangSchema::registerModuleCallback(const std::function<std::string(const char*, const char*, const char*, const char*)>& clb) |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 382 | { |
| 383 | auto lambda = [clb](const char* mod_name, const char* mod_revision, const char* submod_name, const char* submod_revision) { |
| 384 | (void)submod_revision; |
Václav Kubernát | b52dc25 | 2019-12-04 13:03:39 +0100 | [diff] [blame] | 385 | auto moduleSource = clb(mod_name, mod_revision, submod_name, submod_revision); |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 386 | if (moduleSource.empty()) { |
| 387 | return libyang::Context::mod_missing_cb_return{LYS_IN_YANG, nullptr}; |
| 388 | } |
| 389 | return libyang::Context::mod_missing_cb_return{LYS_IN_YANG, strdup(moduleSource.c_str())}; |
| 390 | }; |
| 391 | |
| 392 | auto deleter = [](void* data) { |
| 393 | free(data); |
| 394 | }; |
| 395 | m_context->add_missing_module_callback(lambda, deleter); |
| 396 | } |
Václav Kubernát | c31bd60 | 2019-03-07 11:44:48 +0100 | [diff] [blame] | 397 | |
| 398 | std::shared_ptr<libyang::Data_Node> YangSchema::dataNodeFromPath(const std::string& path, const std::optional<const std::string> value) const |
| 399 | { |
| 400 | return std::make_shared<libyang::Data_Node>(m_context, |
| 401 | path.c_str(), |
| 402 | value ? value.value().c_str() : nullptr, |
| 403 | LYD_ANYDATA_CONSTSTRING, |
Václav Kubernát | ab612e9 | 2019-11-26 19:51:31 +0100 | [diff] [blame] | 404 | LYD_PATH_OPT_EDIT); |
Václav Kubernát | c31bd60 | 2019-03-07 11:44:48 +0100 | [diff] [blame] | 405 | } |
| 406 | |
| 407 | std::shared_ptr<libyang::Module> YangSchema::getYangModule(const std::string& name) |
| 408 | { |
| 409 | return m_context->get_module(name.c_str(), nullptr, 0); |
| 410 | } |
Václav Kubernát | 34ee85a | 2020-02-18 17:12:12 +0100 | [diff] [blame] | 411 | |
| 412 | namespace { |
| 413 | yang::NodeTypes impl_nodeType(const libyang::S_Schema_Node& node) |
| 414 | { |
| 415 | if (!node) { |
| 416 | throw InvalidNodeException(); |
| 417 | } |
| 418 | switch (node->nodetype()) { |
| 419 | case LYS_CONTAINER: |
| 420 | return libyang::Schema_Node_Container{node}.presence() ? yang::NodeTypes::PresenceContainer : yang::NodeTypes::Container; |
| 421 | case LYS_LEAF: |
| 422 | return yang::NodeTypes::Leaf; |
| 423 | case LYS_LIST: |
| 424 | return yang::NodeTypes::List; |
Václav Kubernát | aaafeae | 2020-05-05 15:41:45 +0200 | [diff] [blame] | 425 | case LYS_RPC: |
| 426 | return yang::NodeTypes::Rpc; |
| 427 | case LYS_ACTION: |
| 428 | return yang::NodeTypes::Action; |
| 429 | case LYS_NOTIF: |
| 430 | return yang::NodeTypes::Notification; |
| 431 | case LYS_ANYXML: |
| 432 | return yang::NodeTypes::AnyXml; |
| 433 | case LYS_LEAFLIST: |
| 434 | return yang::NodeTypes::LeafList; |
Václav Kubernát | 34ee85a | 2020-02-18 17:12:12 +0100 | [diff] [blame] | 435 | default: |
Václav Kubernát | 2a14139 | 2020-02-18 17:12:32 +0100 | [diff] [blame] | 436 | throw InvalidNodeException(); // FIXME: Implement all types. |
Václav Kubernát | 34ee85a | 2020-02-18 17:12:12 +0100 | [diff] [blame] | 437 | } |
| 438 | } |
| 439 | } |
| 440 | |
| 441 | yang::NodeTypes YangSchema::nodeType(const schemaPath_& location, const ModuleNodePair& node) const |
| 442 | { |
| 443 | return impl_nodeType(getSchemaNode(location, node)); |
| 444 | } |
| 445 | |
| 446 | yang::NodeTypes YangSchema::nodeType(const std::string& path) const |
| 447 | { |
| 448 | return impl_nodeType(getSchemaNode(path)); |
| 449 | } |
Václav Kubernát | 1e09bd6 | 2020-02-17 15:13:38 +0100 | [diff] [blame] | 450 | |
| 451 | std::optional<std::string> YangSchema::description(const std::string& path) const |
| 452 | { |
| 453 | auto node = getSchemaNode(path.c_str()); |
| 454 | return node->dsc() ? std::optional{node->dsc()} : std::nullopt; |
| 455 | } |
Václav Kubernát | 0599e9f | 2020-04-21 09:51:33 +0200 | [diff] [blame] | 456 | |
Václav Kubernát | a1c4c9e | 2020-04-22 00:37:52 +0200 | [diff] [blame] | 457 | yang::Status YangSchema::status(const std::string& location) const |
| 458 | { |
| 459 | auto node = getSchemaNode(location.c_str()); |
| 460 | if (node->flags() & LYS_STATUS_DEPRC) { |
| 461 | return yang::Status::Deprecated; |
| 462 | } else if (node->flags() & LYS_STATUS_OBSLT) { |
| 463 | return yang::Status::Obsolete; |
| 464 | } else { |
| 465 | return yang::Status::Current; |
| 466 | } |
| 467 | } |
| 468 | |
Václav Kubernát | 0599e9f | 2020-04-21 09:51:33 +0200 | [diff] [blame] | 469 | bool YangSchema::isConfig(const std::string& path) const |
| 470 | { |
| 471 | return getSchemaNode(path.c_str())->flags() & LYS_CONFIG_W; |
| 472 | } |
Václav Kubernát | b1a75c6 | 2020-04-21 15:20:16 +0200 | [diff] [blame] | 473 | |
| 474 | std::optional<std::string> YangSchema::defaultValue(const std::string& leafPath) const |
| 475 | { |
| 476 | libyang::Schema_Node_Leaf leaf(getSchemaNode(leafPath)); |
| 477 | |
| 478 | if (auto leafDefault = leaf.dflt()) { |
| 479 | return leafDefault; |
| 480 | } |
| 481 | |
| 482 | for (auto type = leaf.type()->der(); type != nullptr; type = type->type()->der()) { |
| 483 | if (auto defaultValue = type->dflt()) { |
| 484 | return defaultValue; |
| 485 | } |
| 486 | } |
| 487 | |
| 488 | return std::nullopt; |
| 489 | } |