blob: f6e8d1deb5441b3b0c4b7936c22807a0b31997eb [file] [log] [blame]
/*
* 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 <experimental/iterator>
#include <libyang/Tree_Data.hpp>
#include <libyang/Tree_Schema.hpp>
#include <sysrepo-cpp/Session.hpp>
#include <sstream>
#include "libyang_utils.hpp"
#include "sysrepo_access.hpp"
#include "utils.hpp"
#include "yang_schema.hpp"
const auto OPERATION_TIMEOUT_MS = 1000;
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_IDENTITYREF_T:
{
auto pair = splitModuleNode(value->data()->get_identityref());
return identityRef_{*pair.first, pair.second};
}
case SR_BINARY_T:
return binary_{value->data()->get_binary()};
case SR_LEAF_EMPTY_T:
return empty_{};
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};
case SR_BITS_T:
{
bits_ res;
std::istringstream ss(value->data()->get_bits());
while (!ss.eof()) {
std::string bit;
ss >> bit;
res.m_bits.push_back(bit);
}
return res;
}
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 empty_) const
{
return std::make_shared<sysrepo::Val>(nullptr, SR_LEAF_EMPTY_T);
}
sysrepo::S_Val operator()(const identityRef_& value) const
{
auto res = value.m_prefix ? (value.m_prefix.value().m_name + ":" + value.m_value) : 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());
}
sysrepo::S_Val operator()(const bits_& value) const
{
std::stringstream ss;
std::copy(value.m_bits.begin(), value.m_bits.end(), std::experimental::make_ostream_joiner(ss, " "));
return std::make_shared<sysrepo::Val>(ss.str().c_str(), SR_BITS_T);
}
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 empty_) const
{
v->set(xpath.c_str(), nullptr, SR_LEAF_EMPTY_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
{
switch (value.m_value) {
case SpecialValue::PresenceContainer:
v->set(xpath.c_str(), nullptr, SR_CONTAINER_PRESENCE_T);
break;
case SpecialValue::List:
v->set(xpath.c_str(), nullptr, SR_LIST_T);
break;
default:
throw std::runtime_error("Tried constructing S_Val from a " + specialValueToString(value));
}
}
auto operator()(const bits_& value) const
{
std::stringstream ss;
std::copy(value.m_bits.begin(), value.m_bits.end(), std::experimental::make_ostream_joiner(ss, " "));
v->set(xpath.c_str(), ss.str().c_str(), SR_BITS_T);
}
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;
sr_datastore_t toSrDatastore(Datastore datastore)
{
switch (datastore) {
case Datastore::Running:
return SR_DS_RUNNING;
case Datastore::Startup:
return SR_DS_STARTUP;
}
__builtin_unreachable();
}
SysrepoAccess::SysrepoAccess(const Datastore datastore)
: m_connection(std::make_shared<sysrepo::Connection>())
, m_session(std::make_shared<sysrepo::Session>(m_connection))
, m_schema(std::make_shared<YangSchema>(m_session->get_context()))
{
try {
m_session = std::make_shared<sysrepo::Session>(m_connection, toSrDatastore(datastore));
} catch (sysrepo::sysrepo_exception& ex) {
reportErrors();
}
}
DatastoreAccess::Tree SysrepoAccess::getItems(const std::string& path) const
{
using namespace std::string_literals;
Tree res;
try {
auto oldDs = m_session->session_get_ds();
m_session->session_switch_ds(SR_DS_OPERATIONAL);
auto config = m_session->get_data(((path == "/") ? "/*" : path).c_str());
m_session->session_switch_ds(oldDs);
if (config) {
lyNodesToTree(res, config->tree_for());
}
} 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::createItem(const std::string& path)
{
try {
m_session->set_item(path.c_str());
} catch (sysrepo::sysrepo_exception& ex) {
reportErrors();
}
}
void SysrepoAccess::deleteItem(const std::string& path)
{
try {
// Have to use SR_EDIT_ISOLATE, because deleting something that's been set without committing is not supported
// https://github.com/sysrepo/sysrepo/issues/1967#issuecomment-625085090
m_session->delete_item(path.c_str(), SR_EDIT_ISOLATE);
} catch (sysrepo::sysrepo_exception& ex) {
reportErrors();
}
}
struct impl_toSrMoveOp {
sr_move_position_t operator()(yang::move::Absolute& absolute)
{
return absolute == yang::move::Absolute::Begin ? SR_MOVE_FIRST : SR_MOVE_LAST;
}
sr_move_position_t operator()(yang::move::Relative& relative)
{
return relative.m_position == yang::move::Relative::Position::After ? SR_MOVE_AFTER : SR_MOVE_BEFORE;
}
};
sr_move_position_t toSrMoveOp(std::variant<yang::move::Absolute, yang::move::Relative> move)
{
return std::visit(impl_toSrMoveOp{}, move);
}
void SysrepoAccess::moveItem(const std::string& source, std::variant<yang::move::Absolute, yang::move::Relative> move)
{
std::string destination;
if (std::holds_alternative<yang::move::Relative>(move)) {
auto relative = std::get<yang::move::Relative>(move);
if (m_schema->nodeType(source) == yang::NodeTypes::LeafList) {
destination = leafDataToString(relative.m_path.at("."));
} else {
destination = instanceToString(relative.m_path);
}
}
m_session->move_item(source.c_str(), toSrMoveOp(move), destination.c_str(), destination.c_str());
}
void SysrepoAccess::commitChanges()
{
try {
m_session->apply_changes(OPERATION_TIMEOUT_MS, 1);
} catch (sysrepo::sysrepo_exception& ex) {
reportErrors();
}
}
void SysrepoAccess::discardChanges()
{
try {
m_session->discard_changes();
} catch (sysrepo::sysrepo_exception& ex) {
reportErrors();
}
}
namespace {
std::shared_ptr<sysrepo::Vals> toSrVals(const std::string& path, const DatastoreAccess::Tree& input)
{
auto res = std::make_shared<sysrepo::Vals>(input.size());
{
size_t i = 0;
for (const auto& [k, v] : input) {
boost::apply_visitor(updateSrValFromValue(joinPaths(path, k), res->val(i)), v);
++i;
}
}
return res;
}
DatastoreAccess::Tree toTree(const std::string& path, const std::shared_ptr<sysrepo::Vals>& output)
{
DatastoreAccess::Tree res;
for (size_t i = 0; i < output->val_cnt(); ++i) {
const auto& v = output->val(i);
res.emplace_back(std::string(v->xpath()).substr(joinPaths(path, "/").size()), leafValueFromVal(v));
}
return res;
}
}
// TODO: merge this with executeAction
DatastoreAccess::Tree SysrepoAccess::executeRpc(const std::string &path, const Tree &input)
{
auto srInput = toSrVals(path, input);
auto output = m_session->rpc_send(path.c_str(), srInput);
return toTree(path, output);
}
DatastoreAccess::Tree SysrepoAccess::executeAction(const std::string& path, const Tree& input)
{
auto srInput = toSrVals(path, input);
auto output = m_session->rpc_send(path.c_str(), srInput);
return toTree(path, output);
}
void SysrepoAccess::copyConfig(const Datastore source, const Datastore destination)
{
auto oldDs = m_session->session_get_ds();
m_session->session_switch_ds(toSrDatastore(destination));
m_session->copy_config(toSrDatastore(source), nullptr, OPERATION_TIMEOUT_MS, 1);
m_session->session_switch_ds(oldDs);
}
std::shared_ptr<Schema> SysrepoAccess::schema()
{
return m_schema;
}
[[noreturn]] void SysrepoAccess::reportErrors() const
{
// I only use get_error 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_error();
std::vector<DatastoreError> res;
for (size_t i = 0; i < srErrors->error_cnt(); i++) {
res.emplace_back(srErrors->message(i), srErrors->xpath(i) ? std::optional<std::string>{srErrors->xpath(i)} : std::nullopt);
}
throw DatastoreException(res);
}
std::vector<ListInstance> SysrepoAccess::listInstances(const std::string& path)
{
std::vector<ListInstance> res;
auto lists = getItems(path);
decltype(lists) instances;
auto wantedTree = *(m_schema->dataNodeFromPath(path)->find_path(path.c_str())->data().begin());
std::copy_if(lists.begin(), lists.end(), std::inserter(instances, instances.end()), [this, pathToCheck=wantedTree->schema()->path()](const auto& item) {
// This filters out non-instances.
if (item.second.type() != typeid(special_) || boost::get<special_>(item.second).m_value != SpecialValue::List) {
return false;
}
// Now, getItems is recursive: it gives everything including nested lists. So I try create a tree from the instance...
auto instanceTree = *(m_schema->dataNodeFromPath(item.first)->find_path(item.first.c_str())->data().begin());
// And then check if its schema path matches the list we actually want. This filters out lists which are not the ones I requested.
return instanceTree->schema()->path() == pathToCheck;
});
// If there are no instances, then just return
if (instances.empty()) {
return res;
}
// I need to find out which keys does the list have. To do that, I create a
// tree from the first instance. This is gives me some top level node,
// which will be our list in case out list is a top-level node. In case it
// isn't, we have call find_path on the top level node. After that, I just
// retrieve the keys.
auto topLevelTree = m_schema->dataNodeFromPath(instances.begin()->first);
auto list = *(topLevelTree->find_path(path.c_str())->data().begin());
auto keys = libyang::Schema_Node_List{list->schema()}.keys();
// Creating a full tree at the same time from the values sysrepo gives me
// would be a pain (and after sysrepo switches to libyang meaningless), so
// I just use this algorithm to create data nodes one by one and get the
// key values from them.
for (const auto& instance : instances) {
auto wantedList = *(m_schema->dataNodeFromPath(instance.first)->find_path(path.c_str())->data().begin());
ListInstance instanceRes;
for (const auto& key : keys) {
auto vec = wantedList->find_path(key->name())->data();
auto leaf = std::make_shared<libyang::Data_Node_Leaf_List>(*(vec.begin()));
instanceRes.emplace(key->name(), leafValueFromNode(leaf));
}
res.emplace_back(instanceRes);
}
return res;
}
std::string SysrepoAccess::dump(const DataFormat format) const
{
auto root = m_session->get_data("/*");
return root->print_mem(format == DataFormat::Xml ? LYD_XML : LYD_JSON, LYP_WITHSIBLINGS | LYP_FORMAT);
}