refine zonemgr info map and unittest

git-svn-id: svn://bind10.isc.org/svn/bind10/branches/trac289@2633 e5f2f494-b856-4b98-b285-d166d9295462

src/bin/zonemgr/tests/zonemgr_test.py

@@ -13,7 +13,7 @@
 # NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 # WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-'''Tests for the ZoneRefreshInfo and ZoneMgr classes '''
+'''Tests for the ZoneMgrRefreshInfo and ZoneMgr classes '''
 
 
 import unittest
@@ -21,6 +21,8 @@ import os
 import tempfile
 from zonemgr import *
 
+ZONE_NAME_CLASS1 = ("sd.cn.", "IN")
+ZONE_NAME_CLASS2 = ("tw.cn", "IN")
 class ZonemgrTestException(Exception):
     pass
 
@@ -32,28 +34,29 @@ class MySession():
         if module_name not in ("Auth", "Xfrin"):
             raise ZonemgrTestException("module name not exist")
 
-class MyZoneRefreshInfo(ZoneRefreshInfo):
+class MyZoneMgrRefreshInfo(ZoneMgrRefreshInfo):
     def __init__(self):
         self._cc = MySession()
         self._sock_file = UNIX_SOCKET_FILE
         self._db_file = "initdb.file"
-        self._zone_name_list = ['sd.cn.', 'tw.cn']
-        self._zones_refresh_info = [
-        {'last_refresh_time': 1280474398.822142,
+        self._zonemgr_refresh_info = { 
+         ('sd.cn.', 'IN'): {
+         'last_refresh_time': 1280474398.822142,
          'next_refresh_time': 1280481598.822153, 
          'zone_soa_rdata': 'a.dns.cn. root.cnnic.cn. 2009073105 7200 3600 2419200 21600', 
          'zone_state': 0},
-        {'last_refresh_time': 1280474399.116421, 
+         ('tw.cn', 'IN'): {
+         'last_refresh_time': 1280474399.116421, 
          'next_refresh_time': 1280481599.116433, 
          'zone_soa_rdata': 'a.dns.cn. root.cnnic.cn. 2009073112 7200 3600 2419200 21600', 
          'zone_state': 0}
-        ]
+        } 
 
-class TestZoneRefreshInfo(unittest.TestCase):
+class TestZoneMgrRefreshInfo(unittest.TestCase):
     def setUp(self):
         self.stdout_backup = sys.stdout
         sys.stdout = open(os.devnull, 'w')
-        self.zoneinfo = MyZoneRefreshInfo()
+        self.zoneinfo = MyZoneMgrRefreshInfo()
 
     def test_random_jitter(self):
         max = 100025.120
@@ -70,56 +73,59 @@ class TestZoneRefreshInfo(unittest.TestCase):
         max = 3600
         jitter = 900
         time1 = time.time()
-        self.zoneinfo._set_zone_timer(0, 3600, 900)
+        self.zoneinfo._set_zone_timer(ZONE_NAME_CLASS1, 3600, 900)
         time2 = time.time()
-        zone_timeout = float(self.zoneinfo._zones_refresh_info[0]["next_refresh_time"])
+        zone_timeout = float(self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["next_refresh_time"])
         self.assertTrue((3600 - 900) <= (zone_timeout - time1))
         self.assertTrue((zone_timeout - time2) <= 3600)
 
     def test_set_zone_refresh_timer(self):
         time1 = time.time()
-        self.zoneinfo._set_zone_refresh_timer(0)
-        zone_timeout = self.zoneinfo._zones_refresh_info[0]["next_refresh_time"]
+        self.zoneinfo._set_zone_refresh_timer(ZONE_NAME_CLASS1)
+        zone_timeout = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["next_refresh_time"]
         time2 = time.time()
         self.assertTrue((time1 + 7200 * 3 / 4) <= zone_timeout)
         self.assertTrue(zone_timeout <= time2 + 7200)
         
     def test_set_zone_retry_timer(self):
         time1 = time.time()
-        self.zoneinfo._set_zone_retry_timer(0)
-        zone_timeout = self.zoneinfo._zones_refresh_info[0]["next_refresh_time"]
+        self.zoneinfo._set_zone_retry_timer(ZONE_NAME_CLASS1)
+        zone_timeout = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["next_refresh_time"]
         time2 = time.time()
         self.assertTrue((time1 + 3600 * 3 / 4) <= zone_timeout)
         self.assertTrue(zone_timeout <= time2 + 3600)
 
+    def test_zone_not_exist(self):
+        self.assertFalse(self.zoneinfo._zone_not_exist(ZONE_NAME_CLASS1))
+        self.assertFalse(self.zoneinfo._zone_not_exist(ZONE_NAME_CLASS2))
+        ZONE_NAME_CLASS3 = ("example.com", "IN")
+        self.assertTrue(self.zoneinfo._zone_not_exist(ZONE_NAME_CLASS3))
+
     def test_set_zone_notify_timer(self):
         time1 = time.time()
-        self.zoneinfo._set_zone_notify_timer(0)
-        zone_timeout = self.zoneinfo._zones_refresh_info[0]["next_refresh_time"]
+        self.zoneinfo._set_zone_notify_timer(ZONE_NAME_CLASS1)
+        zone_timeout = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["next_refresh_time"]
         time2 = time.time()
         self.assertTrue(time1 <= zone_timeout)
         self.assertTrue(zone_timeout <= time2)
 
-    def test_get_zone_index(self):
-        self.assertTrue(-1 == self.zoneinfo._get_zone_index("org.cn"))
-        self.assertTrue(0 == self.zoneinfo._get_zone_index("sd.cn."))
-        self.assertTrue(1 == self.zoneinfo._get_zone_index("tw.cn"))
-
     def test_zone_is_expired(self):
         current_time = time.time()
         zone_expired_time = 2419200
-        self.zoneinfo._zones_refresh_info[0]["last_refresh_time"] = current_time - zone_expired_time - 1
-        self.assertTrue(self.zoneinfo._zone_is_expired(0))
-        self.zoneinfo._zones_refresh_info[0]["last_refresh_time"] = current_time - zone_expired_time + 1
-        self.assertFalse(self.zoneinfo._zone_is_expired(0))
-        self.zoneinfo._zones_refresh_info[0]["zone_state"] = ZONE_EXPIRED
-        self.assertTrue(self.zoneinfo._zone_is_expired(0))
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["last_refresh_time"] = \
+                                                  current_time - zone_expired_time - 1
+        self.assertTrue(self.zoneinfo._zone_is_expired(ZONE_NAME_CLASS1))
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["last_refresh_time"] = \
+                                                  current_time - zone_expired_time + 1
+        self.assertFalse(self.zoneinfo._zone_is_expired(ZONE_NAME_CLASS1))
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"] = ZONE_EXPIRED
+        self.assertTrue(self.zoneinfo._zone_is_expired(ZONE_NAME_CLASS1))
 
     def test_get_zone_soa_rdata(self):
         soa_rdata1  = 'a.dns.cn. root.cnnic.cn. 2009073105 7200 3600 2419200 21600' 
         soa_rdata2  = 'a.dns.cn. root.cnnic.cn. 2009073112 7200 3600 2419200 21600' 
-        self.assertEqual(soa_rdata1, self.zoneinfo._get_zone_soa_rdata(0))
-        self.assertEqual(soa_rdata2, self.zoneinfo._get_zone_soa_rdata(1))
+        self.assertEqual(soa_rdata1, self.zoneinfo._get_zone_soa_rdata(ZONE_NAME_CLASS1))
+        self.assertEqual(soa_rdata2, self.zoneinfo._get_zone_soa_rdata(ZONE_NAME_CLASS2))
          
     def test_zonemgr_reload_zone(self):
         soa_rdata = 'a.dns.cn. root.cnnic.cn. 2009073106 1800 900 2419200 21600'
@@ -128,83 +134,88 @@ class TestZoneRefreshInfo(unittest.TestCase):
                     'a.dns.cn. root.cnnic.cn. 2009073106 1800 900 2419200 21600')
         sqlite3_ds.get_zone_soa = get_zone_soa
 
-        self.zoneinfo._zonemgr_reload_zone(0)
-        self.assertEqual(soa_rdata, self.zoneinfo._zones_refresh_info[0]["zone_soa_rdata"])
+        self.zoneinfo._zonemgr_reload_zone(ZONE_NAME_CLASS1)
+        self.assertEqual(soa_rdata, self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_soa_rdata"])
 
     def test_get_zone_notifier_master(self):
-        notify_master = ["192.168.1.1", 53]
-        self.assertEqual(None, self.zoneinfo._get_zone_notifier_master(0))
-        self.zoneinfo._zones_refresh_info[0]["notify_master"] = notify_master
-        self.assertEqual(notify_master, self.zoneinfo._get_zone_notifier_master(0))
+        notify_master = "192.168.1.1"
+        self.assertEqual(None, self.zoneinfo._get_zone_notifier_master(ZONE_NAME_CLASS1))
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["notify_master"] = notify_master
+        self.assertEqual(notify_master, self.zoneinfo._get_zone_notifier_master(ZONE_NAME_CLASS1))
 
     def test_set_zone_notifier_master(self):
-        notify_master = ["192.168.1.1", 53]
-        self.zoneinfo._set_zone_notifier_master(0, notify_master)
-        self.assertEqual(self.zoneinfo._zones_refresh_info[0]["notify_master"], notify_master)
+        notify_master = "192.168.1.1"
+        self.zoneinfo._set_zone_notifier_master(ZONE_NAME_CLASS1, notify_master)
+        self.assertEqual(self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]\
+                                                                ["notify_master"], notify_master)
 
     def test_clear_zone_notifier_master(self):
-        notify_master = ["192.168.1.1", 53]
-        self.zoneinfo._zones_refresh_info[0]["notify_master"] = notify_master
-        self.zoneinfo._clear_zone_notifier_master(0)
-        self.assertFalse("notify_master" in self.zoneinfo._zones_refresh_info[0].keys())
-        self.zoneinfo._clear_zone_notifier_master(1)
-        self.assertFalse("notify_master" in self.zoneinfo._zones_refresh_info[1].keys())
+        notify_master = "192.168.1.1"
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["notify_master"] = notify_master
+        self.zoneinfo._clear_zone_notifier_master(ZONE_NAME_CLASS1)
+        self.assertFalse("notify_master" in self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1].keys())
+        self.zoneinfo._clear_zone_notifier_master(ZONE_NAME_CLASS2)
+        self.assertFalse("notify_master" in self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS2].keys())
 
     def test_get_zone_state(self):
