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.