Merge branch 'master' into trac1114

ChangeLog

@@ -1,10 +1,3 @@
-279.    [func]          naokikambe
-	Statistics items are specified by each module's spec file.
-	Stats module can read these through the config manager. Stats
-	module and stats httpd report statistics data and statistics
-	schema by each module via both bindctl and HTTP/XML.
-	(Trac #928,#929,#930, git f20be125d667bceea0d940fc5fabf87b2eef86cd)
-
 278.	[doc]		jelte
 	Add logging configuration documentation to the guide.
 	(Trac #1011, git TODO)

configure.ac

@@ -801,6 +801,13 @@ AC_CONFIG_FILES([Makefile
                  src/bin/zonemgr/tests/Makefile
                  src/bin/stats/Makefile
                  src/bin/stats/tests/Makefile
+                 src/bin/stats/tests/isc/Makefile
+                 src/bin/stats/tests/isc/cc/Makefile
+                 src/bin/stats/tests/isc/config/Makefile
+                 src/bin/stats/tests/isc/util/Makefile
+                 src/bin/stats/tests/isc/log/Makefile
+                 src/bin/stats/tests/testdata/Makefile
+                 src/bin/stats/tests/http/Makefile
                  src/bin/usermgr/Makefile
                  src/bin/tests/Makefile
                  src/lib/Makefile

doc/guide/bind10-guide.html

@@ -664,30 +664,24 @@ This may be a temporary setting until then.
 
     </p><p>
 
-       This stats daemon provides commands to identify if it is
-       running, show specified or all statistics data, show specified
-       or all statistics data schema, and set specified statistics
-       data.
+       This stats daemon provides commands to identify if it is running,
+       show specified or all statistics data, set values, remove data,
+       and reset data.
 
        For example, using <span class="command"><strong>bindctl</strong></span>:
 
        </p><pre class="screen">
 &gt; <strong class="userinput"><code>Stats show</code></strong>
 {
-    "Auth": {
-        "queries.tcp": 1749,
-        "queries.udp": 867868
-    },
-    "Boss": {
-        "boot_time": "2011-01-20T16:59:03Z"
-    },
-    "Stats": {
-        "boot_time": "2011-01-20T16:59:05Z",
-        "last_update_time": "2011-01-20T17:04:05Z",
-        "lname": "4d3869d9_a@jreed.example.net",
-        "report_time": "2011-01-20T17:04:06Z",
-        "timestamp": 1295543046.823504
-    }
+    "auth.queries.tcp": 1749,
+    "auth.queries.udp": 867868,
+    "bind10.boot_time": "2011-01-20T16:59:03Z",
+    "report_time": "2011-01-20T17:04:06Z",
+    "stats.boot_time": "2011-01-20T16:59:05Z",
+    "stats.last_update_time": "2011-01-20T17:04:05Z",
+    "stats.lname": "4d3869d9_a@jreed.example.net",
+    "stats.start_time": "2011-01-20T16:59:05Z",
+    "stats.timestamp": 1295543046.823504
 }
        </pre><p>
     </p></div><div class="chapter" title="Chapter 14. Logging"><div class="titlepage"><div><div><h2 class="title"><a name="logging"></a>Chapter 14. Logging</h2></div></div></div><p>

doc/guide/bind10-guide.xml

@@ -1453,30 +1453,24 @@ then change those defaults with config set Resolver/forward_addresses[0]/address
 
     <para>
 
-       This stats daemon provides commands to identify if it is
-       running, show specified or all statistics data, show specified
-       or all statistics data schema, and set specified statistics
-       data.
+       This stats daemon provides commands to identify if it is running,
+       show specified or all statistics data, set values, remove data,
+       and reset data.
 
        For example, using <command>bindctl</command>:
 
        <screen>
 &gt; <userinput>Stats show</userinput>
 {
-    "Auth": {
-        "queries.tcp": 1749,
-        "queries.udp": 867868
-    },
-    "Boss": {
-        "boot_time": "2011-01-20T16:59:03Z"
-    },
-    "Stats": {
-        "boot_time": "2011-01-20T16:59:05Z",
-        "last_update_time": "2011-01-20T17:04:05Z",
-        "lname": "4d3869d9_a@jreed.example.net",
-        "report_time": "2011-01-20T17:04:06Z",
-        "timestamp": 1295543046.823504
-    }
+    "auth.queries.tcp": 1749,
+    "auth.queries.udp": 867868,
+    "bind10.boot_time": "2011-01-20T16:59:03Z",
+    "report_time": "2011-01-20T17:04:06Z",
+    "stats.boot_time": "2011-01-20T16:59:05Z",
+    "stats.last_update_time": "2011-01-20T17:04:05Z",
+    "stats.lname": "4d3869d9_a@jreed.example.net",
+    "stats.start_time": "2011-01-20T16:59:05Z",
+    "stats.timestamp": 1295543046.823504
 }
        </screen>
     </para>

src/bin/auth/auth_messages.mes

@@ -257,7 +257,4 @@ request. The zone manager component has been informed of the request,
 but has returned an error response (which is included in the message). The
 NOTIFY request will not be honored.
 
-% AUTH_INVALID_STATISTICS_DATA invalid specification of statistics data specified
-An error was encountered when the authoritiative server specified
-statistics data which is invalid for the auth specification file.
 

src/bin/auth/auth_srv.cc

@@ -125,10 +125,6 @@ public:
 
     /// The TSIG keyring
     const shared_ptr<TSIGKeyRing>* keyring_;
-
-    /// Bind the ModuleSpec object in config_session_ with
-    /// isc:config::ModuleSpec::validateStatistics.
-    void registerStatisticsValidator();
 private:
     std::string db_file_;
 
@@ -143,9 +139,6 @@ private:
 
     /// Increment query counter
     void incCounter(const int protocol);
-
-    // validateStatistics
-    bool validateStatistics(isc::data::ConstElementPtr data) const;
 };
 
 AuthSrvImpl::AuthSrvImpl(const bool use_cache,
@@ -324,7 +317,6 @@ AuthSrv::setXfrinSession(AbstractSession* xfrin_session) {
 void
 AuthSrv::setConfigSession(ModuleCCSession* config_session) {
     impl_->config_session_ = config_session;
-    impl_->registerStatisticsValidator();
 }
 
 void
@@ -678,22 +670,6 @@ AuthSrvImpl::incCounter(const int protocol) {
     }
 }
 
-void
-AuthSrvImpl::registerStatisticsValidator() {
-    counters_.registerStatisticsValidator(
-        boost::bind(&AuthSrvImpl::validateStatistics, this, _1));
-}
-
-bool
-AuthSrvImpl::validateStatistics(isc::data::ConstElementPtr data) const {
-    if (config_session_ == NULL) {
-        return (false);
-    }
-    return (
-        config_session_->getModuleSpec().validateStatistics(
-            data, true));
-}
-
 ConstElementPtr
 AuthSrvImpl::setDbFile(ConstElementPtr config) {
     ConstElementPtr answer = isc::config::createAnswer();

src/bin/auth/statistics.cc

@@ -37,14 +37,11 @@ public:
     void inc(const AuthCounters::CounterType type);
     bool submitStatistics() const;
     void setStatisticsSession(isc::cc::AbstractSession* statistics_session);
-    void registerStatisticsValidator
-    (AuthCounters::validator_type validator);
     // Currently for testing purpose only
     uint64_t getCounter(const AuthCounters::CounterType type) const;
 private:
     std::vector<uint64_t> counters_;
     isc::cc::AbstractSession* statistics_session_;
-    AuthCounters::validator_type validator_;
 };
 
 AuthCountersImpl::AuthCountersImpl() :
@@ -70,25 +67,16 @@ AuthCountersImpl::submitStatistics() const {
     }
     std::stringstream statistics_string;
     statistics_string << "{\"command\": [\"set\","
-                      <<   "{ \"owner\": \"Auth\","
-                      <<   "  \"data\":"
-                      <<     "{ \"queries.udp\": "
+                      <<   "{ \"stats_data\": "
+                      <<     "{ \"auth.queries.udp\": "
                       <<     counters_.at(AuthCounters::COUNTER_UDP_QUERY)
-                      <<     ", \"queries.tcp\": "
+                      <<     ", \"auth.queries.tcp\": "
                       <<     counters_.at(AuthCounters::COUNTER_TCP_QUERY)
                       <<   " }"
                       <<   "}"
                       << "]}";
     isc::data::ConstElementPtr statistics_element =
         isc::data::Element::fromJSON(statistics_string);
-    // validate the statistics data before send
-    if (validator_) {
-        if (!validator_(
-                statistics_element->get("command")->get(1)->get("data"))) {
-            LOG_ERROR(auth_logger, AUTH_INVALID_STATISTICS_DATA);
-            return (false);
-        }
-    }
     try {
         // group_{send,recv}msg() can throw an exception when encountering
         // an error, and group_recvmsg() will throw an exception on timeout.
@@ -117,13 +105,6 @@ AuthCountersImpl::setStatisticsSession
     statistics_session_ = statistics_session;
 }
 
-void
-AuthCountersImpl::registerStatisticsValidator
-    (AuthCounters::validator_type validator)
-{
-    validator_ = validator;
-}
-
 // Currently for testing purpose only
 uint64_t
 AuthCountersImpl::getCounter(const AuthCounters::CounterType type) const {
@@ -158,10 +139,3 @@ uint64_t
 AuthCounters::getCounter(const AuthCounters::CounterType type) const {
     return (impl_->getCounter(type));
 }
-
-void
-AuthCounters::registerStatisticsValidator
-    (AuthCounters::validator_type validator) const
-{
-    return (impl_->registerStatisticsValidator(validator));
-}

src/bin/auth/statistics.h

@@ -131,26 +131,6 @@ public:
     /// \return the value of the counter specified by \a type.
     ///
     uint64_t getCounter(const AuthCounters::CounterType type) const;
-
-    /// \brief A type of validation function for the specification in
-    /// isc::config::ModuleSpec.
-    ///
-    /// This type might be useful for not only statistics
-    /// specificatoin but also for config_data specification and for
-    /// commnad.
-    ///
-    typedef boost::function<bool(const isc::data::ConstElementPtr&)>
-    validator_type;
-
-    /// \brief Register a function type of the statistics validation
-    /// function for AuthCounters.
-    ///
-    /// This method never throws an exception.
-    ///
-    /// \param validator A function type of the validation of
-    /// statistics specification.
-    ///
-    void registerStatisticsValidator(AuthCounters::validator_type validator) const;
 };
 
 #endif // __STATISTICS_H

src/bin/auth/tests/statistics_unittest.cc

@@ -16,8 +16,6 @@
 
 #include <gtest/gtest.h>
 
-#include <boost/bind.hpp>
-
 #include <cc/data.h>
 #include <cc/session.h>
 
@@ -78,13 +76,6 @@ protected:
     }
     MockSession statistics_session_;
     AuthCounters counters;
-    // no need to be inherited from the original class here.
-    class MockModuleSpec {
-    public:
-        bool validateStatistics(ConstElementPtr, const bool valid) const
-            { return (valid); }
-    };
-    MockModuleSpec module_spec_;
 };
 
 void
@@ -190,7 +181,7 @@ TEST_F(AuthCountersTest, submitStatisticsWithException) {
     statistics_session_.setThrowSessionTimeout(false);
 }
 
-TEST_F(AuthCountersTest, submitStatisticsWithoutValidator) {
+TEST_F(AuthCountersTest, submitStatistics) {
     // Submit statistics data.
     // Validate if it submits correct data.
 
@@ -210,69 +201,12 @@ TEST_F(AuthCountersTest, submitStatisticsWithoutValidator) {
     // Command is "set".
     EXPECT_EQ("set", statistics_session_.sent_msg->get("command")
                          ->get(0)->stringValue());
-    EXPECT_EQ("Auth", statistics_session_.sent_msg->get("command")
-                         ->get(1)->get("owner")->stringValue());
     ConstElementPtr statistics_data = statistics_session_.sent_msg
                                           ->get("command")->get(1)
-                                          ->get("data");
+                                          ->get("stats_data");
     // UDP query counter is 2 and TCP query counter is 1.
-    EXPECT_EQ(2, statistics_data->get("queries.udp")->intValue());
-    EXPECT_EQ(1, statistics_data->get("queries.tcp")->intValue());
+    EXPECT_EQ(2, statistics_data->get("auth.queries.udp")->intValue());
+    EXPECT_EQ(1, statistics_data->get("auth.queries.tcp")->intValue());
 }
 
-TEST_F(AuthCountersTest, submitStatisticsWithValidator) {
-
-    //a validator for the unittest
-    AuthCounters::validator_type validator;
-    ConstElementPtr el;
-
-    // Submit statistics data with correct statistics validator.
-    validator = boost::bind(
-        &AuthCountersTest::MockModuleSpec::validateStatistics,
-        &module_spec_, _1, true);
-
-    EXPECT_TRUE(validator(el));
-
-    // register validator to AuthCounters
-    counters.registerStatisticsValidator(validator);
-
-    // Counters should be initialized to 0.
-    EXPECT_EQ(0, counters.getCounter(AuthCounters::COUNTER_UDP_QUERY));
-    EXPECT_EQ(0, counters.getCounter(AuthCounters::COUNTER_TCP_QUERY));
-
-    // UDP query counter is set to 2.
-    counters.inc(AuthCounters::COUNTER_UDP_QUERY);
-    counters.inc(AuthCounters::COUNTER_UDP_QUERY);
-    // TCP query counter is set to 1.
-    counters.inc(AuthCounters::COUNTER_TCP_QUERY);
-
-    // checks the value returned by submitStatistics
-    EXPECT_TRUE(counters.submitStatistics());
-
-    // Destination is "Stats".
-    EXPECT_EQ("Stats", statistics_session_.msg_destination);
-    // Command is "set".
-    EXPECT_EQ("set", statistics_session_.sent_msg->get("command")
-                         ->get(0)->stringValue());
-    EXPECT_EQ("Auth", statistics_session_.sent_msg->get("command")
-                         ->get(1)->get("owner")->stringValue());
-    ConstElementPtr statistics_data = statistics_session_.sent_msg
-                                          ->get("command")->get(1)
-                                          ->get("data");
-    // UDP query counter is 2 and TCP query counter is 1.
-    EXPECT_EQ(2, statistics_data->get("queries.udp")->intValue());
-    EXPECT_EQ(1, statistics_data->get("queries.tcp")->intValue());
-
-    // Submit statistics data with incorrect statistics validator.
-    validator = boost::bind(
-        &AuthCountersTest::MockModuleSpec::validateStatistics,
-        &module_spec_, _1, false);
-
-    EXPECT_FALSE(validator(el));
-
-    counters.registerStatisticsValidator(validator);
-
-    // checks the value returned by submitStatistics
-    EXPECT_FALSE(counters.submitStatistics());
-}
 }

src/bin/bind10/bind10_messages.mes

@@ -198,7 +198,3 @@ the message channel.
 % BIND10_UNKNOWN_CHILD_PROCESS_ENDED unknown child pid %1 exited
 An unknown child process has exited. The PID is printed, but no further
 action will be taken by the boss process.
-
-% BIND10_INVALID_STATISTICS_DATA invalid specification of statistics data specified
-An error was encountered when the boss module specified
-statistics data which is invalid for the boss specification file.

src/bin/bind10/bind10_src.py.in

@@ -85,7 +85,7 @@ isc.util.process.rename(sys.argv[0])
 # number, and the overall BIND 10 version number (set in configure.ac).
 VERSION = "bind10 20110223 (BIND 10 @PACKAGE_VERSION@)"
 
-# This is for boot_time of Boss
+# This is for bind10.boottime of stats module
 _BASETIME = time.gmtime()
 
 class RestartSchedule:
@@ -318,22 +318,13 @@ class BoB:
                 answer = isc.config.ccsession.create_answer(0)
             elif command == "sendstats":
                 # send statistics data to the stats daemon immediately
-                statistics_data = {
-                    'boot_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', _BASETIME)
-                    }
-                valid = self.ccs.get_module_spec().validate_statistics(
-                    True, statistics_data)
-                if valid:
-                    cmd = isc.config.ccsession.create_command(
-                    'set', { "owner": "Boss",
-                             "data": statistics_data })
-                    seq = self.cc_session.group_sendmsg(cmd, 'Stats')
-                    self.cc_session.group_recvmsg(True, seq)
-                    answer = isc.config.ccsession.create_answer(0)
-                else:
-                    logger.fatal(BIND10_INVALID_STATISTICS_DATA);
-                    answer = isc.config.ccsession.create_answer(
-                        1, "specified statistics data is invalid")
+                cmd = isc.config.ccsession.create_command(
+                    'set', { "stats_data": {
+                            'bind10.boot_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', _BASETIME)
+                            }})
+                seq = self.cc_session.group_sendmsg(cmd, 'Stats')
+                self.cc_session.group_recvmsg(True, seq)
+                answer = isc.config.ccsession.create_answer(0)
             elif command == "ping":
                 answer = isc.config.ccsession.create_answer(0, "pong")
             elif command == "show_processes":

src/bin/bind10/tests/bind10_test.py.in

@@ -137,27 +137,9 @@ class TestBoB(unittest.TestCase):
             def group_sendmsg(self, msg, group):
                 (self.msg, self.group) = (msg, group)
             def group_recvmsg(self, nonblock, seq): pass
-        class DummyModuleCCSession():
-            module_spec = isc.config.module_spec.ModuleSpec({
-                    "module_name": "Boss",
-                    "statistics": [
-                        {
-                            "item_name": "boot_time",
-                            "item_type": "string",
-                            "item_optional": False,
-                            "item_default": "1970-01-01T00:00:00Z",
-                            "item_title": "Boot time",
-                            "item_description": "A date time when bind10 process starts initially",
-                            "item_format": "date-time"
-                            }
-                        ]
-                    })
-            def get_module_spec(self):
-                return self.module_spec
         bob = BoB()
         bob.verbose = True
         bob.cc_session = DummySession()
-        bob.ccs = DummyModuleCCSession()
         # a bad command
         self.assertEqual(bob.command_handler(-1, None),
                          isc.config.ccsession.create_answer(1, "bad command"))
@@ -171,9 +153,8 @@ class TestBoB(unittest.TestCase):
         self.assertEqual(bob.cc_session.group, "Stats")
         self.assertEqual(bob.cc_session.msg,
                          isc.config.ccsession.create_command(
-                "set", { "owner": "Boss",
-                         "data": {
-                        "boot_time": time.strftime("%Y-%m-%dT%H:%M:%SZ", _BASETIME)
+                'set', { "stats_data": {
+                        'bind10.boot_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', _BASETIME)
                         }}))
         # "ping" command
         self.assertEqual(bob.command_handler("ping", None),

src/bin/stats/Makefile.am

@@ -5,7 +5,7 @@ pkglibexecdir = $(libexecdir)/@PACKAGE@
 pkglibexec_SCRIPTS = b10-stats b10-stats-httpd
 
 b10_statsdir = $(pkgdatadir)
-b10_stats_DATA = stats.spec stats-httpd.spec
+b10_stats_DATA = stats.spec stats-httpd.spec stats-schema.spec
 b10_stats_DATA += stats-httpd-xml.tpl stats-httpd-xsd.tpl stats-httpd-xsl.tpl
 pyexec_DATA = stats_messages.py stats_httpd_messages.py
 
@@ -16,7 +16,7 @@ CLEANFILES += stats_httpd_messages.py stats_httpd_messages.pyc
 
 man_MANS = b10-stats.8 b10-stats-httpd.8
 EXTRA_DIST = $(man_MANS) b10-stats.xml b10-stats-httpd.xml
-EXTRA_DIST += stats.spec stats-httpd.spec
+EXTRA_DIST += stats.spec stats-httpd.spec stats-schema.spec
 EXTRA_DIST += stats-httpd-xml.tpl stats-httpd-xsd.tpl stats-httpd-xsl.tpl
 EXTRA_DIST += stats_messages.mes stats_httpd_messages.mes
 

src/bin/stats/b10-stats-httpd.xml

@@ -57,7 +57,7 @@
       by the BIND 10 boss process (<command>bind10</command>) and eventually
       exited by it.  The server is intended to be server requests by HTTP
       clients like web browsers and third-party modules. When the server is
-      asked, it requests BIND 10 statistics data or its schema from
+      asked, it requests BIND 10 statistics data from
       <command>b10-stats</command>, and it sends the data back in Python
       dictionary format and the server converts it into XML format. The server
       sends it to the HTTP client. The server can send three types of document,
@@ -112,6 +112,12 @@
       of <refentrytitle>bindctl</refentrytitle><manvolnum>1</manvolnum> about
       how to configure the settings.
     </para>
+    <para><filename>/usr/local/share/bind10-devel/stats-schema.spec</filename>
+      <!--TODO: The filename should be computed from prefix-->
+      &mdash; This is a spec file for data schema of
+      of BIND 10 statistics. This schema cannot be configured 
+      via <refentrytitle>bindctl</refentrytitle><manvolnum>1</manvolnum>.
+    </para>
     <para>
       <filename>/usr/local/share/bind10-devel/stats-httpd-xml.tpl</filename>
       <!--TODO: The filename should be computed from prefix-->
@@ -132,7 +138,7 @@
   <refsect1>
     <title>CONFIGURATION AND COMMANDS</title>
     <para>
-      The configurable setting in
+      The configurable setting in 
       <filename>stats-httpd.spec</filename> is:
     </para>
     <variablelist>

src/bin/stats/b10-stats.8

@@ -66,6 +66,10 @@ switches to verbose mode\&. It sends verbose messages to STDOUT\&.
 \fBb10\-stats\fR\&. It contains commands for
 \fBb10\-stats\fR\&. They can be invoked via
 bindctl(1)\&.
+.PP
+/usr/local/share/bind10\-devel/stats\-schema\&.spec
+\(em This is a spec file for data schema of of BIND 10 statistics\&. This schema cannot be configured via
+bindctl(1)\&.
 .SH "SEE ALSO"
 .PP
 

src/bin/stats/b10-stats.xml

@@ -95,6 +95,12 @@
       invoked
       via <refentrytitle>bindctl</refentrytitle><manvolnum>1</manvolnum>.
     </para>
+    <para><filename>/usr/local/share/bind10-devel/stats-schema.spec</filename>
+      <!--TODO: The filename should be computed from prefix-->
+      &mdash; This is a spec file for data schema of
+      of BIND 10 statistics. This schema cannot be configured 
+      via <refentrytitle>bindctl</refentrytitle><manvolnum>1</manvolnum>.
+    </para>
   </refsect1>
 
   <refsect1>

src/bin/stats/stats-httpd-xsl.tpl

@@ -44,7 +44,6 @@ td.title {
         <h1>BIND 10 Statistics</h1>
         <table>
           <tr>
-            <th>Owner</th>
             <th>Title</th>
             <th>Value</th>
           </tr>

src/bin/stats/stats-schema.spec

@@ -0,0 +1,86 @@
+{
+  "module_spec": {
+    "module_name": "Stats",
+    "module_description": "Statistics data schema",
+    "config_data": [
+      {
+        "item_name": "report_time",
+        "item_type": "string",
+        "item_optional": false,
+        "item_default": "1970-01-01T00:00:00Z",
+        "item_title": "Report time",
+        "item_description": "A date time when stats module reports",
+        "item_format": "date-time"
+      },
+      {
+        "item_name": "bind10.boot_time",
+        "item_type": "string",
+        "item_optional": false,
+        "item_default": "1970-01-01T00:00:00Z",
+        "item_title": "bind10.BootTime",
+        "item_description": "A date time when bind10 process starts initially",
+        "item_format": "date-time"
+      },
+      {
+        "item_name": "stats.boot_time",
+        "item_type": "string",
+        "item_optional": false,
+        "item_default": "1970-01-01T00:00:00Z",
+        "item_title": "stats.BootTime",
+        "item_description": "A date time when the stats module starts initially or when the stats module restarts",
+        "item_format": "date-time"
+      },
+      {
+        "item_name": "stats.start_time",
+        "item_type": "string",
+        "item_optional": false,
+        "item_default": "1970-01-01T00:00:00Z",
+        "item_title": "stats.StartTime",
+        "item_description": "A date time when the stats module starts collecting data or resetting values last time",
+        "item_format": "date-time"
+      },
+      {
+        "item_name": "stats.last_update_time",
+        "item_type": "string",
+        "item_optional": false,
+        "item_default": "1970-01-01T00:00:00Z",
+        "item_title": "stats.LastUpdateTime",
+        "item_description": "The latest date time when the stats module receives from other modules like auth server or boss process and so on",
+        "item_format": "date-time"
+      },
+      {
+        "item_name": "stats.timestamp",
+        "item_type": "real",
+        "item_optional": false,
+        "item_default": 0.0,
+        "item_title": "stats.Timestamp",
+        "item_description": "A current time stamp since epoch time (1970-01-01T00:00:00Z)"
+      },
+      {
+        "item_name": "stats.lname",
+        "item_type": "string",
+        "item_optional": false,
+        "item_default": "",
+        "item_title": "stats.LocalName",
+        "item_description": "A localname of stats module given via CC protocol"
+      },
+      {
+        "item_name": "auth.queries.tcp",
+        "item_type": "integer",
+        "item_optional": false,
+        "item_default": 0,
+        "item_title": "auth.queries.tcp",
+        "item_description": "A number of total query counts which all auth servers receive over TCP since they started initially"
+      },
+      {
+        "item_name": "auth.queries.udp",
+        "item_type": "integer",
+        "item_optional": false,
+        "item_default": 0,
+        "item_title": "auth.queries.udp",
+        "item_description": "A number of total query counts which all auth servers receive over UDP since they started initially"
+      }
+    ],
+    "commands": []
+  }
+}

src/bin/stats/stats.py.in

@@ -15,17 +15,16 @@
 # NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 # WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-"""
-Statistics daemon in BIND 10
-
-"""
 import sys; sys.path.append ('@@PYTHONPATH@@')
 import os
+import signal
+import select
 from time import time, strftime, gmtime
 from optparse import OptionParser, OptionValueError
+from collections import defaultdict
+from isc.config.ccsession import ModuleCCSession, create_answer
+from isc.cc import Session, SessionError
 
-import isc
-import isc.util.process
 import isc.log
 from stats_messages import *
 
@@ -36,140 +35,211 @@ logger = isc.log.Logger("stats")
 # have #1074
 DBG_STATS_MESSAGING = 30
 
-# This is for boot_time of Stats
-_BASETIME = gmtime()
-
 # for setproctitle
+import isc.util.process
 isc.util.process.rename()
 
 # If B10_FROM_SOURCE is set in the environment, we use data files
 # from a directory relative to that, otherwise we use the ones
 # installed on the system
 if "B10_FROM_SOURCE" in os.environ:
-    SPECFILE_LOCATION = os.environ["B10_FROM_SOURCE"] + os.sep + \
-        "src" + os.sep + "bin" + os.sep + "stats" + os.sep + "stats.spec"
+    BASE_LOCATION = os.environ["B10_FROM_SOURCE"] + os.sep + \
+        "src" + os.sep + "bin" + os.sep + "stats"
 else:
     PREFIX = "@prefix@"
     DATAROOTDIR = "@datarootdir@"
-    SPECFILE_LOCATION = "@datadir@" + os.sep + "@PACKAGE@" + os.sep + "stats.spec"
-    SPECFILE_LOCATION = SPECFILE_LOCATION.replace("${datarootdir}", DATAROOTDIR)\
-        .replace("${prefix}", PREFIX)
+    BASE_LOCATION = "@datadir@" + os.sep + "@PACKAGE@"
+    BASE_LOCATION = BASE_LOCATION.replace("${datarootdir}", DATAROOTDIR).replace("${prefix}", PREFIX)
+SPECFILE_LOCATION = BASE_LOCATION + os.sep + "stats.spec"
+SCHEMA_SPECFILE_LOCATION = BASE_LOCATION + os.sep + "stats-schema.spec"
 
-def get_timestamp():
+class Singleton(type):
     """
-    get current timestamp
+    A abstract class of singleton pattern
     """
-    return time()
+    # Because of singleton pattern: 
+    #   At the beginning of coding, one UNIX domain socket is needed
+    #  for config manager, another socket is needed for stats module,
+    #  then stats module might need two sockets. So I adopted the
+    #  singleton pattern because I avoid creating multiple sockets in
+    #  one stats module. But in the initial version stats module
+    #  reports only via bindctl, so just one socket is needed. To use
+    #  the singleton pattern is not important now. :(
 
-def get_datetime(gmt=None):
-    """
-    get current datetime
-    """
-    if not gmt: gmt = gmtime()
-    return strftime("%Y-%m-%dT%H:%M:%SZ", gmt)
+    def __init__(self, *args, **kwargs):
+        type.__init__(self, *args, **kwargs)
+        self._instances = {}
 
-def get_spec_defaults(spec):
-    """
-    extracts the default values of the items from spec specified in
-    arg, and returns the dict-type variable which is a set of the item
-    names and the default values
-    """
-    if type(spec) is not list: return {}
-    def _get_spec_defaults(spec):
-        item_type = spec['item_type']
-        if item_type == "integer":
-            return int(spec.get('item_default', 0))
-        elif item_type == "real":
-            return float(spec.get('item_default', 0.0))
-        elif item_type == "boolean":
-            return bool(spec.get('item_default', False))
-        elif item_type == "string":
-            return str(spec.get('item_default', ""))
-        elif item_type == "list":
-            return spec.get(
-                    "item_default",
-                    [ _get_spec_defaults(s) for s in spec["list_item_spec"] ])
-        elif item_type == "map":
-            return spec.get(
-                    "item_default",
-                    dict([ (s["item_name"], _get_spec_defaults(s)) for s in spec["map_item_spec"] ]) )
-        else:
-            return spec.get("item_default", None)
-    return dict([ (s['item_name'], _get_spec_defaults(s)) for s in spec ])
+    def __call__(self, *args, **kwargs):
+        if args not in self._instances:
+            self._instances[args]={}
+        kw = tuple(kwargs.items())
+        if  kw not in self._instances[args]:
+            self._instances[args][kw] = type.__call__(self, *args, **kwargs)
+        return self._instances[args][kw]
 
 class Callback():
     """
     A Callback handler class
     """
-    def __init__(self, command=None, args=(), kwargs={}):
-        self.command = command
+    def __init__(self, name=None, callback=None, args=(), kwargs={}):
+        self.name = name
+        self.callback = callback
         self.args = args
         self.kwargs = kwargs
 
     def __call__(self, *args, **kwargs):
-        if not args: args = self.args
-        if not kwargs: kwargs = self.kwargs
-        if self.command: return self.command(*args, **kwargs)
-
-class StatsError(Exception):
-    """Exception class for Stats class"""
-    pass
+        if not args:
+            args = self.args
+        if not kwargs:
+            kwargs = self.kwargs
+        if self.callback:
+            return self.callback(*args, **kwargs)
 
-class Stats:
+class Subject():
     """
-    Main class of stats module
+    A abstract subject class of observer pattern
     """
+    # Because of observer pattern:
+    #   In the initial release, I'm also sure that observer pattern
+    #  isn't definitely needed because the interface between gathering
+    #  and reporting statistics data is single.  However in the future
+    #  release, the interfaces may be multiple, that is, multiple
+    #  listeners may be needed. For example, one interface, which
+    #  stats module has, is for between ''config manager'' and stats
+    #  module, another interface is for between ''HTTP server'' and
+    #  stats module, and one more interface is for between ''SNMP
+    #  server'' and stats module. So by considering that stats module
+    #  needs multiple interfaces in the future release, I adopted the
+    #  observer pattern in stats module. But I don't have concrete
+    #  ideas in case of multiple listener currently.
+
     def __init__(self):
+        self._listeners = []
+
+    def attach(self, listener):
+        if not listener in self._listeners:
+            self._listeners.append(listener)
+
+    def detach(self, listener):
+        try:
+            self._listeners.remove(listener)
+        except ValueError:
+            pass
+
+    def notify(self, event, modifier=None):
+        for listener in self._listeners:
+            if modifier != listener:
+                listener.update(event)
+
+class Listener():
+    """
+    A abstract listener class of observer pattern
+    """
+    def __init__(self, subject):
+        self.subject = subject
+        self.subject.attach(self)
+        self.events = {}
+
+    def update(self, name):
+        if name in self.events:
+            callback = self.events[name]
+            return callback()
+
+    def add_event(self, event):
+        self.events[event.name]=event
+
+class SessionSubject(Subject, metaclass=Singleton):
+    """
+    A concrete subject class which creates CC session object
+    """
+    def __init__(self, session=None):
+        Subject.__init__(self)
+        self.session=session
         self.running = False
+
+    def start(self):
+        self.running = True
+        self.notify('start')
+
+    def stop(self):
+        self.running = False
+        self.notify('stop')
+
+    def check(self):
+        self.notify('check')
+
+class CCSessionListener(Listener):
+    """
+    A concrete listener class which creates SessionSubject object and
+    ModuleCCSession object
+    """
+    def __init__(self, subject):
+        Listener.__init__(self, subject)
+        self.session = subject.session
+        self.boot_time = get_datetime()
+
         # create ModuleCCSession object
-        self.mccs = isc.config.ModuleCCSession(SPECFILE_LOCATION,
-                                               self.config_handler,
-                                               self.command_handler)
-        self.cc_session = self.mccs._session
-        # get module spec
-        self.module_name = self.mccs.get_module_spec().get_module_name()
-        self.modules = {}
-        self.statistics_data = {}
+        self.cc_session = ModuleCCSession(SPECFILE_LOCATION,
+                                          self.config_handler,
+                                          self.command_handler,
+                                          self.session)
+
+        self.session = self.subject.session = self.cc_session._session
+
+        # initialize internal data
+        self.stats_spec = isc.config.module_spec_from_file(SCHEMA_SPECFILE_LOCATION).get_config_spec()
+        self.stats_data = self.initialize_data(self.stats_spec)
+
+        # add event handler invoked via SessionSubject object
+        self.add_event(Callback('start', self.start))
+        self.add_event(Callback('stop', self.stop))
+        self.add_event(Callback('check', self.check))
+        # don't add 'command_' suffix to the special commands in
+        # order to prevent executing internal command via bindctl
+
         # get commands spec
-        self.commands_spec = self.mccs.get_module_spec().get_commands_spec()
+        self.commands_spec = self.cc_session.get_module_spec().get_commands_spec()
+
         # add event handler related command_handler of ModuleCCSession
-        self.callbacks = {}
+        # invoked via bindctl
         for cmd in self.commands_spec:
-            # add prefix "command_"
-            name = "command_" + cmd["command_name"]
             try:
+                # add prefix "command_"
+                name = "command_" + cmd["command_name"]
                 callback = getattr(self, name)
-                kwargs = get_spec_defaults(cmd["command_args"])
-                self.callbacks[name] = Callback(command=callback, kwargs=kwargs)
-            except AttributeError:
-                raise StatsError(STATS_UNKNOWN_COMMAND_IN_SPEC, cmd["command_name"])
-        self.mccs.start()
+                kwargs = self.initialize_data(cmd["command_args"])
+                self.add_event(Callback(name=name, callback=callback, args=(), kwargs=kwargs))
+            except AttributeError as ae:
+                logger.error(STATS_UNKNOWN_COMMAND_IN_SPEC, cmd["command_name"])
 
     def start(self):
         """
-        Start stats module
+        start the cc chanel
         """
-        self.running = True
-        logger.info(STATS_STARTING)
-
+        # set initial value
+        self.stats_data['stats.boot_time'] = self.boot_time
+        self.stats_data['stats.start_time'] = get_datetime()
+        self.stats_data['stats.last_update_time'] = get_datetime()
+        self.stats_data['stats.lname'] = self.session.lname
+        self.cc_session.start()
         # request Bob to send statistics data
         logger.debug(DBG_STATS_MESSAGING, STATS_SEND_REQUEST_BOSS)
         cmd = isc.config.ccsession.create_command("sendstats", None)
-        seq = self.cc_session.group_sendmsg(cmd, 'Boss')
-        self.cc_session.group_recvmsg(True, seq)
-
-        # initialized Statistics data
-        errors = self.update_statistics_data(
-            self.module_name,
-            lname=self.cc_session.lname,
-            boot_time=get_datetime(_BASETIME)
-            )
-        if errors:
-            raise StatsError("stats spec file is incorrect: "
-                             + ", ".join(errors))
-
-        while self.running:
-            self.mccs.check_command(False)
+        seq = self.session.group_sendmsg(cmd, 'Boss')
+        self.session.group_recvmsg(True, seq)
+
+    def stop(self):
+        """
+        stop the cc chanel
+        """
+        return self.cc_session.close()
+
+    def check(self):
+        """
+        check the cc chanel
+        """
+        return self.cc_session.check_command(False)
 
     def config_handler(self, new_config):
         """
@@ -177,222 +247,174 @@ class Stats:
         """
         logger.debug(DBG_STATS_MESSAGING, STATS_RECEIVED_NEW_CONFIG,
                      new_config)
+
         # do nothing currently
-        return isc.config.create_answer(0)
+        return create_answer(0)
 
-    def command_handler(self, command, kwargs):
+    def command_handler(self, command, *args, **kwargs):
         """
         handle commands from the cc channel
         """
+        # add 'command_' suffix in order to executing command via bindctl
         name = 'command_' + command
-        if name in self.callbacks:
-            callback = self.callbacks[name]
-            if kwargs:
-                return callback(**kwargs)
-            else:
-                return callback()
+        
+        if name in self.events:
+            event = self.events[name]
+            return event(*args, **kwargs)
         else:
-            logger.error(STATS_RECEIVED_UNKNOWN_COMMAND, command)
-            return isc.config.create_answer(1, "Unknown command: '"+str(command)+"'")
+            return self.command_unknown(command, args)
 
-    def update_modules(self):
+    def command_shutdown(self, args):
         """
-        updates information of each module. This method gets each
-        module's information from the config manager and sets it into
-        self.modules. If its getting from the config manager fails, it
-        raises StatsError.
+        handle shutdown command
         """
-        modules = {}
-        seq = self.cc_session.group_sendmsg(
-            isc.config.ccsession.create_command(
-                isc.config.ccsession.COMMAND_GET_STATISTICS_SPEC),
-            'ConfigManager')
-        (answer, env) = self.cc_session.group_recvmsg(False, seq)
-        if answer:
-            (rcode, value) = isc.config.ccsession.parse_answer(answer)
-            if rcode == 0:
-                for mod in value:
-                    spec = { "module_name" : mod }
-                    if value[mod] and type(value[mod]) is list:
-                        spec["statistics"] = value[mod]
-                    modules[mod] = isc.config.module_spec.ModuleSpec(spec)
-            else:
-                raise StatsError("Updating module spec fails: " + str(value))
-        modules[self.module_name] = self.mccs.get_module_spec()
-        self.modules = modules
+        logger.info(STATS_RECEIVED_SHUTDOWN_COMMAND)
+        self.subject.running = False
+        return create_answer(0)
 
-    def get_statistics_data(self, owner=None, name=None):
+    def command_set(self, args, stats_data={}):
         """
-        returns statistics data which stats module has of each
-        module. If it can't find specified statistics data, it raises
-        StatsError.
+        handle set command
         """
-        self.update_statistics_data()
-        if owner and name:
-            try:
-                return self.statistics_data[owner][name]
-            except KeyError:
-                pass
-        elif owner:
-            try:
-                return self.statistics_data[owner]
-            except KeyError:
-                pass
-        elif name:
-            pass
-        else:
-            return self.statistics_data
-        raise StatsError("No statistics data found: "
-                         + "owner: " + str(owner) + ", "
-                         + "name: " + str(name))
+        # 'args' must be dictionary type
+        self.stats_data.update(args['stats_data'])
+
+        # overwrite "stats.LastUpdateTime"
+        self.stats_data['stats.last_update_time'] = get_datetime()
 
-    def update_statistics_data(self, owner=None, **data):
+        return create_answer(0)
+
+    def command_remove(self, args, stats_item_name=''):
         """
-        change statistics date of specified module into specified
-        data. It updates information of each module first, and it
-        updates statistics data. If specified data is invalid for
-        statistics spec of specified owner, it returns a list of error
-        messeges. If there is no error or if neither owner nor data is
-        specified in args, it returns None.
+        handle remove command
         """
-        self.update_modules()
-        statistics_data = {}
-        for (name, module) in self.modules.items():
-            value = get_spec_defaults(module.get_statistics_spec())
-            if module.validate_statistics(True, value):
-                statistics_data[name] = value
-        for (name, value) in self.statistics_data.items():
-            if name in statistics_data:
-                statistics_data[name].update(value)
-            else:
-                statistics_data[name] = value
-        self.statistics_data = statistics_data
-        if owner and data:
-            errors = []
-            try:
-                if self.modules[owner].validate_statistics(False, data, errors):
-                    self.statistics_data[owner].update(data)
-                    return
-            except KeyError:
-                errors.append("unknown module name: " + str(owner))
-            return errors
-
-    def command_status(self):
+
+        # 'args' must be dictionary type
+        if args and args['stats_item_name'] in self.stats_data:
+            stats_item_name = args['stats_item_name']
+
+        logger.debug(DBG_STATS_MESSAGING, STATS_RECEIVED_REMOVE_COMMAND,
+                     stats_item_name)
+
+        # just remove one item
+        self.stats_data.pop(stats_item_name)
+
+        return create_answer(0)
+
+    def command_show(self, args, stats_item_name=''):
         """
-        handle status command
+        handle show command
         """
-        logger.debug(DBG_STATS_MESSAGING, STATS_RECEIVED_STATUS_COMMAND)
-        return isc.config.create_answer(
-            0, "Stats is up. (PID " + str(os.getpid()) + ")")
 
-    def command_shutdown(self):
+        # always overwrite 'report_time' and 'stats.timestamp'
+        # if "show" command invoked
+        self.stats_data['report_time'] = get_datetime()
+        self.stats_data['stats.timestamp'] = get_timestamp()
+
+        # if with args
+        if args and args['stats_item_name'] in self.stats_data:
+            stats_item_name = args['stats_item_name']
+            logger.debug(DBG_STATS_MESSAGING,
+                         STATS_RECEIVED_SHOW_NAME_COMMAND,
+                         stats_item_name)
+            return create_answer(0, {stats_item_name: self.stats_data[stats_item_name]})
+
+        logger.debug(DBG_STATS_MESSAGING,
+                     STATS_RECEIVED_SHOW_ALL_COMMAND)
+        return create_answer(0, self.stats_data)
+
+    def command_reset(self, args):
         """
-        handle shutdown command
+        handle reset command
         """
-        logger.info(STATS_RECEIVED_SHUTDOWN_COMMAND)
-        self.running = False
-        return isc.config.create_answer(0)
+        logger.debug(DBG_STATS_MESSAGING,
+                     STATS_RECEIVED_RESET_COMMAND)
 
-    def command_show(self, owner=None, name=None):
+        # re-initialize internal variables
+        self.stats_data = self.initialize_data(self.stats_spec)
+
+        # reset initial value
+        self.stats_data['stats.boot_time'] = self.boot_time
+        self.stats_data['stats.start_time'] = get_datetime()
+        self.stats_data['stats.last_update_time'] = get_datetime()
+        self.stats_data['stats.lname'] = self.session.lname
+
+        return create_answer(0)
+
+    def command_status(self, args):
         """
-        handle show command
+        handle status command
         """
-        if owner or name:
-            logger.debug(DBG_STATS_MESSAGING,
-                         STATS_RECEIVED_SHOW_NAME_COMMAND,
-                         str(owner)+", "+str(name))
-        else:
-            logger.debug(DBG_STATS_MESSAGING,
-                         STATS_RECEIVED_SHOW_ALL_COMMAND)
-        errors = self.update_statistics_data(
-            self.module_name,
-            timestamp=get_timestamp(),
-            report_time=get_datetime()
-            )
-        if errors:
-            raise StatsError("stats spec file is incorrect: "
-                             + ", ".join(errors))
-        try:
-            return isc.config.create_answer(
-                0, self.get_statistics_data(owner, name))
-        except StatsError:
-            return isc.config.create_answer(
-                1, "specified arguments are incorrect: " \
-                    + "owner: " + str(owner) + ", name: " + str(name))
-
-    def command_showschema(self, owner=None, name=None):
+        logger.debug(DBG_STATS_MESSAGING, STATS_RECEIVED_STATUS_COMMAND)
+        # just return "I'm alive."
+        return create_answer(0, "I'm alive.")
+
+    def command_unknown(self, command, args):
         """
-        handle show command
+        handle an unknown command
         """
-        if owner or name:
-            logger.debug(DBG_STATS_MESSAGING,
-                         STATS_RECEIVED_SHOWSCHEMA_NAME_COMMAND,
-                         str(owner)+", "+str(name))
-        else:
-            logger.debug(DBG_STATS_MESSAGING,
-                         STATS_RECEIVED_SHOWSCHEMA_ALL_COMMAND)
-        self.update_modules()
-        schema = {}
-        schema_byname = {}
-        for mod in self.modules:
-            spec = self.modules[mod].get_statistics_spec()
-            schema_byname[mod] = {}
-            if spec:
-                schema[mod] = spec
-                for item in spec:
-                    schema_byname[mod][item['item_name']] = item
-        if owner:
-            try:
-                if name:
-                    return isc.config.create_answer(0, schema_byname[owner][name])
-                else:
-                    return isc.config.create_answer(0, schema[owner])
-            except KeyError:
-                pass
-        else:
-            if name:
-                return isc.config.create_answer(1, "module name is not specified")
-            else:
-                return isc.config.create_answer(0, schema)
-        return isc.config.create_answer(
-                1, "specified arguments are incorrect: " \
-                    + "owner: " + str(owner) + ", name: " + str(name))
+        logger.error(STATS_RECEIVED_UNKNOWN_COMMAND, command)
+        return create_answer(1, "Unknown command: '"+str(command)+"'")
 
-    def command_set(self, owner, data):
+
+    def initialize_data(self, spec):
         """
-        handle set command
+        initialize stats data
         """
-        errors = self.update_statistics_data(owner, **data)
-        if errors:
-            return isc.config.create_answer(
-                1, "errors while setting statistics data: " \
-                    + ", ".join(errors))
-        errors = self.update_statistics_data(
-            self.module_name, last_update_time=get_datetime() )
-        if errors:
-            raise StatsError("stats spec file is incorrect: "
-                             + ", ".join(errors))
-        return isc.config.create_answer(0)
+        def __get_init_val(spec):
+            if spec['item_type'] == 'null':
+                return None
+            elif spec['item_type'] == 'boolean':
+                return bool(spec.get('item_default', False))
+            elif spec['item_type'] == 'string':
+                return str(spec.get('item_default', ''))
+            elif spec['item_type'] in set(['number', 'integer']):
+                return int(spec.get('item_default', 0))
+            elif spec['item_type'] in set(['float', 'double', 'real']):
+                return float(spec.get('item_default', 0.0))
+            elif spec['item_type'] in set(['list', 'array']):
+                return spec.get('item_default',
+                                [ __get_init_val(s) for s in spec['list_item_spec'] ])
+            elif spec['item_type'] in set(['map', 'object']):
+                return spec.get('item_default',
+                                dict([ (s['item_name'], __get_init_val(s)) for s in spec['map_item_spec'] ]) )
+            else:
+                return spec.get('item_default')
+        return dict([ (s['item_name'], __get_init_val(s)) for s in spec ])
 
-if __name__ == "__main__":
+def get_timestamp():
+    """
+    get current timestamp
+    """
+    return time()
+
+def get_datetime():
+    """
+    get current datetime
+    """
+    return strftime("%Y-%m-%dT%H:%M:%SZ", gmtime())
+
+def main(session=None):
     try:
         parser = OptionParser()
-        parser.add_option(
-            "-v", "--verbose", dest="verbose", action="store_true",
-            help="display more about what is going on")
+        parser.add_option("-v", "--verbose", dest="verbose", action="store_true",
+                      help="display more about what is going on")
         (options, args) = parser.parse_args()
         if options.verbose:
             isc.log.init("b10-stats", "DEBUG", 99)
-        stats = Stats()
-        stats.start()
+        subject = SessionSubject(session=session)
+        listener = CCSessionListener(subject)
+        subject.start()
+        while subject.running:
+            subject.check()
+        subject.stop()
+
     except OptionValueError as ove:
         logger.fatal(STATS_BAD_OPTION_VALUE, ove)
-        sys.exit(1)
     except SessionError as se:
         logger.fatal(STATS_CC_SESSION_ERROR, se)
-        sys.exit(1)
-    except StatsError as se:
-        logger.fatal(STATS_START_ERROR, se)
-        sys.exit(1)
     except KeyboardInterrupt as kie:
         logger.info(STATS_STOPPED_BY_KEYBOARD)
+
+if __name__ == "__main__":
+    main()

src/bin/stats/stats.spec

@@ -6,74 +6,55 @@
     "commands": [
       {
         "command_name": "status",
-        "command_description": "Show status of the stats daemon",
-        "command_args": []
-      },
-      {
-        "command_name": "shutdown",
-        "command_description": "Shut down the stats module",
+        "command_description": "identify whether stats module is alive or not",
         "command_args": []
       },
       {
         "command_name": "show",
-        "command_description": "Show the specified/all statistics data",
+        "command_description": "show the specified/all statistics data",
         "command_args": [
           {
-            "item_name": "owner",
-            "item_type": "string",
-            "item_optional": true,
-            "item_default": "",
-            "item_description": "module name of the owner of the statistics data"
-          },
-	  {
-	    "item_name": "name",
+            "item_name": "stats_item_name",
             "item_type": "string",
             "item_optional": true,
-            "item_default": "",
-            "item_description": "statistics item name of the owner"
+            "item_default": ""
           }
         ]
       },
       {
-        "command_name": "showschema",
-        "command_description": "show the specified/all statistics shema",
+        "command_name": "set",
+        "command_description": "set the value of specified name in statistics data",
         "command_args": [
           {
-            "item_name": "owner",
-            "item_type": "string",
-            "item_optional": true,
-            "item_default": "",
-            "item_description": "module name of the owner of the statistics data"
-          },
-	  {
-	    "item_name": "name",
-            "item_type": "string",
-            "item_optional": true,
-            "item_default": "",
-            "item_description": "statistics item name of the owner"
+            "item_name": "stats_data",
+            "item_type": "map",
+            "item_optional": false,
+            "item_default": {},
+            "map_item_spec": []
           }
         ]
       },
       {
-        "command_name": "set",
-        "command_description": "set the value of specified name in statistics data",
+        "command_name": "remove",
+        "command_description": "remove the specified name from statistics data",
         "command_args": [
           {
-            "item_name": "owner",
+            "item_name": "stats_item_name",
             "item_type": "string",
             "item_optional": false,
-            "item_default": "",
-            "item_description": "module name of the owner of the statistics data"
-          },
-	  {
-	    "item_name": "data",
-            "item_type": "map",
-            "item_optional": false,
-            "item_default": {},
-            "item_description": "statistics data set of the owner",
-            "map_item_spec": []
+            "item_default": ""
           }
         ]
+      },
+      {
+        "command_name": "reset",
+        "command_description": "reset all statistics data to default values except for several constant names",
+        "command_args": []
+      },
+      {
+        "command_name": "shutdown",
+        "command_description": "Shut down the stats module",
+        "command_args": []
       }
     ],
     "statistics": [
@@ -119,7 +100,7 @@
         "item_default": "",
         "item_title": "Local Name",
         "item_description": "A localname of stats module given via CC protocol"
-      }
+       }
     ]
   }
 }

src/bin/stats/stats_httpd.py.in

@@ -57,6 +57,7 @@ else:
     BASE_LOCATION = "@datadir@" + os.sep + "@PACKAGE@"
     BASE_LOCATION = BASE_LOCATION.replace("${datarootdir}", DATAROOTDIR).replace("${prefix}", PREFIX)
 SPECFILE_LOCATION = BASE_LOCATION + os.sep + "stats-httpd.spec"
+SCHEMA_SPECFILE_LOCATION = BASE_LOCATION + os.sep + "stats-schema.spec"
 XML_TEMPLATE_LOCATION = BASE_LOCATION + os.sep + "stats-httpd-xml.tpl"
 XSD_TEMPLATE_LOCATION = BASE_LOCATION + os.sep + "stats-httpd-xsd.tpl"
 XSL_TEMPLATE_LOCATION = BASE_LOCATION + os.sep + "stats-httpd-xsl.tpl"
@@ -68,7 +69,7 @@ XSD_URL_PATH = '/bind10/statistics/xsd'
 XSL_URL_PATH = '/bind10/statistics/xsl'
 # TODO: This should be considered later.
 XSD_NAMESPACE = 'http://bind10.isc.org' + XSD_URL_PATH
-DEFAULT_CONFIG = dict(version=0, listen_on=[('127.0.0.1', 8000)])
+DEFAULT_CONFIG = dict(listen_on=[('127.0.0.1', 8000)])
 
 # Assign this process name
 isc.util.process.rename()
@@ -160,6 +161,8 @@ class StatsHttpd:
         self.httpd = []
         self.open_mccs()
         self.load_config()
+        self.load_templates()
+        self.open_httpd()
 
     def open_mccs(self):
         """Opens a ModuleCCSession object"""
@@ -168,6 +171,10 @@ class StatsHttpd:
         self.mccs = isc.config.ModuleCCSession(
             SPECFILE_LOCATION, self.config_handler, self.command_handler)
         self.cc_session = self.mccs._session
+        # read spec file of stats module and subscribe 'Stats'
+        self.stats_module_spec = isc.config.module_spec_from_file(SCHEMA_SPECFILE_LOCATION)
+        self.stats_config_spec = self.stats_module_spec.get_config_spec()
+        self.stats_module_name = self.stats_module_spec.get_module_name()
 
     def close_mccs(self):
         """Closes a ModuleCCSession object"""
@@ -201,41 +208,45 @@ class StatsHttpd:
         for addr in self.http_addrs:
             self.httpd.append(self._open_httpd(addr))
 
-    def _open_httpd(self, server_address):
-        httpd = None
+    def _open_httpd(self, server_address, address_family=None):
         try:
-            # get address family for the server_address before
-            # creating HttpServer object
-            address_family = socket.getaddrinfo(*server_address)[0][0]
-            HttpServer.address_family = address_family
+            # try IPv6 at first
+            if address_family is not None:
+                HttpServer.address_family = address_family
+            elif socket.has_ipv6:
+                HttpServer.address_family = socket.AF_INET6
             httpd = HttpServer(
                 server_address, HttpHandler,
                 self.xml_handler, self.xsd_handler, self.xsl_handler,
                 self.write_log)
-            logger.info(STATHTTPD_STARTED, server_address[0],
-                        server_address[1])
-            return httpd
         except (socket.gaierror, socket.error,
                 OverflowError, TypeError) as err:
-           if httpd:
-                httpd.server_close()
-           raise HttpServerError(
-               "Invalid address %s, port %s: %s: %s" %
-               (server_address[0], server_address[1],
-                err.__class__.__name__, err))
+            # try IPv4 next
+            if HttpServer.address_family == socket.AF_INET6:
+                httpd = self._open_httpd(server_address, socket.AF_INET)
+            else:
+                raise HttpServerError(
+                    "Invalid address %s, port %s: %s: %s" %
+                    (server_address[0], server_address[1],
+                     err.__class__.__name__, err))
+        else:
+            logger.info(STATHTTPD_STARTED, server_address[0],
+                        server_address[1])
+        return httpd
 
     def close_httpd(self):
         """Closes sockets for HTTP"""
-        while len(self.httpd)>0:
-            ht = self.httpd.pop()
+        if len(self.httpd) == 0:
+            return
+        for ht in self.httpd:
             logger.info(STATHTTPD_CLOSING, ht.server_address[0],
                         ht.server_address[1])
             ht.server_close()
+        self.httpd = []
 
     def start(self):
         """Starts StatsHttpd objects to run. Waiting for client
         requests by using select.select functions"""
-        self.open_httpd()
         self.mccs.start()
         self.running = True
         while self.running:
@@ -299,9 +310,9 @@ class StatsHttpd:
         except HttpServerError as err:
             logger.error(STATHTTPD_SERVER_ERROR, err)
             # restore old config
-            self.load_config(old_config)
-            self.open_httpd()
-            return isc.config.ccsession.create_answer(1, str(err))
+            self.config_handler(old_config)
+            return isc.config.ccsession.create_answer(
+                1, "[b10-stats-httpd] %s" % err)
         else:
             return isc.config.ccsession.create_answer(0)
 
@@ -330,7 +341,8 @@ class StatsHttpd:
         the data which obtains from it"""
         try:
             seq = self.cc_session.group_sendmsg(
-                isc.config.ccsession.create_command('show'), 'Stats')
+                isc.config.ccsession.create_command('show'),
+                self.stats_module_name)
             (answer, env) = self.cc_session.group_recvmsg(False, seq)
             if answer:
                 (rcode, value) = isc.config.ccsession.parse_answer(answer)
@@ -345,82 +357,34 @@ class StatsHttpd:
                 raise StatsHttpdError("Stats module: %s" % str(value))
 
     def get_stats_spec(self):
-        """Requests statistics data to the Stats daemon and returns
-        the data which obtains from it"""
-        try:
-            seq = self.cc_session.group_sendmsg(
-                isc.config.ccsession.create_command('showschema'), 'Stats')
-            (answer, env) = self.cc_session.group_recvmsg(False, seq)
-            if answer:
-                (rcode, value) = isc.config.ccsession.parse_answer(answer)
-                if rcode == 0:
-                    return value
-                else:
-                    raise StatsHttpdError("Stats module: %s" % str(value))
-        except (isc.cc.session.SessionTimeout,
-                isc.cc.session.SessionError) as err:
-            raise StatsHttpdError("%s: %s" %
-                                  (err.__class__.__name__, err))
-
-    def xml_handler(self):
-        """Handler which requests to Stats daemon to obtain statistics
-        data and returns the body of XML document"""
-        xml_list=[]
-        for (mod, spec) in self.get_stats_data().items():
-            if not spec: continue
-            elem1 = xml.etree.ElementTree.Element(str(mod))
-            for (k, v) in spec.items():
-                elem2 = xml.etree.ElementTree.Element(str(k))
-                elem2.text = str(v)
-                elem1.append(elem2)
-            # The coding conversion is tricky. xml..tostring() of Python 3.2
-            # returns bytes (not string) regardless of the coding, while
-            # tostring() of Python 3.1 returns a string.  To support both
-            # cases transparently, we first make sure tostring() returns
-            # bytes by specifying utf-8 and then convert the result to a
-            # plain string (code below assume it).
-            xml_list.append(
-                str(xml.etree.ElementTree.tostring(elem1, encoding='utf-8'),
-                    encoding='us-ascii'))
-        xml_string = "".join(xml_list)
-        self.xml_body = self.open_template(XML_TEMPLATE_LOCATION).substitute(
-            xml_string=xml_string,
-            xsd_namespace=XSD_NAMESPACE,
-            xsd_url_path=XSD_URL_PATH,
-            xsl_url_path=XSL_URL_PATH)
-        assert self.xml_body is not None
-        return self.xml_body
-
-    def xsd_handler(self):
-        """Handler which just returns the body of XSD document"""
+        """Just returns spec data"""
+        return self.stats_config_spec
+
+    def load_templates(self):
+        """Setup the bodies of XSD and XSL documents to be responds to
+        HTTP clients. Before that it also creates XML tag structures by
+        using xml.etree.ElementTree.Element class and substitutes
+        concrete strings with parameters embed in the string.Template
+        object."""
         # for XSD
         xsd_root = xml.etree.ElementTree.Element("all") # started with "all" tag
-        for (mod, spec) in self.get_stats_spec().items():
-            if not spec: continue
-            alltag = xml.etree.ElementTree.Element("all")
-            for item in spec:
-                element = xml.etree.ElementTree.Element(
-                    "element",
-                    dict( name=item["item_name"],
-                          type=item["item_type"] if item["item_type"].lower() != 'real' else 'float',
-                          minOccurs="1",
-                          maxOccurs="1" ),
-                    )
-                annotation = xml.etree.ElementTree.Element("annotation")
-                appinfo = xml.etree.ElementTree.Element("appinfo")
-                documentation = xml.etree.ElementTree.Element("documentation")
-                appinfo.text = item["item_title"]
-                documentation.text = item["item_description"]
-                annotation.append(appinfo)
-                annotation.append(documentation)
-                element.append(annotation)
-                alltag.append(element)
-
-            complextype = xml.etree.ElementTree.Element("complexType")
-            complextype.append(alltag)
-            mod_element = xml.etree.ElementTree.Element("element", { "name" : mod })
-            mod_element.append(complextype)
-            xsd_root.append(mod_element)
+        for item in self.get_stats_spec():
+            element = xml.etree.ElementTree.Element(
+                "element",
+                dict( name=item["item_name"],
+                      type=item["item_type"] if item["item_type"].lower() != 'real' else 'float',
+                      minOccurs="1",
+                      maxOccurs="1" ),
+                )
+            annotation = xml.etree.ElementTree.Element("annotation")
+            appinfo = xml.etree.ElementTree.Element("appinfo")
+            documentation = xml.etree.ElementTree.Element("documentation")
+            appinfo.text = item["item_title"]
+            documentation.text = item["item_description"]
+            annotation.append(appinfo)
+            annotation.append(documentation)
+            element.append(annotation)
+            xsd_root.append(element)
         # The coding conversion is tricky. xml..tostring() of Python 3.2
         # returns bytes (not string) regardless of the coding, while
         # tostring() of Python 3.1 returns a string.  To support both
@@ -434,33 +398,25 @@ class StatsHttpd:
             xsd_namespace=XSD_NAMESPACE
             )
         assert self.xsd_body is not None
-        return self.xsd_body
 
-    def xsl_handler(self):
-        """Handler which just returns the body of XSL document"""
         # for XSL
         xsd_root = xml.etree.ElementTree.Element(
             "xsl:template",
             dict(match="*")) # started with xml:template tag
-        for (mod, spec) in self.get_stats_spec().items():
-            if not spec: continue
-            for item in spec:
-                tr = xml.etree.ElementTree.Element("tr")
-                td0 = xml.etree.ElementTree.Element("td")
-                td0.text = str(mod)
-                td1 = xml.etree.ElementTree.Element(
-                    "td", { "class" : "title",
-                            "title" : item["item_description"] })
-                td1.text = item["item_title"]
-                td2 = xml.etree.ElementTree.Element("td")
-                xsl_valueof = xml.etree.ElementTree.Element(
-                    "xsl:value-of",
-                    dict(select=mod+'/'+item["item_name"]))
-                td2.append(xsl_valueof)
-                tr.append(td0)
-                tr.append(td1)
-                tr.append(td2)
-                xsd_root.append(tr)
+        for item in self.get_stats_spec():
+            tr = xml.etree.ElementTree.Element("tr")
+            td1 = xml.etree.ElementTree.Element(
+                "td", { "class" : "title",
+                        "title" : item["item_description"] })
+            td1.text = item["item_title"]
+            td2 = xml.etree.ElementTree.Element("td")
+            xsl_valueof = xml.etree.ElementTree.Element(
+                "xsl:value-of",
+                dict(select=item["item_name"]))
+            td2.append(xsl_valueof)
+            tr.append(td1)
+            tr.append(td2)
+            xsd_root.append(tr)
         # The coding conversion is tricky. xml..tostring() of Python 3.2
         # returns bytes (not string) regardless of the coding, while
         # tostring() of Python 3.1 returns a string.  To support both
@@ -473,15 +429,47 @@ class StatsHttpd:
             xsl_string=xsl_string,
             xsd_namespace=XSD_NAMESPACE)
         assert self.xsl_body is not None
+
+    def xml_handler(self):
+        """Handler which requests to Stats daemon to obtain statistics
+        data and returns the body of XML document"""
+        xml_list=[]
+        for (k, v) in self.get_stats_data().items():
+            (k, v) = (str(k), str(v))
+            elem = xml.etree.ElementTree.Element(k)
+            elem.text = v
+            # The coding conversion is tricky. xml..tostring() of Python 3.2
+            # returns bytes (not string) regardless of the coding, while
+            # tostring() of Python 3.1 returns a string.  To support both
+            # cases transparently, we first make sure tostring() returns
+            # bytes by specifying utf-8 and then convert the result to a
+            # plain string (code below assume it).
+            xml_list.append(
+                str(xml.etree.ElementTree.tostring(elem, encoding='utf-8'),
+                    encoding='us-ascii'))
+        xml_string = "".join(xml_list)
+        self.xml_body = self.open_template(XML_TEMPLATE_LOCATION).substitute(
+            xml_string=xml_string,
+            xsd_namespace=XSD_NAMESPACE,
+            xsd_url_path=XSD_URL_PATH,
+            xsl_url_path=XSL_URL_PATH)
+        assert self.xml_body is not None
+        return self.xml_body
+
+    def xsd_handler(self):
+        """Handler which just returns the body of XSD document"""
+        return self.xsd_body
+
+    def xsl_handler(self):
+        """Handler which just returns the body of XSL document"""
         return self.xsl_body
 
     def open_template(self, file_name):
         """It opens a template file, and it loads all lines to a
         string variable and returns string. Template object includes
         the variable. Limitation of a file size isn't needed there."""
-        f = open(file_name, 'r')
-        lines = "".join(f.readlines())
-        f.close()
+        lines = "".join(
+            open(file_name, 'r').readlines())
         assert lines is not None
         return string.Template(lines)
 

src/bin/stats/stats_messages.mes

@@ -28,6 +28,16 @@ control bus. A likely problem is that the message bus daemon
 This debug message is printed when the stats module has received a
 configuration update from the configuration manager.
 
+% STATS_RECEIVED_REMOVE_COMMAND received command to remove %1
+A remove command for the given name was sent to the stats module, and
+the given statistics value will now be removed. It will not appear in
+statistics reports until it appears in a statistics update from a
+module again.
+
+% STATS_RECEIVED_RESET_COMMAND received command to reset all statistics
+The stats module received a command to clear all collected statistics.
+The data is cleared until it receives an update from the modules again.
+
 % STATS_RECEIVED_SHOW_ALL_COMMAND received command to show all statistics
 The stats module received a command to show all statistics that it has
 collected.
@@ -62,15 +72,4 @@ installation problem, where the specification file stats.spec is
 from a different version of BIND 10 than the stats module itself.
 Please check your installation.
 
-% STATS_STARTING starting
-The stats module will be now starting.
-
-% STATS_RECEIVED_SHOWSCHEMA_ALL_COMMAND received command to show all statistics schema
-The stats module received a command to show all statistics schemas of all modules.
-
-% STATS_RECEIVED_SHOWSCHEMA_NAME_COMMAND received command to show statistics schema for %1
-The stats module received a command to show the specified statistics schema of the specified module.
 
-% STATS_START_ERROR stats module error: %1
-An internal error occurred while starting the stats module. The stats
-module will be now shutting down.

src/bin/stats/tests/Makefile.am

@@ -1,7 +1,8 @@
+SUBDIRS = isc http testdata
 PYCOVERAGE_RUN = @PYCOVERAGE_RUN@
 PYTESTS = b10-stats_test.py b10-stats-httpd_test.py
-EXTRA_DIST = $(PYTESTS) test_utils.py
-CLEANFILES = test_utils.pyc
+EXTRA_DIST = $(PYTESTS) fake_time.py fake_socket.py fake_select.py
+CLEANFILES = fake_time.pyc fake_socket.pyc fake_select.pyc
 
 # If necessary (rare cases), explicitly specify paths to dynamic libraries
 # required by loadable python modules.
@@ -13,16 +14,15 @@ endif
 # test using command-line arguments, so use check-local target instead of TESTS
 check-local:
 if ENABLE_PYTHON_COVERAGE
-	touch $(abs_top_srcdir)/.coverage
+	touch $(abs_top_srcdir)/.coverage 
 	rm -f .coverage
 	${LN_S} $(abs_top_srcdir)/.coverage .coverage
 endif
 	for pytest in $(PYTESTS) ; do \
 	echo Running test: $$pytest ; \
 	$(LIBRARY_PATH_PLACEHOLDER) \
-	env PYTHONPATH=$(abs_top_srcdir)/src/lib/python:$(abs_top_builddir)/src/lib/python:$(abs_top_builddir)/src/bin/stats:$(abs_top_builddir)/src/bin/stats/tests:$(abs_top_builddir)/src/bin/msgq:$(abs_top_builddir)/src/lib/python/isc/config \
+	env PYTHONPATH=$(abs_top_srcdir)/src/lib/python:$(abs_top_builddir)/src/lib/python:$(abs_top_builddir)/src/bin/stats:$(abs_top_builddir)/src/bin/stats/tests \
 	B10_FROM_SOURCE=$(abs_top_srcdir) \
-	CONFIG_TESTDATA_PATH=$(abs_top_srcdir)/src/lib/config/tests/testdata \
 	$(PYCOVERAGE_RUN) $(abs_srcdir)/$$pytest || exit ; \
 	done
 

src/bin/stats/tests/b10-stats-httpd_test.py

@@ -13,251 +13,147 @@
 # NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 # WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-"""
-In each of these tests we start several virtual components. They are
-not the real components, no external processes are started. They are
-just simple mock objects running each in its own thread and pretending
-to be bind10 modules. This helps testing the stats http server in a
-close to real environment.
-"""
-
 import unittest
 import os
-import imp
-import socket
-import errno
-import select
+import http.server
 import string
-import time
-import threading
-import http.client
-import xml.etree.ElementTree
+import fake_select
+import imp
+import sys
+import fake_socket
 
-import isc
-import stats_httpd
-import stats
-from test_utils import BaseModules, ThreadingServerManager, MyStats, MyStatsHttpd, TIMEOUT_SEC
+import isc.cc
 
-# set test name for logger
-isc.log.init("b10-stats-httpd_test")
+import stats_httpd
+stats_httpd.socket = fake_socket
+stats_httpd.select = fake_select
 
 DUMMY_DATA = {
-    'Boss' : {
-        "boot_time": "2011-03-04T11:59:06Z"
-        },
-    'Auth' : {
-        "queries.tcp": 2,
-        "queries.udp": 3
-        },
-    'Stats' : {
-        "report_time": "2011-03-04T11:59:19Z",
-        "boot_time": "2011-03-04T11:59:06Z",
-        "last_update_time": "2011-03-04T11:59:07Z",
-        "lname": "4d70d40a_c@host",
-        "timestamp": 1299239959.560846
-        }
+    "auth.queries.tcp": 10000,
+    "auth.queries.udp": 12000,
+    "bind10.boot_time": "2011-03-04T11:59:05Z",
+    "report_time": "2011-03-04T11:59:19Z",
+    "stats.boot_time": "2011-03-04T11:59:06Z",
+    "stats.last_update_time": "2011-03-04T11:59:07Z",
+    "stats.lname": "4d70d40a_c@host",
+    "stats.start_time": "2011-03-04T11:59:06Z",
+    "stats.timestamp": 1299239959.560846
     }
 
+def push_answer(stats_httpd):
+    stats_httpd.cc_session.group_sendmsg(
+        { 'result': 
+          [ 0, DUMMY_DATA ] }, "Stats")
+
+def pull_query(stats_httpd):
+    (msg, env) = stats_httpd.cc_session.group_recvmsg()
+    if 'result' in msg:
+        (ret, arg) = isc.config.ccsession.parse_answer(msg)
+    else:
+        (ret, arg) = isc.config.ccsession.parse_command(msg)
+    return (ret, arg, env)
+
 class TestHttpHandler(unittest.TestCase):
     """Tests for HttpHandler class"""
 
     def setUp(self):
-        self.base = BaseModules()
-        self.stats_server = ThreadingServerManager(MyStats)
-        self.stats = self.stats_server.server
-        self.stats_server.run()
-
-    def tearDown(self):
-        self.stats_server.shutdown()
-        self.base.shutdown()
+        self.stats_httpd = stats_httpd.StatsHttpd()
+        self.assertTrue(type(self.stats_httpd.httpd) is list)
+        self.httpd = self.stats_httpd.httpd
 
     def test_do_GET(self):
-        (address, port) = ('127.0.0.1', 65450)
-        statshttpd_server = ThreadingServerManager(MyStatsHttpd)
-        self.stats_httpd = statshttpd_server.server
-        self.stats_httpd.load_config({'listen_on' : [{ 'address': address, 'port' : port }]})
-        self.assertTrue(type(self.stats_httpd.httpd) is list)
-        self.assertEqual(len(self.stats_httpd.httpd), 0)
-        statshttpd_server.run()
-        client = http.client.HTTPConnection(address, port)
-        client._http_vsn_str = 'HTTP/1.0\n'
-        client.connect()
+        for ht in self.httpd:
+            self._test_do_GET(ht._handler)
+
+    def _test_do_GET(self, handler):
 
         # URL is '/bind10/statistics/xml'
-        client.putrequest('GET', stats_httpd.XML_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.getheader("Content-type"), "text/xml")
-        self.assertTrue(int(response.getheader("Content-Length")) > 0)
-        self.assertEqual(response.status, 200)
-        root = xml.etree.ElementTree.parse(response).getroot()
-        self.assertTrue(root.tag.find('stats_data') > 0)
-        for (k,v) in root.attrib.items():
-            if k.find('schemaLocation') > 0:
-                self.assertEqual(v, stats_httpd.XSD_NAMESPACE + ' ' + stats_httpd.XSD_URL_PATH)
-        for mod in DUMMY_DATA:
-            for (item, value) in DUMMY_DATA[mod].items():
-                self.assertIsNotNone(root.find(mod + '/' + item))
+        handler.path = stats_httpd.XML_URL_PATH
+        push_answer(self.stats_httpd)
+        handler.do_GET()
+        (ret, arg, env) = pull_query(self.stats_httpd)
+        self.assertEqual(ret, "show")
+        self.assertIsNone(arg)
+        self.assertTrue('group' in env)
+        self.assertEqual(env['group'], 'Stats')
+        self.assertEqual(handler.response.code, 200)
+        self.assertEqual(handler.response.headers["Content-type"], "text/xml")
+        self.assertTrue(handler.response.headers["Content-Length"] > 0)
+        self.assertTrue(handler.response.wrote_headers)
+        self.assertTrue(handler.response.body.find(stats_httpd.XSD_NAMESPACE)>0)
+        self.assertTrue(handler.response.body.find(stats_httpd.XSD_URL_PATH)>0)
+        for (k, v) in DUMMY_DATA.items():
+            self.assertTrue(handler.response.body.find(str(k))>0)
+            self.assertTrue(handler.response.body.find(str(v))>0)
 
         # URL is '/bind10/statitics/xsd'
-        client.putrequest('GET', stats_httpd.XSD_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.getheader("Content-type"), "text/xml")
-        self.assertTrue(int(response.getheader("Content-Length")) > 0)
-        self.assertEqual(response.status, 200)
-        root = xml.etree.ElementTree.parse(response).getroot()
-        url_xmlschema = '{http://www.w3.org/2001/XMLSchema}'
-        tags = [ url_xmlschema + t for t in [ 'element', 'complexType', 'all', 'element' ] ]
-        xsdpath = '/'.join(tags)
-        self.assertTrue(root.tag.find('schema') > 0)
-        self.assertTrue(hasattr(root, 'attrib'))
-        self.assertTrue('targetNamespace' in root.attrib)
-        self.assertEqual(root.attrib['targetNamespace'],
-                         stats_httpd.XSD_NAMESPACE)
-        for elm in root.findall(xsdpath):
-            self.assertIsNotNone(elm.attrib['name'])
-            self.assertTrue(elm.attrib['name'] in DUMMY_DATA)
+        handler.path = stats_httpd.XSD_URL_PATH
+        handler.do_GET()
+        self.assertEqual(handler.response.code, 200)
+        self.assertEqual(handler.response.headers["Content-type"], "text/xml")
+        self.assertTrue(handler.response.headers["Content-Length"] > 0)
+        self.assertTrue(handler.response.wrote_headers)
+        self.assertTrue(handler.response.body.find(stats_httpd.XSD_NAMESPACE)>0)
+        for (k, v) in DUMMY_DATA.items():
+            self.assertTrue(handler.response.body.find(str(k))>0)
 
         # URL is '/bind10/statitics/xsl'
-        client.putrequest('GET', stats_httpd.XSL_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.getheader("Content-type"), "text/xml")
-        self.assertTrue(int(response.getheader("Content-Length")) > 0)
-        self.assertEqual(response.status, 200)
-        root = xml.etree.ElementTree.parse(response).getroot()
-        url_trans = '{http://www.w3.org/1999/XSL/Transform}'
-        url_xhtml = '{http://www.w3.org/1999/xhtml}'
-        xslpath = url_trans + 'template/' + url_xhtml + 'tr'
-        self.assertEqual(root.tag, url_trans + 'stylesheet')
-        for tr in root.findall(xslpath):
-            tds = tr.findall(url_xhtml + 'td')
-            self.assertIsNotNone(tds)
-            self.assertEqual(type(tds), list)
-            self.assertTrue(len(tds) > 2)
-            self.assertTrue(hasattr(tds[0], 'text'))
-            self.assertTrue(tds[0].text in DUMMY_DATA)
-            valueof = tds[2].find(url_trans + 'value-of')
-            self.assertIsNotNone(valueof)
-            self.assertTrue(hasattr(valueof, 'attrib'))
-            self.assertIsNotNone(valueof.attrib)
-            self.assertTrue('select' in valueof.attrib)
-            self.assertTrue(valueof.attrib['select'] in \
-                                [ tds[0].text+'/'+item for item in DUMMY_DATA[tds[0].text].keys() ])
+        handler.path = stats_httpd.XSL_URL_PATH
+        handler.do_GET()
+        self.assertEqual(handler.response.code, 200)
+        self.assertEqual(handler.response.headers["Content-type"], "text/xml")
+        self.assertTrue(handler.response.headers["Content-Length"] > 0)
+        self.assertTrue(handler.response.wrote_headers)
+        self.assertTrue(handler.response.body.find(stats_httpd.XSD_NAMESPACE)>0)
+        for (k, v) in DUMMY_DATA.items():
+            self.assertTrue(handler.response.body.find(str(k))>0)
 
         # 302 redirect
-        client._http_vsn_str = 'HTTP/1.1'
-        client.putrequest('GET', '/')
-        client.putheader('Host', address)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 302)
-        self.assertEqual(response.getheader('Location'),
-                         "http://%s:%d%s" % (address, port, stats_httpd.XML_URL_PATH))
-
-        # # 404 NotFound
-        client._http_vsn_str = 'HTTP/1.0'
-        client.putrequest('GET', '/path/to/foo/bar')
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 404)
-
-        client.close()
-        statshttpd_server.shutdown()
-
-    def test_do_GET_failed1(self):
-        # failure case(connection with Stats is down)
-        (address, port) = ('127.0.0.1', 65451)
-        statshttpd_server = ThreadingServerManager(MyStatsHttpd)
-        statshttpd = statshttpd_server.server
-        statshttpd.load_config({'listen_on' : [{ 'address': address, 'port' : port }]})
-        statshttpd_server.run()
-        self.assertTrue(self.stats_server.server.running)
-        self.stats_server.shutdown()
-        self.assertFalse(self.stats_server.server.running)
-        statshttpd.cc_session.set_timeout(milliseconds=TIMEOUT_SEC/1000)
-        client = http.client.HTTPConnection(address, port)
-        client.connect()
-
-        # request XML
-        client.putrequest('GET', stats_httpd.XML_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 500)
-
-        # request XSD
-        client.putrequest('GET', stats_httpd.XSD_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 500)
-
-        # request XSL
-        client.putrequest('GET', stats_httpd.XSL_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 500)
-
-        client.close()
-        statshttpd_server.shutdown()
-
-    def test_do_GET_failed2(self):
+        handler.path = '/'
+        handler.headers = {'Host': 'my.host.domain'}
+        handler.do_GET()
+        self.assertEqual(handler.response.code, 302)
+        self.assertEqual(handler.response.headers["Location"],
+                         "http://my.host.domain%s" % stats_httpd.XML_URL_PATH)
+
+        # 404 NotFound
+        handler.path = '/path/to/foo/bar'
+        handler.headers = {}
+        handler.do_GET()
+        self.assertEqual(handler.response.code, 404)
+
         # failure case(connection with Stats is down)
-        (address, port) = ('127.0.0.1', 65452)
-        statshttpd_server = ThreadingServerManager(MyStatsHttpd)
-        self.stats_httpd = statshttpd_server.server
-        self.stats_httpd.load_config({'listen_on' : [{ 'address': address, 'port' : port }]})
-        statshttpd_server.run()
-        self.stats.mccs.set_command_handler(
-            lambda cmd, args: \
-                isc.config.ccsession.create_answer(1, "I have an error.")
-            )
-        client = http.client.HTTPConnection(address, port)
-        client.connect()
-
-        # request XML
-        client.putrequest('GET', stats_httpd.XML_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 500)
-
-        # request XSD
-        client.putrequest('GET', stats_httpd.XSD_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 500)
-
-        # request XSL
-        client.putrequest('GET', stats_httpd.XSL_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 500)
-
-        client.close()
-        statshttpd_server.shutdown()
+        handler.path = stats_httpd.XML_URL_PATH
+        push_answer(self.stats_httpd)
+        self.assertFalse(self.stats_httpd.cc_session._socket._closed)
+        self.stats_httpd.cc_session._socket._closed = True
+        handler.do_GET()
+        self.stats_httpd.cc_session._socket._closed = False
+        self.assertEqual(handler.response.code, 500)
+        self.stats_httpd.cc_session._clear_queues()
+
+        # failure case(Stats module returns err)
+        handler.path = stats_httpd.XML_URL_PATH
+        self.stats_httpd.cc_session.group_sendmsg(
+            { 'result': [ 1, "I have an error." ] }, "Stats")
+        self.assertFalse(self.stats_httpd.cc_session._socket._closed)
+        self.stats_httpd.cc_session._socket._closed = False
+        handler.do_GET()
+        self.assertEqual(handler.response.code, 500)
+        self.stats_httpd.cc_session._clear_queues()
 
     def test_do_HEAD(self):
-        (address, port) = ('127.0.0.1', 65453)
-        statshttpd_server = ThreadingServerManager(MyStatsHttpd)
-        self.stats_httpd = statshttpd_server.server
-        self.stats_httpd.load_config({'listen_on' : [{ 'address': address, 'port' : port }]})
-        statshttpd_server.run()
-        client = http.client.HTTPConnection(address, port)
-        client.connect()
-        client.putrequest('HEAD', stats_httpd.XML_URL_PATH)
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 200)
-
-        client.putrequest('HEAD', '/path/to/foo/bar')
-        client.endheaders()
-        response = client.getresponse()
-        self.assertEqual(response.status, 404)
-        client.close()
-        statshttpd_server.shutdown()
+        for ht in self.httpd:
+            self._test_do_HEAD(ht._handler)
+
+    def _test_do_HEAD(self, handler):
+        handler.path = '/path/to/foo/bar'
+        handler.do_HEAD()
+        self.assertEqual(handler.response.code, 404)
 
 class TestHttpServerError(unittest.TestCase):
     """Tests for HttpServerError exception"""
+
     def test_raises(self):
         try:
             raise stats_httpd.HttpServerError('Nothing')
@@ -266,16 +162,17 @@ class TestHttpServerError(unittest.TestCase):
 
 class TestHttpServer(unittest.TestCase):
     """Tests for HttpServer class"""
-    def setUp(self):
-        self.base = BaseModules()
-
-    def tearDown(self):
-        self.base.shutdown()
 
     def test_httpserver(self):
-        statshttpd = stats_httpd.StatsHttpd()
-        self.assertEqual(type(statshttpd.httpd), list)
-        self.assertEqual(len(statshttpd.httpd), 0)
+        self.stats_httpd = stats_httpd.StatsHttpd()
+        for ht in self.stats_httpd.httpd:
+            self.assertTrue(ht.server_address in self.stats_httpd.http_addrs)
+            self.assertEqual(ht.xml_handler, self.stats_httpd.xml_handler)
+            self.assertEqual(ht.xsd_handler, self.stats_httpd.xsd_handler)
+            self.assertEqual(ht.xsl_handler, self.stats_httpd.xsl_handler)
+            self.assertEqual(ht.log_writer, self.stats_httpd.write_log)
+            self.assertTrue(isinstance(ht._handler, stats_httpd.HttpHandler))
+            self.assertTrue(isinstance(ht.socket, fake_socket.socket))
 
 class TestStatsHttpdError(unittest.TestCase):
     """Tests for StatsHttpdError exception"""
@@ -290,173 +187,130 @@ class TestStatsHttpd(unittest.TestCase):
     """Tests for StatsHttpd class"""
 
     def setUp(self):
-        self.base = BaseModules()
-        self.stats_server = ThreadingServerManager(MyStats)
-        self.stats = self.stats_server.server
-        self.stats_server.run()
+        fake_socket._CLOSED = False
+        fake_socket.has_ipv6 = True
         self.stats_httpd = stats_httpd.StatsHttpd()
 
-        # checking IPv6 enabled on this platform
-        self.ipv6_enabled = True
-        try:
-            sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
-            sock.bind(("::1",8000))
-            sock.close()
-        except socket.error:
-            self.ipv6_enabled = False
-
     def tearDown(self):
         self.stats_httpd.stop()
-        self.stats_server.shutdown()
-        self.base.shutdown()
 
     def test_init(self):
-        self.assertEqual(self.stats_httpd.running, False)
-        self.assertEqual(self.stats_httpd.poll_intval, 0.5)
-        self.assertEqual(self.stats_httpd.httpd, [])
-        self.assertEqual(type(self.stats_httpd.mccs), isc.config.ModuleCCSession)
-        self.assertEqual(type(self.stats_httpd.cc_session), isc.cc.Session)
-        self.assertEqual(len(self.stats_httpd.config), 2)
-        self.assertTrue('listen_on' in self.stats_httpd.config)
-        self.assertEqual(len(self.stats_httpd.config['listen_on']), 1)
-        self.assertTrue('address' in self.stats_httpd.config['listen_on'][0])
-        self.assertTrue('port' in self.stats_httpd.config['listen_on'][0])
-        self.assertTrue(('127.0.0.1', 8000) in set(self.stats_httpd.http_addrs))
-
-    def test_openclose_mccs(self):
-        statshttpd = stats_httpd.StatsHttpd()
-        statshttpd.close_mccs()
-        self.assertEqual(statshttpd.mccs, None)
-        statshttpd.open_mccs()
-        self.assertIsNotNone(statshttpd.mccs)
-        statshttpd.mccs = None
-        self.assertEqual(statshttpd.mccs, None)
-        self.assertEqual(statshttpd.close_mccs(), None)
+        self.assertFalse(self.stats_httpd.mccs.get_socket()._closed)
+        self.assertEqual(self.stats_httpd.mccs.get_socket().fileno(),
+                         id(self.stats_httpd.mccs.get_socket()))
+        for ht in self.stats_httpd.httpd:
+            self.assertFalse(ht.socket._closed)
+            self.assertEqual(ht.socket.fileno(), id(ht.socket))
+        fake_socket._CLOSED = True
+        self.assertRaises(isc.cc.session.SessionError,
+                          stats_httpd.StatsHttpd)
+        fake_socket._CLOSED = False
 
     def test_mccs(self):
-        self.assertIsNotNone(self.stats_httpd.mccs.get_socket())
+        self.stats_httpd.open_mccs()
         self.assertTrue(
-            isinstance(self.stats_httpd.mccs.get_socket(), socket.socket))
+            isinstance(self.stats_httpd.mccs.get_socket(), fake_socket.socket))
         self.assertTrue(
             isinstance(self.stats_httpd.cc_session, isc.cc.session.Session))
-        self.statistics_spec = self.stats_httpd.get_stats_spec()
-        for mod in DUMMY_DATA:
-            self.assertTrue(mod in self.statistics_spec)
-            for cfg in self.statistics_spec[mod]:
-                self.assertTrue('item_name' in cfg)
-                self.assertTrue(cfg['item_name'] in DUMMY_DATA[mod])
-            self.assertTrue(len(self.statistics_spec[mod]), len(DUMMY_DATA[mod]))
-        self.stats_httpd.close_mccs()
-        self.assertIsNone(self.stats_httpd.mccs)
+        self.assertTrue(
+            isinstance(self.stats_httpd.stats_module_spec, isc.config.ModuleSpec))
+        for cfg in self.stats_httpd.stats_config_spec:
+            self.assertTrue('item_name' in cfg)
+            self.assertTrue(cfg['item_name'] in DUMMY_DATA)
+        self.assertTrue(len(self.stats_httpd.stats_config_spec), len(DUMMY_DATA))
+
+    def test_load_config(self):
+        self.stats_httpd.load_config()
+        self.assertTrue(('127.0.0.1', 8000) in set(self.stats_httpd.http_addrs))
 
     def test_httpd(self):
         # dual stack (addresses is ipv4 and ipv6)
-        if self.ipv6_enabled:
-            self.assertTrue(('127.0.0.1', 8000) in set(self.stats_httpd.http_addrs))
-            self.stats_httpd.http_addrs = [ ('::1', 8000), ('127.0.0.1', 8000) ]
-            self.assertTrue(
-                stats_httpd.HttpServer.address_family in set([socket.AF_INET, socket.AF_INET6]))
-            self.stats_httpd.open_httpd()
-            for ht in self.stats_httpd.httpd:
-                self.assertTrue(isinstance(ht.socket, socket.socket))
-            self.stats_httpd.close_httpd()
+        fake_socket.has_ipv6 = True
+        self.assertTrue(('127.0.0.1', 8000) in set(self.stats_httpd.http_addrs))
+        self.stats_httpd.http_addrs = [ ('::1', 8000), ('127.0.0.1', 8000) ]
+        self.assertTrue(
+            stats_httpd.HttpServer.address_family in set([fake_socket.AF_INET, fake_socket.AF_INET6]))
+        self.stats_httpd.open_httpd()
+        for ht in self.stats_httpd.httpd:
+            self.assertTrue(isinstance(ht.socket, fake_socket.socket))
+        self.stats_httpd.close_httpd()
 
         # dual stack (address is ipv6)
-        if self.ipv6_enabled:
-            self.stats_httpd.http_addrs = [ ('::1', 8000) ]
-            self.stats_httpd.open_httpd()
-            for ht in self.stats_httpd.httpd:
-                self.assertTrue(isinstance(ht.socket, socket.socket))
-            self.stats_httpd.close_httpd()
+        fake_socket.has_ipv6 = True
+        self.stats_httpd.http_addrs = [ ('::1', 8000) ]
+        self.stats_httpd.open_httpd()
+        for ht in self.stats_httpd.httpd:
+            self.assertTrue(isinstance(ht.socket, fake_socket.socket))
+        self.stats_httpd.close_httpd()
 
         # dual stack (address is ipv4)
-        if self.ipv6_enabled:
-            self.stats_httpd.http_addrs = [ ('127.0.0.1', 8000) ]
-            self.stats_httpd.open_httpd()
-            for ht in self.stats_httpd.httpd:
-                self.assertTrue(isinstance(ht.socket, socket.socket))
-            self.stats_httpd.close_httpd()
+        fake_socket.has_ipv6 = True
+        self.stats_httpd.http_addrs = [ ('127.0.0.1', 8000) ]
+        self.stats_httpd.open_httpd()
+        for ht in self.stats_httpd.httpd:
+            self.assertTrue(isinstance(ht.socket, fake_socket.socket))
+        self.stats_httpd.close_httpd()
 
         # only-ipv4 single stack
-        if not self.ipv6_enabled:
-            self.stats_httpd.http_addrs = [ ('127.0.0.1', 8000) ]
-            self.stats_httpd.open_httpd()
-            for ht in self.stats_httpd.httpd:
-                self.assertTrue(isinstance(ht.socket, socket.socket))
-            self.stats_httpd.close_httpd()
+        fake_socket.has_ipv6 = False
+        self.stats_httpd.http_addrs = [ ('127.0.0.1', 8000) ]
+        self.stats_httpd.open_httpd()
+        for ht in self.stats_httpd.httpd:
+            self.assertTrue(isinstance(ht.socket, fake_socket.socket))
+        self.stats_httpd.close_httpd()
 
         # only-ipv4 single stack (force set ipv6 )
-        if not self.ipv6_enabled:
-            self.stats_httpd.http_addrs = [ ('::1', 8000) ]
-            self.assertRaises(stats_httpd.HttpServerError,
-                              self.stats_httpd.open_httpd)
+        fake_socket.has_ipv6 = False
+        self.stats_httpd.http_addrs = [ ('::1', 8000) ]
+        self.assertRaises(stats_httpd.HttpServerError,
+            self.stats_httpd.open_httpd)
 
         # hostname
         self.stats_httpd.http_addrs = [ ('localhost', 8000) ]
         self.stats_httpd.open_httpd()
         for ht in self.stats_httpd.httpd:
-            self.assertTrue(isinstance(ht.socket, socket.socket))
+            self.assertTrue(isinstance(ht.socket, fake_socket.socket))
         self.stats_httpd.close_httpd()
 
         self.stats_httpd.http_addrs = [ ('my.host.domain', 8000) ]
-        self.assertRaises(stats_httpd.HttpServerError, self.stats_httpd.open_httpd)
-        self.assertEqual(type(self.stats_httpd.httpd), list)
-        self.assertEqual(len(self.stats_httpd.httpd), 0)
+        self.stats_httpd.open_httpd()
+        for ht in self.stats_httpd.httpd:
+            self.assertTrue(isinstance(ht.socket, fake_socket.socket))
         self.stats_httpd.close_httpd()
 
         # over flow of port number
         self.stats_httpd.http_addrs = [ ('', 80000) ]
         self.assertRaises(stats_httpd.HttpServerError, self.stats_httpd.open_httpd)
-
         # negative
         self.stats_httpd.http_addrs = [ ('', -8000) ]
         self.assertRaises(stats_httpd.HttpServerError, self.stats_httpd.open_httpd)
-
         # alphabet
         self.stats_httpd.http_addrs = [ ('', 'ABCDE') ]
         self.assertRaises(stats_httpd.HttpServerError, self.stats_httpd.open_httpd)
 
-        # Address already in use
-        self.statshttpd_server = ThreadingServerManager(MyStatsHttpd)
-        self.statshttpd_server.server.load_config({'listen_on' : [{ 'address': '127.0.0.1', 'port' : 65454 }]})
-        self.statshttpd_server.run()
-        self.stats_httpd.load_config({'listen_on' : [{ 'address': '127.0.0.1', 'port' : 65454 }]})
-        self.assertRaises(stats_httpd.HttpServerError, self.stats_httpd.open_httpd)
-        self.statshttpd_server.shutdown()
+    def test_start(self):
+        self.stats_httpd.cc_session.group_sendmsg(
+            { 'command': [ "shutdown" ] }, "StatsHttpd")
+        self.stats_httpd.start()
+        self.stats_httpd = stats_httpd.StatsHttpd()
+        self.assertRaises(
+            fake_select.error, self.stats_httpd.start)
 
-    def test_running(self):
-        self.assertFalse(self.stats_httpd.running)
-        self.statshttpd_server = ThreadingServerManager(MyStatsHttpd)
-        self.stats_httpd = self.statshttpd_server.server
-        self.stats_httpd.load_config({'listen_on' : [{ 'address': '127.0.0.1', 'port' : 65455 }]})
-        self.statshttpd_server.run()
-        self.assertTrue(self.stats_httpd.running)
-        self.statshttpd_server.shutdown()
+    def test_stop(self):
+        # success case
+        fake_socket._CLOSED = False
+        self.stats_httpd.stop()
         self.assertFalse(self.stats_httpd.running)
-
+        self.assertIsNone(self.stats_httpd.mccs)
+        for ht in self.stats_httpd.httpd:
+            self.assertTrue(ht.socket._closed)
+        self.assertTrue(self.stats_httpd.cc_session._socket._closed)
         # failure case
-        self.stats_httpd = stats_httpd.StatsHttpd()
-        self.stats_httpd.cc_session.close()
-        self.assertRaises(
-            isc.cc.session.SessionError, self.stats_httpd.start)
-
-    def test_select_failure(self):
-        def raise_select_except(*args):
-            raise select.error('dummy error')
-        def raise_select_except_with_errno(*args):
-            raise select.error(errno.EINTR)
-        (address, port) = ('127.0.0.1', 65456)
-        stats_httpd.select.select = raise_select_except
-        statshttpd = stats_httpd.StatsHttpd()
-        statshttpd.load_config({'listen_on' : [{ 'address': address, 'port' : port }]})
-        self.assertRaises(select.error, statshttpd.start)
-        statshttpd.stop()
-        stats_httpd.select.select = raise_select_except_with_errno
-        statshttpd_server = ThreadingServerManager(MyStatsHttpd)
-        statshttpd = statshttpd_server.server
-        statshttpd.load_config({'listen_on' : [{ 'address': address, 'port' : port }]})
-        statshttpd_server.run()
-        statshttpd_server.shutdown()
+        self.stats_httpd.cc_session._socket._closed = False
+        self.stats_httpd.open_mccs()
+        self.stats_httpd.cc_session._socket._closed = True
+        self.stats_httpd.stop() # No excetion raises
+        self.stats_httpd.cc_session._socket._closed = False
 
     def test_open_template(self):
         # successful conditions
@@ -509,40 +363,38 @@ class TestStatsHttpd(unittest.TestCase):
         self.assertEqual(
             self.stats_httpd.config_handler(dict(_UNKNOWN_KEY_=None)),
             isc.config.ccsession.create_answer(
-                1, "Unknown known config: _UNKNOWN_KEY_"))
-
+                    1, "Unknown known config: _UNKNOWN_KEY_"))
         self.assertEqual(
             self.stats_httpd.config_handler(
-                dict(listen_on=[dict(address="127.0.0.1",port=8000)])),
+                        dict(listen_on=[dict(address="::2",port=8000)])),
             isc.config.ccsession.create_answer(0))
         self.assertTrue("listen_on" in self.stats_httpd.config)
         for addr in self.stats_httpd.config["listen_on"]:
             self.assertTrue("address" in addr)
             self.assertTrue("port" in addr)
-            self.assertTrue(addr["address"] == "127.0.0.1")
+            self.assertTrue(addr["address"] == "::2")
             self.assertTrue(addr["port"] == 8000)
 
-        if self.ipv6_enabled:
-            self.assertEqual(
-                self.stats_httpd.config_handler(
-                    dict(listen_on=[dict(address="::1",port=8000)])),
-                isc.config.ccsession.create_answer(0))
-            self.assertTrue("listen_on" in self.stats_httpd.config)
-            for addr in self.stats_httpd.config["listen_on"]:
-                self.assertTrue("address" in addr)
-                self.assertTrue("port" in addr)
-                self.assertTrue(addr["address"] == "::1")
-                self.assertTrue(addr["port"] == 8000)
+        self.assertEqual(
+            self.stats_httpd.config_handler(
+                        dict(listen_on=[dict(address="::1",port=80)])),
+            isc.config.ccsession.create_answer(0))
+        self.assertTrue("listen_on" in self.stats_httpd.config)
+        for addr in self.stats_httpd.config["listen_on"]:
+            self.assertTrue("address" in addr)
+            self.assertTrue("port" in addr)
+            self.assertTrue(addr["address"] == "::1")
+            self.assertTrue(addr["port"] == 80)
 
         self.assertEqual(
             self.stats_httpd.config_handler(
-                        dict(listen_on=[dict(address="127.0.0.1",port=54321)])),
+                        dict(listen_on=[dict(address="1.2.3.4",port=54321)])),
             isc.config.ccsession.create_answer(0))
         self.assertTrue("listen_on" in self.stats_httpd.config)
         for addr in self.stats_httpd.config["listen_on"]:
             self.assertTrue("address" in addr)
             self.assertTrue("port" in addr)
-            self.assertTrue(addr["address"] == "127.0.0.1")
+            self.assertTrue(addr["address"] == "1.2.3.4")
             self.assertTrue(addr["port"] == 54321)
         (ret, arg) = isc.config.ccsession.parse_answer(
             self.stats_httpd.config_handler(
@@ -552,11 +404,10 @@ class TestStatsHttpd(unittest.TestCase):
 
     def test_xml_handler(self):
         orig_get_stats_data = stats_httpd.StatsHttpd.get_stats_data
-        stats_httpd.StatsHttpd.get_stats_data = lambda x: \
-            { 'Dummy' : { 'foo':'bar' } }
+        stats_httpd.StatsHttpd.get_stats_data = lambda x: {'foo':'bar'}
         xml_body1 = stats_httpd.StatsHttpd().open_template(
             stats_httpd.XML_TEMPLATE_LOCATION).substitute(
-            xml_string='<Dummy><foo>bar</foo></Dummy>',
+            xml_string='<foo>bar</foo>',
             xsd_namespace=stats_httpd.XSD_NAMESPACE,
             xsd_url_path=stats_httpd.XSD_URL_PATH,
             xsl_url_path=stats_httpd.XSL_URL_PATH)
@@ -564,8 +415,7 @@ class TestStatsHttpd(unittest.TestCase):
         self.assertEqual(type(xml_body1), str)
         self.assertEqual(type(xml_body2), str)
         self.assertEqual(xml_body1, xml_body2)
-        stats_httpd.StatsHttpd.get_stats_data = lambda x: \
-            { 'Dummy' : {'bar':'foo'} }
+        stats_httpd.StatsHttpd.get_stats_data = lambda x: {'bar':'foo'}
         xml_body2 = stats_httpd.StatsHttpd().xml_handler()
         self.assertNotEqual(xml_body1, xml_body2)
         stats_httpd.StatsHttpd.get_stats_data = orig_get_stats_data
@@ -573,41 +423,35 @@ class TestStatsHttpd(unittest.TestCase):
     def test_xsd_handler(self):
         orig_get_stats_spec = stats_httpd.StatsHttpd.get_stats_spec
         stats_httpd.StatsHttpd.get_stats_spec = lambda x: \
-            { "Dummy" :
-                  [{
-                        "item_name": "foo",
-                        "item_type": "string",
-                        "item_optional": False,
-                        "item_default": "bar",
-                        "item_description": "foo is bar",
-                        "item_title": "Foo"
-                        }]
-              }
+            [{
+                "item_name": "foo",
+                "item_type": "string",
+                "item_optional": False,
+                "item_default": "bar",
+                "item_description": "foo is bar",
+                "item_title": "Foo"
+               }]
         xsd_body1 = stats_httpd.StatsHttpd().open_template(
             stats_httpd.XSD_TEMPLATE_LOCATION).substitute(
-            xsd_string=\
-                '<all><element name="Dummy"><complexType><all>' \
+            xsd_string='<all>' \
                 + '<element maxOccurs="1" minOccurs="1" name="foo" type="string">' \
                 + '<annotation><appinfo>Foo</appinfo>' \
                 + '<documentation>foo is bar</documentation>' \
-                + '</annotation></element></all>' \
-                + '</complexType></element></all>',
+                + '</annotation></element></all>',
             xsd_namespace=stats_httpd.XSD_NAMESPACE)
         xsd_body2 = stats_httpd.StatsHttpd().xsd_handler()
         self.assertEqual(type(xsd_body1), str)
         self.assertEqual(type(xsd_body2), str)
         self.assertEqual(xsd_body1, xsd_body2)
         stats_httpd.StatsHttpd.get_stats_spec = lambda x: \
-            { "Dummy" :
-                  [{
-                        "item_name": "bar",
-                        "item_type": "string",
-                        "item_optional": False,
-                        "item_default": "foo",
-                        "item_description": "bar is foo",
-                        "item_title": "bar"
-                        }]
-              }
+            [{
+                "item_name": "bar",
+                "item_type": "string",
+                "item_optional": False,
+                "item_default": "foo",
+                "item_description": "bar is foo",
+                "item_title": "bar"
+               }]
         xsd_body2 = stats_httpd.StatsHttpd().xsd_handler()
         self.assertNotEqual(xsd_body1, xsd_body2)
         stats_httpd.StatsHttpd.get_stats_spec = orig_get_stats_spec
@@ -615,22 +459,19 @@ class TestStatsHttpd(unittest.TestCase):
     def test_xsl_handler(self):
         orig_get_stats_spec = stats_httpd.StatsHttpd.get_stats_spec
         stats_httpd.StatsHttpd.get_stats_spec = lambda x: \
-            { "Dummy" :
-                  [{
-                        "item_name": "foo",
-                        "item_type": "string",
-                        "item_optional": False,
-                        "item_default": "bar",
-                        "item_description": "foo is bar",
-                        "item_title": "Foo"
-                        }]
-              }
+            [{
+                "item_name": "foo",
+                "item_type": "string",
+                "item_optional": False,
+                "item_default": "bar",
+                "item_description": "foo is bar",
+                "item_title": "Foo"
+               }]
         xsl_body1 = stats_httpd.StatsHttpd().open_template(
             stats_httpd.XSL_TEMPLATE_LOCATION).substitute(
             xsl_string='<xsl:template match="*"><tr>' \
-                + '<td>Dummy</td>' \
                 + '<td class="title" title="foo is bar">Foo</td>' \
-                + '<td><xsl:value-of select="Dummy/foo" /></td>' \
+                + '<td><xsl:value-of select="foo" /></td>' \
                 + '</tr></xsl:template>',
             xsd_namespace=stats_httpd.XSD_NAMESPACE)
         xsl_body2 = stats_httpd.StatsHttpd().xsl_handler()
@@ -638,16 +479,14 @@ class TestStatsHttpd(unittest.TestCase):
         self.assertEqual(type(xsl_body2), str)
         self.assertEqual(xsl_body1, xsl_body2)
         stats_httpd.StatsHttpd.get_stats_spec = lambda x: \
-            { "Dummy" :
-                  [{
-                        "item_name": "bar",
-                        "item_type": "string",
-                        "item_optional": False,
-                        "item_default": "foo",
-                        "item_description": "bar is foo",
-                        "item_title": "bar"
-                        }]
-              }
+            [{
+                "item_name": "bar",
+                "item_type": "string",
+                "item_optional": False,
+                "item_default": "foo",
+                "item_description": "bar is foo",
+                "item_title": "bar"
+               }]
         xsl_body2 = stats_httpd.StatsHttpd().xsl_handler()
         self.assertNotEqual(xsl_body1, xsl_body2)
         stats_httpd.StatsHttpd.get_stats_spec = orig_get_stats_spec
@@ -661,6 +500,8 @@ class TestStatsHttpd(unittest.TestCase):
             imp.reload(stats_httpd)
             os.environ["B10_FROM_SOURCE"] = tmppath
             imp.reload(stats_httpd)
+            stats_httpd.socket = fake_socket
+            stats_httpd.select = fake_select
 
 if __name__ == "__main__":
     unittest.main()

src/bin/stats/tests/fake_select.py

@@ -0,0 +1,43 @@
+# Copyright (C) 2011  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.
+
+"""
+A mock-up module of select
+
+*** NOTE ***
+It is only for testing stats_httpd module and not reusable for
+external module.
+"""
+
+import fake_socket
+import errno
+
+class error(Exception):
+    pass
+
+def select(rlst, wlst, xlst, timeout):
+    if type(timeout) != int and type(timeout) != float:
+            raise TypeError("Error: %s must be integer or float"
+                            % timeout.__class__.__name__)
+    for s in rlst + wlst + xlst:
+        if type(s) != fake_socket.socket:
+            raise TypeError("Error: %s must be a dummy socket"
+                            % s.__class__.__name__)
+        s._called = s._called + 1
+        if s._called > 3:
+            raise error("Something is happened!")
+        elif s._called > 2:
+            raise error(errno.EINTR)
+    return (rlst, wlst, xlst)

src/bin/stats/tests/fake_socket.py

@@ -0,0 +1,70 @@
+# Copyright (C) 2011  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.
+
+"""
+A mock-up module of socket
+
+*** NOTE ***
+It is only for testing stats_httpd module and not reusable for
+external module.
+"""
+
+import re
+
+AF_INET = 'AF_INET'
+AF_INET6 = 'AF_INET6'
+_ADDRFAMILY = AF_INET
+has_ipv6 = True
+_CLOSED = False
+
+class gaierror(Exception):
+    pass
+
+class error(Exception):
+    pass
+
+class socket:
+
+    def __init__(self, family=None):
+        if family is None:
+            self.address_family = _ADDRFAMILY
+        else:
+            self.address_family = family
+        self._closed = _CLOSED
+        if self._closed:
+            raise error('socket is already closed!')
+        self._called = 0
+
+    def close(self):
+        self._closed = True
+
+    def fileno(self):
+        return id(self)
+
+    def bind(self, server_class):
+        (self.server_address, self.server_port) = server_class
+        if self.address_family not in set([AF_INET, AF_INET6]):
+            raise error("Address family not supported by protocol: %s" % self.address_family)
+        if self.address_family == AF_INET6 and not has_ipv6:
+            raise error("Address family not supported in this machine: %s has_ipv6: %s"
+                        % (self.address_family, str(has_ipv6)))
+        if self.address_family == AF_INET and re.search(':', self.server_address) is not None:
+            raise gaierror("Address family for hostname not supported : %s %s" % (self.server_address, self.address_family))
+        if self.address_family == AF_INET6 and re.search(':', self.server_address) is None:
+            raise error("Cannot assign requested address : %s" % str(self.server_address))
+        if type(self.server_port) is not int:
+            raise TypeError("an integer is required: %s" % str(self.server_port))
+        if self.server_port < 0 or self.server_port > 65535:
+            raise OverflowError("port number must be 0-65535.: %s" % str(self.server_port))

src/bin/stats/tests/fake_time.py

@@ -0,0 +1,47 @@
+# 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.
+
+__version__ = "$Revision$"
+
+# This is a dummy time class against a Python standard time class.
+# It is just testing use only.
+# Other methods which time class has is not implemented.
+# (This class isn't orderloaded for time class.)
+
+# These variables are constant. These are example.
+_TEST_TIME_SECS = 1283364938.229088
+_TEST_TIME_STRF = '2010-09-01T18:15:38Z'
+
+def time():
+    """
+    This is a dummy time() method against time.time()
+    """
+    # return float constant value
+    return _TEST_TIME_SECS
+
+def gmtime():
+    """
+    This is a dummy gmtime() method against time.gmtime()
+    """
+    # always return nothing
+    return None
+
+def strftime(*arg):
+    """
+    This is a dummy gmtime() method against time.gmtime()
+    """
+    return _TEST_TIME_STRF
+
+

src/bin/stats/tests/http/Makefile.am

@@ -0,0 +1,6 @@
+EXTRA_DIST = __init__.py server.py
+CLEANFILES = __init__.pyc server.pyc
+CLEANDIRS = __pycache__
+
+clean-local:
+	rm -rf $(CLEANDIRS)

src/bin/stats/tests/http/server.py

@@ -0,0 +1,96 @@
+# Copyright (C) 2011  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.
+
+"""
+A mock-up module of http.server
+
+*** NOTE ***
+It is only for testing stats_httpd module and not reusable for
+external module.
+"""
+
+import fake_socket
+
+class DummyHttpResponse:
+    def __init__(self, path):
+        self.path = path
+        self.headers={}
+        self.log = ""
+
+    def _write_log(self, msg):
+        self.log = self.log + msg
+
+class HTTPServer:
+    """
+    A mock-up class of http.server.HTTPServer
+    """
+    address_family = fake_socket.AF_INET
+    def __init__(self, server_class, handler_class):
+        self.socket = fake_socket.socket(self.address_family)
+        self.server_class = server_class
+        self.socket.bind(self.server_class)
+        self._handler = handler_class(None, None, self)
+
+    def handle_request(self):
+        pass
+
+    def server_close(self):
+        self.socket.close()
+
+class BaseHTTPRequestHandler:
+    """
+    A mock-up class of http.server.BaseHTTPRequestHandler
+    """
+
+    def __init__(self, request, client_address, server):
+        self.path = "/path/to"
+        self.headers = {}
+        self.server = server
+        self.response = DummyHttpResponse(path=self.path)
+        self.response.write = self._write
+        self.wfile = self.response
+
+    def send_response(self, code=0):
+        if self.path != self.response.path:
+            self.response = DummyHttpResponse(path=self.path)
+        self.response.code = code
+
+    def send_header(self, key, value):
+        if self.path != self.response.path:
+            self.response = DummyHttpResponse(path=self.path)
+        self.response.headers[key] = value
+
+    def end_headers(self):
+        if self.path != self.response.path:
+            self.response = DummyHttpResponse(path=self.path)
+        self.response.wrote_headers = True
+
+    def send_error(self, code, message=None):
+        if self.path != self.response.path:
+            self.response = DummyHttpResponse(path=self.path)
+        self.response.code = code
+        self.response.body = message
+
+    def address_string(self):
+        return 'dummyhost'
+
+    def log_date_time_string(self):
+        return '[DD/MM/YYYY HH:MI:SS]'
+
+    def _write(self, obj):
+        if self.path != self.response.path:
+            self.response = DummyHttpResponse(path=self.path)
+        self.response.body = obj.decode()
+

src/bin/stats/tests/isc/Makefile.am

@@ -0,0 +1,8 @@
+SUBDIRS = cc config util log
+EXTRA_DIST = __init__.py
+CLEANFILES = __init__.pyc
+
+CLEANDIRS = __pycache__
+
+clean-local:
+	rm -rf $(CLEANDIRS)

src/bin/stats/tests/isc/cc/Makefile.am

@@ -0,0 +1,7 @@
+EXTRA_DIST = __init__.py session.py
+CLEANFILES = __init__.pyc session.pyc
+
+CLEANDIRS = __pycache__
+
+clean-local:
+	rm -rf $(CLEANDIRS)

src/bin/stats/tests/isc/cc/__init__.py

@@ -0,0 +1 @@
+from isc.cc.session import *

src/bin/stats/tests/isc/cc/session.py

@@ -0,0 +1,148 @@
+# Copyright (C) 2010,2011  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.
+
+"""
+A mock-up module of isc.cc.session
+
+*** NOTE ***
+It is only for testing stats_httpd module and not reusable for
+external module.
+"""
+
+import sys
+import fake_socket
+
+# set a dummy lname
+_TEST_LNAME = '123abc@xxxx'
+
+class Queue():
+    def __init__(self, msg=None, env={}):
+        self.msg = msg
+        self.env = env
+
+    def dump(self):
+        return { 'msg': self.msg, 'env': self.env }
+               
+class SessionError(Exception):
+    pass
+
+class SessionTimeout(Exception):
+    pass
+
+class Session:
+    def __init__(self, socket_file=None, verbose=False):
+        self._lname = _TEST_LNAME
+        self.message_queue = []
+        self.old_message_queue = []
+        try:
+            self._socket = fake_socket.socket()
+        except fake_socket.error as se:
+            raise SessionError(se)
+        self.verbose = verbose
+
+    @property
+    def lname(self):
+        return self._lname
+
+    def close(self):
+        self._socket.close()
+
+    def _clear_queues(self):
+        while len(self.message_queue) > 0:
+            self.dequeue()
+
+    def _next_sequence(self, que=None):
+        return len(self.message_queue)
+
+    def enqueue(self, msg=None, env={}):
+        if self._socket._closed:
+            raise SessionError("Session has been closed.")
+        seq = self._next_sequence()
+        env.update({"seq": 0}) # fixed here
+        que = Queue(msg=msg, env=env)
+        self.message_queue.append(que)
+        if self.verbose:
+            sys.stdout.write("[Session] enqueue: " + str(que.dump()) + "\n")
+        return seq
+
+    def dequeue(self):
+        if self._socket._closed:
+            raise SessionError("Session has been closed.")
+        que = None
+        try:
+            que = self.message_queue.pop(0) # always pop at index 0
+            self.old_message_queue.append(que)
+        except IndexError:
+            que = Queue()
+        if self.verbose:
+            sys.stdout.write("[Session] dequeue: " + str(que.dump()) + "\n")
+        return que
+
+    def get_queue(self, seq=None):
+        if self._socket._closed:
+            raise SessionError("Session has been closed.")
+        if seq is None:
+            seq = len(self.message_queue) - 1
+        que = None
+        try:
+            que = self.message_queue[seq]
+        except IndexError:
+            raise IndexError
+            que = Queue()
+        if self.verbose:
+            sys.stdout.write("[Session] get_queue: " + str(que.dump()) + "\n")
+        return que
+
+    def group_sendmsg(self, msg, group, instance="*", to="*"):
+        return self.enqueue(msg=msg, env={
+                "type": "send",
+                "from": self._lname,
+                "to": to,
+                "group": group,
+                "instance": instance })
+
+    def group_recvmsg(self, nonblock=True, seq=0):
+        que = self.dequeue()
+        return que.msg, que.env
+        
+    def group_reply(self, routing, msg):
+        return self.enqueue(msg=msg, env={
+                "type": "send",
+                "from": self._lname,
+                "to": routing["from"],
+                "group": routing["group"],
+                "instance": routing["instance"],
+                "reply": routing["seq"] })
+
+    def get_message(self, group, to='*'):
+        if self._socket._closed:
+            raise SessionError("Session has been closed.")
+        que = Queue()
+        for q in self.message_queue:
+            if q.env['group'] == group:
+                self.message_queue.remove(q)
+                self.old_message_queue.append(q)
+                que = q
+        if self.verbose:
+            sys.stdout.write("[Session] get_message: " + str(que.dump()) + "\n")
+        return q.msg
+
+    def group_subscribe(self, group, instance = "*"):
+        if self._socket._closed:
+            raise SessionError("Session has been closed.")
+
+    def group_unsubscribe(self, group, instance = "*"):
+        if self._socket._closed:
+            raise SessionError("Session has been closed.")

src/bin/stats/tests/isc/config/Makefile.am

@@ -0,0 +1,7 @@
+EXTRA_DIST = __init__.py ccsession.py
+CLEANFILES = __init__.pyc ccsession.pyc
+
+CLEANDIRS = __pycache__
+
+clean-local:
+	rm -rf $(CLEANDIRS)

src/bin/stats/tests/isc/config/__init__.py

@@ -0,0 +1 @@
+from isc.config.ccsession import *

src/bin/stats/tests/isc/config/ccsession.py

@@ -0,0 +1,249 @@
+# Copyright (C) 2010,2011  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.
+
+"""
+A mock-up module of isc.cc.session
+
+*** NOTE ***
+It is only for testing stats_httpd module and not reusable for
+external module.
+"""
+
+import json
+import os
+import time
+from isc.cc.session import Session
+
+COMMAND_CONFIG_UPDATE = "config_update"
+
+def parse_answer(msg):
+    assert 'result' in msg
+    try:
+        return msg['result'][0], msg['result'][1]
+    except IndexError:
+        return msg['result'][0], None
+
+def create_answer(rcode, arg = None):
+    if arg is None:
+        return { 'result': [ rcode ] }
+    else:
+        return { 'result': [ rcode, arg ] }
+
+def parse_command(msg):
+    assert 'command' in msg
+    try:
+        return msg['command'][0], msg['command'][1]
+    except IndexError:
+        return msg['command'][0], None
+
+def create_command(command_name, params = None):
+    if params is None:
+        return {"command": [command_name]}
+    else:
+        return {"command": [command_name, params]}
+
+def module_spec_from_file(spec_file, check = True):
+    try:
+        file = open(spec_file)
+        json_str = file.read()
+        module_spec = json.loads(json_str)
+        file.close()
+        return ModuleSpec(module_spec['module_spec'], check)
+    except IOError as ioe:
+        raise ModuleSpecError("JSON read error: " + str(ioe))
+    except ValueError as ve:
+        raise ModuleSpecError("JSON parse error: " + str(ve))
+    except KeyError as err:
+        raise ModuleSpecError("Data definition has no module_spec element")
+
+class ModuleSpecError(Exception):
+    pass
+
+class ModuleSpec:
+    def __init__(self, module_spec, check = True):
+        # check only confi_data for testing
+        if check and "config_data" in module_spec:
+            _check_config_spec(module_spec["config_data"])
+        self._module_spec = module_spec
+
+    def get_config_spec(self):
+        return self._module_spec['config_data']
+
+    def get_commands_spec(self):
+        return self._module_spec['commands']
+
+    def get_module_name(self):
+        return self._module_spec['module_name']
+
+def _check_config_spec(config_data):
+    # config data is a list of items represented by dicts that contain
+    # things like "item_name", depending on the type they can have
+    # specific subitems
+    """Checks a list that contains the configuration part of the
+       specification. Raises a ModuleSpecError if there is a
+       problem."""
+    if type(config_data) != list:
+        raise ModuleSpecError("config_data is of type " + str(type(config_data)) + ", not a list of items")
+    for config_item in config_data:
+        _check_item_spec(config_item)
+
+def _check_item_spec(config_item):
+    """Checks the dict that defines one config item
+       (i.e. containing "item_name", "item_type", etc.
+       Raises a ModuleSpecError if there is an error"""
+    if type(config_item) != dict:
+        raise ModuleSpecError("item spec not a dict")
+    if "item_name" not in config_item:
+        raise ModuleSpecError("no item_name in config item")
+    if type(config_item["item_name"]) != str:
+        raise ModuleSpecError("item_name is not a string: " + str(config_item["item_name"]))
+    item_name = config_item["item_name"]
+    if "item_type" not in config_item:
+        raise ModuleSpecError("no item_type in config item")
+    item_type = config_item["item_type"]
+    if type(item_type) != str:
+        raise ModuleSpecError("item_type in " + item_name + " is not a string: " + str(type(item_type)))
+    if item_type not in ["integer", "real", "boolean", "string", "list", "map", "any"]:
+        raise ModuleSpecError("unknown item_type in " + item_name + ": " + item_type)
+    if "item_optional" in config_item:
+        if type(config_item["item_optional"]) != bool:
+            raise ModuleSpecError("item_default in " + item_name + " is not a boolean")
+        if not config_item["item_optional"] and "item_default" not in config_item:
+            raise ModuleSpecError("no default value for non-optional item " + item_name)
+    else:
+        raise ModuleSpecError("item_optional not in item " + item_name)
+    if "item_default" in config_item:
+        item_default = config_item["item_default"]
+        if (item_type == "integer" and type(item_default) != int) or \
+           (item_type == "real" and type(item_default) != float) or \
+           (item_type == "boolean" and type(item_default) != bool) or \
+           (item_type == "string" and type(item_default) != str) or \
+           (item_type == "list" and type(item_default) != list) or \
+           (item_type == "map" and type(item_default) != dict):
+            raise ModuleSpecError("Wrong type for item_default in " + item_name)
+    # TODO: once we have check_type, run the item default through that with the list|map_item_spec
+    if item_type == "list":
+        if "list_item_spec" not in config_item:
+            raise ModuleSpecError("no list_item_spec in list item " + item_name)
+        if type(config_item["list_item_spec"]) != dict:
+            raise ModuleSpecError("list_item_spec in " + item_name + " is not a dict")
+        _check_item_spec(config_item["list_item_spec"])
+    if item_type == "map":
+        if "map_item_spec" not in config_item:
+            raise ModuleSpecError("no map_item_sepc in map item " + item_name)
+        if type(config_item["map_item_spec"]) != list:
+            raise ModuleSpecError("map_item_spec in " + item_name + " is not a list")
+        for map_item in config_item["map_item_spec"]:
+            if type(map_item) != dict:
+                raise ModuleSpecError("map_item_spec element is not a dict")
+            _check_item_spec(map_item)
+    if 'item_format' in config_item and 'item_default' in config_item:
+        item_format = config_item["item_format"]
+        item_default = config_item["item_default"]
+        if not _check_format(item_default, item_format):
+            raise ModuleSpecError(
+                "Wrong format for " + str(item_default) + " in " + str(item_name))
+
+def _check_format(value, format_name):
+    """Check if specified value and format are correct. Return True if
+       is is correct."""
+    # TODO: should be added other format types if necessary
+    time_formats = { 'date-time' : "%Y-%m-%dT%H:%M:%SZ",
+                     'date'      : "%Y-%m-%d",
+                     'time'      : "%H:%M:%S" }
+    for fmt in time_formats:
+        if format_name == fmt:
+            try:
+                time.strptime(value, time_formats[fmt])
+                return True
+            except (ValueError, TypeError):
+                break
+    return False
+
+class ModuleCCSessionError(Exception):
+    pass
+
+class DataNotFoundError(Exception):
+    pass
+
+class ConfigData:
+    def __init__(self, specification):
+        self.specification = specification
+
+    def get_value(self, identifier):
+        """Returns a tuple where the first item is the value at the
+           given identifier, and the second item is absolutely False
+           even if the value is an unset default or not. Raises an
+           DataNotFoundError if the identifier is not found in the
+           specification file.
+           *** NOTE ***
+           There are some differences from the original method. This
+           method never handles local settings like the original
+           method. But these different behaviors aren't so big issues
+           for a mock-up method of stats_httpd because stats_httpd
+           calls this method at only first."""
+        for config_map in self.get_module_spec().get_config_spec():
+            if config_map['item_name'] == identifier:
+                if 'item_default' in config_map:
+                    return config_map['item_default'], False
+        raise DataNotFoundError("item_name %s is not found in the specfile" % identifier)
+
+    def get_module_spec(self):
+        return self.specification
+
+class ModuleCCSession(ConfigData):
+    def __init__(self, spec_file_name, config_handler, command_handler, cc_session = None):
+        module_spec = module_spec_from_file(spec_file_name)
+        ConfigData.__init__(self, module_spec)
+        self._module_name = module_spec.get_module_name()
+        self.set_config_handler(config_handler)
+        self.set_command_handler(command_handler)
+        if not cc_session:
+            self._session = Session(verbose=True)
+        else:
+            self._session = cc_session
+
+    def start(self):
+        pass
+
+    def close(self):
+        self._session.close()
+
+    def check_command(self, nonblock=True):
+        msg, env = self._session.group_recvmsg(nonblock)
+        if not msg or 'result' in msg:
+            return
+        cmd, arg = parse_command(msg)
+        answer = None
+        if cmd == COMMAND_CONFIG_UPDATE and self._config_handler:
+            answer = self._config_handler(arg)
+        elif env['group'] == self._module_name and self._command_handler:
+            answer = self._command_handler(cmd, arg)
+        if answer:
+            self._session.group_reply(env, answer)
+
+    def set_config_handler(self, config_handler):
+        self._config_handler = config_handler
+        # should we run this right now since we've changed the handler?
+
+    def set_command_handler(self, command_handler):
+        self._command_handler = command_handler
+
+    def get_module_spec(self):
+        return self.specification
+
+    def get_socket(self):
+        return self._session._socket
+

src/bin/stats/tests/isc/log/Makefile.am

@@ -0,0 +1,7 @@
+EXTRA_DIST = __init__.py
+CLEANFILES = __init__.pyc
+
+CLEANDIRS = __pycache__
+
+clean-local:
+	rm -rf $(CLEANDIRS)

src/bin/stats/tests/isc/log/__init__.py

@@ -0,0 +1,33 @@
+# Copyright (C) 2011  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.
+
+# This file is not installed. The log.so is installed into the right place.
+# It is only to find it in the .libs directory when we run as a test or
+# from the build directory.
+# But as nobody gives us the builddir explicitly (and we can't use generation
+# from .in file, as it would put us into the builddir and we wouldn't be found)
+# we guess from current directory. Any idea for something better? This should
+# be enough for the tests, but would it work for B10_FROM_SOURCE as well?
+# Should we look there? Or define something in bind10_config?
+
+import os
+import sys
+
+for base in sys.path[:]:
+    loglibdir = os.path.join(base, 'isc/log/.libs')
+    if os.path.exists(loglibdir):
+        sys.path.insert(0, loglibdir)
+
+from log import *

src/bin/stats/tests/isc/util/Makefile.am

@@ -0,0 +1,7 @@
+EXTRA_DIST = __init__.py process.py
+CLEANFILES = __init__.pyc process.pyc
+
+CLEANDIRS = __pycache__
+
+clean-local:
+	rm -rf $(CLEANDIRS)

src/bin/stats/tests/isc/util/process.py

@@ -0,0 +1,21 @@
+# 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.
+
+"""
+A dummy function of isc.util.process.rename()
+"""
+
+def rename(name=None):
+    pass

src/bin/stats/tests/test_utils.py

@@ -1,291 +0,0 @@
-"""
-Utilities and mock modules for unittests of statistics modules
-
-"""
-import os
-import io
-import time
-import sys
-import threading
-import tempfile
-
-import msgq
-import isc.config.cfgmgr
-import stats
-import stats_httpd
-
-# TODO: consider appropriate timeout seconds
-TIMEOUT_SEC = 0.05
-
-def send_command(command_name, module_name, params=None, session=None, nonblock=False, timeout=TIMEOUT_SEC):
-    if not session:
-        cc_session = isc.cc.Session()
-    else:
-        cc_session = session
-    orig_timeout = cc_session.get_timeout()
-    cc_session.set_timeout(timeout * 1000)
-    command = isc.config.ccsession.create_command(command_name, params)
-    seq = cc_session.group_sendmsg(command, module_name)
-    try:
-        (answer, env) = cc_session.group_recvmsg(nonblock, seq)
-        if answer:
-            return isc.config.ccsession.parse_answer(answer)
-    except isc.cc.SessionTimeout:
-        pass
-    finally:
-        if not session:
-            cc_session.close()
-        else:
-            cc_session.set_timeout(orig_timeout)
-
-def send_shutdown(module_name):
-    return send_command("shutdown", module_name)
-
-class ThreadingServerManager:
-    def __init__(self, server_class):
-        self.server_class = server_class
-        self.server_class_name = server_class.__name__
-        self.server = self.server_class()
-        self.server._thread = threading.Thread(
-            name=self.server_class_name, target=self.server.run)
-        self.server._thread.daemon = True
-
-    def run(self):
-        self.server._thread.start()
-        self.server._started.wait()
-        self.server._started.clear()
-        # waiting for the server's being ready for listening
-        time.sleep(TIMEOUT_SEC)
-
-    def shutdown(self):
-        self.server.shutdown()
-        self.server._thread.join(TIMEOUT_SEC)
-
-class MockMsgq:
-    def __init__(self):
-        self._started = threading.Event()
-        self.msgq = msgq.MsgQ(None)
-        result = self.msgq.setup()
-        if result:
-            sys.exit("Error on Msgq startup: %s" % result)
-
-    def run(self):
-        self._started.set()
-        try:
-            self.msgq.run()
-        except Exception:
-            pass
-        finally:
-            self.shutdown()
-
-    def shutdown(self):
-        self.msgq.shutdown()
-
-class MockCfgmgr:
-    def __init__(self):
-        self._started = threading.Event()
-        self.cfgmgr = isc.config.cfgmgr.ConfigManager(
-            os.environ['CONFIG_TESTDATA_PATH'], "b10-config.db")
-        self.cfgmgr.read_config()
-
-    def run(self):
-        self._started.set()
-        try:
-            self.cfgmgr.run()
-        finally:
-            self.shutdown()
-
-    def shutdown(self):
-        self.cfgmgr.running = False
-
-class MockBoss:
-    spec_str = """\
-{
-  "module_spec": {
-    "module_name": "Boss",
-    "module_description": "Mock Master process",
-    "config_data": [],
-    "commands": [
-      {
-        "command_name": "sendstats",
-        "command_description": "Send data to a statistics module at once",
-        "command_args": []
-      }
-    ],
-    "statistics": [
-      {
-        "item_name": "boot_time",
-        "item_type": "string",
-        "item_optional": false,
-        "item_default": "1970-01-01T00:00:00Z",
-        "item_title": "Boot time",
-        "item_description": "A date time when bind10 process starts initially",
-        "item_format": "date-time"
-      }
-    ]
-  }
-}
-"""
-    _BASETIME = (2011, 6, 22, 8, 14, 8, 2, 173, 0)
-
-    def __init__(self):
-        self._started = threading.Event()
-        self.running = False
-        self.spec_file = io.StringIO(self.spec_str)
-        # create ModuleCCSession object
-        self.mccs = isc.config.ModuleCCSession(
-            self.spec_file,
-            self.config_handler,
-            self.command_handler)
-        self.spec_file.close()
-        self.cc_session = self.mccs._session
-        self.got_command_name = ''
-
-    def run(self):
-        self.mccs.start()
-        self.running = True
-        self._started.set()
-        while self.running:
-            self.mccs.check_command(False)
-
-    def shutdown(self):
-        self.running = False
-
-    def config_handler(self, new_config):
-        return isc.config.create_answer(0)
-
-    def command_handler(self, command, *args, **kwargs):
-        self.got_command_name = command
-        if command == 'sendstats':
-            params = { "owner": "Boss",
-                       "data": {
-                    'boot_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', self._BASETIME)
-                    }
-                       }
-            return send_command("set", "Stats", params=params, session=self.cc_session)
-        return isc.config.create_answer(1, "Unknown Command")
-
-class MockAuth:
-    spec_str = """\
-{
-  "module_spec": {
-    "module_name": "Auth",
-    "module_description": "Mock Authoritative service",
-    "config_data": [],
-    "commands": [
-      {
-        "command_name": "sendstats",
-        "command_description": "Send data to a statistics module at once",
-        "command_args": []
-      }
-    ],
-    "statistics": [
-      {
-        "item_name": "queries.tcp",
-        "item_type": "integer",
-        "item_optional": false,
-        "item_default": 0,
-        "item_title": "Queries TCP",
-        "item_description": "A number of total query counts which all auth servers receive over TCP since they started initially"
-      },
-      {
-        "item_name": "queries.udp",
-        "item_type": "integer",
-        "item_optional": false,
-        "item_default": 0,
-        "item_title": "Queries UDP",
-        "item_description": "A number of total query counts which all auth servers receive over UDP since they started initially"
-      }
-    ]
-  }
-}
-"""
-    def __init__(self):
-        self._started = threading.Event()
-        self.running = False
-        self.spec_file = io.StringIO(self.spec_str)
-        # create ModuleCCSession object
-        self.mccs = isc.config.ModuleCCSession(
-            self.spec_file,
-            self.config_handler,
-            self.command_handler)
-        self.spec_file.close()
-        self.cc_session = self.mccs._session
-        self.got_command_name = ''
-        self.queries_tcp = 3
-        self.queries_udp = 2
-
-    def run(self):
-        self.mccs.start()
-        self.running = True
-        self._started.set()
-        while self.running:
-            self.mccs.check_command(False)
-
-    def shutdown(self):
-        self.running = False
-
-    def config_handler(self, new_config):
-        return isc.config.create_answer(0)
-
-    def command_handler(self, command, *args, **kwargs):
-        self.got_command_name = command
-        if command == 'sendstats':
-            params = { "owner": "Auth",
-                       "data": { 'queries.tcp': self.queries_tcp,
-                                 'queries.udp': self.queries_udp } }
-            return send_command("set", "Stats", params=params, session=self.cc_session)
-        return isc.config.create_answer(1, "Unknown Command")
-
-class MyStats(stats.Stats):
-    def __init__(self):
-        self._started = threading.Event()
-        stats.Stats.__init__(self)
-
-    def run(self):
-        self._started.set()
-        stats.Stats.start(self)
-
-    def shutdown(self):
-        send_shutdown("Stats")
-
-class MyStatsHttpd(stats_httpd.StatsHttpd):
-    def __init__(self):
-        self._started = threading.Event()
-        stats_httpd.StatsHttpd.__init__(self)
-
-    def run(self):
-        self._started.set()
-        stats_httpd.StatsHttpd.start(self)
-
-    def shutdown(self):
-        send_shutdown("StatsHttpd")
-
-class BaseModules:
-    def __init__(self):
-        self.class_name = BaseModules.__name__
-
-        # Change value of BIND10_MSGQ_SOCKET_FILE in environment variables
-        os.environ['BIND10_MSGQ_SOCKET_FILE'] = tempfile.mktemp(prefix='unix_socket.')
-        # MockMsgq
-        self.msgq = ThreadingServerManager(MockMsgq)
-        self.msgq.run()
-        # MockCfgmgr
-        self.cfgmgr = ThreadingServerManager(MockCfgmgr)
-        self.cfgmgr.run()
-        # MockBoss
-        self.boss = ThreadingServerManager(MockBoss)
-        self.boss.run()
-        # MockAuth
-        self.auth = ThreadingServerManager(MockAuth)
-        self.auth.run()
-
-    def shutdown(self):
-        # MockAuth
-        self.auth.shutdown()
-        # MockBoss
-        self.boss.shutdown()
-        # MockCfgmgr
-        self.cfgmgr.shutdown()
-        # MockMsgq
-        self.msgq.shutdown()

src/bin/stats/tests/testdata/Makefile.am

@@ -0,0 +1 @@
+EXTRA_DIST = stats_test.spec

src/bin/stats/tests/testdata/stats_test.spec

@@ -0,0 +1,19 @@
+{
+  "module_spec": {
+    "module_name": "Stats",
+    "module_description": "Stats daemon",
+    "config_data": [],
+    "commands": [
+      {
+        "command_name": "status",
+        "command_description": "identify whether stats module is alive or not",
+        "command_args": []
+      },
+      {
+        "command_name": "the_dummy",
+        "command_description": "this is for testing",
+        "command_args": []
+      }
+    ]
+  }
+}

src/bin/tests/Makefile.am

@@ -14,7 +14,7 @@ endif
 # test using command-line arguments, so use check-local target instead of TESTS
 check-local:
 if ENABLE_PYTHON_COVERAGE
-	touch $(abs_top_srcdir)/.coverage
+	touch $(abs_top_srcdir)/.coverage 
 	rm -f .coverage
 	${LN_S} $(abs_top_srcdir)/.coverage .coverage
 endif

tests/system/bindctl/tests.sh

@@ -24,10 +24,6 @@ SYSTEMTESTTOP=..
 status=0
 n=0
 
-# TODO: consider consistency with statistics definition in auth.spec
-auth_queries_tcp="\<queries\.tcp\>"
-auth_queries_udp="\<queries\.udp\>"
-
 echo "I:Checking b10-auth is working by default ($n)"
 $DIG +norec @10.53.0.1 -p 53210 ns.example.com. A >dig.out.$n || status=1
 # perform a simple check on the output (digcomp would be too much for this)
@@ -44,8 +40,8 @@ echo 'Stats show
 	--csv-file-dir=$BINDCTL_CSV_DIR > bindctl.out.$n || status=1
 # the server should have received 1 UDP and 1 TCP queries (TCP query was
 # sent from the server startup script)
-grep $auth_queries_tcp".*\<1\>" bindctl.out.$n > /dev/null || status=1
-grep $auth_queries_udp".*\<1\>" bindctl.out.$n > /dev/null || status=1
+grep "\"auth.queries.tcp\": 1," bindctl.out.$n > /dev/null || status=1
+grep "\"auth.queries.udp\": 1," bindctl.out.$n > /dev/null || status=1
 if [ $status != 0 ]; then echo "I:failed"; fi
 n=`expr $n + 1`
 
@@ -77,8 +73,8 @@ echo 'Stats show
 ' | $RUN_BINDCTL \
 	--csv-file-dir=$BINDCTL_CSV_DIR > bindctl.out.$n || status=1
 # The statistics counters should have been reset while stop/start.
-grep $auth_queries_tcp".*\<0\>" bindctl.out.$n > /dev/null || status=1
-grep $auth_queries_udp".*\<1\>" bindctl.out.$n > /dev/null || status=1
+grep "\"auth.queries.tcp\": 0," bindctl.out.$n > /dev/null || status=1
+grep "\"auth.queries.udp\": 1," bindctl.out.$n > /dev/null || status=1
 if [ $status != 0 ]; then echo "I:failed"; fi
 n=`expr $n + 1`
 
@@ -101,8 +97,8 @@ echo 'Stats show
 ' | $RUN_BINDCTL \
 	--csv-file-dir=$BINDCTL_CSV_DIR > bindctl.out.$n || status=1
 # The statistics counters shouldn't be reset due to hot-swapping datasource.
-grep $auth_queries_tcp".*\<0\>" bindctl.out.$n > /dev/null || status=1
-grep $auth_queries_udp".*\<2\>" bindctl.out.$n > /dev/null || status=1
+grep "\"auth.queries.tcp\": 0," bindctl.out.$n > /dev/null || status=1
+grep "\"auth.queries.udp\": 2," bindctl.out.$n > /dev/null || status=1
 if [ $status != 0 ]; then echo "I:failed"; fi
 n=`expr $n + 1`