17using namespace libyang;
 
   18using namespace sysrepo;
 
   51        if (
model_ == IETF_DHCPV6_SERVER) {
 
   53        } 
else if (
model_ == KEA_DHCP4_SERVER) {
 
   55        } 
else if (
model_ == KEA_DHCP6_SERVER) {
 
   58    } 
catch (Error 
const& ex) {
 
   62              "getConfig not implemented for the model: " << 
model_);
 
 
   69    result->set(
"Dhcp6", dhcp6);
 
   70    string const xpath(
"/ietf-dhcpv6-server:server");
 
   79                         [&](DataNode 
const& data_node) -> 
ElementPtr const {
 
 
   91    result->set(
"Dhcp4", 
dhcp);
 
 
   99    result->set(
"Dhcp6", 
dhcp);
 
 
  126    return (result->empty() ? 
ElementPtr() : result);
 
 
  144    return (result->empty() ? 
ElementPtr() : result);
 
 
  152    if (databases && !databases->empty()) {
 
  153        result->set(
"config-databases", databases);
 
  155    return (result->empty() ? 
ElementPtr() : result);
 
 
  161    optional<DataNode> 
const& interfaces_config_optional(
config.findPath(
"interfaces-config"));
 
  162    if (interfaces_config_optional) {
 
  163        DataNode 
const interfaces_config(*interfaces_config_optional);
 
  170        checkAndGetLeaf(result, interfaces_config, 
"service-sockets-max-retries");
 
  171        checkAndGetLeaf(result, interfaces_config, 
"service-sockets-require-all");
 
  172        checkAndGetLeaf(result, interfaces_config, 
"service-sockets-retry-wait-time");
 
  176    return (result->empty() ? 
ElementPtr() : result);
 
 
  202    checkAndGetLeaf(result, data_node, 
"early-global-reservations-lookup");
 
  228    if (classes && !classes->empty()) {
 
  229        result->set(
"client-classes", classes);
 
  233                [&](DataNode 
const& node) -> 
ElementPtr const {
 
  237                    return compatibility;
 
  241                [&](DataNode 
const& node) -> 
ElementPtr const {
 
  246    if (control_sockets && !control_sockets->empty()) {
 
  247        result->set(
"control-sockets", control_sockets);
 
  250                    [&](DataNode 
const& node) -> 
ElementPtr const {
 
  256                [&](DataNode 
const& node) -> 
ElementPtr const {
 
  260    checkAndGet(result, data_node, 
"expired-leases-processing",
 
  261                [&](DataNode 
const& node) -> 
ElementPtr const {
 
  267        result->set(
"hooks-libraries", 
hooks);
 
  271    if (hosts_databases && !hosts_databases->empty()) {
 
  272        result->set(
"hosts-databases", hosts_databases);
 
  276                [&](DataNode 
const& node) -> 
ElementPtr const {
 
  281    if (loggers && !loggers->empty()) {
 
  282        result->set(
"loggers", loggers);
 
  286                [&](DataNode 
const& node) -> 
ElementPtr const {
 
  291                    return multi_threading;
 
  296        result->set(
"option-data", options);
 
  301        result->set(
"option-def", defs);
 
  306        result->set(
"reservations", hosts);
 
  311        result->set(
"shared-networks", networks);
 
  315                [&](DataNode 
const& node) -> 
ElementPtr const {
 
  319                    return sanity_checks;
 
 
  327    string xpath = 
"/kea-dhcp4-server:config";
 
  328    optional<DataNode> config_optional;
 
  334    DataNode 
const config(*config_optional);
 
  348                [&](DataNode 
const& node) -> 
ElementPtr const {
 
  352                    if (const_compatibility) {
 
  353                        compatibility = 
copy(const_compatibility);
 
  360                    return compatibility;
 
  365    if (interfaces_config) {
 
  366        result->set(
"interfaces-config", interfaces_config);
 
  372        result->set(
"subnet4", subnets);
 
 
  380    string xpath = 
"/kea-dhcp6-server:config";
 
  381    optional<DataNode> config_optional;
 
  387    DataNode 
const config(*config_optional);
 
  401    if (interfaces_config) {
 
  402        result->set(
"interfaces-config", interfaces_config);
 
  406    optional<DataNode> 
const& server_id_optional(
config.findPath(
"server-id"));
 
  407    if (server_id_optional) {
 
  408        DataNode 
const server_id(*server_id_optional);
 
  417        if (!server_id_map->empty()) {
 
  418            result->set(
"server-id", server_id_map);
 
  425        result->set(
"subnet6", subnets);
 
 
  434        if (
model_ == IETF_DHCPV6_SERVER) {
 
  441        } 
else if (
model_ == KEA_DHCP4_SERVER) {
 
  448        } 
else if (
model_ == KEA_DHCP6_SERVER) {
 
  457                      "setConfig not implemented for the model: " << 
model_);
 
  459    } 
catch (Error 
const& ex) {
 
  461                  "setting config '" << elem->str()
 
  462                  << 
"': " << ex.
what());
 
 
  473    string xpath = 
"/" + 
model_ + 
":server/server-config";
 
  480    if (ranges && !ranges->empty()) {
 
  481        setSubnets(xpath + 
"/network-ranges", ranges);
 
 
  514    checkAndSetLeaf(elem, xpath, 
"calculate-tee-times", LeafBaseType::Bool);
 
  515    checkAndSetLeaf(elem, xpath, 
"ddns-generated-prefix", LeafBaseType::String);
 
  516    checkAndSetLeaf(elem, xpath, 
"ddns-override-client-update", LeafBaseType::Bool);
 
  517    checkAndSetLeaf(elem, xpath, 
"ddns-override-no-update", LeafBaseType::Bool);
 
  518    checkAndSetLeaf(elem, xpath, 
"ddns-qualifying-suffix", LeafBaseType::String);
 
  519    checkAndSetLeaf(elem, xpath, 
"ddns-replace-client-name", LeafBaseType::String);
 
  525    checkAndSetLeaf(elem, xpath, 
"ddns-update-on-renew", LeafBaseType::Bool);
 
  526    checkAndSetLeaf(elem, xpath, 
"ddns-use-conflict-resolution", LeafBaseType::Bool);
 
  527    checkAndSetLeaf(elem, xpath, 
"ddns-conflict-resolution-mode", LeafBaseType::Enum);
 
  529    checkAndSetLeaf(elem, xpath, 
"decline-probation-period", LeafBaseType::Uint32);
 
  530    checkAndSetLeaf(elem, xpath, 
"early-global-reservations-lookup", LeafBaseType::Bool);
 
  531    checkAndSetLeaf(elem, xpath, 
"hostname-char-replacement", LeafBaseType::String);
 
  532    checkAndSetLeaf(elem, xpath, 
"hostname-char-set", LeafBaseType::String);
 
  533    checkAndSetLeaf(elem, xpath, 
"ip-reservations-unique", LeafBaseType::Bool);
 
  534    checkAndSetLeaf(elem, xpath, 
"max-valid-lifetime", LeafBaseType::Uint32);
 
  535    checkAndSetLeaf(elem, xpath, 
"min-valid-lifetime", LeafBaseType::Uint32);
 
  536    checkAndSetLeaf(elem, xpath, 
"parked-packet-limit", LeafBaseType::Uint32);
 
  539    checkAndSetLeaf(elem, xpath, 
"reservations-global", LeafBaseType::Bool);
 
  540    checkAndSetLeaf(elem, xpath, 
"reservations-in-subnet", LeafBaseType::Bool);
 
  541    checkAndSetLeaf(elem, xpath, 
"reservations-lookup-first", LeafBaseType::Bool);
 
  542    checkAndSetLeaf(elem, xpath, 
"reservations-out-of-pool", LeafBaseType::Bool);
 
  544    checkAndSetLeaf(elem, xpath, 
"statistic-default-sample-age", LeafBaseType::Uint32);
 
  545    checkAndSetLeaf(elem, xpath, 
"statistic-default-sample-count", LeafBaseType::Uint32);
 
  546    checkAndSetLeaf(elem, xpath, 
"store-extended-info", LeafBaseType::Bool);
 
  558    if (classes && !classes->empty()) {
 
  564        checkAndSetLeaf(compatibility, xpath + 
"/compatibility", 
"ignore-rai-link-selection", LeafBaseType::Bool);
 
  565        checkAndSetLeaf(compatibility, xpath + 
"/compatibility", 
"lenient-option-parsing", LeafBaseType::Bool);
 
  569    if (config_ctrl && !config_ctrl->empty()) {
 
  570        checkAndSetLeaf(config_ctrl, xpath + 
"/config-control", 
"config-fetch-wait-time", LeafBaseType::Uint32);
 
  571        ConstElementPtr config_databases = config_ctrl->get(
"config-databases");
 
  572        if (config_databases && !config_databases->empty()) {
 
  573            setDatabases(xpath + 
"/config-control/config-database", config_databases);
 
  578    if (control_sockets && !control_sockets->empty()) {
 
  582        if (control_socket && !control_socket->empty()) {
 
  589        string const ddns_xpath(xpath + 
"/dhcp-ddns");
 
  590        checkAndSetLeaf(ddns, ddns_xpath, 
"enable-updates", LeafBaseType::Bool);
 
  591        checkAndSetLeaf(ddns, ddns_xpath, 
"max-queue-size", LeafBaseType::Uint32);
 
  595        checkAndSetLeaf(ddns, ddns_xpath, 
"sender-port", LeafBaseType::Uint16);
 
  597        checkAndSetLeaf(ddns, ddns_xpath, 
"server-port", LeafBaseType::Uint16);
 
  603        string const expired_xpath(xpath + 
"/expired-leases-processing");
 
  604        checkAndSetLeaf(expired, expired_xpath, 
"flush-reclaimed-timer-wait-time", LeafBaseType::Uint32);
 
  605        checkAndSetLeaf(expired, expired_xpath, 
"hold-reclaimed-time", LeafBaseType::Uint32);
 
  606        checkAndSetLeaf(expired, expired_xpath, 
"max-reclaim-leases", LeafBaseType::Uint32);
 
  607        checkAndSetLeaf(expired, expired_xpath, 
"max-reclaim-time", LeafBaseType::Uint32);
 
  608        checkAndSetLeaf(expired, expired_xpath, 
"reclaim-timer-wait-time", LeafBaseType::Uint32);
 
  609        checkAndSetLeaf(expired, expired_xpath, 
"unwarned-reclaim-cycles", LeafBaseType::Uint32);
 
  614        for (
ElementPtr const& lib : hook_libs->listValue()) {
 
  619            ostringstream hook_lib;
 
  620            hook_lib << xpath << 
"/hook-library[library='" 
  621                     << name->stringValue() << 
"']";
 
  622            string const hook_xpath(hook_lib.str());
 
  629    if (hosts_databases && !hosts_databases->empty()) {
 
  630        setDatabases(xpath + 
"/hosts-database", hosts_databases);
 
  634    if (database && !database->empty()) {
 
  635        setDatabase(xpath + 
"/lease-database", database,  
false);
 
  644    if (multi_threading) {
 
  645        string const mt_xpath(xpath + 
"/multi-threading");
 
  646        checkAndSetLeaf(multi_threading, mt_xpath, 
"enable-multi-threading", LeafBaseType::Bool);
 
  647        checkAndSetLeaf(multi_threading, mt_xpath, 
"packet-queue-size", LeafBaseType::Uint32);
 
  648        checkAndSetLeaf(multi_threading, mt_xpath, 
"thread-pool-size", LeafBaseType::Uint32);
 
  652    if (options && !options->empty()) {
 
  657    if (defs && !defs->empty()) {
 
  662    if (hosts && !hosts->empty()) {
 
  668        checkAndSetLeaf(sanity, xpath + 
"/sanity-checks", 
"extended-info-checks", LeafBaseType::Enum);
 
  669        checkAndSetLeaf(sanity, xpath + 
"/sanity-checks", 
"lease-checks", LeafBaseType::Enum);
 
  673    if (networks && !networks->empty()) {
 
 
  680    string xpath = 
"/kea-dhcp4-server:config";
 
  691    checkAndSetLeaf(elem, xpath, 
"stash-agent-options", LeafBaseType::Bool);
 
  695        checkAndSetLeaf(compatibility, xpath + 
"/compatibility", 
"exclude-first-last-24", LeafBaseType::Bool);
 
  696        checkAndSetLeaf(compatibility, xpath + 
"/compatibility", 
"ignore-dhcp-server-identifier", LeafBaseType::Bool);
 
  701        string const if_cfg_xpath(xpath + 
"/interfaces-config");
 
  702        checkAndSetLeaf(if_config, if_cfg_xpath, 
"dhcp-socket-type", LeafBaseType::Enum);
 
  703        checkAndSetLeaf(if_config, if_cfg_xpath, 
"outbound-interface", LeafBaseType::Enum);
 
  704        checkAndSetLeaf(if_config, if_cfg_xpath, 
"service-sockets-max-retries", LeafBaseType::Uint32);
 
  705        checkAndSetLeaf(if_config, if_cfg_xpath, 
"service-sockets-require-all", LeafBaseType::Bool);
 
  706        checkAndSetLeaf(if_config, if_cfg_xpath, 
"service-sockets-retry-wait-time", LeafBaseType::Uint32);
 
  707        checkAndSetLeaf(if_config, if_cfg_xpath, 
"re-detect", LeafBaseType::Bool);
 
 
  720    string xpath = 
"/kea-dhcp6-server:config";
 
  725    checkAndSetLeaf(elem, xpath, 
"max-preferred-lifetime", LeafBaseType::Uint32);
 
  726    checkAndSetLeaf(elem, xpath, 
"min-preferred-lifetime", LeafBaseType::Uint32);
 
  728    checkAndSetLeaf(elem, xpath, 
"preferred-lifetime", LeafBaseType::Uint32);
 
  735        string const if_cfg_xpath(xpath + 
"/interfaces-config");
 
  736        checkAndSetLeaf(if_config, if_cfg_xpath, 
"service-sockets-max-retries", LeafBaseType::Uint32);
 
  737        checkAndSetLeaf(if_config, if_cfg_xpath, 
"service-sockets-require-all", LeafBaseType::Bool);
 
  738        checkAndSetLeaf(if_config, if_cfg_xpath, 
"service-sockets-retry-wait-time", LeafBaseType::Uint32);
 
  739        checkAndSetLeaf(if_config, if_cfg_xpath, 
"re-detect", LeafBaseType::Bool);
 
  746        string const srv_id_xpath(xpath + 
"/server-id");
 
  748        checkAndSetLeaf(server_id, srv_id_xpath, 
"identifier", LeafBaseType::String);
 
  749        checkAndSetLeaf(server_id, srv_id_xpath, 
"time", LeafBaseType::Uint32);
 
  750        checkAndSetLeaf(server_id, srv_id_xpath, 
"htype", LeafBaseType::Uint16);
 
  751        checkAndSetLeaf(server_id, srv_id_xpath, 
"enterprise-id", LeafBaseType::Uint32);
 
  752        checkAndSetLeaf(server_id, srv_id_xpath, 
"persist", LeafBaseType::Bool);
 
 
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
A generic exception that is thrown when a function is not implemented.
static void preProcess4(isc::data::ElementPtr config)
Pre process a DHCPv4 configuration.
static void preProcess6(isc::data::ElementPtr config)
Pre process a DHCPv6 configuration.
Client class translation between YANG and JSON.
isc::data::ElementPtr getClasses(libyang::DataNode const &data_node)
Translate client classes from YANG to JSON.
void setClasses(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set client classes from JSON to YANG.
TranslatorClasses(sysrepo::Session session, const std::string &model)
Constructor.
isc::data::ElementPtr getConfigKea4()
getConfig for kea-dhcp4-server.
isc::data::ElementPtr getHook(libyang::DataNode const &data_node)
void setServerKeaDhcpCommon(const std::string &xpath, isc::data::ConstElementPtr elem)
setServer common part for kea-dhcp[46]-server:config.
void delConfigKea()
delConfig for kea-dhcp[46]-server.
isc::data::ElementPtr getExpiredKea(libyang::DataNode const &data_node)
Retrieves expired leases processing parameters from sysrepo.
isc::data::ElementPtr getServerKeaDhcp4()
getServer for kea-dhcp4-server:config.
void setConfigKea6(isc::data::ConstElementPtr elem)
setConfig for kea-dhcp6-server.
TranslatorConfig(sysrepo::Session session, const std::string &model)
Constructor.
void setConfigIetf6(isc::data::ConstElementPtr elem)
setConfig for ietf-dhcpv6-server.
isc::data::ElementPtr getDdnsKea(libyang::DataNode const &data_node)
Retrieves DDNS configuration from sysrepo.
isc::data::ElementPtr getInterfacesKea(libyang::DataNode const &data_node)
Retrieves interfaces configuration from sysrepo.
void setConfigKea4(isc::data::ConstElementPtr elem)
setConfig for kea-dhcp[46]-server.
void setConfig(isc::data::ElementPtr elem)
Translate and set the DHCP server configuration from JSON to YANG.
isc::data::ElementPtr getConfigControlKea(libyang::DataNode const &data_node)
Retrieves configuration control from sysrepo.
void setServerKeaDhcp6(isc::data::ConstElementPtr elem)
setServer for kea-dhcp6-server:config.
isc::data::ElementPtr getConfigKea6()
getConfig for kea-dhcp6-server.
isc::data::ElementPtr getConfigIetf6()
getConfig for ietf-dhcpv6-server.
void setServerKeaDhcp4(isc::data::ConstElementPtr elem)
setServer for kea-dhcp4-server:config.
isc::data::ElementPtr getServerKeaDhcp6()
getServer for kea-dhcp6-server:config.
void delConfigIetf6()
delConfig for ietf-dhcpv6-server.
isc::data::ElementPtr getConfig()
Translate the whole DHCP server configuration from YANG to JSON.
isc::data::ElementPtr getServerKeaDhcpCommon(libyang::DataNode const &data_node)
getServer common part for kea-dhcp[46]-server:config.
isc::data::ElementPtr getHooksKea(libyang::DataNode const &data_node)
Retrieves hooks configuration from sysrepo.
void setControlSocket(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set control socket from JSON to YANG.
TranslatorControlSocket(sysrepo::Session session, const std::string &model)
Constructor.
void setControlSockets(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set control sockets from JSON to YANG.
isc::data::ElementPtr getControlSocket(libyang::DataNode const &data_node)
Translate a control socket from YANG to JSON.
isc::data::ElementPtr getControlSockets(libyang::DataNode const &data_node)
Translate a control socket from YANG to JSON.
Database access translation between YANG and JSON.
isc::data::ElementPtr getDatabase(libyang::DataNode const &data_node)
Translate a database access from YANG to JSON.
void setDatabase(const std::string &xpath, isc::data::ConstElementPtr elem, bool has_mandatory_key)
Translate and set database access from JSON to YANG.
void setDatabases(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set database accesses from JSON to YANG.
isc::data::ElementPtr getDatabases(libyang::DataNode const &data_node, std::string const &xpath)
Translate database accesses from YANG to JSON.
TranslatorDatabases(sysrepo::Session session, const std::string &model)
Constructor.
Translation between YANG and JSON for a single host reservation.
A translator class for converting host reservations list between YANG and JSON.
isc::data::ElementPtr getHosts(libyang::DataNode const &data_node)
Translate host reservations from YANG to JSON.
void setHosts(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set (address) host reservations from JSON to YANG.
Logger translation between YANG and JSON.
void setLoggers(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set loggers from JSON to YANG.
isc::data::ConstElementPtr getLoggers(libyang::DataNode const &data_node)
Translate loggers from YANG to JSON.
TranslatorLoggers(sysrepo::Session session, const std::string &model)
Constructor.
A translator class for converting an option data list between YANG and JSON.
void setOptionDataList(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set option data list from JSON to YANG.
isc::data::ConstElementPtr getOptionDataList(libyang::DataNode const &data_node)
Translate option data list from YANG to JSON.
Option data translation between YANG and JSON.
Currently supports kea-dhcp[46]-server models.
isc::data::ConstElementPtr getOptionDefList(libyang::DataNode const &data_node)
Translate option definition list from YANG to JSON.
void setOptionDefList(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set option definition list from JSON to YANG.
Option definition translation between YANG and JSON.
Prefix delegation pool translation between YANG and JSON.
A translator class for converting a pd-pool list between YANG and JSON.
A translator class for converting a pool between YANG and JSON.
A translator class for converting pools between YANG and JSON.
Shared network translation between YANG and JSON.
TranslatorSharedNetworks(sysrepo::Session session, const std::string &model)
Constructor.
isc::data::ElementPtr getSharedNetworks(libyang::DataNode const &data_node)
Translate shared networks from YANG to JSON.
void setSharedNetworks(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set shared networks from JSON to YANG.
Subnet (aka network range) translation between YANG and JSON.
A translator class for converting a subnet list between YANG and JSON.
void setSubnets(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set subnets from JSON to YANG.
isc::data::ElementPtr getSubnets(libyang::DataNode const &data_node)
Get and translate subnets from YANG to JSON.
Between YANG and JSON translator class for basic values.
isc::data::ElementPtr getList(libyang::DataNode const &data_node, std::string const &xpath, T &t, isc::data::ElementPtr(T::*f)(libyang::DataNode const &)) const
Retrieve a list as ElementPtr from sysrepo from a certain xpath.
void checkAndSetLeaf(isc::data::ConstElementPtr const &from, std::string const &xpath, std::string const &name, libyang::LeafBaseType const type)
Get an element from given ElementPtr node and set it in sysrepo at given xpath.
void checkAndGet(isc::data::ElementPtr const &storage, libyang::DataNode const &data_node, std::string const &xpath, T translate) const
Calls {translate} for the element found at {xpath} relative to {data_node} and sets the result in {st...
libyang::DataNode findXPath(std::string const &xpath) const
Retrieves a YANG data node by xpath.
void checkAndGetLeaf(isc::data::ElementPtr &storage, libyang::DataNode const &data_node, std::string const &name) const
Retrieves a child YANG data node identified by name from the given parent YANG container node and sto...
void checkAndSetUserContext(isc::data::ConstElementPtr const &from, std::string const &xpath)
Get an element from given ElementPtr node and set it in sysrepo at given xpath.
void deleteItem(const std::string &xpath)
Delete basic value from YANG.
void setItem(const std::string &xpath, isc::data::ConstElementPtr const elem, libyang::LeafBaseType const type)
Translate and set basic value from JSON to YANG.
std::string model_
The model.
void checkAndGetAndJsonifyLeaf(isc::data::ElementPtr &storage, libyang::DataNode const &data_node, const std::string &name) const
Retrieves a child YANG data node identified by name from the given parent YANG container node,...
void checkAndSetLeafList(isc::data::ConstElementPtr const &from, std::string const &xpath, std::string const &name, libyang::LeafBaseType const type)
Get an element from given ElementPtr node and set it in sysrepo at given xpath as a leaf-list.
void checkAndStringifyAndSetLeaf(isc::data::ConstElementPtr const &from, std::string const &xpath, std::string const &name)
Get an element from given ElementPtr node and set it in sysrepo at given xpath.
void checkAndGetDiverging(isc::data::ElementPtr const &storage, libyang::DataNode const &data_node, std::string const &key, std::string const &xpath, T translate) const
Calls {translate} for the element found at {xpath} relative to {data_node} and sets the result in {st...
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
ElementPtr copy(ConstElementPtr from, int level)
Copy the data up to a nesting level.
boost::shared_ptr< const Element > ConstElementPtr
boost::shared_ptr< Element > ElementPtr
Defines the logger used by the top-level component of kea-lfc.