Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +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 | |
Jan Kundrát | 68d4a2c | 2018-10-01 17:17:09 +0200 | [diff] [blame] | 9 | #include <sysrepo-cpp/Session.hpp> |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 10 | #include "sysrepo_access.hpp" |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 11 | #include "yang_schema.hpp" |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 12 | |
Jan Kundrát | 68d4a2c | 2018-10-01 17:17:09 +0200 | [diff] [blame] | 13 | leaf_data_ leafValueFromVal(const sysrepo::S_Val& value) |
Václav Kubernát | c89736b | 2018-08-30 16:14:05 +0200 | [diff] [blame] | 14 | { |
Václav Kubernát | b6ff0b6 | 2018-08-30 16:14:53 +0200 | [diff] [blame] | 15 | using namespace std::string_literals; |
Václav Kubernát | c89736b | 2018-08-30 16:14:05 +0200 | [diff] [blame] | 16 | switch (value->type()) { |
Václav Kubernát | b6ff0b6 | 2018-08-30 16:14:53 +0200 | [diff] [blame] | 17 | case SR_INT32_T: |
| 18 | return value->data()->get_int32(); |
| 19 | case SR_UINT32_T: |
| 20 | return value->data()->get_uint32(); |
| 21 | case SR_BOOL_T: |
| 22 | return value->data()->get_bool(); |
| 23 | case SR_STRING_T: |
| 24 | return std::string(value->data()->get_string()); |
| 25 | case SR_ENUM_T: |
| 26 | return std::string(value->data()->get_enum()); |
| 27 | case SR_DECIMAL64_T: |
| 28 | return value->data()->get_decimal64(); |
| 29 | case SR_CONTAINER_T: |
| 30 | return "(container)"s; |
| 31 | case SR_CONTAINER_PRESENCE_T: |
| 32 | return "(presence container)"s; |
| 33 | case SR_LIST_T: |
| 34 | return "(list)"s; |
| 35 | default: // TODO: implement all types |
| 36 | return value->val_to_string(); |
Václav Kubernát | c89736b | 2018-08-30 16:14:05 +0200 | [diff] [blame] | 37 | } |
| 38 | } |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 39 | |
Jan Kundrát | 68d4a2c | 2018-10-01 17:17:09 +0200 | [diff] [blame] | 40 | struct valFromValue : boost::static_visitor<sysrepo::S_Val> { |
| 41 | sysrepo::S_Val operator()(const enum_& value) const |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 42 | { |
Jan Kundrát | 68d4a2c | 2018-10-01 17:17:09 +0200 | [diff] [blame] | 43 | return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_ENUM_T); |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 44 | } |
| 45 | |
Václav Kubernát | ab53899 | 2019-03-06 15:30:50 +0100 | [diff] [blame] | 46 | sysrepo::S_Val operator()(const binary_& value) const |
| 47 | { |
| 48 | return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_BINARY_T); |
| 49 | } |
| 50 | |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 51 | sysrepo::S_Val operator()(const identityRef_& value) const |
| 52 | { |
| 53 | auto res = value.m_prefix.value().m_name + ":" + value.m_value; |
| 54 | return std::make_shared<sysrepo::Val>(res.c_str(), SR_IDENTITYREF_T); |
| 55 | } |
| 56 | |
Jan Kundrát | 68d4a2c | 2018-10-01 17:17:09 +0200 | [diff] [blame] | 57 | sysrepo::S_Val operator()(const std::string& value) const |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 58 | { |
Jan Kundrát | 68d4a2c | 2018-10-01 17:17:09 +0200 | [diff] [blame] | 59 | return std::make_shared<sysrepo::Val>(value.c_str()); |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 60 | } |
| 61 | |
Jan Kundrát | bd17836 | 2019-02-05 19:00:04 +0100 | [diff] [blame] | 62 | template <typename T> |
| 63 | sysrepo::S_Val operator()(const T& value) const |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 64 | { |
Jan Kundrát | 68d4a2c | 2018-10-01 17:17:09 +0200 | [diff] [blame] | 65 | return std::make_shared<sysrepo::Val>(value); |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 66 | } |
| 67 | }; |
| 68 | |
Václav Kubernát | 812ee28 | 2018-08-30 17:10:03 +0200 | [diff] [blame] | 69 | SysrepoAccess::~SysrepoAccess() = default; |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 70 | |
| 71 | SysrepoAccess::SysrepoAccess(const std::string& appname) |
Jan Kundrát | 68d4a2c | 2018-10-01 17:17:09 +0200 | [diff] [blame] | 72 | : m_connection(new sysrepo::Connection(appname.c_str())) |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 73 | , m_schema(new YangSchema()) |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 74 | { |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 75 | try { |
| 76 | m_session = std::make_shared<sysrepo::Session>(m_connection); |
| 77 | } catch (sysrepo::sysrepo_exception& ex) { |
| 78 | reportErrors(); |
| 79 | } |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 80 | m_schema->registerModuleCallback([this](const char* moduleName, const char* revision, const char* submodule) { |
| 81 | return fetchSchema(moduleName, revision, submodule); |
| 82 | }); |
| 83 | |
| 84 | for (const auto& it : listImplementedSchemas()) { |
| 85 | m_schema->loadModule(it); |
| 86 | } |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 87 | } |
| 88 | |
| 89 | std::map<std::string, leaf_data_> SysrepoAccess::getItems(const std::string& path) |
| 90 | { |
Václav Kubernát | b6ff0b6 | 2018-08-30 16:14:53 +0200 | [diff] [blame] | 91 | using namespace std::string_literals; |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 92 | std::map<std::string, leaf_data_> res; |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 93 | |
Václav Kubernát | b6ff0b6 | 2018-08-30 16:14:53 +0200 | [diff] [blame] | 94 | auto fillMap = [&res](auto items) { |
| 95 | if (!items) |
| 96 | return; |
| 97 | for (unsigned int i = 0; i < items->val_cnt(); i++) { |
| 98 | res.emplace(items->val(i)->xpath(), leafValueFromVal(items->val(i))); |
| 99 | } |
| 100 | }; |
Václav Kubernát | c89736b | 2018-08-30 16:14:05 +0200 | [diff] [blame] | 101 | |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 102 | try { |
| 103 | if (path == "/") { |
| 104 | // Sysrepo doesn't have a root node ("/"), so we take all top-level nodes from all schemas |
| 105 | auto schemas = m_session->list_schemas(); |
| 106 | for (unsigned int i = 0; i < schemas->schema_cnt(); i++) { |
| 107 | fillMap(m_session->get_items(("/"s + schemas->schema(i)->module_name() + ":*//.").c_str())); |
| 108 | } |
| 109 | } else { |
| 110 | fillMap(m_session->get_items((path + "//.").c_str())); |
Václav Kubernát | b6ff0b6 | 2018-08-30 16:14:53 +0200 | [diff] [blame] | 111 | } |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 112 | } catch (sysrepo::sysrepo_exception& ex) { |
| 113 | reportErrors(); |
Václav Kubernát | c89736b | 2018-08-30 16:14:05 +0200 | [diff] [blame] | 114 | } |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 115 | return res; |
| 116 | } |
| 117 | |
| 118 | void SysrepoAccess::setLeaf(const std::string& path, leaf_data_ value) |
| 119 | { |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 120 | try { |
| 121 | m_session->set_item(path.c_str(), boost::apply_visitor(valFromValue(), value)); |
| 122 | } catch (sysrepo::sysrepo_exception& ex) { |
| 123 | reportErrors(); |
| 124 | } |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 125 | } |
| 126 | |
| 127 | void SysrepoAccess::createPresenceContainer(const std::string& path) |
| 128 | { |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 129 | try { |
| 130 | m_session->set_item(path.c_str()); |
| 131 | } catch (sysrepo::sysrepo_exception& ex) { |
| 132 | reportErrors(); |
| 133 | } |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | void SysrepoAccess::deletePresenceContainer(const std::string& path) |
| 137 | { |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 138 | try { |
| 139 | m_session->delete_item(path.c_str()); |
| 140 | } catch (sysrepo::sysrepo_exception& ex) { |
| 141 | reportErrors(); |
| 142 | } |
Václav Kubernát | 80aacc0 | 2018-08-22 17:41:54 +0200 | [diff] [blame] | 143 | } |
Václav Kubernát | 812ee28 | 2018-08-30 17:10:03 +0200 | [diff] [blame] | 144 | |
Václav Kubernát | f5f64f0 | 2019-03-19 17:15:47 +0100 | [diff] [blame] | 145 | void SysrepoAccess::createListInstance(const std::string& path) |
| 146 | { |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 147 | try { |
| 148 | m_session->set_item(path.c_str()); |
| 149 | } catch (sysrepo::sysrepo_exception& ex) { |
| 150 | reportErrors(); |
| 151 | } |
Václav Kubernát | f5f64f0 | 2019-03-19 17:15:47 +0100 | [diff] [blame] | 152 | } |
| 153 | |
| 154 | void SysrepoAccess::deleteListInstance(const std::string& path) |
| 155 | { |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 156 | try { |
| 157 | m_session->delete_item(path.c_str()); |
| 158 | } catch (sysrepo::sysrepo_exception& ex) { |
| 159 | reportErrors(); |
| 160 | } |
Václav Kubernát | f5f64f0 | 2019-03-19 17:15:47 +0100 | [diff] [blame] | 161 | } |
| 162 | |
Václav Kubernát | 812ee28 | 2018-08-30 17:10:03 +0200 | [diff] [blame] | 163 | void SysrepoAccess::commitChanges() |
| 164 | { |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 165 | try { |
| 166 | m_session->commit(); |
| 167 | } catch (sysrepo::sysrepo_exception& ex) { |
| 168 | reportErrors(); |
| 169 | } |
Václav Kubernát | 812ee28 | 2018-08-30 17:10:03 +0200 | [diff] [blame] | 170 | } |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 171 | |
Václav Kubernát | 6d79143 | 2018-10-25 16:00:35 +0200 | [diff] [blame] | 172 | void SysrepoAccess::discardChanges() |
| 173 | { |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 174 | try { |
| 175 | m_session->discard_changes(); |
| 176 | } catch (sysrepo::sysrepo_exception& ex) { |
| 177 | reportErrors(); |
| 178 | } |
Václav Kubernát | 6d79143 | 2018-10-25 16:00:35 +0200 | [diff] [blame] | 179 | } |
| 180 | |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 181 | std::string SysrepoAccess::fetchSchema(const char* module, const char* revision, const char* submodule) |
| 182 | { |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 183 | std::string schema; |
| 184 | try { |
| 185 | schema = m_session->get_schema(module, revision, submodule, SR_SCHEMA_YANG); // FIXME: maybe we should use get_submodule_schema for submodules? |
| 186 | } catch (sysrepo::sysrepo_exception& ex) { |
| 187 | reportErrors(); |
| 188 | } |
| 189 | |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 190 | if (schema.empty()) |
| 191 | throw std::runtime_error(std::string("Module ") + module + " not available"); |
| 192 | |
| 193 | return schema; |
| 194 | } |
| 195 | |
| 196 | std::vector<std::string> SysrepoAccess::listImplementedSchemas() |
| 197 | { |
| 198 | std::vector<std::string> res; |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 199 | std::shared_ptr<sysrepo::Yang_Schemas> schemas; |
| 200 | try { |
| 201 | schemas = m_session->list_schemas(); |
| 202 | } catch (sysrepo::sysrepo_exception& ex) { |
| 203 | reportErrors(); |
| 204 | } |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 205 | for (unsigned int i = 0; i < schemas->schema_cnt(); i++) { |
| 206 | auto schema = schemas->schema(i); |
| 207 | if (schema->implemented()) |
| 208 | res.push_back(schema->module_name()); |
| 209 | } |
| 210 | return res; |
| 211 | } |
| 212 | |
| 213 | std::shared_ptr<Schema> SysrepoAccess::schema() |
| 214 | { |
| 215 | return m_schema; |
| 216 | } |
Václav Kubernát | c58e4aa | 2019-04-03 18:37:32 +0200 | [diff] [blame] | 217 | |
| 218 | [[noreturn]] void SysrepoAccess::reportErrors() |
| 219 | { |
| 220 | // I only use get_last_errors to get error info, since the error code from |
| 221 | // sysrepo_exception doesn't really give any meaningful information. For |
| 222 | // example an "invalid argument" error could mean a node isn't enabled, or |
| 223 | // it could mean something totally different and there is no documentation |
| 224 | // for that, so it's better to just use the message sysrepo gives me. |
| 225 | auto srErrors = m_session->get_last_errors(); |
| 226 | std::vector<DatastoreError> res; |
| 227 | |
| 228 | for (size_t i = 0; i < srErrors->error_cnt(); i++) { |
| 229 | auto error = srErrors->error(i); |
| 230 | res.emplace_back(error->message(), error->xpath() ? std::optional<std::string>{error->xpath()} : std::nullopt); |
| 231 | } |
| 232 | |
| 233 | throw DatastoreException(res); |
| 234 | } |