[2225_xfrout] rename module name(counter) to class name(Counter)

src/bin/xfrout/tests/xfrout_test.py.in

@@ -291,7 +291,7 @@ class TestXfroutSessionBase(unittest.TestCase):
         # the XfroutSession object.  We check the condition here.
         self.assertEqual(0, self.xfrsess._server.transfer_counter)
         # clear statistics counters
-        counter.clear_counters()
+        Counter.clear_counters()
 
 class TestXfroutSession(TestXfroutSessionBase):
     def test_quota_error(self):
@@ -380,7 +380,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         ]))
         # check the 'xfrrej' counter initially
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_xfrrej, TEST_ZONE_NAME_STR)
+                          Counter.get_xfrrej, TEST_ZONE_NAME_STR)
         # Localhost (the default in this test) is accepted
         rcode, msg = self.xfrsess._parse_query_message(self.mdata)
         self.assertEqual(rcode.to_text(), "NOERROR")
@@ -395,7 +395,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         rcode, msg = self.xfrsess._parse_query_message(self.mdata)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(counter.get_xfrrej(TEST_ZONE_NAME_STR), 1)
+        self.assertEqual(Counter.get_xfrrej(TEST_ZONE_NAME_STR), 1)
 
         # TSIG signed request
         request_data = self.create_request_data(with_tsig=True)
@@ -425,7 +425,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         [rcode, msg] = self.xfrsess._parse_query_message(request_data)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(counter.get_xfrrej(TEST_ZONE_NAME_STR), 2)
+        self.assertEqual(Counter.get_xfrrej(TEST_ZONE_NAME_STR), 2)
 
         # ACL using TSIG: no TSIG; should be rejected
         acl_setter(isc.acl.dns.REQUEST_LOADER.load([
@@ -434,7 +434,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         [rcode, msg] = self.xfrsess._parse_query_message(self.mdata)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(counter.get_xfrrej(TEST_ZONE_NAME_STR), 3)
+        self.assertEqual(Counter.get_xfrrej(TEST_ZONE_NAME_STR), 3)
 
         #
         # ACL using IP + TSIG: both should match
@@ -455,21 +455,21 @@ class TestXfroutSession(TestXfroutSessionBase):
         [rcode, msg] = self.xfrsess._parse_query_message(request_data)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(counter.get_xfrrej(TEST_ZONE_NAME_STR), 4)
+        self.assertEqual(Counter.get_xfrrej(TEST_ZONE_NAME_STR), 4)
         # Address matches, but TSIG doesn't (not included)
         self.xfrsess._remote = (socket.AF_INET, socket.SOCK_STREAM,
                                 ('192.0.2.1', 12345))
         [rcode, msg] = self.xfrsess._parse_query_message(self.mdata)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(counter.get_xfrrej(TEST_ZONE_NAME_STR), 5)
+        self.assertEqual(Counter.get_xfrrej(TEST_ZONE_NAME_STR), 5)
         # Neither address nor TSIG matches
         self.xfrsess._remote = (socket.AF_INET, socket.SOCK_STREAM,
                                 ('192.0.2.2', 12345))
         [rcode, msg] = self.xfrsess._parse_query_message(self.mdata)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(counter.get_xfrrej(TEST_ZONE_NAME_STR), 6)
+        self.assertEqual(Counter.get_xfrrej(TEST_ZONE_NAME_STR), 6)
 
     def test_transfer_acl(self):
         # ACL checks only with the default ACL
@@ -853,9 +853,9 @@ class TestXfroutSession(TestXfroutSessionBase):
 
         self.xfrsess._reply_xfrout_query = myreply
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_unixsocket_senderr)
+                          Counter.get_unixsocket_senderr)
         self.xfrsess.dns_xfrout_start(self.sock, self.mdata)
-        self.assertEqual(counter.get_unixsocket_senderr(), 1)
+        self.assertEqual(Counter.get_unixsocket_senderr(), 1)
 
     def test_dns_xfrout_start_noerror(self):
         def noerror(msg, name, rrclass):
@@ -866,12 +866,12 @@ class TestXfroutSession(TestXfroutSessionBase):
             self.sock.send(b"success")
 
         self.assertRaises(isc.cc.data.DataNotFoundError,
-            counter.get_xfrreqdone, TEST_ZONE_NAME_STR)
+            Counter.get_xfrreqdone, TEST_ZONE_NAME_STR)
         self.xfrsess._reply_xfrout_query = myreply
         self.xfrsess.dns_xfrout_start(self.sock, self.mdata)
         self.assertEqual(self.sock.readsent(), b"success")
         self.assertGreater(\
-            counter.get_xfrreqdone(TEST_ZONE_NAME_STR), 0)
+            Counter.get_xfrreqdone(TEST_ZONE_NAME_STR), 0)
 
     def test_reply_xfrout_query_axfr(self):
         self.xfrsess._soa = self.soa_rrset
@@ -1128,7 +1128,7 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
 
     def test_axfr_normal_session(self):
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_axfr_running)
+                          Counter.get_axfr_running)
         XfroutSession._handle(self.xfrsess)
         response = self.sock.read_msg(Message.PRESERVE_ORDER);
         self.assertEqual(Rcode.NOERROR(), response.get_rcode())
@@ -1136,8 +1136,8 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
         self.assertEqual(self.xfrsess._request_type, RRType.AXFR())
         self.assertNotEqual(self.xfrsess._request_type, RRType.IXFR())
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_ixfr_running)
-        self.assertEqual(counter.get_axfr_running(), 0)
+                          Counter.get_ixfr_running)
+        self.assertEqual(Counter.get_axfr_running(), 0)
 
     def test_ixfr_to_axfr(self):
         self.xfrsess._request_data = \
@@ -1157,9 +1157,9 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
         self.xfrsess._request_data = \
             self.create_request_data(ixfr=IXFR_OK_VERSION)
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_axfr_running)
+                          Counter.get_axfr_running)
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_ixfr_running)
+                          Counter.get_ixfr_running)
         XfroutSession._handle(self.xfrsess)
         response = self.sock.read_msg(Message.PRESERVE_ORDER)
         actual_records = response.get_section(Message.SECTION_ANSWER)
@@ -1178,8 +1178,8 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
         self.assertNotEqual(self.xfrsess._request_type, RRType.AXFR())
         self.assertEqual(self.xfrsess._request_type, RRType.IXFR())
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_axfr_running)
-        self.assertEqual(counter.get_ixfr_running(), 0)
+                          Counter.get_axfr_running)
+        self.assertEqual(Counter.get_ixfr_running(), 0)
 
     def ixfr_soa_only_common_checks(self, request_serial):
         self.xfrsess._request_data = \
@@ -1568,45 +1568,45 @@ class TestUnixSockServerForCounter(unittest.TestCase):
             super,
             self.orig_process_request,
             self.orig_select )
-        counter.clear_counters()
+        Counter.clear_counters()
 
     def test_open(self):
         # open
-        self.assertEqual(counter.get_unixsocket_open(), 1)
+        self.assertEqual(Counter.get_unixsocket_open(), 1)
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_unixsocket_openfail)
+                          Counter.get_unixsocket_openfail)
         xfrout.ThreadingUnixStreamServer = DummySocketserverException
         self.unix = UnixSockServer(None, None, None, None, None)
-        self.assertEqual(counter.get_unixsocket_open(), 1)
-        self.assertEqual(counter.get_unixsocket_openfail(), 1)
+        self.assertEqual(Counter.get_unixsocket_open(), 1)
+        self.assertEqual(Counter.get_unixsocket_openfail(), 1)
 
     def test_close(self):
         # close
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_unixsocket_close)
+                          Counter.get_unixsocket_close)
         self.unix.shutdown()
-        self.assertEqual(counter.get_unixsocket_close(), 1)
+        self.assertEqual(Counter.get_unixsocket_close(), 1)
 
     def test_bindfail(self):
         # bindfail
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_unixsocket_bindfail)
+                          Counter.get_unixsocket_bindfail)
         self.assertRaises(Exception, self.unix.server_bind)
-        self.assertEqual(counter.get_unixsocket_bindfail(), 1)
+        self.assertEqual(Counter.get_unixsocket_bindfail(), 1)
 
     def test_accept(self):
         # accept
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_unixsocket_accept)
+                          Counter.get_unixsocket_accept)
         self.unix.get_request()
-        self.assertEqual(counter.get_unixsocket_accept(), 1)
+        self.assertEqual(Counter.get_unixsocket_accept(), 1)
         # acceptfail
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_unixsocket_acceptfail)
+                          Counter.get_unixsocket_acceptfail)
         xfrout.super = lambda : DummyClassException()
         self.unix = UnixSockServer(None, None, None, None, None)
         self.assertRaises(Exception, self.unix.get_request)
-        self.assertEqual(counter.get_unixsocket_acceptfail(), 1)
+        self.assertEqual(Counter.get_unixsocket_acceptfail(), 1)
 
     def test_senderr(self):
         # do inside of above TestXfroutSession
@@ -1615,12 +1615,12 @@ class TestUnixSockServerForCounter(unittest.TestCase):
     def test_recverr(self):
         # recverr
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          counter.get_unixsocket_recverr)
+                          Counter.get_unixsocket_recverr)
         def raise_socketerror(x,y):
             raise socket.error
         self.unix.process_request = raise_socketerror
         self.unix._select_loop(None)
-        self.assertEqual(counter.get_unixsocket_recverr(), 1)
+        self.assertEqual(Counter.get_unixsocket_recverr(), 1)
 
 class TestInitialization(unittest.TestCase):
     def setEnv(self, name, value):

src/bin/xfrout/xfrout.py.in

@@ -27,7 +27,7 @@ from socketserver import *
 import os
 from isc.config.ccsession import *
 from isc.cc import SessionError, SessionTimeout
-from isc.statistics import counter
+from isc.statistics import Counter
 from isc.notify import notify_out
 import isc.util.process
 import socket
@@ -110,7 +110,7 @@ XFROUT_DNS_HEADER_SIZE = 12     # protocol constant
 XFROUT_MAX_MESSAGE_SIZE = 65535 # ditto
 
 # setup statistics counter
-counter.init(SPECFILE_LOCATION)
+Counter.init(SPECFILE_LOCATION)
 
 # borrowed from xfrin.py @ #1298.  We should eventually unify it.
 def format_zone_str(zone_name, zone_class):
@@ -275,7 +275,7 @@ class XfroutSession():
             return None, None
         elif acl_result == REJECT:
             # count rejected Xfr request by each zone name
-            counter.inc_xfrrej(zone_name.to_text())
+            Counter.inc_xfrrej(zone_name.to_text())
             logger.debug(DBG_XFROUT_TRACE, XFROUT_QUERY_REJECTED,
                          self._request_type, format_addrinfo(self._remote),
                          format_zone_str(zone_name, zone_class))
@@ -527,25 +527,25 @@ class XfroutSession():
         try:
             # increment Xfr starts by RRType
             if self._request_type == RRType.AXFR():
-                counter.inc_axfr_running()
+                Counter.inc_axfr_running()
             else:
-                counter.inc_ixfr_running()
+                Counter.inc_ixfr_running()
             logger.info(XFROUT_XFR_TRANSFER_STARTED, self._request_typestr,
                         format_addrinfo(self._remote), zone_str)
             self._reply_xfrout_query(msg, sock_fd)
         except Exception as err:
             # count unixsockets send errors
-            counter.inc_unixsocket_senderr()
+            Counter.inc_unixsocket_senderr()
             logger.error(XFROUT_XFR_TRANSFER_ERROR, self._request_typestr,
                     format_addrinfo(self._remote), zone_str, err)
         finally:
             # decrement Xfr starts by RRType
             if self._request_type == RRType.AXFR():
-                counter.dec_axfr_running()
+                Counter.dec_axfr_running()
             else:
-                counter.dec_ixfr_running()
+                Counter.dec_ixfr_running()
         # count done Xfr requests by each zone name
-        counter.inc_xfrreqdone(zone_name.to_text())
+        Counter.inc_xfrreqdone(zone_name.to_text())
         logger.info(XFROUT_XFR_TRANSFER_DONE, self._request_typestr,
                     format_addrinfo(self._remote), zone_str)
 
@@ -663,9 +663,9 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
             ThreadingUnixStreamServer.__init__(self, sock_file, \
                                                    handle_class)
         except:
-            counter.inc_unixsocket_openfail()
+            Counter.inc_unixsocket_openfail()
         else:
-            counter.inc_unixsocket_open()
+            Counter.inc_unixsocket_open()
         self._shutdown_event = shutdown_event
         self._write_sock, self._read_sock = socket.socketpair()
         self._common_init()
@@ -682,7 +682,7 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
             return super().server_bind()
         except:
             # count bind failed unixsockets
-            counter.inc_unixsocket_bindfail()
+            Counter.inc_unixsocket_bindfail()
             raise
 
     def get_request(self):
@@ -694,11 +694,11 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
             # ThreadingUnixStreamServer
             ret = super().get_request()
             # count successfully accepted unixsockets
-            counter.inc_unixsocket_accept()
+            Counter.inc_unixsocket_accept()
             return ret
         except:
             # count failed accepted unixsockets
-            counter.inc_unixsocket_acceptfail()
+            Counter.inc_unixsocket_acceptfail()
             raise
 
     def _common_init(self):
@@ -768,7 +768,7 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
                     break
             except Exception as pre:
                 # count unixsockets receive errors
-                counter.inc_unixsocket_recverr()
+                Counter.inc_unixsocket_recverr()
                 logger.error(XFROUT_PROCESS_REQUEST_ERROR, pre)
                 break
 
@@ -895,7 +895,7 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
         super().shutdown() # call the shutdown() of class socketserver_mixin.NoPollMixIn
         try:
             # count closed unixsockets
-            counter.inc_unixsocket_close()
+            Counter.inc_unixsocket_close()
             os.unlink(self._sock_file)
         except Exception as e:
             logger.error(XFROUT_REMOVE_UNIX_SOCKET_FILE_ERROR, self._sock_file, str(e))
@@ -1093,7 +1093,7 @@ class XfroutServer:
             # The log level is here set to debug in order to avoid
             # that a log becomes too verbose. Because the b10-stats
             # daemon is periodically asking to the b10-xfrout daemon.
-            answer = create_answer(0, counter.dump_statistics())
+            answer = create_answer(0, Counter.dump_statistics())
             logger.debug(DBG_XFROUT_TRACE, \
                              XFROUT_RECEIVED_GETSTATS_COMMAND, \
                              str(answer))

src/lib/python/isc/notify/notify_out.py

@@ -25,7 +25,7 @@ from isc.datasrc import DataSourceClient
 from isc.net import addr
 import isc
 from isc.log_messages.notify_out_messages import *
-from isc.statistics import counter
+from isc.statistics import Counter
 
 logger = isc.log.Logger("notify_out")
 
@@ -481,9 +481,9 @@ class NotifyOut:
             sock.sendto(render.get_data(), 0, addrinfo)
             # count notifying by IPv4 or IPv6 for statistics
             if zone_notify_info.get_socket().family == socket.AF_INET:
-                counter.inc_notifyoutv4(zone_notify_info.zone_name)
+                Counter.inc_notifyoutv4(zone_notify_info.zone_name)
             elif zone_notify_info.get_socket().family == socket.AF_INET6:
