rename DataDefinition[Error] to ModuleSpec[Error]

git-svn-id: svn://bind10.isc.org/svn/bind10/branches/jelte-configuration@868 e5f2f494-b856-4b98-b285-d166d9295462

src/lib/config/cpp/ccsession.cc

@@ -45,9 +45,9 @@ using namespace std;
 
 using isc::data::Element;
 using isc::data::ElementPtr;
-using isc::data::DataDefinition;
+using isc::data::ModuleSpec;
 using isc::data::ParseError;
-using isc::data::DataDefinitionError;
+using isc::data::ModuleSpecError;
 
 void
 CommandSession::read_data_definition(const std::string& filename) {
@@ -61,11 +61,11 @@ CommandSession::read_data_definition(const std::string& filename) {
     }
 
     try {
-        data_definition_ = DataDefinition(file, true);
+        data_definition_ = ModuleSpec(file, true);
     } catch (ParseError pe) {
         cout << "Error parsing definition file: " << pe.what() << endl;
         exit(1);
-    } catch (DataDefinitionError dde) {
+    } catch (ModuleSpecError dde) {
         cout << "Error reading definition file: " << dde.what() << endl;
         exit(1);
     }

src/lib/config/cpp/ccsession.h

@@ -75,7 +75,7 @@ private:
     
     std::string module_name_;
     isc::cc::Session session_;
-    isc::data::DataDefinition data_definition_;
+    isc::data::ModuleSpec data_definition_;
     isc::data::ElementPtr config_;
 
     isc::data::ElementPtr(*config_handler_)(isc::data::ElementPtr new_config);

src/lib/config/cpp/data_def.cc

@@ -1,3 +1,17 @@
+// Copyright (C) 2010  Internet Systems Consortium.
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SYSTEMS CONSORTIUM
+// DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+// INTERNET SYSTEMS CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+// FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+// NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+// WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 #include "data_def.h"
 
@@ -8,7 +22,7 @@
 
 #include <boost/foreach.hpp>
 
-// todo: add more context to thrown DataDefinitionErrors?
+// todo: add more context to thrown ModuleSpecErrors?
 
 using namespace isc::data;
 
@@ -51,7 +65,7 @@ getType_value(const std::string& type_name) {
     } else if (type_name == "any") {
         return Element::any;
     } else {
-        throw DataDefinitionError(type_name + " is not a valid type name");
+        throw ModuleSpecError(type_name + " is not a valid type name");
     }
 }
 
@@ -62,13 +76,13 @@ check_leaf_item(const ElementPtr& spec, const std::string& name, Element::types
         if (spec->get(name)->getType() == type) {
             return;
         } else {
-            throw DataDefinitionError(name + " not of type " + getType_string(type));
+            throw ModuleSpecError(name + " not of type " + getType_string(type));
         }
     } else if (mandatory) {
         // todo: want parent item name, and perhaps some info about location
         // in list? or just catch and throw new...
         // or make this part non-throwing and check return value...
-        throw DataDefinitionError(name + " missing in " + spec->str());
+        throw ModuleSpecError(name + " missing in " + spec->str());
     }
 }
 
