src/sysrepo_access.cpp - CzechLight/netconf-cli - Gitiles

 /*
  * Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
  * Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
  *
  * Written by Václav Kubernát <kubervac@fit.cvut.cz>
  *
 */

 #include <sysrepo-cpp/Session.hpp>
 #include "sysrepo_access.hpp"
 #include "utils.hpp"
 #include "yang_schema.hpp"

 leaf_data_ leafValueFromVal(const sysrepo::S_Val& value)
 {
     using namespace std::string_literals;
     switch (value->type()) {
     case SR_INT8_T:
         return value->data()->get_int8();
     case SR_UINT8_T:
         return value->data()->get_uint8();
     case SR_INT16_T:
         return value->data()->get_int16();
     case SR_UINT16_T:
         return value->data()->get_uint16();
     case SR_INT32_T:
         return value->data()->get_int32();
     case SR_UINT32_T:
         return value->data()->get_uint32();
     case SR_INT64_T:
         return value->data()->get_int64();
     case SR_UINT64_T:
         return value->data()->get_uint64();
     case SR_BOOL_T:
         return value->data()->get_bool();
     case SR_STRING_T:
         return std::string(value->data()->get_string());
     case SR_ENUM_T:
         return enum_{std::string(value->data()->get_enum())};
     case SR_DECIMAL64_T:
         return value->data()->get_decimal64();
     case SR_CONTAINER_T:
         return special_{SpecialValue::Container};
     case SR_CONTAINER_PRESENCE_T:
         return special_{SpecialValue::PresenceContainer};
     case SR_LIST_T:
         return special_{SpecialValue::List};
     default: // TODO: implement all types
         return value->val_to_string();
     }
 }

 struct valFromValue : boost::static_visitor<sysrepo::S_Val> {
     sysrepo::S_Val operator()(const enum_& value) const
     {
         return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_ENUM_T);
     }

     sysrepo::S_Val operator()(const binary_& value) const
     {
         return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_BINARY_T);
     }

     sysrepo::S_Val operator()(const identityRef_& value) const
     {
         auto res = value.m_prefix.value().m_name + ":" + value.m_value;
         return std::make_shared<sysrepo::Val>(res.c_str(), SR_IDENTITYREF_T);
     }

     sysrepo::S_Val operator()(const special_& value) const
     {
         throw std::runtime_error("Tried constructing S_Val from a " + specialValueToString(value));
     }

     sysrepo::S_Val operator()(const std::string& value) const
     {
         return std::make_shared<sysrepo::Val>(value.c_str());
     }

     template <typename T>
     sysrepo::S_Val operator()(const T& value) const
     {
         return std::make_shared<sysrepo::Val>(value);
     }
 };

 struct updateSrValFromValue : boost::static_visitor<void> {
     std::string xpath;
     sysrepo::S_Val v;
     updateSrValFromValue(const std::string& xpath, sysrepo::S_Val v)
         : xpath(xpath)
         , v(v)
     {
     }

     void operator()(const enum_& value) const
     {
         v->set(xpath.c_str(), value.m_value.c_str(), SR_ENUM_T);
     }

     void operator()(const binary_& value) const
     {
         v->set(xpath.c_str(), value.m_value.c_str(), SR_BINARY_T);
     }

     void operator()(const identityRef_& value) const
     {
         v->set(xpath.c_str(), (value.m_prefix.value().m_name + ":" + value.m_value).c_str(), SR_IDENTITYREF_T);
     }

     void operator()(const special_& value) const
     {
         throw std::runtime_error("Tried constructing S_Val from a " + specialValueToString(value));
     }

     void operator()(const std::string& value) const
     {
         v->set(xpath.c_str(), value.c_str(), SR_STRING_T);
     }

     template <typename T>
     void operator()(const T value) const
     {
         v->set(xpath.c_str(), value);
     }
 };

 SysrepoAccess::~SysrepoAccess() = default;

 SysrepoAccess::SysrepoAccess(const std::string& appname)
     : m_connection(new sysrepo::Connection(appname.c_str()))
     , m_schema(new YangSchema())
 {
     try {
         m_session = std::make_shared<sysrepo::Session>(m_connection);
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }

     // If fetching a submodule, sysrepo::Session::get_schema will determine the revision from the main module.
     // That's why submoduleRevision is ignored.
     m_schema->registerModuleCallback([this](const char* moduleName, const char* revision, const char* submodule, [[maybe_unused]] const char* submoduleRevision) {
         return fetchSchema(moduleName, revision, submodule);
     });

     for (const auto& it : listSchemas()) {
         if (it->implemented()) {
             m_schema->loadModule(it->module_name());
             for (unsigned int i = 0; i < it->enabled_feature_cnt(); i++) {
                 m_schema->enableFeature(it->module_name(), it->enabled_features(i));
             }
         }
     }
 }

 DatastoreAccess::Tree SysrepoAccess::getItems(const std::string& path)
 {
     using namespace std::string_literals;
     Tree res;

     auto fillMap = [&res](auto items) {
         if (!items)
             return;
         for (unsigned int i = 0; i < items->val_cnt(); i++) {
             res.emplace(items->val(i)->xpath(), leafValueFromVal(items->val(i)));
         }
     };

     try {
         if (path == "/") {
             // Sysrepo doesn't have a root node ("/"), so we take all top-level nodes from all schemas
             auto schemas = m_session->list_schemas();
             for (unsigned int i = 0; i < schemas->schema_cnt(); i++) {
                 fillMap(m_session->get_items(("/"s + schemas->schema(i)->module_name() + ":*//.").c_str()));
             }
         } else {
             fillMap(m_session->get_items((path + "//.").c_str()));
         }
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }
     return res;
 }

 void SysrepoAccess::setLeaf(const std::string& path, leaf_data_ value)
 {
     try {
         m_session->set_item(path.c_str(), boost::apply_visitor(valFromValue(), value));
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }
 }

 void SysrepoAccess::createPresenceContainer(const std::string& path)
 {
     try {
         m_session->set_item(path.c_str());
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }
 }

 void SysrepoAccess::deletePresenceContainer(const std::string& path)
 {
     try {
         m_session->delete_item(path.c_str());
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }
 }

 void SysrepoAccess::createListInstance(const std::string& path)
 {
     try {
         m_session->set_item(path.c_str());
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }
 }

 void SysrepoAccess::deleteListInstance(const std::string& path)
 {
     try {
         m_session->delete_item(path.c_str());
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }
 }

 void SysrepoAccess::commitChanges()
 {
     try {
         m_session->commit();
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }
 }

 void SysrepoAccess::discardChanges()
 {
     try {
         m_session->discard_changes();
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }
 }

 DatastoreAccess::Tree SysrepoAccess::executeRpc(const std::string &path, const Tree &input)
 {
     auto srInput = std::make_shared<sysrepo::Vals>(input.size());
     {
         size_t i = 0;
         for (const auto& [k, v] : input) {
             boost::apply_visitor(updateSrValFromValue(joinPaths(path, k), srInput->val(i)), v);
             ++i;
         }
     }
     auto output = m_session->rpc_send(path.c_str(), srInput);
     Tree res;
     for (size_t i = 0; i < output->val_cnt(); ++i) {
         const auto& v = output->val(i);
         res.emplace(std::string(v->xpath()).substr(joinPaths(path, "/").size()), leafValueFromVal(v));
     }
     return res;
 }

 std::string SysrepoAccess::fetchSchema(const char* module, const char* revision, const char* submodule)
 {
     std::string schema;
     try {
         schema = m_session->get_schema(module, revision, submodule, SR_SCHEMA_YANG);
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }

     if (schema.empty())
         throw std::runtime_error(std::string("Module ") + module + " not available");

     return schema;
 }

 std::vector<std::shared_ptr<sysrepo::Yang_Schema>> SysrepoAccess::listSchemas()
 {
     std::vector<sysrepo::S_Yang_Schema> res;
     std::shared_ptr<sysrepo::Yang_Schemas> schemas;
     try {
         schemas = m_session->list_schemas();
     } catch (sysrepo::sysrepo_exception& ex) {
         reportErrors();
     }
     for (unsigned int i = 0; i < schemas->schema_cnt(); i++) {
         auto schema = schemas->schema(i);
         res.push_back(schema);
     }
     return res;
 }

 std::shared_ptr<Schema> SysrepoAccess::schema()
 {
     return m_schema;
 }

 [[noreturn]] void SysrepoAccess::reportErrors()
 {
     // I only use get_last_errors to get error info, since the error code from
     // sysrepo_exception doesn't really give any meaningful information. For
     // example an "invalid argument" error could mean a node isn't enabled, or
     // it could mean something totally different and there is no documentation
     // for that, so it's better to just use the message sysrepo gives me.
     auto srErrors = m_session->get_last_errors();
     std::vector<DatastoreError> res;

     for (size_t i = 0; i < srErrors->error_cnt(); i++) {
         auto error = srErrors->error(i);
         res.emplace_back(error->message(), error->xpath() ? std::optional<std::string>{error->xpath()} : std::nullopt);
     }

     throw DatastoreException(res);
 }
	/*
	* Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
	* Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
	*
	* Written by Václav Kubernát <kubervac@fit.cvut.cz>
	*
	*/

	#include <sysrepo-cpp/Session.hpp>
	#include "sysrepo_access.hpp"
	#include "utils.hpp"
	#include "yang_schema.hpp"

	leaf_data_ leafValueFromVal(const sysrepo::S_Val& value)
	{
	using namespace std::string_literals;
	switch (value->type()) {
	case SR_INT8_T:
	return value->data()->get_int8();
	case SR_UINT8_T:
	return value->data()->get_uint8();
	case SR_INT16_T:
	return value->data()->get_int16();
	case SR_UINT16_T:
	return value->data()->get_uint16();
	case SR_INT32_T:
	return value->data()->get_int32();
	case SR_UINT32_T:
	return value->data()->get_uint32();
	case SR_INT64_T:
	return value->data()->get_int64();
	case SR_UINT64_T:
	return value->data()->get_uint64();
	case SR_BOOL_T:
	return value->data()->get_bool();
	case SR_STRING_T:
	return std::string(value->data()->get_string());
	case SR_ENUM_T:
	return enum_{std::string(value->data()->get_enum())};
	case SR_DECIMAL64_T:
	return value->data()->get_decimal64();
	case SR_CONTAINER_T:
	return special_{SpecialValue::Container};
	case SR_CONTAINER_PRESENCE_T:
	return special_{SpecialValue::PresenceContainer};
	case SR_LIST_T:
	return special_{SpecialValue::List};
	default: // TODO: implement all types
	return value->val_to_string();
	}
	}

	struct valFromValue : boost::static_visitor<sysrepo::S_Val> {
	sysrepo::S_Val operator()(const enum_& value) const
	{
	return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_ENUM_T);
	}

	sysrepo::S_Val operator()(const binary_& value) const
	{
	return std::make_shared<sysrepo::Val>(value.m_value.c_str(), SR_BINARY_T);
	}

	sysrepo::S_Val operator()(const identityRef_& value) const
	{
	auto res = value.m_prefix.value().m_name + ":" + value.m_value;
	return std::make_shared<sysrepo::Val>(res.c_str(), SR_IDENTITYREF_T);
	}

	sysrepo::S_Val operator()(const special_& value) const
	{
	throw std::runtime_error("Tried constructing S_Val from a " + specialValueToString(value));
	}

	sysrepo::S_Val operator()(const std::string& value) const
	{
	return std::make_shared<sysrepo::Val>(value.c_str());
	}

	template <typename T>
	sysrepo::S_Val operator()(const T& value) const
	{
	return std::make_shared<sysrepo::Val>(value);
	}
	};

	struct updateSrValFromValue : boost::static_visitor<void> {
	std::string xpath;
	sysrepo::S_Val v;
	updateSrValFromValue(const std::string& xpath, sysrepo::S_Val v)
	: xpath(xpath)
	, v(v)
	{
	}

	void operator()(const enum_& value) const
	{
	v->set(xpath.c_str(), value.m_value.c_str(), SR_ENUM_T);
	}

	void operator()(const binary_& value) const
	{
	v->set(xpath.c_str(), value.m_value.c_str(), SR_BINARY_T);
	}

	void operator()(const identityRef_& value) const
	{
	v->set(xpath.c_str(), (value.m_prefix.value().m_name + ":" + value.m_value).c_str(), SR_IDENTITYREF_T);
	}

	void operator()(const special_& value) const
	{
	throw std::runtime_error("Tried constructing S_Val from a " + specialValueToString(value));
	}

	void operator()(const std::string& value) const
	{
	v->set(xpath.c_str(), value.c_str(), SR_STRING_T);
	}

	template <typename T>
	void operator()(const T value) const
	{
	v->set(xpath.c_str(), value);
	}
	};

	SysrepoAccess::~SysrepoAccess() = default;

	SysrepoAccess::SysrepoAccess(const std::string& appname)
	: m_connection(new sysrepo::Connection(appname.c_str()))
	, m_schema(new YangSchema())
	{
	try {
	m_session = std::make_shared<sysrepo::Session>(m_connection);
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}

	// If fetching a submodule, sysrepo::Session::get_schema will determine the revision from the main module.
	// That's why submoduleRevision is ignored.
	m_schema->registerModuleCallback([this](const char* moduleName, const char* revision, const char* submodule, [[maybe_unused]] const char* submoduleRevision) {
	return fetchSchema(moduleName, revision, submodule);
	});

	for (const auto& it : listSchemas()) {
	if (it->implemented()) {
	m_schema->loadModule(it->module_name());
	for (unsigned int i = 0; i < it->enabled_feature_cnt(); i++) {
	m_schema->enableFeature(it->module_name(), it->enabled_features(i));
	}
	}
	}
	}

	DatastoreAccess::Tree SysrepoAccess::getItems(const std::string& path)
	{
	using namespace std::string_literals;
	Tree res;

	auto fillMap = [&res](auto items) {
	if (!items)
	return;
	for (unsigned int i = 0; i < items->val_cnt(); i++) {
	res.emplace(items->val(i)->xpath(), leafValueFromVal(items->val(i)));
	}
	};

	try {
	if (path == "/") {
	// Sysrepo doesn't have a root node ("/"), so we take all top-level nodes from all schemas
	auto schemas = m_session->list_schemas();
	for (unsigned int i = 0; i < schemas->schema_cnt(); i++) {
	fillMap(m_session->get_items(("/"s + schemas->schema(i)->module_name() + ":*//.").c_str()));
	}
	} else {
	fillMap(m_session->get_items((path + "//.").c_str()));
	}
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}
	return res;
	}

	void SysrepoAccess::setLeaf(const std::string& path, leaf_data_ value)
	{
	try {
	m_session->set_item(path.c_str(), boost::apply_visitor(valFromValue(), value));
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}
	}

	void SysrepoAccess::createPresenceContainer(const std::string& path)
	{
	try {
	m_session->set_item(path.c_str());
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}
	}

	void SysrepoAccess::deletePresenceContainer(const std::string& path)
	{
	try {
	m_session->delete_item(path.c_str());
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}
	}

	void SysrepoAccess::createListInstance(const std::string& path)
	{
	try {
	m_session->set_item(path.c_str());
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}
	}

	void SysrepoAccess::deleteListInstance(const std::string& path)
	{
	try {
	m_session->delete_item(path.c_str());
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}
	}

	void SysrepoAccess::commitChanges()
	{
	try {
	m_session->commit();
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}
	}

	void SysrepoAccess::discardChanges()
	{
	try {
	m_session->discard_changes();
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}
	}

	DatastoreAccess::Tree SysrepoAccess::executeRpc(const std::string &path, const Tree &input)
	{
	auto srInput = std::make_shared<sysrepo::Vals>(input.size());
	{
	size_t i = 0;
	for (const auto& [k, v] : input) {
	boost::apply_visitor(updateSrValFromValue(joinPaths(path, k), srInput->val(i)), v);
	++i;
	}
	}
	auto output = m_session->rpc_send(path.c_str(), srInput);
	Tree res;
	for (size_t i = 0; i < output->val_cnt(); ++i) {
	const auto& v = output->val(i);
	res.emplace(std::string(v->xpath()).substr(joinPaths(path, "/").size()), leafValueFromVal(v));
	}
	return res;
	}

	std::string SysrepoAccess::fetchSchema(const char* module, const char* revision, const char* submodule)
	{
	std::string schema;
	try {
	schema = m_session->get_schema(module, revision, submodule, SR_SCHEMA_YANG);
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}

	if (schema.empty())
	throw std::runtime_error(std::string("Module ") + module + " not available");

	return schema;
	}

	std::vector<std::shared_ptr<sysrepo::Yang_Schema>> SysrepoAccess::listSchemas()
	{
	std::vector<sysrepo::S_Yang_Schema> res;
	std::shared_ptr<sysrepo::Yang_Schemas> schemas;
	try {
	schemas = m_session->list_schemas();
	} catch (sysrepo::sysrepo_exception& ex) {
	reportErrors();
	}
	for (unsigned int i = 0; i < schemas->schema_cnt(); i++) {
	auto schema = schemas->schema(i);
	res.push_back(schema);
	}
	return res;
	}

	std::shared_ptr<Schema> SysrepoAccess::schema()
	{
	return m_schema;
	}

	[[noreturn]] void SysrepoAccess::reportErrors()
	{
	// I only use get_last_errors to get error info, since the error code from
	// sysrepo_exception doesn't really give any meaningful information. For
	// example an "invalid argument" error could mean a node isn't enabled, or
	// it could mean something totally different and there is no documentation
	// for that, so it's better to just use the message sysrepo gives me.
	auto srErrors = m_session->get_last_errors();
	std::vector<DatastoreError> res;

	for (size_t i = 0; i < srErrors->error_cnt(); i++) {
	auto error = srErrors->error(i);
	res.emplace_back(error->message(), error->xpath() ? std::optional<std::string>{error->xpath()} : std::nullopt);
	}

	throw DatastoreException(res);
	}