-                counter.inc_notifyoutv6(zone_notify_info.zone_name)
+                Counter.inc_notifyoutv6(zone_notify_info.zone_name)
             logger.info(NOTIFY_OUT_SENDING_NOTIFY, addrinfo[0],
                         addrinfo[1])
         except (socket.error, addr.InvalidAddress) as err:

src/lib/python/isc/notify/tests/notify_out_test.py

@@ -107,8 +107,8 @@ class DummyNotifyOutCounter:
         self._notifiesv4 = []
         self._notifiesv6 = []
 
-counter = DummyNotifyOutCounter()
-notify_out.counter = counter
+notify_out.Counter = DummyNotifyOutCounter()
+Counter = notify_out.Counter
 
 class TestNotifyOut(unittest.TestCase):
     def setUp(self):
@@ -129,7 +129,7 @@ class TestNotifyOut(unittest.TestCase):
         com_ch_info.notify_slaves.append(('1.1.1.1', 5353))
 
     def tearDown(self):
-        counter.clear_counters()
+        Counter.clear_counters()
 
     def test_send_notify(self):
         notify_out._MAX_NOTIFY_NUM = 2
@@ -283,35 +283,35 @@ class TestNotifyOut(unittest.TestCase):
     def test_send_notify_message_udp_ipv4(self):
         example_com_info = self._notify._notify_infos[('example.net.', 'IN')]
 
-        self.assertEqual(counter.get_notifyoutv4('example.net.'), 0)
-        self.assertEqual(counter.get_notifyoutv6('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv4('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv6('example.net.'), 0)
 
         example_com_info.prepare_notify_out()
         ret = self._notify._send_notify_message_udp(example_com_info,
                                                     ('192.0.2.1', 53))
         self.assertTrue(ret)
         self.assertEqual(socket.AF_INET, example_com_info.sock_family)
-        self.assertGreater(counter.get_notifyoutv4('example.net.'), 0)
-        self.assertEqual(counter.get_notifyoutv6('example.net.'), 0)
+        self.assertGreater(Counter.get_notifyoutv4('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv6('example.net.'), 0)
 
     def test_send_notify_message_udp_ipv6(self):
         example_com_info = self._notify._notify_infos[('example.net.', 'IN')]
 
-        self.assertEqual(counter.get_notifyoutv4('example.net.'), 0)
-        self.assertEqual(counter.get_notifyoutv6('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv4('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv6('example.net.'), 0)
 
         ret = self._notify._send_notify_message_udp(example_com_info,
                                                     ('2001:db8::53', 53))
         self.assertTrue(ret)
         self.assertEqual(socket.AF_INET6, example_com_info.sock_family)
-        self.assertEqual(counter.get_notifyoutv4('example.net.'), 0)
-        self.assertGreater(counter.get_notifyoutv6('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv4('example.net.'), 0)
+        self.assertGreater(Counter.get_notifyoutv6('example.net.'), 0)
 
     def test_send_notify_message_with_bogus_address(self):
         example_com_info = self._notify._notify_infos[('example.net.', 'IN')]
 
-        self.assertEqual(counter.get_notifyoutv4('example.net.'), 0)
-        self.assertEqual(counter.get_notifyoutv6('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv4('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv6('example.net.'), 0)
 
         # As long as the underlying data source validates RDATA this shouldn't
         # happen, but right now it's not actually the case.  Even if the
@@ -321,8 +321,8 @@ class TestNotifyOut(unittest.TestCase):
                                                     ('invalid', 53))
         self.assertFalse(ret)
 
-        self.assertEqual(counter.get_notifyoutv4('example.net.'), 0)
-        self.assertEqual(counter.get_notifyoutv6('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv4('example.net.'), 0)
+        self.assertEqual(Counter.get_notifyoutv6('example.net.'), 0)
 
     def test_zone_notify_handler(self):
         old_send_msg = self._notify._send_notify_message_udp