@@ -99,7 +113,7 @@ check_config_item(const ElementPtr& spec) {
 static void
 check_config_item_list(const ElementPtr& spec) {
     if (spec->getType() != Element::list) {
-        throw DataDefinitionError("config_data is not a list of elements");
+        throw ModuleSpecError("config_data is not a list of elements");
     }
     BOOST_FOREACH(ElementPtr item, spec->listValue()) {
         check_config_item(item);
@@ -116,7 +130,7 @@ check_command(const ElementPtr& spec) {
 static void
 check_command_list(const ElementPtr& spec) {
     if (spec->getType() != Element::list) {
-        throw DataDefinitionError("commands is not a list of elements");
+        throw ModuleSpecError("commands is not a list of elements");
     }
     BOOST_FOREACH(ElementPtr item, spec->listValue()) {
         check_command(item);
@@ -137,27 +151,27 @@ check_data_specification(const ElementPtr& spec) {
 }
 
 // checks whether the given element is a valid data definition
-// throws a DataDefinitionError if the specification is bad
+// throws a ModuleSpecError if the specification is bad
 static void
 check_definition(const ElementPtr& def)
 {
     if (!def->contains("module_spec")) {
-        throw DataDefinitionError("Data specification does not contain module_spec element");
+        throw ModuleSpecError("Data specification does not contain module_spec element");
     } else {
         check_data_specification(def->get("module_spec"));
     }
 }
 
-DataDefinition::DataDefinition(const std::string& file_name,
+ModuleSpec::ModuleSpec(const std::string& file_name,
                                const bool check)
-                               throw(ParseError, DataDefinitionError) {
+                               throw(ParseError, ModuleSpecError) {
     std::ifstream file;
 
     file.open(file_name.c_str());
     if (!file) {
         std::stringstream errs;
         errs << "Error opening " << file_name << ": " << strerror(errno);
-        throw DataDefinitionError(errs.str());
+        throw ModuleSpecError(errs.str());
     }
 
     definition = Element::createFromString(file, file_name);
@@ -166,8 +180,8 @@ DataDefinition::DataDefinition(const std::string& file_name,
     }
 }
 
-DataDefinition::DataDefinition(std::istream& in, const bool check)
-                               throw(ParseError, DataDefinitionError) {
+ModuleSpec::ModuleSpec(std::istream& in, const bool check)
+                               throw(ParseError, ModuleSpecError) {
     definition = Element::createFromString(in);
     // make sure the whole structure is complete and valid
     if (check) {
@@ -210,7 +224,7 @@ check_type(ElementPtr spec, ElementPtr element)
 }
 
 bool
-DataDefinition::validate_item(const ElementPtr spec, const ElementPtr data) {
+ModuleSpec::validate_item(const ElementPtr spec, const ElementPtr data) {
     if (!check_type(spec, data)) {
         // we should do some proper error feedback here
         // std::cout << "type mismatch; not " << spec->get("item_type") << ": " << data << std::endl;
@@ -240,7 +254,7 @@ DataDefinition::validate_item(const ElementPtr spec, const ElementPtr data) {
 
 // spec is a map with item_name etc, data is a map
 bool
-DataDefinition::validate_spec(const ElementPtr spec, const ElementPtr data) {
+ModuleSpec::validate_spec(const ElementPtr spec, const ElementPtr data) {
     std::string item_name = spec->get("item_name")->stringValue();
     bool optional = spec->get("item_optional")->boolValue();
     ElementPtr data_el;
@@ -260,7 +274,7 @@ DataDefinition::validate_spec(const ElementPtr spec, const ElementPtr data) {
 
 // spec is a list of maps, data is a map
 bool
-DataDefinition::validate_spec_list(const ElementPtr spec, const ElementPtr data) {
+ModuleSpec::validate_spec_list(const ElementPtr spec, const ElementPtr data) {
     ElementPtr cur_data_el;
     std::string cur_item_name;
     BOOST_FOREACH(ElementPtr cur_spec_el, spec->listValue()) {
@@ -275,7 +289,7 @@ DataDefinition::validate_spec_list(const ElementPtr spec, const ElementPtr data)
 // this function does *not* check if the specification is in correct
 // form, we should do that in the constructor
 bool
-DataDefinition::validate(const ElementPtr data) {
+ModuleSpec::validate(const ElementPtr data) {
     ElementPtr spec = definition->find("module_spec/config_data");
     return validate_spec_list(spec, data);
 }

src/lib/config/cpp/data_def.h

@@ -1,5 +1,20 @@
-#ifndef _DATA_DEF_H
-#define _DATA_DEF_H 1
+// Copyright (C) 2010  Internet Systems Consortium.
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SYSTEMS CONSORTIUM
+// DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+// INTERNET SYSTEMS CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+// FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+// NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+// WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef _MODULE_SPEC_H
+#define _MODULE_SPEC_H 1
 
 #include <cc/data.h>
 
@@ -8,22 +23,22 @@
 namespace isc { namespace data {
 
     ///
-    /// A standard DataDefinition exception that is thrown when a
+    /// A standard ModuleSpec exception that is thrown when a
     /// specification is not in the correct form.
     ///
     /// TODO: use jinmei's exception class as a base and not c_str in
     /// what() there
-    class DataDefinitionError : public std::exception {
+    class ModuleSpecError : public std::exception {
     public:
-        DataDefinitionError(std::string m = "Data definition is invalid") : msg(m) {}
-        ~DataDefinitionError() throw() {}
+        ModuleSpecError(std::string m = "Data definition is invalid") : msg(m) {}
+        ~ModuleSpecError() throw() {}
         const char* what() const throw() { return msg.c_str(); }
     private:
         std::string msg;
     };
 
     ///
-    /// The \c DataDefinition class holds a data specification.
+    /// The \c ModuleSpec class holds a data specification.
     /// Each module should have a .spec file containing the specification
     /// for configuration and commands for that module.
     /// This class holds that specification, and provides a function to
@@ -32,36 +47,36 @@ namespace isc { namespace data {
     ///
     /// The form of the specification is described in doc/ (TODO)
     ///
-    class DataDefinition {
+    class ModuleSpec {
     public:
-        explicit DataDefinition() {};
-        /// Create a \c DataDefinition instance with the given data as
+        explicit ModuleSpec() {};
+        /// Create a \c ModuleSpec instance with the given data as
         /// the specification
         /// \param e The Element containing the data specification
-        explicit DataDefinition(ElementPtr e) : definition(e) {};
+        explicit ModuleSpec(ElementPtr e) : definition(e) {};
 
-        /// Creates a \c DataDefinition instance from the contents
+        /// Creates a \c ModuleSpec instance from the contents
         /// of the file given by file_name.
         /// If check is true, and the definition is not of the correct
-        /// form, a DataDefinitionError is thrown. If the file could
+        /// form, a ModuleSpecError is thrown. If the file could
         /// not be parse, a ParseError is thrown.
         /// \param file_name The file to be opened and parsed
         /// \param check If true, the data definition in the file is
         /// checked to be of the correct form
-        DataDefinition(const std::string& file_name, const bool check = true)
-                       throw(ParseError, DataDefinitionError);
+        ModuleSpec(const std::string& file_name, const bool check = true)
+                       throw(ParseError, ModuleSpecError);
 
         // todo: make check default false, or leave out option completely and always check?
-        /// Creates a \c DataDefinition instance from the given input
+        /// Creates a \c ModuleSpec instance from the given input
         /// stream that contains the contents of a .spec file.
         /// If check is true, and the definition is not of
-        /// the correct form, a DataDefinitionError is thrown. If the
+        /// the correct form, a ModuleSpecError is thrown. If the
         /// file could not be parsed, a ParseError is thrown.
         /// \param in The std::istream containing the .spec file data
         /// \param check If true, the data definition is checked to be
         /// of the correct form
-        explicit DataDefinition(std::istream& in, const bool check = true)
-                                throw(ParseError, DataDefinitionError);
+        explicit ModuleSpec(std::istream& in, const bool check = true)
+                                throw(ParseError, ModuleSpecError);
 
         /// Returns the base \c element of the data definition contained
         /// by this instance

src/lib/config/cpp/data_def_unittests.cc

@@ -34,23 +34,23 @@ data_def_error(const std::string& file,
                const std::string& error2 = "",
                const std::string& error3 = "")
 {
-    EXPECT_THROW(DataDefinition(specfile(file)), DataDefinitionError);
+    EXPECT_THROW(ModuleSpec(specfile(file)), ModuleSpecError);
     try {
-        DataDefinition dd = DataDefinition(specfile(file));
-    } catch (DataDefinitionError dde) {
+        ModuleSpec dd = ModuleSpec(specfile(file));
+    } catch (ModuleSpecError dde) {
         std::string ddew = dde.what();
         EXPECT_EQ(error1 + error2 + error3, ddew);
     }
 }
 
-TEST(DataDefinition, ReadingSpecfiles) {
+TEST(ModuleSpec, ReadingSpecfiles) {
     // Tests whether we can open specfiles and if we get the
     // right parse errors
-    DataDefinition dd = DataDefinition(specfile("spec1.spec"));
+    ModuleSpec dd = ModuleSpec(specfile("spec1.spec"));
     EXPECT_EQ(dd.getDefinition()->get("module_spec")
                                 ->get("module_name")
                                 ->stringValue(), "Spec1");
-    dd = DataDefinition(specfile("spec2.spec"));
+    dd = ModuleSpec(specfile("spec2.spec"));
     EXPECT_EQ(dd.getDefinition()->get("module_spec")
                                 ->get("config_data")->size(), 6);
     data_def_error("doesnotexist",
@@ -60,13 +60,13 @@ TEST(DataDefinition, ReadingSpecfiles) {
 
     std::ifstream file;
     file.open(specfile("spec1.spec").c_str());
-    dd = DataDefinition(file);
+    dd = ModuleSpec(file);
     EXPECT_EQ(dd.getDefinition()->get("module_spec")
                                 ->get("module_name")
                                 ->stringValue(), "Spec1");
 }
 
-TEST(DataDefinition, SpecfileItems) {
+TEST(ModuleSpec, SpecfileItems) {
     data_def_error("spec3.spec",
                    "item_name missing in {\"item_default\": 1, \"item_optional\": False, \"item_type\": \"integer\"}");
     data_def_error("spec4.spec",
@@ -91,7 +91,7 @@ TEST(DataDefinition, SpecfileItems) {
                    "badname is not a valid type name");
 }
 
-TEST(DataDefinition, SpecfileConfigData)
+TEST(ModuleSpec, SpecfileConfigData)
 {
     data_def_error("spec7.spec",
                    "module_name missing in {}");
@@ -103,7 +103,7 @@ TEST(DataDefinition, SpecfileConfigData)
                    "commands is not a list of elements");
 }
 
-TEST(DataDefinition, SpecfileCommands)
+TEST(ModuleSpec, SpecfileCommands)
 {
     data_def_error("spec17.spec",
                    "command_name missing in {\"command_args\": [ {\"item_default\": \"\", \"item_name\": \"message\", \"item_optional\": False, \"item_type\": \"string\"} ], \"command_description\": \"Print the given message to stdout\"}");
@@ -120,7 +120,7 @@ TEST(DataDefinition, SpecfileCommands)
 }
 
 bool
-data_test(DataDefinition dd, const std::string& data_file_name)
+data_test(ModuleSpec dd, const std::string& data_file_name)
 {
     std::ifstream data_file;
 
@@ -131,8 +131,8 @@ data_test(DataDefinition dd, const std::string& data_file_name)
     return dd.validate(data);
 }
 
-TEST(DataDefinition, DataValidation) {
-    DataDefinition dd = DataDefinition(specfile("spec22.spec"));
+TEST(ModuleSpec, DataValidation) {
+    ModuleSpec dd = ModuleSpec(specfile("spec22.spec"));
 
     EXPECT_TRUE(data_test(dd, "data22_1.data"));
     EXPECT_FALSE(data_test(dd, "data22_2.data"));

src/lib/config/python/isc/config/module_spec.py

@@ -57,7 +57,7 @@ class ModuleSpec:
         """Initializes a ModuleSpec object from the specification in
            the given module_spec (which must be a dict). If check is
            True, the contents are verified. Raises a ModuleSpec error
-           if there is something wrong with the contents of the dict""".
+           if there is something wrong with the contents of the dict"""
         if type(module_spec) != dict:
             raise ModuleSpecError("module_spec is of type " + str(type(module_spec)) + ", not dict")
         if check: