From b8eb5a85676b2bc27213e9f0aaa9b110cf9ce309 Mon Sep 17 00:00:00 2001 From: Francis Dupont Date: Sat, 6 Oct 2018 02:46:26 +0200 Subject: [PATCH] [128-netconf-config] Addressed comments --- src/bin/netconf/netconf_cfg_mgr.cc | 4 +- src/bin/netconf/netconf_cfg_mgr.h | 8 +- src/bin/netconf/netconf_config.cc | 84 +++---- src/bin/netconf/netconf_config.h | 102 ++++----- src/bin/netconf/simple_parser.cc | 18 +- src/bin/netconf/tests/.gitignore | 1 + src/bin/netconf/tests/get_config_unittest.cc | 2 +- .../tests/netconf_cfg_mgr_unittests.cc | 212 +++++++++--------- .../tests/netconf_controller_unittests.cc | 6 +- 9 files changed, 219 insertions(+), 218 deletions(-) diff --git a/src/bin/netconf/netconf_cfg_mgr.cc b/src/bin/netconf/netconf_cfg_mgr.cc index 90a6c67fac..2e52efc40a 100644 --- a/src/bin/netconf/netconf_cfg_mgr.cc +++ b/src/bin/netconf/netconf_cfg_mgr.cc @@ -21,7 +21,7 @@ namespace isc { namespace netconf { NetconfConfig::NetconfConfig() - : servers_map_(new ServersMap()) { + : servers_map_(new CfgServersMap()) { } NetconfConfig::NetconfConfig(const NetconfConfig& orig) @@ -45,7 +45,7 @@ NetconfCfgMgr::getConfigSummary(const uint32_t /*selection*/) { std::ostringstream s; // Then print managed servers. - for (auto serv : *ctx->getServersMap()) { + for (auto serv : *ctx->getCfgServersMap()) { if (s.tellp() != 0) { s << " "; } diff --git a/src/bin/netconf/netconf_cfg_mgr.h b/src/bin/netconf/netconf_cfg_mgr.h index af437eca7a..131f4e696b 100644 --- a/src/bin/netconf/netconf_cfg_mgr.h +++ b/src/bin/netconf/netconf_cfg_mgr.h @@ -38,14 +38,14 @@ public: /// @brief Returns non-const reference to the managed servers map. /// /// @return non-const reference to the managed servers map. - ServersMapPtr& getServersMap() { + CfgServersMapPtr& getCfgServersMap() { return (servers_map_); } /// @brief Returns const reference to the managed servers map. /// /// @return const reference to the managed servers map. - const ServersMapPtr& getServersMap() const { + const CfgServersMapPtr& getCfgServersMap() const { return (servers_map_); } @@ -88,8 +88,8 @@ private: /// @param rhs Context to be assigned. NetconfConfig& operator=(const NetconfConfig& rhs); - /// @brief Servers map. - ServersMapPtr servers_map_; + /// @brief CfgServers map. + CfgServersMapPtr servers_map_; /// @brief Configured hooks libraries. isc::hooks::HooksConfig hooks_config_; diff --git a/src/bin/netconf/netconf_config.cc b/src/bin/netconf/netconf_config.cc index e05bf7d5ba..0784d15aed 100644 --- a/src/bin/netconf/netconf_config.cc +++ b/src/bin/netconf/netconf_config.cc @@ -26,43 +26,45 @@ using namespace isc::http; namespace isc { namespace netconf { -// *********************** ControlSocket ************************* +// *********************** CfgControlSocket ************************* -ControlSocket::ControlSocket(Type type, const string& name, const Url& url) +CfgControlSocket::CfgControlSocket(Type type, const string& name, + const Url& url) : type_(type), name_(name), url_(url) { } -ControlSocket::~ControlSocket() { +CfgControlSocket::~CfgControlSocket() { } -ControlSocket::Type -ControlSocket::stringToType(const string& type) { +CfgControlSocket::Type +CfgControlSocket::stringToType(const string& type) { if (type == "unix") { - return (ControlSocket::Type::UNIX); + return (CfgControlSocket::Type::UNIX); } else if (type == "http") { - return (ControlSocket::Type::HTTP); + return (CfgControlSocket::Type::HTTP); } else if (type == "stdout") { - return (ControlSocket::Type::STDOUT); + return (CfgControlSocket::Type::STDOUT); } isc_throw(BadValue, "Unknown control socket type: " << type); } const string -ControlSocket::typeToString(ControlSocket::Type type) { +CfgControlSocket::typeToString(CfgControlSocket::Type type) { switch (type) { - case ControlSocket::Type::UNIX: + case CfgControlSocket::Type::UNIX: return ("unix"); - case ControlSocket::Type::HTTP: + case CfgControlSocket::Type::HTTP: return ("http"); - case ControlSocket::Type::STDOUT: + case CfgControlSocket::Type::STDOUT: return ("stdout"); + default: + isc_throw(BadValue, "Unknown control socket type: " << type); } - /*UNREACHED*/ } ElementPtr -ControlSocket::toElement() const { +CfgControlSocket::toElement() const { ElementPtr result = Element::createMap(); // Set user-context contextToElement(result); @@ -75,29 +77,29 @@ ControlSocket::toElement() const { return (result); } -// *********************** Server ************************* -Server::Server(const string& model, ControlSocketPtr ctrl_sock) +// *********************** CfgServer ************************* +CfgServer::CfgServer(const string& model, CfgControlSocketPtr ctrl_sock) : model_(model), control_socket_(ctrl_sock) { } -Server::~Server() { +CfgServer::~CfgServer() { } string -Server::toText() const { +CfgServer::toText() const { ostringstream s; s << "model: " << model_ << ", control socker: "; if (!control_socket_) { s << "none"; } else { switch (control_socket_->getType()) { - case ControlSocket::Type::UNIX: + case CfgControlSocket::Type::UNIX: s << "UNIX:'" << control_socket_->getName() << "'"; break; - case ControlSocket::Type::HTTP: + case CfgControlSocket::Type::HTTP: s << "HTTP:'" << control_socket_->getUrl().toText() << "'"; break; - case ControlSocket::Type::STDOUT: + case CfgControlSocket::Type::STDOUT: s << "STDOUT"; break; } @@ -106,7 +108,7 @@ Server::toText() const { } ElementPtr -Server::toElement() const { +CfgServer::toElement() const { ElementPtr result = Element::createMap(); // Set user-context contextToElement(result); @@ -120,45 +122,45 @@ Server::toElement() const { } ostream& -operator<<(ostream& os, const Server& server) { +operator<<(ostream& os, const CfgServer& server) { os << server.toText(); return (os); } // *************************** PARSERS *********************************** -// *********************** ControlSocketParser ************************* +// *********************** ControlSocketConfigParser ************************* -ControlSocketPtr -ControlSocketParser::parse(ConstElementPtr ctrl_sock_config) { - ControlSocketPtr result; +CfgControlSocketPtr +ControlSocketConfigParser::parse(ConstElementPtr ctrl_sock_config) { + CfgControlSocketPtr result; string type_str = getString(ctrl_sock_config, "socket-type"); string name = getString(ctrl_sock_config, "socket-name"); string url_str = getString(ctrl_sock_config, "socket-url"); ConstElementPtr user_context = ctrl_sock_config->get("user-context"); // Type must be valid. - ControlSocket::Type type; + CfgControlSocket::Type type; try { - type = ControlSocket::stringToType(type_str); + type = CfgControlSocket::stringToType(type_str); } catch (const std::exception& ex) { - isc_throw(NetconfCfgError, ex.what() << " '" << type_str << "' (" + isc_throw(ConfigError, ex.what() << " '" << type_str << "' (" << getPosition("socket-type", ctrl_sock_config) << ")"); } // Url must be valid. Url url(url_str); if (!url.isValid()) { - isc_throw(NetconfCfgError, "invalid control socket url: " + isc_throw(ConfigError, "invalid control socket url: " << url.getErrorMessage() << " '" << url_str << "' (" << getPosition("socket-url", ctrl_sock_config) << ")"); } // Create the control socket. try { - result.reset(new ControlSocket(type, name, url)); + result.reset(new CfgControlSocket(type, name, url)); } catch (const std::exception& ex) { - isc_throw(NetconfCfgError, ex.what() << " (" + isc_throw(ConfigError, ex.what() << " (" << ctrl_sock_config->getPosition() << ")"); } @@ -170,23 +172,23 @@ ControlSocketParser::parse(ConstElementPtr ctrl_sock_config) { return (result); } -// *********************** ServerParser ************************* +// *********************** ServerConfigParser ************************* -ServerPtr -ServerParser::parse(ConstElementPtr server_config) { - ServerPtr result; +CfgServerPtr +ServerConfigParser::parse(ConstElementPtr server_config) { + CfgServerPtr result; string model = getString(server_config, "model"); ConstElementPtr user_context = server_config->get("user-context"); ConstElementPtr ctrl_sock_config = server_config->get("control-socket"); - ControlSocketPtr ctrl_sock; + CfgControlSocketPtr ctrl_sock; if (ctrl_sock_config) { - ControlSocketParser parser; + ControlSocketConfigParser parser; ctrl_sock = parser.parse(ctrl_sock_config); } try { - result.reset(new Server(model, ctrl_sock)); + result.reset(new CfgServer(model, ctrl_sock)); } catch (const std::exception& ex) { - isc_throw(NetconfCfgError, ex.what() << " (" + isc_throw(ConfigError, ex.what() << " (" << server_config->getPosition() << ")"); } diff --git a/src/bin/netconf/netconf_config.h b/src/bin/netconf/netconf_config.h index 100f6a9466..43bf1c11af 100644 --- a/src/bin/netconf/netconf_config.h +++ b/src/bin/netconf/netconf_config.h @@ -35,11 +35,11 @@ namespace netconf { /// /// The parsing class hierarchy reflects this same scheme. Working top down: /// -/// A ServerMapParser handles the managed servers map invoking a ServerParser -/// to parse each server. +/// A ServerMapParser handles the managed servers map invoking a +/// ServerConfigParser to parse each server. /// -/// A ServerParser handles the scalars which belong to the server as well as -/// creating and invoking a CtrlSocketParser to parse its control socket. +/// A ServerConfigParser handles the scalars which belong to the server as well +/// as creating and invoking a CtrlSocketParser to parse its control socket. /// /// A CtrlSocketParser handles the scalars which belong to the control socket. /// @@ -63,19 +63,11 @@ namespace netconf { /// } /// @endcode -/// @brief Exception thrown when the error during configuration handling -/// occurs. -class NetconfCfgError : public isc::Exception { -public: - NetconfCfgError(const char* file, size_t line, const char* what) : - isc::Exception(file, line, what) { }; -}; - /// @brief Represents a Control Socket. /// /// Acts as a storage class containing the basic attributes which /// describe a Control Socket. -class ControlSocket : public isc::data::UserContext, +class CfgControlSocket : public isc::data::UserContext, public isc::data::CfgToElement { public: /// @brief Defines the list of possible constrol socket types. @@ -90,15 +82,15 @@ public: /// @param type The socket type. /// @param name The Unix socket name. /// @param url The HTTP server URL. - ControlSocket(Type type, const std::string& name, - const isc::http::Url& url); + CfgControlSocket(Type type, const std::string& name, + const isc::http::Url& url); /// @brief Destructor (doing nothing). - virtual ~ControlSocket(); + virtual ~CfgControlSocket(); /// @brief Getter which returns the socket type. /// - /// @return returns the socket type as a ControlSocket::Type. + /// @return returns the socket type as a CfgControlSocket::Type. Type getType() const { return (type_); } @@ -117,20 +109,20 @@ public: return (url_); } - /// @brief Converts socket type name to ControlSocket::Type. + /// @brief Converts socket type name to CfgControlSocket::Type. /// /// @param type The type name. /// Currently supported values are "unix", "http" and "stdout". /// - /// @return The ControlSocket::Type corresponding to the type name. + /// @return The CfgControlSocket::Type corresponding to the type name. /// @throw BadValue if the type name isn't recognized. static Type stringToType(const std::string& type); - /// @brief Converts ControlSocket::Type to string. + /// @brief Converts CfgControlSocket::Type to string. /// - /// @param type The ControlSocket::Type type. + /// @param type The CfgControlSocket::Type type. /// @return The type name corresponding to the enumeration element. - static const std::string typeToString(ControlSocket::Type type); + static const std::string typeToString(CfgControlSocket::Type type); /// @brief Unparse a configuration object /// @@ -148,23 +140,23 @@ private: const isc::http::Url url_; }; -/// @brief Defines a pointer for ControlSocket instances. -typedef boost::shared_ptr ControlSocketPtr; +/// @brief Defines a pointer for CfgControlSocket instances. +typedef boost::shared_ptr CfgControlSocketPtr; -/// @brief Represents a Managed Server. +/// @brief Represents a Managed CfgServer. /// /// Acts as a storage class containing the basic attributes and -/// the Control Socket which describe a Managed Server. -class Server : public isc::data::UserContext, public isc::data::CfgToElement { +/// the Control Socket which describe a Managed CfgServer. +class CfgServer : public isc::data::UserContext, public isc::data::CfgToElement { public: /// @brief Constructor. /// /// @param model The model name. /// @param ctrl_sock The control socket. - Server(const std::string& model, ControlSocketPtr ctrl_sock); + CfgServer(const std::string& model, CfgControlSocketPtr ctrl_sock); /// @brief Destructor (doing nothing). - virtual ~Server(); + virtual ~CfgServer(); /// @brief Getter which returns the model name. /// @@ -175,8 +167,8 @@ public: /// @brief Getter which returns the control socket. /// - /// @return returns the control socket as a ControlSocketPtr. - const ControlSocketPtr& getControlSocket() const { + /// @return returns the control socket as a CfgControlSocketPtr. + const CfgControlSocketPtr& getCfgControlSocket() const { return (control_socket_); } @@ -193,60 +185,60 @@ private: const std::string model_; /// @brief The control socket. - ControlSocketPtr control_socket_; + CfgControlSocketPtr control_socket_; }; -/// @brief Defines a pointer for Server instances. -typedef boost::shared_ptr ServerPtr; +/// @brief Defines a pointer for CfgServer instances. +typedef boost::shared_ptr CfgServerPtr; -/// @brief Defines a map of Servers, keyed by the name. -typedef std::map ServersMap; +/// @brief Defines a map of CfgServers, keyed by the name. +typedef std::map CfgServersMap; -/// @brief Defines a iterator pairing of name and Server -typedef std::pair ServersMapPair; +/// @brief Defines a iterator pairing of name and CfgServer +typedef std::pair CfgServersMapPair; -/// @brief Defines a pointer to map of Servers. -typedef boost::shared_ptr ServersMapPtr; +/// @brief Defines a pointer to map of CfgServers. +typedef boost::shared_ptr CfgServersMapPtr; -/// @brief Dumps the contents of a Server as text to a output stream. +/// @brief Dumps the contents of a CfgServer as text to a output stream. /// /// @param os The output stream to which text should be sent. -/// @param server The Server instance to dump. -std::ostream& operator<<(std::ostream& os, const Server& server); +/// @param server The CfgServer instance to dump. +std::ostream& operator<<(std::ostream& os, const CfgServer& server); -/// @brief Parser for ControlSocket. +/// @brief Parser for CfgControlSocket. /// /// This class parses the configuration element "control-socket" -/// and creates an instance of a ControlSocket. -class ControlSocketParser : public data::SimpleParser { +/// and creates an instance of a CfgControlSocket. +class ControlSocketConfigParser : public data::SimpleParser { public: /// @brief Performs the actual parsing of the given "control-socket" element. /// /// Parses a configuration for the elements needed to instantiate a - /// ControlSocket, validates those entries, creates a ControlSocket + /// CfgControlSocket, validates those entries, creates a CfgControlSocket /// instance. /// /// @param ctrl_sock_config is the "control-socket" configuration to parse. /// - /// @return pointer to the new ControlSocket instance. - ControlSocketPtr parse(data::ConstElementPtr ctrl_sock_config); + /// @return pointer to the new CfgControlSocket instance. + CfgControlSocketPtr parse(data::ConstElementPtr ctrl_sock_config); }; -/// @brief Parser for Server. +/// @brief Parser for CfgServer. /// /// This class parses the configuration value from the "managed-servers" map -/// and creates an instance of a Server. -class ServerParser : public data::SimpleParser { +/// and creates an instance of a CfgServer. +class ServerConfigParser : public data::SimpleParser { public: /// @brief Performs the actual parsing of the given value from /// the "managed-servers" map. /// /// Parses a configuration for the elements needed to instantiate a - /// Server, validates those entries, creates a Server instance. + /// CfgServer, validates those entries, creates a CfgServer instance. /// /// @param server_config is the value from the "managed-servers" map to parse. - /// @return pointer to the new Server instance. - ServerPtr parse(data::ConstElementPtr server_config); + /// @return pointer to the new CfgServer instance. + CfgServerPtr parse(data::ConstElementPtr server_config); }; }; // end of isc::netconf namespace diff --git a/src/bin/netconf/simple_parser.cc b/src/bin/netconf/simple_parser.cc index 8edc689658..5f5591b069 100644 --- a/src/bin/netconf/simple_parser.cc +++ b/src/bin/netconf/simple_parser.cc @@ -71,7 +71,7 @@ const SimpleDefaults NetconfSimpleParser::CA_DEFAULTS = { /// --- end of default values ------------------------------------------------- /// --------------------------------------------------------------------------- -size_t NetconfSimpleParser::setAllDefaults(const isc::data::ElementPtr& global) { +size_t NetconfSimpleParser::setAllDefaults(const ElementPtr& global) { size_t cnt = 0; // Set global defaults first. @@ -89,10 +89,10 @@ size_t NetconfSimpleParser::setAllDefaults(const isc::data::ElementPtr& global) size_t NetconfSimpleParser::setServerDefaults(const std::string name, - isc::data::ConstElementPtr server) { + ConstElementPtr server) { size_t cnt = 0; - isc::data::ElementPtr mutable_server = + ElementPtr mutable_server = boost::const_pointer_cast(server); if (name == "dhcp4") { cnt += setDefaults(mutable_server, DHCP4_DEFAULTS); @@ -104,11 +104,11 @@ NetconfSimpleParser::setServerDefaults(const std::string name, cnt += setDefaults(mutable_server, CA_DEFAULTS); } - isc::data::ConstElementPtr ctrl_sock = server->get("control-socket"); + ConstElementPtr ctrl_sock = server->get("control-socket"); if (!ctrl_sock) { return (cnt); } - isc::data::ElementPtr mutable_ctrl_sock = + ElementPtr mutable_ctrl_sock = boost::const_pointer_cast(ctrl_sock); cnt += setDefaults(mutable_ctrl_sock, CTRL_SOCK_DEFAULTS); @@ -117,7 +117,7 @@ NetconfSimpleParser::setServerDefaults(const std::string name, void NetconfSimpleParser::parse(const NetconfConfigPtr& ctx, - const isc::data::ConstElementPtr& config, + const ConstElementPtr& config, bool check_only) { // User context can be done at anytime. @@ -130,9 +130,9 @@ NetconfSimpleParser::parse(const NetconfConfigPtr& ctx, ConstElementPtr servers = config->get("managed-servers"); if (servers) { for (auto it : servers->mapValue()) { - ServerParser server_parser; - ServerPtr server = server_parser.parse(it.second); - ctx->getServersMap()->insert(make_pair(it.first, server)); + ServerConfigParser server_parser; + CfgServerPtr server = server_parser.parse(it.second); + ctx->getCfgServersMap()->insert(make_pair(it.first, server)); } } diff --git a/src/bin/netconf/tests/.gitignore b/src/bin/netconf/tests/.gitignore index 80c2d94b8a..c1442d24aa 100644 --- a/src/bin/netconf/tests/.gitignore +++ b/src/bin/netconf/tests/.gitignore @@ -1,3 +1,4 @@ /netconf_tests.sh netconf_unittests +test_data_files_config.h test_libraries.h diff --git a/src/bin/netconf/tests/get_config_unittest.cc b/src/bin/netconf/tests/get_config_unittest.cc index 8789242ff3..26a96af7b7 100644 --- a/src/bin/netconf/tests/get_config_unittest.cc +++ b/src/bin/netconf/tests/get_config_unittest.cc @@ -221,7 +221,7 @@ public: EXPECT_TRUE(executeConfiguration(config, "reset config")); } - boost::scoped_ptr srv_; ///< CA server under test + boost::scoped_ptr srv_; ///< Netconf server under test int rcode_; ///< Return code from element parsing ConstElementPtr comment_; ///< Reason for parse fail }; diff --git a/src/bin/netconf/tests/netconf_cfg_mgr_unittests.cc b/src/bin/netconf/tests/netconf_cfg_mgr_unittests.cc index ad9ac744ae..c08156245a 100644 --- a/src/bin/netconf/tests/netconf_cfg_mgr_unittests.cc +++ b/src/bin/netconf/tests/netconf_cfg_mgr_unittests.cc @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -22,6 +23,7 @@ using namespace isc::data; using namespace isc::hooks; using namespace isc::http; using namespace isc::process; +using namespace isc::yang; namespace { @@ -63,52 +65,56 @@ TEST(NetconfCfgMgr, contextServer) { // Check managed server parameters. // By default, there are no server stored. - ASSERT_TRUE(ctx.getServersMap()); - EXPECT_EQ(0, ctx.getServersMap()->size()); - - ControlSocketPtr socket1(new ControlSocket(ControlSocket::Type::UNIX, - "socket1", - Url("http://127.0.0.1:8000/"))); - ServerPtr server1(new Server("model1", socket1)); - ControlSocketPtr socket2(new ControlSocket(ControlSocket::Type::UNIX, - "socket2", - Url("http://127.0.0.1:8000/"))); - ServerPtr server2(new Server("model2", socket2)); - ControlSocketPtr socket3(new ControlSocket(ControlSocket::Type::UNIX, - "socket3", - Url("http://127.0.0.1:8000/"))); - ServerPtr server3(new Server("model3", socket3)); - ControlSocketPtr socket4(new ControlSocket(ControlSocket::Type::UNIX, - "socket4", - Url("http://127.0.0.1:8000/"))); - ServerPtr server4(new Server("model4", socket4)); + ASSERT_TRUE(ctx.getCfgServersMap()); + EXPECT_EQ(0, ctx.getCfgServersMap()->size()); + + CfgControlSocketPtr + socket1(new CfgControlSocket(CfgControlSocket::Type::UNIX, + "socket1", + Url("http://127.0.0.1:8000/"))); + CfgServerPtr server1(new CfgServer("model1", socket1)); + CfgControlSocketPtr + socket2(new CfgControlSocket(CfgControlSocket::Type::UNIX, + "socket2", + Url("http://127.0.0.1:8000/"))); + CfgServerPtr server2(new CfgServer("model2", socket2)); + CfgControlSocketPtr + socket3(new CfgControlSocket(CfgControlSocket::Type::UNIX, + "socket3", + Url("http://127.0.0.1:8000/"))); + CfgServerPtr server3(new CfgServer("model3", socket3)); + CfgControlSocketPtr + socket4(new CfgControlSocket(CfgControlSocket::Type::UNIX, + "socket4", + Url("http://127.0.0.1:8000/"))); + CfgServerPtr server4(new CfgServer("model4", socket4)); // Ok, now set the server for D2 - EXPECT_NO_THROW(ctx.getServersMap()->insert(make_pair("d2", server1))); + EXPECT_NO_THROW(ctx.getCfgServersMap()->insert(make_pair("d2", server1))); // Now check the values returned - EXPECT_EQ(1, ctx.getServersMap()->size()); - ASSERT_NO_THROW(ctx.getServersMap()->at("d2")); - EXPECT_EQ(server1, ctx.getServersMap()->at("d2")); - EXPECT_THROW(ctx.getServersMap()->at("dhcp4"), std::out_of_range); + EXPECT_EQ(1, ctx.getCfgServersMap()->size()); + ASSERT_NO_THROW(ctx.getCfgServersMap()->at("d2")); + EXPECT_EQ(server1, ctx.getCfgServersMap()->at("d2")); + EXPECT_THROW(ctx.getCfgServersMap()->at("dhcp4"), std::out_of_range); // Now set the v6 server and sanity check again - EXPECT_NO_THROW(ctx.getServersMap()->insert(make_pair("dhcp6", server2))); + EXPECT_NO_THROW(ctx.getCfgServersMap()->insert(make_pair("dhcp6", server2))); // Should be possible to retrieve two servers - EXPECT_EQ(2, ctx.getServersMap()->size()); - ASSERT_NO_THROW(ctx.getServersMap()->at("dhcp6")); - EXPECT_EQ(server1, ctx.getServersMap()->at("d2")); - EXPECT_EQ(server2, ctx.getServersMap()->at("dhcp6")); + EXPECT_EQ(2, ctx.getCfgServersMap()->size()); + ASSERT_NO_THROW(ctx.getCfgServersMap()->at("dhcp6")); + EXPECT_EQ(server1, ctx.getCfgServersMap()->at("d2")); + EXPECT_EQ(server2, ctx.getCfgServersMap()->at("dhcp6")); // Finally, set all servers. - EXPECT_NO_THROW(ctx.getServersMap()->insert(make_pair("dhcp4", server3))); - EXPECT_NO_THROW(ctx.getServersMap()->insert(make_pair("ca", server4))); - EXPECT_EQ(4, ctx.getServersMap()->size()); - ASSERT_NO_THROW(ctx.getServersMap()->at("dhcp4")); - ASSERT_NO_THROW(ctx.getServersMap()->at("ca")); - EXPECT_EQ(server3, ctx.getServersMap()->at("dhcp4")); - EXPECT_EQ(server4, ctx.getServersMap()->at("ca")); + EXPECT_NO_THROW(ctx.getCfgServersMap()->insert(make_pair("dhcp4", server3))); + EXPECT_NO_THROW(ctx.getCfgServersMap()->insert(make_pair("ca", server4))); + EXPECT_EQ(4, ctx.getCfgServersMap()->size()); + ASSERT_NO_THROW(ctx.getCfgServersMap()->at("dhcp4")); + ASSERT_NO_THROW(ctx.getCfgServersMap()->at("ca")); + EXPECT_EQ(server3, ctx.getCfgServersMap()->at("dhcp4")); + EXPECT_EQ(server4, ctx.getCfgServersMap()->at("ca")); } // Tests if the context can store and retrieve hook libs information. @@ -336,8 +342,8 @@ TEST_F(NetconfParserTest, configParseEmpty) { NetconfConfigPtr ctx = cfg_mgr_.getNetconfConfig(); ASSERT_TRUE(ctx); - ASSERT_TRUE(ctx->getServersMap()); - EXPECT_EQ(0, ctx->getServersMap()->size()); + ASSERT_TRUE(ctx->getCfgServersMap()); + EXPECT_EQ(0, ctx->getCfgServersMap()->size()); } // This test verifies if a config with only globals is handled properly. @@ -346,24 +352,24 @@ TEST_F(NetconfParserTest, configParseGlobalOnly) { NetconfConfigPtr ctx = cfg_mgr_.getNetconfConfig(); ASSERT_TRUE(ctx); - ASSERT_TRUE(ctx->getServersMap()); - EXPECT_EQ(0, ctx->getServersMap()->size()); + ASSERT_TRUE(ctx->getCfgServersMap()); + EXPECT_EQ(0, ctx->getCfgServersMap()->size()); } // Tests if an empty (i.e. without a control socket) can be configured. // Note that the syntax required the server map to not be really empty. -TEST_F(NetconfParserTest, configParseEmptyServer) { +TEST_F(NetconfParserTest, configParseEmptyCfgServer) { configParse(NETCONF_CONFIGS[8], 0); NetconfConfigPtr ctx = cfg_mgr_.getNetconfConfig(); ASSERT_TRUE(ctx); - ASSERT_TRUE(ctx->getServersMap()); - EXPECT_EQ(1, ctx->getServersMap()->size()); - ASSERT_NO_THROW(ctx->getServersMap()->at("dhcp4")); - ServerPtr server = ctx->getServersMap()->at("dhcp4"); + ASSERT_TRUE(ctx->getCfgServersMap()); + EXPECT_EQ(1, ctx->getCfgServersMap()->size()); + ASSERT_NO_THROW(ctx->getCfgServersMap()->at("dhcp4")); + CfgServerPtr server = ctx->getCfgServersMap()->at("dhcp4"); ASSERT_TRUE(server); - EXPECT_EQ("kea-dhcp4-server", server->getModel()); - ControlSocketPtr socket = server->getControlSocket(); + EXPECT_EQ(KEA_DHCP4_SERVER, server->getModel()); + CfgControlSocketPtr socket = server->getCfgControlSocket(); EXPECT_FALSE(socket); } @@ -374,17 +380,17 @@ TEST_F(NetconfParserTest, configParseDefaults) { NetconfConfigPtr ctx = cfg_mgr_.getNetconfConfig(); ASSERT_TRUE(ctx); - ASSERT_TRUE(ctx->getServersMap()); - EXPECT_EQ(1, ctx->getServersMap()->size()); - ASSERT_NO_THROW(ctx->getServersMap()->at("dhcp4")); - ServerPtr server = ctx->getServersMap()->at("dhcp4"); + ASSERT_TRUE(ctx->getCfgServersMap()); + EXPECT_EQ(1, ctx->getCfgServersMap()->size()); + ASSERT_NO_THROW(ctx->getCfgServersMap()->at("dhcp4")); + CfgServerPtr server = ctx->getCfgServersMap()->at("dhcp4"); ASSERT_TRUE(server); - EXPECT_EQ("kea-dhcp4-server", server->getModel()); - ControlSocketPtr socket = server->getControlSocket(); + EXPECT_EQ(KEA_DHCP4_SERVER, server->getModel()); + CfgControlSocketPtr socket = server->getCfgControlSocket(); ASSERT_TRUE(socket); // Checking default. - EXPECT_EQ(ControlSocket::Type::STDOUT, socket->getType()); + EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType()); EXPECT_EQ("", socket->getName()); EXPECT_EQ("http://127.0.0.1:8000/", socket->getUrl().toText()); } @@ -395,15 +401,15 @@ TEST_F(NetconfParserTest, configParseServerDhcp4) { NetconfConfigPtr ctx = cfg_mgr_.getNetconfConfig(); ASSERT_TRUE(ctx); - ASSERT_TRUE(ctx->getServersMap()); - EXPECT_EQ(1, ctx->getServersMap()->size()); - ASSERT_NO_THROW(ctx->getServersMap()->at("dhcp4")); - ServerPtr server = ctx->getServersMap()->at("dhcp4"); + ASSERT_TRUE(ctx->getCfgServersMap()); + EXPECT_EQ(1, ctx->getCfgServersMap()->size()); + ASSERT_NO_THROW(ctx->getCfgServersMap()->at("dhcp4")); + CfgServerPtr server = ctx->getCfgServersMap()->at("dhcp4"); ASSERT_TRUE(server); - EXPECT_EQ("kea-dhcp4-server", server->getModel()); - ControlSocketPtr socket = server->getControlSocket(); + EXPECT_EQ(KEA_DHCP4_SERVER, server->getModel()); + CfgControlSocketPtr socket = server->getCfgControlSocket(); ASSERT_TRUE(socket); - EXPECT_EQ(ControlSocket::Type::STDOUT, socket->getType()); + EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType()); EXPECT_EQ("/tmp/socket-v4", socket->getName()); EXPECT_EQ("http://127.0.0.1:8000/", socket->getUrl().toText()); } @@ -414,15 +420,15 @@ TEST_F(NetconfParserTest, configParseServerD2) { NetconfConfigPtr ctx = cfg_mgr_.getNetconfConfig(); ASSERT_TRUE(ctx); - ASSERT_TRUE(ctx->getServersMap()); - EXPECT_EQ(1, ctx->getServersMap()->size()); - ASSERT_NO_THROW(ctx->getServersMap()->at("d2")); - ServerPtr server = ctx->getServersMap()->at("d2"); + ASSERT_TRUE(ctx->getCfgServersMap()); + EXPECT_EQ(1, ctx->getCfgServersMap()->size()); + ASSERT_NO_THROW(ctx->getCfgServersMap()->at("d2")); + CfgServerPtr server = ctx->getCfgServersMap()->at("d2"); ASSERT_TRUE(server); - EXPECT_EQ("kea-dhcp-ddns", server->getModel()); - ControlSocketPtr socket = server->getControlSocket(); + EXPECT_EQ(KEA_DHCP_DDNS, server->getModel()); + CfgControlSocketPtr socket = server->getCfgControlSocket(); ASSERT_TRUE(socket); - EXPECT_EQ(ControlSocket::Type::STDOUT, socket->getType()); + EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType()); EXPECT_EQ("/tmp/socket-d2", socket->getName()); EXPECT_EQ("http://127.0.0.1:8000/", socket->getUrl().toText()); } @@ -433,15 +439,15 @@ TEST_F(NetconfParserTest, configParseServerDhcp6) { NetconfConfigPtr ctx = cfg_mgr_.getNetconfConfig(); ASSERT_TRUE(ctx); - ASSERT_TRUE(ctx->getServersMap()); - EXPECT_EQ(1, ctx->getServersMap()->size()); - ASSERT_NO_THROW(ctx->getServersMap()->at("dhcp6")); - ServerPtr server = ctx->getServersMap()->at("dhcp6"); + ASSERT_TRUE(ctx->getCfgServersMap()); + EXPECT_EQ(1, ctx->getCfgServersMap()->size()); + ASSERT_NO_THROW(ctx->getCfgServersMap()->at("dhcp6")); + CfgServerPtr server = ctx->getCfgServersMap()->at("dhcp6"); ASSERT_TRUE(server); - EXPECT_EQ("kea-dhcp6-server", server->getModel()); - ControlSocketPtr socket = server->getControlSocket(); + EXPECT_EQ(KEA_DHCP6_SERVER, server->getModel()); + CfgControlSocketPtr socket = server->getCfgControlSocket(); ASSERT_TRUE(socket); - EXPECT_EQ(ControlSocket::Type::STDOUT, socket->getType()); + EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType()); EXPECT_EQ("/tmp/socket-v6", socket->getName()); EXPECT_EQ("http://127.0.0.1:8000/", socket->getUrl().toText()); } @@ -453,46 +459,46 @@ TEST_F(NetconfParserTest, configParse4Servers) { NetconfConfigPtr ctx = cfg_mgr_.getNetconfConfig(); ASSERT_TRUE(ctx); - ASSERT_TRUE(ctx->getServersMap()); - EXPECT_EQ(4, ctx->getServersMap()->size()); + ASSERT_TRUE(ctx->getCfgServersMap()); + EXPECT_EQ(4, ctx->getCfgServersMap()->size()); - ASSERT_NO_THROW(ctx->getServersMap()->at("dhcp4")); - ServerPtr server = ctx->getServersMap()->at("dhcp4"); + ASSERT_NO_THROW(ctx->getCfgServersMap()->at("dhcp4")); + CfgServerPtr server = ctx->getCfgServersMap()->at("dhcp4"); ASSERT_TRUE(server); - EXPECT_EQ("kea-dhcp4-server", server->getModel()); - ControlSocketPtr socket = server->getControlSocket(); + EXPECT_EQ(KEA_DHCP4_SERVER, server->getModel()); + CfgControlSocketPtr socket = server->getCfgControlSocket(); ASSERT_TRUE(socket); - EXPECT_EQ(ControlSocket::Type::STDOUT, socket->getType()); + EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType()); EXPECT_EQ("/tmp/socket-v4", socket->getName()); EXPECT_EQ("http://127.0.0.1:8000/", socket->getUrl().toText()); - ASSERT_NO_THROW(ctx->getServersMap()->at("dhcp6")); - server = ctx->getServersMap()->at("dhcp6"); + ASSERT_NO_THROW(ctx->getCfgServersMap()->at("dhcp6")); + server = ctx->getCfgServersMap()->at("dhcp6"); ASSERT_TRUE(server); - EXPECT_EQ("kea-dhcp6-server", server->getModel()); - socket = server->getControlSocket(); + EXPECT_EQ(KEA_DHCP6_SERVER, server->getModel()); + socket = server->getCfgControlSocket(); ASSERT_TRUE(socket); - EXPECT_EQ(ControlSocket::Type::STDOUT, socket->getType()); + EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType()); EXPECT_EQ("/tmp/socket-v6", socket->getName()); EXPECT_EQ("http://127.0.0.1:8000/", socket->getUrl().toText()); - ASSERT_NO_THROW(ctx->getServersMap()->at("d2")); - server = ctx->getServersMap()->at("d2"); + ASSERT_NO_THROW(ctx->getCfgServersMap()->at("d2")); + server = ctx->getCfgServersMap()->at("d2"); ASSERT_TRUE(server); - EXPECT_EQ("kea-dhcp-ddns", server->getModel()); - socket = server->getControlSocket(); + EXPECT_EQ(KEA_DHCP_DDNS, server->getModel()); + socket = server->getCfgControlSocket(); ASSERT_TRUE(socket); - EXPECT_EQ(ControlSocket::Type::STDOUT, socket->getType()); + EXPECT_EQ(CfgControlSocket::Type::STDOUT, socket->getType()); EXPECT_EQ("/tmp/socket-d2", socket->getName()); EXPECT_EQ("http://127.0.0.1:8000/", socket->getUrl().toText()); - ASSERT_NO_THROW(ctx->getServersMap()->at("ca")); - server = ctx->getServersMap()->at("ca"); + ASSERT_NO_THROW(ctx->getCfgServersMap()->at("ca")); + server = ctx->getCfgServersMap()->at("ca"); ASSERT_TRUE(server); - EXPECT_EQ("kea-ctrl-agent", server->getModel()); - socket = server->getControlSocket(); + EXPECT_EQ(KEA_CTRL_AGENT, server->getModel()); + socket = server->getCfgControlSocket(); ASSERT_TRUE(socket); - EXPECT_EQ(ControlSocket::Type::STDOUT, socket->getType()); + 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()); } @@ -540,9 +546,9 @@ TEST_F(NetconfParserTest, comments) { EXPECT_EQ("\"Indirect comment\"", ctx->get("comment")->str()); // There is a DHCP4 server. - ASSERT_TRUE(netconf_ctx->getServersMap()); - ASSERT_NO_THROW(netconf_ctx->getServersMap()->at("dhcp4")); - ServerPtr server = netconf_ctx->getServersMap()->at("dhcp4"); + ASSERT_TRUE(netconf_ctx->getCfgServersMap()); + ASSERT_NO_THROW(netconf_ctx->getCfgServersMap()->at("dhcp4")); + CfgServerPtr server = netconf_ctx->getCfgServersMap()->at("dhcp4"); ASSERT_TRUE(server); // Check DHCP4 server user context. @@ -553,12 +559,12 @@ TEST_F(NetconfParserTest, comments) { EXPECT_EQ("\"dhcp4 server\"", ctx4->get("comment")->str()); // There is a DHCP6 server. - ASSERT_NO_THROW(netconf_ctx->getServersMap()->at("dhcp6")); - server = netconf_ctx->getServersMap()->at("dhcp6"); + ASSERT_NO_THROW(netconf_ctx->getCfgServersMap()->at("dhcp6")); + server = netconf_ctx->getCfgServersMap()->at("dhcp6"); ASSERT_TRUE(server); // There is a DHCP6 control socket. - ControlSocketPtr socket = server->getControlSocket(); + CfgControlSocketPtr socket = server->getCfgControlSocket(); ASSERT_TRUE(socket); // Check DHCP6 control socket user context. diff --git a/src/bin/netconf/tests/netconf_controller_unittests.cc b/src/bin/netconf/tests/netconf_controller_unittests.cc index 5fe294a0f2..12c80a2e52 100644 --- a/src/bin/netconf/tests/netconf_controller_unittests.cc +++ b/src/bin/netconf/tests/netconf_controller_unittests.cc @@ -34,7 +34,7 @@ const char* valid_netconf_config = " \"dhcp6\": {" " \"control-socket\": {" " \"socket-type\": \"unix\"," - " \"socket-name\": \"/first/dhcp4/socket\"" + " \"socket-name\": \"/first/dhcp6/socket\"" " }" " }" " }" @@ -153,7 +153,7 @@ TEST_F(NetconfControllerTest, launchNormalShutdown) { // Tests that the SIGINT triggers a normal shutdown. TEST_F(NetconfControllerTest, sigintShutdown) { - // Setup to raise SIGHUP in 1 ms. + // Setup to raise SIGINT in 1 ms. TimedSignal sighup(*getIOService(), SIGINT, 1); // Write valid_netconf_config and then run launch() for a maximum @@ -169,7 +169,7 @@ TEST_F(NetconfControllerTest, sigintShutdown) { // Tests that the SIGTERM triggers a normal shutdown. TEST_F(NetconfControllerTest, sigtermShutdown) { - // Setup to raise SIGHUP in 1 ms. + // Setup to raise SIGTERM in 1 ms. TimedSignal sighup(*getIOService(), SIGTERM, 1); // Write valid_netconf_config and then run launch() for a maximum -- 2.47.2