{
"Netconf":
{
+ // Three flags control netconf (default values are true):
+ // - "boot-update" about the YANG configuration load when
+ // netconf boots.
+ // - "subscribe-changes" about the subscription to notifications
+ // when the running YANG module is changed.
+ // - "validate-changes" alloes to validate or not changes.
+ "boot-update": true,
+ "subscribe-changes": true,
+ "validate-changes": true,
+
// This map specifies how each server is managed:
// the YANG model to use and the control channel.
"managed-servers":
// DHCPv4 server is kea-dhcp4-server model.
"model": "kea-dhcp4-server",
+ // The three control flags can be defined in this scope too
+ // and takes precedence over global and default values.
+ "boot-update": false,
+ "subscribe-changes": false,
+ "validate-changes": false,
+
// Currently three control channel types are supported:
// - "stdout" which output the configuration on the standard
// output (this is mainly for testing purposes, but you can
{
"Netconf":
{
+ // Control flags can be defined in the global scope or
+ // in a managed server scope. Precedence are:
+ // - use the default value (true)
+ // - use the global value
+ // - use the local value.
+ // So this overwrites the default value:
+ "boot-update": false,
+
// This map specifies how each server is managed:
// the YANG model to use and the control channel.
// Currently three control channel types are supported:
namespace netconf {
NetconfConfig::NetconfConfig()
- : servers_map_(new CfgServersMap()) {
+ : configured_globals_(Element::createMap()),
+ servers_map_(new CfgServersMap()) {
}
NetconfConfig::NetconfConfig(const NetconfConfig& orig)
- : ConfigBase(), servers_map_(orig.servers_map_),
- hooks_config_(orig.hooks_config_) {
+ : ConfigBase(), configured_globals_(orig.configured_globals_),
+ servers_map_(orig.servers_map_), hooks_config_(orig.hooks_config_) {
+}
+
+void
+NetconfConfig::extractConfiguredGlobals(ConstElementPtr config) {
+ if (config->getType() != Element::map) {
+ isc_throw(BadValue,
+ "extractConfiguredGlobals must be given a map element");
+ }
+
+ const std::map<std::string, ConstElementPtr>& values = config->mapValue();
+ for (auto value = values.begin(); value != values.end(); ++value) {
+ if (value->second->getType() != Element::list &&
+ value->second->getType() != Element::map) {
+ addConfiguredGlobal(value->first, value->second);
+ }
+ }
}
NetconfCfgMgr::NetconfCfgMgr()
NetconfConfigPtr ctx = getNetconfConfig();
- // Set the defaults
+ // Preserve all scalar global parameters.
+ ctx->extractConfiguredGlobals(config_set);
+
+ // Set the defaults and derive parameters.
ElementPtr cfg = boost::const_pointer_cast<Element>(config_set);
NetconfSimpleParser::setAllDefaults(cfg);
+ NetconfSimpleParser::deriveParameters(cfg);
// And parse the configuration.
ConstElementPtr answer;
return (answer);
}
-
-
ElementPtr
NetconfConfig::toElement() const {
ElementPtr netconf = Element::createMap();
// Set user-context
contextToElement(netconf);
+ // Add in explicitly configured globals.
+ netconf->setValue(configured_globals_->mapValue());
// Set hooks-libraries
netconf->set("hooks-libraries", hooks_config_.toElement());
// Set managed-servers
/// @brief Default constructor
NetconfConfig();
+ /// @brief Returns pointer to configured global parameters.
+ isc::data::ConstElementPtr getConfiguredGlobals() const {
+ return (isc::data::ConstElementPtr(configured_globals_));
+ }
+
+ /// @brief Saves scalar elements from the global scope of a configuration.
+ void extractConfiguredGlobals(isc::data::ConstElementPtr config);
+
+ /// @brief Adds a parameter to the collection configured globals.
+ ///
+ /// @param name std::string name of the global to add.
+ /// @param value ElementPtr containing the value of the global.
+ void addConfiguredGlobal(const std::string& name,
+ isc::data::ConstElementPtr value) {
+ configured_globals_->set(name, value);
+ }
+
/// @brief Returns non-const reference to the managed servers map.
///
/// @return non-const reference to the managed servers map.
/// @param rhs Context to be assigned.
NetconfConfig& operator=(const NetconfConfig& rhs);
+ /// @brief Stores the global parameters specified via configuration.
+ isc::data::ElementPtr configured_globals_;
+
/// @brief CfgServers map.
CfgServersMapPtr servers_map_;
// *********************** CfgServer *************************
CfgServer::CfgServer(const string& model, CfgControlSocketPtr ctrl_sock)
- : model_(model), control_socket_(ctrl_sock) {
+ : model_(model), boot_update_(true), subscribe_changes_(true),
+ validate_changes_(true), control_socket_(ctrl_sock) {
}
CfgServer::~CfgServer() {
contextToElement(result);
// Set model
result->set("model", Element::create(model_));
+ // Set boot-update
+ result->set("boot-update", Element::create(boot_update_));
+ // Set subscribe-changes
+ result->set("subscribe-changes", Element::create(subscribe_changes_));
+ // Set validate-changes
+ result->set("validate-changes", Element::create(validate_changes_));
// Set control-socket
if (control_socket_) {
result->set("control-socket", control_socket_->toElement());
<< server_config->getPosition() << ")");
}
+ // Add flags.
+ result->setBootUpdate(getBoolean(server_config, "boot-update"));
+ result->setSubscribeChanges(getBoolean(server_config, "subscribe-changes"));
+ result->setValidateChanges(getBoolean(server_config, "validate-changes"));
+
// Add user-context.
if (user_context) {
result->setContext(user_context);
return (control_socket_);
}
+ /// @brief Getter which returns the boot-update flag.
+ ///
+ /// @return returns the boot-update flag as a bool.
+ bool getBootUpdate() const {
+ return (boot_update_);
+ }
+
+ /// @brief Set the boot-update flag.
+ ///
+ /// @param boot_update The boot-update flag.
+ void setBootUpdate(bool boot_update) {
+ boot_update_ = boot_update;
+ }
+
+ /// @brief Getter which returns the subscribe-changes flag.
+ ///
+ /// @return returns the subscribe-changes flag as a bool.
+ bool getSubscribeChanges() const {
+ return (subscribe_changes_);
+ }
+
+ /// @brief Set the subscribe-changes flag.
+ ///
+ /// @param subscribe_changes The subscribe-changes flag.
+ void setSubscribeChanges(bool subscribe_changes) {
+ subscribe_changes_ = subscribe_changes;
+ }
+
+ /// @brief Getter which returns the validate-changes flag.
+ ///
+ /// @return returns the validate-changes flag as a bool.
+ bool getValidateChanges() const {
+ return (validate_changes_);
+ }
+
+ /// @brief Set the validate-changes flag.
+ ///
+ /// @param validate_changes The validate-changes flag.
+ void setValidateChanges(bool validate_changes) {
+ validate_changes_ = validate_changes;
+ }
+
/// @brief Returns a text representation for the server.
std::string toText() const;
/// @brief The model name.
const std::string model_;
+ /// @brief The boot-update flag.
+ ///
+ /// If true (the defaul) Kea server configuration is updated at (netconf
+ /// agent) boot time.
+ bool boot_update_;
+
+ /// @brief The subscribe-changes flag.
+ ///
+ /// If true (the deault) the netconf agent subscribes module changes
+ /// so will be notified when the YANG running configuration is changed.
+ bool subscribe_changes_;
+
+ /// @brief The validate-changes flag.
+ ///
+ /// If true (the deault) the netconf agent validates module changes
+ /// and can reject bad configurations.
+ bool validate_changes_;
+
/// @brief The control socket.
CfgControlSocketPtr control_socket_;
};
///
/// These are global Netconf parameters.
const SimpleDefaults NetconfSimpleParser::NETCONF_DEFAULTS = {
+ { "boot-update", Element::boolean, "true" },
+ { "subscribe-changes", Element::boolean, "true" },
+ { "validate-changes", Element::boolean, "true" }
};
/// Supplies defaults for control-socket elements
{ "model", Element::string, "kea-ctrl-agent" }
};
+/// @brief List of parameters that can be inherited to managed-servers scope.
+///
+/// Some parameters may be defined on both global (directly in Netconf) and
+/// servers (Netconf/managed-servers/...) scope. If not defined in the
+/// managed-servers scope, the value is being inherited (derived) from
+/// the global scope. This array lists all of such parameters.
+const ParamsList NetconfSimpleParser::INHERIT_TO_SERVERS = {
+ "boot-update",
+ "subscribe-changes",
+ "validate-changes"
+};
+
/// @}
/// ---------------------------------------------------------------------------
return (cnt);
}
+size_t NetconfSimpleParser::deriveParameters(ConstElementPtr global) {
+ size_t cnt = 0;
+
+ // Now derive global parameters into managed-servers.
+ ConstElementPtr servers = global->get("managed-servers");
+ if (servers) {
+ for (auto it : servers->mapValue()) {
+ ElementPtr mutable_server =
+ boost::const_pointer_cast<Element>(it.second);
+ cnt += SimpleParser::deriveParams(global,
+ mutable_server,
+ INHERIT_TO_SERVERS);
+ }
+ }
+
+ return (cnt);
+}
+
size_t
NetconfSimpleParser::setServerDefaults(const std::string name,
ConstElementPtr server) {
/// @return number of default values added
static size_t setAllDefaults(const isc::data::ElementPtr& global);
+ /// @brief Derives (inherits) all parameters from global to more specific scopes.
+ ///
+ /// This method currently does the following:
+ /// - derives global parameters to managed servers (flags for now)
+ /// @param global scope to be modified if needed
+ /// @return number of default values derived
+ static size_t deriveParameters(isc::data::ConstElementPtr global);
+
/// @brief Adds default values to a Managed server entry.
///
/// Adds server specific defaults, e.g. the default model.
static const isc::data::SimpleDefaults DHCP6_DEFAULTS;
static const isc::data::SimpleDefaults D2_DEFAULTS;
static const isc::data::SimpleDefaults CA_DEFAULTS;
+ static const isc::data::ParamsList INHERIT_TO_SERVERS;
};
};
#include <process/testutils/d_test_stubs.h>
#include <process/d_cfg_mgr.h>
#include <yang/yang_models.h>
+#include <testutils/test_to_element.h>
#include <netconf/tests/test_libraries.h>
#include <boost/scoped_ptr.hpp>
#include <gtest/gtest.h>
using namespace std;
+using namespace isc;
using namespace isc::netconf;
using namespace isc::config;
using namespace isc::data;
EXPECT_EQ(libs.get(), stored_libs.get());
}
+// Tests if the context can store and retrieve globals.
+TEST(NetconfCfgMgr, contextGlobals) {
+ NetconfConfig ctx;
+
+ // By default there should be no globals.
+ ConstElementPtr globals = ctx.getConfiguredGlobals();
+ ASSERT_TRUE(globals);
+ ASSERT_EQ(Element::map, globals->getType());
+ EXPECT_EQ(0, globals->mapValue().size());
+
+ // Attempting to extract globals from a non-map should throw.
+ ASSERT_THROW(ctx.extractConfiguredGlobals(Element::create(777)), BadValue);
+
+ // Now let's create a configuration from which to extract global scalars.
+ // Extraction (currently) has no business logic, so the elements we use
+ // can be arbitrary.
+ ConstElementPtr global_cfg;
+ string global_cfg_str =
+ "{\n"
+ " \"astring\": \"okay\",\n"
+ " \"amap\": { \"not-this\":777, \"not-that\": \"poo\" },\n"
+ " \"anint\": 444,\n"
+ " \"alist\": [ 1, 2, 3 ],\n"
+ " \"abool\": true\n"
+ "}\n";
+ ASSERT_NO_THROW(global_cfg = Element::fromJSON(global_cfg_str));
+
+ // Extract globals from the config.
+ ASSERT_NO_THROW(ctx.extractConfiguredGlobals(global_cfg));
+
+ // Now see if the extract was correct.
+ globals = ctx.getConfiguredGlobals();
+ ASSERT_TRUE(globals);
+ ASSERT_EQ(Element::map, globals->getType());
+ EXPECT_NE(0, globals->mapValue().size());
+
+ // Maps and lists should be excluded.
+ for (auto it : globals->mapValue()) {
+ if (it.first == "astring") {
+ ASSERT_EQ(Element::string, it.second->getType());
+ EXPECT_EQ("okay", it.second->stringValue());
+ } else if (it.first == "anint") {
+ ASSERT_EQ(Element::integer, it.second->getType());
+ EXPECT_EQ(444, it.second->intValue());
+ } else if (it.first == "abool") {
+ ASSERT_EQ(Element::boolean, it.second->getType());
+ EXPECT_TRUE(it.second->boolValue());
+ } else {
+ ADD_FAILURE() << "unexpected element found:" << it.first;
+ }
+ }
+}
+
/// Netconf configurations used in tests.
const char* NETCONF_CONFIGS[] = {
// Configuration 1: global parameters only (no server, not hooks)
"{\n"
+ " \"boot-update\": false,\n"
+ " \"subscribe-changes\": false,\n"
+ " \"validate-changes\": false\n"
"}",
// Configuration 2: 1 server
"{\n"
+ " \"boot-update\": false,\n"
" \"managed-servers\": {\n"
" \"dhcp4\": {\n"
+ " \"boot-update\": true,\n"
" \"control-socket\": {\n"
" \"socket-name\": \"/tmp/socket-v4\"\n"
" }\n"
// Configuration 3: all 4 servers
"{\n"
+ " \"boot-update\": false,\n"
" \"managed-servers\": {\n"
" \"dhcp4\": {\n"
+ " \"boot-update\": true,\n"
" \"control-socket\": {\n"
" \"socket-name\": \"/tmp/socket-v4\"\n"
" }\n"
" }\n"
" },\n"
" \"d2\": {\n"
+ " \"subscribe-changes\": false,\n"
" \"control-socket\": {\n"
" \"socket-name\": \"/tmp/socket-d2\"\n"
" }\n"
"{\n"
" \"managed-servers\": {\n"
" \"d2\": {\n"
+ " \"subscribe-changes\": false,\n"
" \"control-socket\": {\n"
" \"socket-name\": \"/tmp/socket-d2\"\n"
" }\n"
// Configuration 9: empty control socket
"{\n"
+ " \"boot-update\": false,\n"
+ " \"subscribe-changes\": false,\n"
+ " \"validate-changes\": false,\n"
" \"managed-servers\": {\n"
" \"dhcp4\": {\n"
" \"control-socket\": {\n"
ASSERT_TRUE(ctx);
ASSERT_TRUE(ctx->getCfgServersMap());
EXPECT_EQ(0, ctx->getCfgServersMap()->size());
+ ConstElementPtr globals = ctx->getConfiguredGlobals();
+ ASSERT_TRUE(globals);
+ string expected = "{ "
+ "\"boot-update\": false, "
+ "\"subscribe-changes\": false, "
+ "\"validate-changes\": false }";
+ EXPECT_EQ(expected, globals->str());
}
// Tests if an empty (i.e. without a control socket) can be configured.
CfgServerPtr server = ctx->getCfgServersMap()->at("dhcp4");
ASSERT_TRUE(server);
EXPECT_EQ(KEA_DHCP4_SERVER, server->getModel());
+ // Defaults.
+ EXPECT_TRUE(server->getBootUpdate());
+ EXPECT_TRUE(server->getSubscribeChanges());
+ EXPECT_TRUE(server->getValidateChanges());
CfgControlSocketPtr socket = server->getCfgControlSocket();
EXPECT_FALSE(socket);
}
CfgServerPtr server = ctx->getCfgServersMap()->at("dhcp4");
ASSERT_TRUE(server);
EXPECT_EQ(KEA_DHCP4_SERVER, server->getModel());
+ // Globals overwrite defaults.
+ EXPECT_FALSE(server->getBootUpdate());
+ EXPECT_FALSE(server->getSubscribeChanges());
+ EXPECT_FALSE(server->getValidateChanges());
CfgControlSocketPtr socket = server->getCfgControlSocket();
ASSERT_TRUE(socket);
CfgServerPtr server = ctx->getCfgServersMap()->at("dhcp4");
ASSERT_TRUE(server);
EXPECT_EQ(KEA_DHCP4_SERVER, server->getModel());
+ // Locals overwrite globals.
+ EXPECT_TRUE(server->getBootUpdate());
+ EXPECT_TRUE(server->getSubscribeChanges());
+ EXPECT_TRUE(server->getValidateChanges());
CfgControlSocketPtr socket = server->getCfgControlSocket();
ASSERT_TRUE(socket);
EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType());
CfgServerPtr server = ctx->getCfgServersMap()->at("d2");
ASSERT_TRUE(server);
EXPECT_EQ(KEA_DHCP_DDNS, server->getModel());
+ EXPECT_TRUE(server->getBootUpdate());
+ EXPECT_FALSE(server->getSubscribeChanges());
+ EXPECT_TRUE(server->getValidateChanges());
CfgControlSocketPtr socket = server->getCfgControlSocket();
ASSERT_TRUE(socket);
EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType());
CfgServerPtr server = ctx->getCfgServersMap()->at("dhcp4");
ASSERT_TRUE(server);
EXPECT_EQ(KEA_DHCP4_SERVER, server->getModel());
+ EXPECT_TRUE(server->getBootUpdate());
+ EXPECT_TRUE(server->getSubscribeChanges());
+ EXPECT_TRUE(server->getValidateChanges());
CfgControlSocketPtr socket = server->getCfgControlSocket();
ASSERT_TRUE(socket);
EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType());
ASSERT_TRUE(server);
EXPECT_EQ(KEA_DHCP6_SERVER, server->getModel());
socket = server->getCfgControlSocket();
+ EXPECT_FALSE(server->getBootUpdate());
+ EXPECT_TRUE(server->getSubscribeChanges());
+ EXPECT_TRUE(server->getValidateChanges());
ASSERT_TRUE(socket);
EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType());
EXPECT_EQ("/tmp/socket-v6", socket->getName());
server = ctx->getCfgServersMap()->at("d2");
ASSERT_TRUE(server);
EXPECT_EQ(KEA_DHCP_DDNS, server->getModel());
+ EXPECT_FALSE(server->getBootUpdate());
+ EXPECT_FALSE(server->getSubscribeChanges());
+ EXPECT_TRUE(server->getValidateChanges());
socket = server->getCfgControlSocket();
ASSERT_TRUE(socket);
EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType());
server = ctx->getCfgServersMap()->at("ca");
ASSERT_TRUE(server);
EXPECT_EQ(KEA_CTRL_AGENT, server->getModel());
+ EXPECT_FALSE(server->getBootUpdate());
+ EXPECT_TRUE(server->getSubscribeChanges());
+ EXPECT_TRUE(server->getValidateChanges());
socket = server->getCfgControlSocket();
ASSERT_TRUE(socket);
EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType());
EXPECT_EQ("/tmp/socket-ca", socket->getName());
EXPECT_EQ("http://127.0.0.1:8000/", socket->getUrl().toText());
+
+ // Check unparsing.
+ string expected = "{\n"
+ " \"Netconf\": {\n"
+ " \"boot-update\": false,\n"
+ " \"managed-servers\": {\n"
+ " \"dhcp4\": {\n"
+ " \"model\": \"kea-dhcp4-server\",\n"
+ " \"boot-update\": true,\n"
+ " \"subscribe-changes\": true,\n"
+ " \"validate-changes\": true,\n"
+ " \"control-socket\": {\n"
+ " \"socket-type\": \"stdout\",\n"
+ " \"socket-name\": \"/tmp/socket-v4\",\n"
+ " \"socket-url\": \"http://127.0.0.1:8000/\"\n"
+ " }\n"
+ " },\n"
+ " \"dhcp6\": {\n"
+ " \"model\": \"kea-dhcp6-server\",\n"
+ " \"boot-update\": false,\n"
+ " \"subscribe-changes\": true,\n"
+ " \"validate-changes\": true,\n"
+ " \"control-socket\": {\n"
+ " \"socket-type\": \"stdout\",\n"
+ " \"socket-name\": \"/tmp/socket-v6\",\n"
+ " \"socket-url\": \"http://127.0.0.1:8000/\"\n"
+ " }\n"
+ " },\n"
+ " \"d2\": {\n"
+ " \"model\": \"kea-dhcp-ddns\",\n"
+ " \"boot-update\": false,\n"
+ " \"subscribe-changes\": false,\n"
+ " \"validate-changes\": true,\n"
+ " \"control-socket\": {\n"
+ " \"socket-type\": \"stdout\",\n"
+ " \"socket-name\": \"/tmp/socket-d2\",\n"
+ " \"socket-url\": \"http://127.0.0.1:8000/\"\n"
+ " }\n"
+ " },\n"
+ " \"ca\": {\n"
+ " \"model\": \"kea-ctrl-agent\",\n"
+ " \"boot-update\": false,\n"
+ " \"subscribe-changes\": true,\n"
+ " \"validate-changes\": true,\n"
+ " \"control-socket\": {\n"
+ " \"socket-type\": \"stdout\",\n"
+ " \"socket-name\": \"/tmp/socket-ca\",\n"
+ " \"socket-url\": \"http://127.0.0.1:8000/\"\n"
+ " }\n"
+ " }\n"
+ " },\n"
+ " \"hooks-libraries\": [ ]\n"
+ " }\n"
+ "}";
+ isc::test::runToElementTest<NetconfConfig>(expected, *ctx);
}
// Tests the handling of invalid socket URL.
/// @brief Valid Netconf Config used in tests.
const char* valid_netconf_config =
"{"
+ " \"boot-update\": false,"
+ " \"subscribe-changes\": false,"
" \"managed-servers\": {"
" \"dhcp4\": {"
" \"control-socket\": {"
// be parsed with syntactic checking (and as pure JSON).
TEST(ParserTest, keywordNetconf) {
string txt = "{ \"Netconf\": {\n"
+ " \"boot-update\": true,"
+ " \"subscribe-changes\": true,"
+ " \"validate-changes\": true,"
" \"managed-servers\": {"
" \"dhcp4\": {"
" \"model\": \"kea-dhcp4-server\","
+ " \"boot-update\": false,"
+ " \"subscribe-changes\": false,"
+ " \"validate-changes\": false,"
" \"control-socket\": {"
" \"socket-type\": \"unix\","
" \"socket-name\": \"/path/to/the/unix/socket-v4\""
" },"
" \"dhcp6\": {"
" \"model\": \"kea-dhcp6-server\","
+ " \"boot-update\": false,"
+ " \"subscribe-changes\": false,"
+ " \"validate-changes\": false,"
" \"control-socket\": {"
" \"socket-type\": \"http\","
" \"socket-url\": \"http://127.0.0.1:12345/\""
" },"
" \"d2\": {"
" \"model\": \"kea-dhcp-ddns\","
+ " \"boot-update\": false,"
+ " \"subscribe-changes\": false,"
+ " \"validate-changes\": false,"
" \"control-socket\": {"
" \"socket-type\": \"stdout\""
" }"
" },"
" \"ca\": {"
" \"model\": \"kea-ctrl-agent\","
+ " \"boot-update\": false,"
+ " \"subscribe-changes\": false,"
+ " \"validate-changes\": false,"
" \"control-socket\": {"
" \"socket-type\": \"http\","
" \"user-context\": { \"use default\": true }"
// This is similar to previous test, but note the lack of outer
// map and Netconf.
string txt = "{\n"
+ " \"boot-update\": true,"
+ " \"subscribe-changes\": true,"
+ " \"validate-changes\": true,"
" \"managed-servers\": {"
" \"dhcp4\": {"
" \"model\": \"kea-dhcp4-server\","
+ " \"boot-update\": false,"
+ " \"subscribe-changes\": false,"
+ " \"validate-changes\": false,"
" \"control-socket\": {"
" \"socket-type\": \"unix\","
" \"socket-name\": \"/path/to/the/unix/socket-v4\""
" },"
" \"dhcp6\": {"
" \"model\": \"kea-dhcp6-server\","
+ " \"boot-update\": false,"
+ " \"subscribe-changes\": false,"
+ " \"validate-changes\": false,"
" \"control-socket\": {"
" \"socket-type\": \"http\","
" \"socket-url\": \"http://127.0.0.1:12345/\""
" },"
" \"d2\": {"
" \"model\": \"kea-dhcp-ddns\","
+ " \"boot-update\": false,"
+ " \"subscribe-changes\": false,"
+ " \"validate-changes\": false,"
" \"control-socket\": {"
" \"socket-type\": \"stdout\""
" }"
" },"
" \"ca\": {"
" \"model\": \"kea-ctrl-agent\","
- " \"model\": \"kea-dhcp6-server\","
+ " \"boot-update\": false,"
+ " \"subscribe-changes\": false,"
+ " \"validate-changes\": false,"
" \"control-socket\": {"
" \"socket-type\": \"http\","
" \"user-context\": { \"use default\": true }"
{
"Netconf": {
+ "boot-update": false,
"hooks-libraries": [
{
"library": "/tmp/ky/src/bin/netconf/tests/.libs/libbasic.so",
],
"managed-servers": {
"ca": {
+ "boot-update": false,
"control-socket": {
"socket-name": "",
"socket-type": "http",
"socket-url": "http://127.0.0.1:8000/"
},
- "model": "kea-ctrl-agent"
+ "model": "kea-ctrl-agent",
+ "subscribe-changes": true,
+ "validate-changes": true
},
"d2": {
+ "boot-update": false,
"control-socket": {
"socket-name": "",
"socket-type": "stdout",
"in-use": false
}
},
- "model": "kea-dhcp-ddns"
+ "model": "kea-dhcp-ddns",
+ "subscribe-changes": true,
+ "validate-changes": true
},
"dhcp4": {
"comment": "DHCP4 server",
+ "boot-update": false,
"control-socket": {
"socket-name": "/path/to/the/unix/socket-v4",
"socket-type": "unix",
"socket-url": "http://127.0.0.1:8000/"
},
- "model": "kea-dhcp4-server"
+ "model": "kea-dhcp4-server",
+ "subscribe-changes": true,
+ "validate-changes": true
},
"dhcp6": {
+ "boot-update": false,
"control-socket": {
"socket-name": "/path/to/the/unix/socket-v6",
"socket-type": "unix",
"socket-url": "http://127.0.0.1:8000/"
},
- "model": "kea-dhcp6-server"
+ "model": "kea-dhcp6-server",
+ "subscribe-changes": true,
+ "validate-changes": true
}
}
}
projects / thirdparty / kea.git / commitdiff