-        self.assertEqual(ZONE_OK, self.zoneinfo._get_zone_state(0))
-        self.assertEqual(ZONE_OK, self.zoneinfo._get_zone_state(1))
+        self.assertEqual(ZONE_OK, self.zoneinfo._get_zone_state(ZONE_NAME_CLASS2))
+        self.assertEqual(ZONE_OK, self.zoneinfo._get_zone_state(ZONE_NAME_CLASS2))
 
     def test_set_zone_state(self):
-        self.zoneinfo._set_zone_state(0, ZONE_REFRESHING)
-        self.zoneinfo._set_zone_state(1, ZONE_EXPIRED)
-        self.assertEqual(ZONE_REFRESHING, self.zoneinfo._zones_refresh_info[0]["zone_state"])
-        self.assertEqual(ZONE_EXPIRED, self.zoneinfo._zones_refresh_info[1]["zone_state"])
+        self.zoneinfo._set_zone_state(ZONE_NAME_CLASS1, ZONE_REFRESHING)
+        self.zoneinfo._set_zone_state(ZONE_NAME_CLASS2, ZONE_EXPIRED)
+        self.assertEqual(ZONE_REFRESHING, \
+                self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"])
+        self.assertEqual(ZONE_EXPIRED, \
+                self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS2]["zone_state"])
 
     def test_get_zone_refresh_timeout(self):
         current_time = time.time()
-        self.assertFalse("refresh_timeout" in self.zoneinfo._zones_refresh_info[0].keys())
-        self.zoneinfo._zones_refresh_info[0]["refresh_timeout"] = current_time
-        self.assertEqual(current_time, self.zoneinfo._get_zone_refresh_timeout(0))
+        self.assertFalse("refresh_timeout" in self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1].keys())
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["refresh_timeout"] = current_time
+        self.assertEqual(current_time, self.zoneinfo._get_zone_refresh_timeout(ZONE_NAME_CLASS1))
 
     def test_set_zone_refresh_timeout(self):
         current_time = time.time()
-        self.zoneinfo._set_zone_refresh_timeout(0, current_time)
-        self.assertEqual(current_time, self.zoneinfo._zones_refresh_info[0]["refresh_timeout"])
+        self.zoneinfo._set_zone_refresh_timeout(ZONE_NAME_CLASS1, current_time)
+        refresh_time = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["refresh_timeout"]
+        self.assertEqual(current_time, refresh_time) 
 
     def test_get_zone_next_refresh_time(self):
         current_time = time.time()
-        self.zoneinfo._zones_refresh_info[0]["next_refresh_time"] = current_time
-        self.assertEqual(current_time, self.zoneinfo._get_zone_next_refresh_time(0))
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["next_refresh_time"] = current_time
+        self.assertEqual(current_time, self.zoneinfo._get_zone_next_refresh_time(ZONE_NAME_CLASS1))
 
     def test_set_zone_next_refresh_time(self):
         current_time = time.time()
-        self.zoneinfo._set_zone_next_refresh_time(0, current_time)
-        self.assertEqual(current_time, self.zoneinfo._zones_refresh_info[0]["next_refresh_time"])
+        self.zoneinfo._set_zone_next_refresh_time(ZONE_NAME_CLASS1, current_time)
+        next_refresh_time = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["next_refresh_time"]
+        self.assertEqual(current_time, next_refresh_time)
 
     def test_get_zone_last_refresh_time(self):
         current_time = time.time()
-        self.zoneinfo._zones_refresh_info[0]["last_refresh_time"] = current_time
-        self.assertEqual(current_time, self.zoneinfo._get_zone_last_refresh_time(0))
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["last_refresh_time"] = current_time
+        self.assertEqual(current_time, self.zoneinfo._get_zone_last_refresh_time(ZONE_NAME_CLASS1))
 
     def test_set_zone_last_refresh_time(self):
         current_time = time.time()
-        self.zoneinfo._set_zone_last_refresh_time(0, current_time)
-        self.assertEqual(current_time, self.zoneinfo._zones_refresh_info[0]["last_refresh_time"])
+        self.zoneinfo._set_zone_last_refresh_time(ZONE_NAME_CLASS1, current_time)
+        last_refresh_time = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["last_refresh_time"]
+        self.assertEqual(current_time, last_refresh_time) 
 
     def test_send_command(self):
         self.assertRaises(ZonemgrTestException, self.zoneinfo._send_command, "Unknown", "Notify", None)
 
     def test_zone_mgr_is_empty(self):
         self.assertFalse(self.zoneinfo._zone_mgr_is_empty())
-        self.zoneinfo._zones_refresh_info = []
+        self.zoneinfo._zonemgr_refresh_info = {} 
         self.assertTrue(self.zoneinfo._zone_mgr_is_empty())
 
     def test_build_zonemgr_refresh_info(self):
-        zone_name_list = [("sd.cn.", "IN")]
         soa_rdata = 'a.dns.cn. root.cnnic.cn. 2009073106 1800 900 2419200 21600'
 
         def get_zones_info(db_file):
-            return zone_name_list
+            return [("sd.cn.", "IN")] 
 
         def get_zone_soa(zone_name, db_file):
             return (1, 2, 'sd.cn.', 'cn.sd.', 21600, 'SOA', None, 
@@ -213,22 +224,24 @@ class TestZoneRefreshInfo(unittest.TestCase):
         sqlite3_ds.get_zones_info = get_zones_info
         sqlite3_ds.get_zone_soa = get_zone_soa
 
-        self.zoneinfo._zones_refresh_info = []
+        self.zoneinfo._zonemgr_refresh_info = {}
         self.zoneinfo._build_zonemgr_refresh_info()
-        self.assertEqual(1, len(self.zoneinfo._zones_refresh_info))
-        self.assertEqual(soa_rdata, self.zoneinfo._zones_refresh_info[0]["zone_soa_rdata"])
-        self.assertEqual(ZONE_OK, self.zoneinfo._zones_refresh_info[0]["zone_state"])
-        self.assertTrue("last_refresh_time" in self.zoneinfo._zones_refresh_info[0].keys())
-        self.assertTrue("next_refresh_time" in self.zoneinfo._zones_refresh_info[0].keys())
+        self.assertEqual(1, len(self.zoneinfo._zonemgr_refresh_info))
+        zone_soa_rdata = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_soa_rdata"]
+        self.assertEqual(soa_rdata, zone_soa_rdata) 
+        self.assertEqual(ZONE_OK, self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"])
+        self.assertTrue("last_refresh_time" in self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1].keys())
+        self.assertTrue("next_refresh_time" in self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1].keys())
 
     def test_zone_handle_notify(self):
-        self.zoneinfo.zone_handle_notify("sd.cn.", "127.0.0.1", 53)
-        self.assertEqual(["127.0.0.1", 53], self.zoneinfo._zones_refresh_info[0]["notify_master"])
-        zone_timeout = float(self.zoneinfo._zones_refresh_info[0]["next_refresh_time"])
+        self.zoneinfo.zone_handle_notify(ZONE_NAME_CLASS1,"127.0.0.1")
+        notify_master = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["notify_master"]
+        self.assertEqual("127.0.0.1", notify_master) 
+        zone_timeout = float(self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["next_refresh_time"])
         current_time = time.time()
         self.assertTrue(zone_timeout <= current_time)
         self.assertRaises(ZonemgrException, self.zoneinfo.zone_handle_notify,
-                          "org.cn.", "127.0.0.1", 53)
+                          "org.cn.", "127.0.0.1")
 
     def test_zone_refresh_success(self):
         soa_rdata = 'a.dns.cn. root.cnnic.cn. 2009073106 1800 900 2419200 21600'
@@ -237,84 +250,93 @@ class TestZoneRefreshInfo(unittest.TestCase):
                     'a.dns.cn. root.cnnic.cn. 2009073106 1800 900 2419200 21600')
         sqlite3_ds.get_zone_soa = get_zone_soa
         time1 = time.time()
-        self.zoneinfo._zones_refresh_info[0]["zone_state"] = ZONE_REFRESHING
-        self.zoneinfo.zone_refresh_success("sd.cn.")
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"] = ZONE_REFRESHING
+        self.zoneinfo.zone_refresh_success(ZONE_NAME_CLASS1)
         time2 = time.time()
-        self.assertEqual(soa_rdata, self.zoneinfo._zones_refresh_info[0]["zone_soa_rdata"])
-        self.assertTrue((time1 + 3 * 1800 / 4) <= self.zoneinfo._zones_refresh_info[0]["next_refresh_time"])
-        self.assertTrue(self.zoneinfo._zones_refresh_info[0]["next_refresh_time"] <= time2 + 1800)
-        self.assertEqual(ZONE_OK, self.zoneinfo._zones_refresh_info[0]["zone_state"])
-        self.assertTrue(time1 <= self.zoneinfo._zones_refresh_info[0]["last_refresh_time"])
-        self.assertTrue(self.zoneinfo._zones_refresh_info[0]["last_refresh_time"] <= time2)
+        zone_soa_rdata = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_soa_rdata"]
+        self.assertEqual(soa_rdata, zone_soa_rdata) 
+        next_refresh_time = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["next_refresh_time"]
+        self.assertTrue((time1 + 3 * 1800 / 4) <= next_refresh_time) 
+        self.assertTrue(next_refresh_time <= time2 + 1800)
+        self.assertEqual(ZONE_OK, self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"])
+        last_refresh_time = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["last_refresh_time"]
+        self.assertTrue(time1 <= last_refresh_time)
+        self.assertTrue(last_refresh_time <= time2)
         self.assertRaises(ZonemgrException, self.zoneinfo.zone_refresh_success, "org.cn.")
 
     def test_zone_refresh_fail(self):
         soa_rdata = 'a.dns.cn. root.cnnic.cn. 2009073105 7200 3600 2419200 21600' 
         time1 = time.time()
-        self.zoneinfo._zones_refresh_info[0]["zone_state"] = ZONE_REFRESHING
-        self.zoneinfo.zone_refresh_fail("sd.cn.")
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"] = ZONE_REFRESHING
+        self.zoneinfo.zone_refresh_fail(ZONE_NAME_CLASS1)
         time2 = time.time()
-        self.assertEqual(soa_rdata, self.zoneinfo._zones_refresh_info[0]["zone_soa_rdata"])
-        self.assertTrue((time1 + 3 * 3600 / 4) <= self.zoneinfo._zones_refresh_info[0]["next_refresh_time"])
-        self.assertTrue(self.zoneinfo._zones_refresh_info[0]["next_refresh_time"] <= time2 + 3600)
-        self.assertEqual(ZONE_OK, self.zoneinfo._zones_refresh_info[0]["zone_state"])
+        zone_soa_rdata = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_soa_rdata"]
+        self.assertEqual(soa_rdata, zone_soa_rdata)
+        next_refresh_time = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["next_refresh_time"]
+        self.assertTrue((time1 + 3 * 3600 / 4) <= next_refresh_time)
+        self.assertTrue(next_refresh_time <= time2 + 3600)
+        self.assertEqual(ZONE_OK, self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"])
         self.assertRaises(ZonemgrException, self.zoneinfo.zone_refresh_success, "org.cn.")
 
     def test_find_minimum_timeout_zone(self):
         time1 = time.time()
-        self.zoneinfo._zones_refresh_info = [
-        {'last_refresh_time': time1,
-         'next_refresh_time': time1 + 7200, 
-         'zone_soa_rdata': 'a.dns.cn. root.cnnic.cn. 2009073105 7200 3600 2419200 21600', 
-         'zone_state': ZONE_OK},
-        {'last_refresh_time': time1 - 7200, 
-         'next_refresh_time': time1, 
-         'refresh_timeout': time1 + MAX_TRANSFER_TIMEOUT, 
-         'zone_soa_rdata': 'a.dns.cn. root.cnnic.cn. 2009073112 7200 3600 2419200 21600', 
-         'zone_state': ZONE_REFRESHING}
-        ]
-        zone_index = self.zoneinfo._find_minimum_timeout_zone()
-        self.assertEqual(0, zone_index)
-
-        self.zoneinfo._zones_refresh_info[0]["last_refresh_time"] = time1 - 2419200
-        self.zoneinfo._zones_refresh_info[0]["zone_state"] = ZONE_EXPIRED
-        zone_index = self.zoneinfo._find_minimum_timeout_zone()
-        self.assertEqual(-1, zone_index)
-
-        self.zoneinfo._zones_refresh_info[0]["zone_state"] = ZONE_REFRESHING
-        self.zoneinfo._zones_refresh_info[0]["notify_master"] = ["192.168.0.1", 6363]
-        zone_index = self.zoneinfo._find_minimum_timeout_zone()
-        self.assertEqual(0, zone_index)
-        self.assertEqual(ZONE_EXPIRED, self.zoneinfo._zones_refresh_info[0]["zone_state"])
-
-        self.zoneinfo._zones_refresh_info[1]["refresh_timeout"] = time1 
-        zone_index = self.zoneinfo._find_minimum_timeout_zone()
-        self.assertEqual(1, zone_index)
+        self.zoneinfo._zonemgr_refresh_info = { 
+                ("sd.cn.","IN"):{
+                    'last_refresh_time': time1,
+                    'next_refresh_time': time1 + 7200, 
+                    'zone_soa_rdata': 'a.dns.cn. root.cnnic.cn. 2009073105 7200 3600 2419200 21600', 
+                    'zone_state': ZONE_OK},
+                ("tw.cn","IN"):{
+                    'last_refresh_time': time1 - 7200, 
+                    'next_refresh_time': time1, 
+                    'refresh_timeout': time1 + MAX_TRANSFER_TIMEOUT, 
+                    'zone_soa_rdata': 'a.dns.cn. root.cnnic.cn. 2009073112 7200 3600 2419200 21600', 
+                    'zone_state': ZONE_REFRESHING}
+                }
+        zone_need_refresh = self.zoneinfo._find_need_do_refresh_zone()
+        self.assertEqual(ZONE_NAME_CLASS1, zone_need_refresh)
+
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["last_refresh_time"] = time1 - 2419200
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"] = ZONE_EXPIRED
+        zone_need_refresh = self.zoneinfo._find_need_do_refresh_zone()
+        self.assertEqual(None, zone_need_refresh)
+
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"] = ZONE_REFRESHING
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["notify_master"] = "192.168.0.1"
+        zone_need_refresh = self.zoneinfo._find_need_do_refresh_zone()
+        self.assertEqual(ZONE_NAME_CLASS1, zone_need_refresh)
+        self.assertEqual(ZONE_EXPIRED, self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"])
+
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS2]["refresh_timeout"] = time1 
+        zone_need_refresh = self.zoneinfo._find_need_do_refresh_zone()
+        self.assertEqual(ZONE_NAME_CLASS2, zone_need_refresh)
 
     def test_do_refresh(self):
         time1 = time.time()
-        self.zoneinfo._zones_refresh_info = [
-        {'last_refresh_time': time1 - 7200,
-         'next_refresh_time': time1 - 1, 
-         'zone_soa_rdata': 'a.dns.cn. root.cnnic.cn. 2009073105 7200 3600 2419200 21600', 
-         'zone_state': ZONE_OK}
-        ]
-        self.zoneinfo._do_refresh(0)
+        self.zoneinfo._zonemgr_refresh_info = {
+                ("sd.cn.", "IN"):{
+                    'last_refresh_time': time1 - 7200,
+                    'next_refresh_time': time1 - 1, 
+                    'zone_soa_rdata': 'a.dns.cn. root.cnnic.cn. 2009073105 7200 3600 2419200 21600', 
+                    'zone_state': ZONE_OK}
+                }
+        self.zoneinfo._do_refresh(ZONE_NAME_CLASS1)
         time2 = time.time()
-        self.assertEqual(ZONE_REFRESHING, self.zoneinfo._zones_refresh_info[0]["zone_state"])
-        self.assertTrue(time1 + MAX_TRANSFER_TIMEOUT <= 
-                        self.zoneinfo._zones_refresh_info[0]["refresh_timeout"])
-        self.assertTrue(time2 + MAX_TRANSFER_TIMEOUT >= 
-                        self.zoneinfo._zones_refresh_info[0]["refresh_timeout"])
-        self.zoneinfo._zones_refresh_info[0]["notify_master"] = ["127.0.0.1", 53]
-        self.zoneinfo._do_refresh(0)
+        zone_state = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"]
+        self.assertEqual(ZONE_REFRESHING, zone_state)
+        refresh_timeout = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["refresh_timeout"] 
+        self.assertTrue(time1 + MAX_TRANSFER_TIMEOUT <= refresh_timeout)
+        self.assertTrue(time2 + MAX_TRANSFER_TIMEOUT >= refresh_timeout) 
+
+        self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["notify_master"] = "127.0.0.1"
+        self.zoneinfo._do_refresh(ZONE_NAME_CLASS1)
         time2 = time.time()
-        self.assertEqual(ZONE_REFRESHING, self.zoneinfo._zones_refresh_info[0]["zone_state"])
-        self.assertTrue(time1 + MAX_TRANSFER_TIMEOUT <= 
-                        self.zoneinfo._zones_refresh_info[0]["refresh_timeout"])
-        self.assertTrue(time2 + MAX_TRANSFER_TIMEOUT >= 
-                        self.zoneinfo._zones_refresh_info[0]["refresh_timeout"])
-        self.assertFalse("notify_master" in self.zoneinfo._zones_refresh_info[0].keys())
+        zone_state = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"]
+        self.assertEqual(ZONE_REFRESHING, zone_state) 
+        refrsh_timeout = self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["refresh_timeout"] 
+        self.assertTrue(time1 + MAX_TRANSFER_TIMEOUT <= refresh_timeout)
+        self.assertTrue(time2 + MAX_TRANSFER_TIMEOUT >= refresh_timeout)
+        self.assertFalse("notify_master" in self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1].keys())
 
     def test_shutdown(self):
         pass
@@ -341,7 +363,7 @@ class MyZonemgr(Zonemgr):
         self._shutdown_event = threading.Event()
         self._cc = MySession()
         self._module_cc = MyCCSession()
-        self._config_data = {"zone_name" : "org.cn", "master" : "127.0.0.1", "port" : 53}
+        self._config_data = {"zone_name" : "org.cn", "zone_class" : "IN", "master" : "127.0.0.1"}
 
     def _start_zone_refresh_timer(self):
         pass
@@ -352,7 +374,7 @@ class TestZonemgr(unittest.TestCase):
         self.zonemgr = MyZonemgr()
 
     def test_config_handler(self):
-        config_data = {"zone_name" : "sd.cn.", "master" : "192.168.1.1", "port" : 53}
+        config_data = {"zone_name" : "sd.cn.", "zone_class" : "IN", "master" : "192.168.1.1"}
         self.zonemgr.config_handler(config_data)
         self.assertEqual(config_data, self.zonemgr._config_data)
 
@@ -360,11 +382,13 @@ class TestZonemgr(unittest.TestCase):
         self.assertEqual("initdb.file", self.zonemgr.get_db_file())
     
     def test_parse_cmd_params(self):
-        params1 = {"zone_name" : "org.cn", "master" : "127.0.0.1", "port" : "53"}
-        answer = ("org.cn", "127.0.0.1", "53")
-        self.assertEqual(answer, self.zonemgr._parse_cmd_params(params1))
-        params2 = {"zone_name" : "org.cn", "master" : "127.0.0.1"}
-        self.assertEqual(answer, self.zonemgr._parse_cmd_params(params2))
+        params1 = {"zone_name" : "org.cn", "zone_class" : "IN", "master" : "127.0.0.1"}
+        answer1 = ("org.cn", "IN", "127.0.0.1")
+        self.assertEqual(answer1, self.zonemgr._parse_cmd_params(params1, ZONE_NOTIFY_COMMAND))
+        params2 = {"zone_name" : "org.cn", "zone_class" : "IN"}
+        answer2 = ("org.cn", "IN")
+        self.assertEqual(answer2, self.zonemgr._parse_cmd_params(params2, ZONE_XFRIN_SUCCESS_COMMAND))
+        self.assertRaises(ZonemgrException, self.zonemgr._parse_cmd_params, params2, ZONE_NOTIFY_COMMAND)
 
     def tearDown(self):
         pass

src/bin/zonemgr/zonemgr.py.in

@@ -60,7 +60,7 @@ XFRIN_MODULE_NAME = 'Xfrin'
 AUTH_MODULE_NAME = 'Auth'
 ZONE_XFRIN_FAILED_COMMAND = 'zone_xfrin_failed'
 ZONE_XFRIN_SUCCESS_COMMAND = 'zone_new_data_ready'
-ZONE_REFRESH_COMMAND = 'refresh_from_zonemgr'
+ZONE_REFRESH_COMMAND = 'refresh'
 ZONE_NOTIFY_COMMAND = 'notify'
 #default master port
 DEFAULT_MASTER_PORT = "53"
@@ -80,15 +80,14 @@ MAX_TRANSFER_TIMEOUT = 14400
 class ZonemgrException(Exception):
     pass
 
-class ZoneRefreshInfo:
+class ZoneMgrRefreshInfo:
     """This class will maintain and manage zone refresh info"""
 
     def __init__(self, cc, db_file, slave_socket):
         self._cc = cc
         self._socket = slave_socket 
         self._db_file = db_file
-        self._zone_name_list = []
-        self._zones_refresh_info = []
+        self._zonemgr_refresh_info = {} 
         self._build_zonemgr_refresh_info()
     
     def _random_jitter(self, max, jitter):
@@ -102,183 +101,187 @@ class ZoneRefreshInfo:
     def _get_current_time(self):
         return time.time()
 
-    def _set_zone_timer(self, zone_index, max, jitter):
-        self._set_zone_next_refresh_time(zone_index, self._get_current_time() + \
+    def _set_zone_timer(self, zone_name_class, max, jitter):
+        self._set_zone_next_refresh_time(zone_name_class, self._get_current_time() + \
                                             self._random_jitter(max, jitter))
 
-    def _set_zone_refresh_timer(self, zone_index):
+    def _set_zone_refresh_timer(self, zone_name_class):
         """Set timer for zone refresh timeout after zone refresh success."""
-        zone_refresh_time = float(self._get_zone_soa_rdata(zone_index).split(" ")[3])
+        zone_refresh_time = float(self._get_zone_soa_rdata(zone_name_class).split(" ")[3])
         if (zone_refresh_time < LOWERBOUND_REFRESH):
             zone_refresh_time = LOWERBOUND_REFRESH
-        self._set_zone_timer(zone_index, zone_refresh_time, (1 * zone_refresh_time) / 4)
+        self._set_zone_timer(zone_name_class, zone_refresh_time, (1 * zone_refresh_time) / 4)
 
-    def _set_zone_retry_timer(self, zone_index):
+    def _set_zone_retry_timer(self, zone_name_class):
         """Set timer for zone retry timeout after zone refresh fail."""
-        zone_retry_time = float(self._get_zone_soa_rdata(zone_index).split(" ")[4])
+        zone_retry_time = float(self._get_zone_soa_rdata(zone_name_class).split(" ")[4])
         if (zone_retry_time < LOWERBOUND_RETRY):
             zone_retry_time = LOWERBOUND_RETRY
-        self._set_zone_timer(zone_index, zone_retry_time, (1 * zone_retry_time) / 4)
+        self._set_zone_timer(zone_name_class, zone_retry_time, (1 * zone_retry_time) / 4)
 
-    def _set_zone_notify_timer(self, zone_index):
+    def _set_zone_notify_timer(self, zone_name_class):
         """Set timer for a zone after receiving notify"""
-        self._set_zone_timer(zone_index, 0, 0)
+        self._set_zone_timer(zone_name_class, 0, 0)
 
-    def zone_refresh_success(self, zone_name):
+    def _zone_not_exist(self, zone_name_class):
+        if zone_name_class in self._zonemgr_refresh_info.keys():
+            return False
+        return True
+
+    def zone_refresh_success(self, zone_name_class):
         """Update zone update info after zone refresh success"""
-        zone_index = self._get_zone_index(zone_name)
-        if (-1 == zone_index):
-            raise ZonemgrException("[b10-zonemgr] Zone %s doesn't belong to zonemgr" % zone_name)
+        if (self._zone_not_exist(zone_name_class)):
+            raise ZonemgrException("[b10-zonemgr] Zone %s doesn't \
+                                    belong to zonemgr" % zone_name_class[0])
             return
-        self._zonemgr_reload_zone(zone_index)
-        self._set_zone_refresh_timer(zone_index)
-        self._set_zone_state(zone_index, ZONE_OK)
-        self._set_zone_last_refresh_time(zone_index, self._get_current_time())
+        self._zonemgr_reload_zone(zone_name_class)
+        self._set_zone_refresh_timer(zone_name_class)
+        self._set_zone_state(zone_name_class, ZONE_OK)
+        self._set_zone_last_refresh_time(zone_name_class, self._get_current_time())
 
-    def zone_refresh_fail(self, zone_name):
+    def zone_refresh_fail(self, zone_name_class):
         """Update zone update info after zone refresh fail"""
-        zone_index = self._get_zone_index(zone_name)
-        if (-1 == zone_index):
-            raise ZonemgrException("[b10-zonemgr] Zone %s doesn't belong to zonemgr" % zone_name)
+        if (self._zone_not_exist(zone_name_class)):
+            raise ZonemgrException("[b10-zonemgr] Zone %s doesn't \
+                                    belong to zonemgr" % zone_name_class[0])
             return
-        self._set_zone_state(zone_index, ZONE_OK)
-        self._set_zone_retry_timer(zone_index)
+        self._set_zone_state(zone_name_class, ZONE_OK)
+        self._set_zone_retry_timer(zone_name_class)
 
-    def zone_handle_notify(self, zone_name, master, port):
+    def zone_handle_notify(self, zone_name_class, master):
         """Handle zone notify"""
-        zone_index = self._get_zone_index(zone_name)
-        if (-1 == zone_index):
-            raise ZonemgrException("[b10-zonemgr] Notified zone %s doesn't belong to zonemgr" % zone_name)
+        if (self._zone_not_exist(zone_name_class)):
+            raise ZonemgrException("[b10-zonemgr] Notified zone %s doesn't \
+                                    belong to zonemgr" % zone_name_class[0])
             return
-        self._set_zone_notifier_master(zone_index, [master, port])
-        self._set_zone_notify_timer(zone_index)
+        self._set_zone_notifier_master(zone_name_class, master)
+        self._set_zone_notify_timer(zone_name_class)
 
     def _build_zonemgr_refresh_info(self):
         for zone_name, zone_class in sqlite3_ds.get_zones_info(self._db_file):
             zone_info = {}
-            self._zone_name_list.append(str(zone_name))
             zone_soa = sqlite3_ds.get_zone_soa(str(zone_name), self._db_file)
             zone_info["zone_soa_rdata"] = zone_soa[7]
             zone_info["zone_state"] = ZONE_OK
             zone_info["last_refresh_time"] = self._get_current_time() 
             zone_info["next_refresh_time"] = self._get_current_time() + float(zone_soa[7].split(" ")[3])
-            self._zones_refresh_info.append(zone_info)
-
-    def _get_zone_index(self, zone_name):
-        """Get zone index in zone_refresh_list by zone name."""
-        if (str(zone_name) in self._zone_name_list):
-            zone_index = self._zone_name_list.index(str(zone_name))
-            return zone_index
+            self._zonemgr_refresh_info[(zone_name, zone_class)] = zone_info
 
-        return -1
-
-    def _zone_is_expired(self, zone_index):
-        zone_expired_time = float(self._get_zone_soa_rdata(zone_index).split(" ")[5])
-        zone_last_refresh_time = self._get_zone_last_refresh_time(zone_index)
-        if (ZONE_EXPIRED == self._get_zone_state(zone_index) or
+    def _zone_is_expired(self, zone_name_class):
+        zone_expired_time = float(self._get_zone_soa_rdata(zone_name_class).split(" ")[5])
+        zone_last_refresh_time = self._get_zone_last_refresh_time(zone_name_class)
+        if (ZONE_EXPIRED == self._get_zone_state(zone_name_class) or
             zone_last_refresh_time + zone_expired_time <= self._get_current_time()):
             return True
 
         return False
 
-    def _get_zone_soa_rdata(self, zone_index):
-        return self._zones_refresh_info[zone_index]["zone_soa_rdata"]
+    def _get_zone_soa_rdata(self, zone_name_class):
+        return self._zonemgr_refresh_info[zone_name_class]["zone_soa_rdata"]
 
-    def _zonemgr_reload_zone(self, zone_index):
-        zone_name = self._zone_name_list[zone_index]
-        zone_soa = sqlite3_ds.get_zone_soa(str(zone_name), self._db_file)
-        self._zones_refresh_info[zone_index]["zone_soa_rdata"] = zone_soa[7]
+    def _zonemgr_reload_zone(self, zone_name_class):
+        zone_soa = sqlite3_ds.get_zone_soa(str(zone_name_class[0]), self._db_file)
+        self._zonemgr_refresh_info[zone_name_class]["zone_soa_rdata"] = zone_soa[7]
 
-    def _get_zone_last_refresh_time(self, zone_index):
-        return self._zones_refresh_info[zone_index]["last_refresh_time"]
+    def _get_zone_last_refresh_time(self, zone_name_class):
+        return self._zonemgr_refresh_info[zone_name_class]["last_refresh_time"]
 
-    def _set_zone_last_refresh_time(self, zone_index, time):
-        self._zones_refresh_info[zone_index]["last_refresh_time"] = time
+    def _set_zone_last_refresh_time(self, zone_name_class, time):
+        self._zonemgr_refresh_info[zone_name_class]["last_refresh_time"] = time
 
-    def _get_zone_notifier_master(self, zone_index):
-        if ("notify_master" in self._zones_refresh_info[zone_index].keys()):
-            return self._zones_refresh_info[zone_index]["notify_master"] 
+    def _get_zone_notifier_master(self, zone_name_class):
+        if ("notify_master" in self._zonemgr_refresh_info[zone_name_class].keys()):
+            return self._zonemgr_refresh_info[zone_name_class]["notify_master"] 
 
         return None
 
-    def _set_zone_notifier_master(self, zone_index, master_addr):
-        self._zones_refresh_info[zone_index]["notify_master"] = master_addr
+    def _set_zone_notifier_master(self, zone_name_class, master_addr):
+        self._zonemgr_refresh_info[zone_name_class]["notify_master"] = master_addr
 
-    def _clear_zone_notifier_master(self, zone_index):
-        if ("notify_master" in self._zones_refresh_info[zone_index].keys()):
-            del self._zones_refresh_info[zone_index]["notify_master"]
+    def _clear_zone_notifier_master(self, zone_name_class):
+        if ("notify_master" in self._zonemgr_refresh_info[zone_name_class].keys()):
+            del self._zonemgr_refresh_info[zone_name_class]["notify_master"]
 
-    def _get_zone_state(self, zone_index):
-        return self._zones_refresh_info[zone_index]["zone_state"]
+    def _get_zone_state(self, zone_name_class):
+        return self._zonemgr_refresh_info[zone_name_class]["zone_state"]
 
-    def _set_zone_state(self, zone_index, zone_state):
-        self._zones_refresh_info[zone_index]["zone_state"] = zone_state 
+    def _set_zone_state(self, zone_name_class, zone_state):
+        self._zonemgr_refresh_info[zone_name_class]["zone_state"] = zone_state 
 
-    def _get_zone_refresh_timeout(self, zone_index):
-        return self._zones_refresh_info[zone_index]["refresh_timeout"]
+    def _get_zone_refresh_timeout(self, zone_name_class):
+        return self._zonemgr_refresh_info[zone_name_class]["refresh_timeout"]
 
-    def _set_zone_refresh_timeout(self, zone_index, time):
-        self._zones_refresh_info[zone_index]["refresh_timeout"] = time
+    def _set_zone_refresh_timeout(self, zone_name_class, time):
+        self._zonemgr_refresh_info[zone_name_class]["refresh_timeout"] = time
 
-    def _get_zone_next_refresh_time(self, zone_index):
-        return self._zones_refresh_info[zone_index]["next_refresh_time"]
+    def _get_zone_next_refresh_time(self, zone_name_class):
+        return self._zonemgr_refresh_info[zone_name_class]["next_refresh_time"]
 
-    def _set_zone_next_refresh_time(self, zone_index, time):
-        self._zones_refresh_info[zone_index]["next_refresh_time"] = time
+    def _set_zone_next_refresh_time(self, zone_name_class, time):
+        self._zonemgr_refresh_info[zone_name_class]["next_refresh_time"] = time
 
     def _send_command(self, module_name, command_name, params):
         msg = create_command(command_name, params)
         self._cc.group_sendmsg(msg, module_name)
 
-    def _find_minimum_timeout_zone(self):
-        minimum_index = -1
-        for i in range(0, len(self._zones_refresh_info)):
+    def _find_need_do_refresh_zone(self):
+        """Find the first zone need do refresh, if no zone need
+        do refresh, return the zone with minimum next_refresh_time.
+        """
+        zone_need_refresh = None
+        for zone_name_class in self._zonemgr_refresh_info.keys():
             # Does the zone expired?
-            if (ZONE_EXPIRED != self._get_zone_state(i) and 
-                self._zone_is_expired(i)):
-                self._set_zone_state(i, ZONE_EXPIRED)
+            if (ZONE_EXPIRED != self._get_zone_state(zone_name_class) and 
+                self._zone_is_expired(zone_name_class)):
+                self._set_zone_state(zone_name_class, ZONE_EXPIRED)
 
-            zone_state = self._get_zone_state(i)
+            zone_state = self._get_zone_state(zone_name_class)
             # If zone is expired and doesn't receive notify, skip the zone
             if (ZONE_EXPIRED == zone_state and 
-                (not self._get_zone_notifier_master(i))):
+                (not self._get_zone_notifier_master(zone_name_class))):
                 continue
 
             # If hasn't received xfr response within xfr timeout, skip the zone
             if (ZONE_REFRESHING == zone_state and
-                (self._get_zone_refresh_timeout(i) > self._get_current_time())):
+                (self._get_zone_refresh_timeout(zone_name_class) > self._get_current_time())):
                 continue
                     
-            # Get the zone with minimum timeout
-            if ((-1 == minimum_index) or 
-                (self._get_zone_next_refresh_time(i) < self._get_zone_next_refresh_time(minimum_index))):
-                minimum_index = i
+            # Get the zone with minimum next_refresh_time 
+            if ((None == zone_need_refresh) or 
+                (self._get_zone_next_refresh_time(zone_name_class) < 
+                    self._get_zone_next_refresh_time(zone_need_refresh))):
+                zone_need_refresh = zone_name_class
+
+            # Fine the zone need to refresh
+            if (self._get_zone_next_refresh_time(zone_need_refresh) < self._get_current_time()):
+                break
 
-        return minimum_index
+        return zone_need_refresh 
 
     
-    def _do_refresh(self, zone_index):
+    def _do_refresh(self, zone_name_class):
         """Do zone refresh"""
-        zone_name = self._zone_name_list[zone_index]
-        self._set_zone_state(zone_index, ZONE_REFRESHING)
-        self._set_zone_refresh_timeout(zone_index, self._get_current_time() + MAX_TRANSFER_TIMEOUT) 
-        notify_master = self._get_zone_notifier_master(zone_index)
+        self._set_zone_state(zone_name_class, ZONE_REFRESHING)
+        self._set_zone_refresh_timeout(zone_name_class, self._get_current_time() + MAX_TRANSFER_TIMEOUT) 
+        notify_master = self._get_zone_notifier_master(zone_name_class)
         # If has notify master, send notify command to xfrin module
         if notify_master:
-            param = {"zone_name" : zone_name,
-                     "master" : notify_master[0],
-                     "port" : notify_master[1]
+            param = {"zone_name" : zone_name_class[0],
+                     "zone_class" : zone_name_class[1],
+                     "master" : notify_master[0]
                      }
             self._send_command(XFRIN_MODULE_NAME, ZONE_NOTIFY_COMMAND, param) 
-            self._clear_zone_notifier_master(zone_index)
+            self._clear_zone_notifier_master(zone_name_class)
         # Send refresh command to xfrin module
         else:
-            param = {"zone_name" : zone_name}
+            param = {"zone_name" : zone_name_class[0],
+                     "zone_class" : zone_name_class[1]
+                    }
             self._send_command(XFRIN_MODULE_NAME, ZONE_REFRESH_COMMAND, param)
 
     def _zone_mgr_is_empty(self):
         """Does zone manager has no zone?"""
-        if not len(self._zones_refresh_info):
+        if not len(self._zonemgr_refresh_info):
             return True
 
         return False
@@ -290,14 +293,14 @@ class ZoneRefreshInfo:
                 time.sleep(1) # A better time?
                 continue
 
-            minimum_index = self._find_minimum_timeout_zone()
+            zone_need_refresh = self._find_need_do_refresh_zone()
             # If don't get zone with minimum timeout, timer will wait LOWERBOUND_REFRESH
-            if (-1 == minimum_index):
+            if not zone_need_refresh:
                 timeout = LOWERBOUND_REFRESH 
             else:
-                timeout = self._get_zone_next_refresh_time(minimum_index) - self._get_current_time()
-                if (timeout < 0):
-                    self._do_refresh(minimum_index)
+                timeout = self._get_zone_next_refresh_time(zone_need_refresh)
+                if (timeout < self._get_current_time()):
+                    self._do_refresh(zone_need_refresh)
                     continue
 
             # Start timer, wait for timeout if not received notification
@@ -334,7 +337,7 @@ class Zonemgr:
         self._sock_file = UNIX_SOCKET_FILE 
 
         self._master_socket, self._slave_scoket = socket.socketpair(socket.AF_UNIX, socket.SOCK_STREAM)
-        self._zone_refresh_info = ZoneRefreshInfo(self._cc, self._db_file, self._slave_scoket)
+        self._zone_refresh_info = ZoneMgrRefreshInfo(self._cc, self._db_file, self._slave_scoket)
         self._start_zone_refresh_timer()
 
         self._lock = threading.Lock()
@@ -342,7 +345,7 @@ class Zonemgr:
         self._verbose = verbose
 
     def _start_zone_refresh_timer(self):
-        """Start a new thread to run zone refresh timer"""
+        """Start a new thread to run zonemgr refresh timer"""
         listener = threading.Thread(target = start_timer, args = (self._zone_refresh_info,))
         listener.setDaemon(True)
         listener.start()
@@ -368,10 +371,7 @@ class Zonemgr:
     def shutdown(self):
 
         self._zone_refresh_info.shutdown()
-        try:
-            self._master_socket.close()
-        except Exception as e:
-            sys.stderr.write(str(e))
+        self._master_socket.close()
 
         self._shutdown_event.set()
         main_thread = threading.currentThread()
@@ -389,48 +389,52 @@ class Zonemgr:
             self._config_data[key] = new_config[key]
         return answer
 
-    def _parse_cmd_params(self, args):
+    def _parse_cmd_params(self, args, command):
         zone_name = args.get("zone_name")
         if not zone_name:
             raise ZonemgrException("zone name should be provided")
 
+        zone_class = args.get("zone_class")
+        if not zone_class:
+                raise ZonemgrException("zone class should be provided")
+
+        if (command != ZONE_NOTIFY_COMMAND):
+            return (zone_name, zone_class)
+
         master_str = args.get("master")
         if not master_str:
             raise ZonemgrException("master address should be provided")
 
-        port_str = args.get("port")
-        if not port_str:
-            port_str = DEFAULT_MASTER_PORT
-
-        return (zone_name, master_str, port_str)
+        return (zone_name, zone_class, master_str)
 
 
     def command_handler(self, command, args):
         answer = create_answer(0)
         if command == ZONE_NOTIFY_COMMAND:
-            zone_name, master, port = self._parse_cmd_params(args)
+            """ Handle Auth notify command"""
+            zone_name, zone_class, master = self._parse_cmd_params(args, command)
+            zone_name_class = (zone_name, zone_class)
             self._lock.acquire()
-            self._zone_refresh_info.zone_handle_notify(zone_name, master ,port)
+            self._zone_refresh_info.zone_handle_notify(zone_name_class, master)
             self._lock.release()
+            # Send message to zonemgr timer, timer will stop waiting and check zone state
             self._master_socket.send(b" ")
 
         elif command == ZONE_XFRIN_SUCCESS_COMMAND:
-            zone_name = args.get("zone_name")
-            if not zone_name:
-                raise ZonemgrException("zone name should be provided")
-            else:
-                self._lock.acquire()
-                self._zone_refresh_info.zone_refresh_success(zone_name)
-                self._lock.release()
+            """ Handle xfrin succes command"""
+            zone_name, zone_class = self._parse_cmd_params(args, command)
+            zone_name_class = (zone_name, zone_class)
+            self._lock.acquire()
+            self._zone_refresh_info.zone_refresh_success(zone_name_class)
+            self._lock.release()
 
         elif command == ZONE_XFRIN_FAILED_COMMAND:
-            zone_name = args.get("zone_name")
-            if not zone_name:
-                raise ZonemgrException("zone name should be provided")
-            else:
-                self._lock.acquire()
-                self._zone_refresh_info.zone_refresh_fail(zone_name)
-                self._lock.release()
+            """ Handle xfrin fail command"""
+            zone_name, zone_class = self._parse_cmd_params(args, command)
+            zone_name_class = (zone_name, zone_class)
+            self._lock.acquire()
+            self._zone_refresh_info.zone_refresh_fail(zone_name_class)
+            self._lock.release()
 
         elif command == "shutdown":
             self.shutdown()