[svn] commit: r2633 - in /branches/trac289/src/bin/zonemgr: tests/zonemgr_test.py zonemgr.py.in
BIND 10 source code commits
bind10-changes at lists.isc.org
Wed Aug 4 13:07:28 UTC 2010
Author: chenzhengzhang
Date: Wed Aug 4 13:07:28 2010
New Revision: 2633
Log:
refine zonemgr info map and unittest
Modified:
branches/trac289/src/bin/zonemgr/tests/zonemgr_test.py
branches/trac289/src/bin/zonemgr/zonemgr.py.in
Modified: branches/trac289/src/bin/zonemgr/tests/zonemgr_test.py
==============================================================================
--- branches/trac289/src/bin/zonemgr/tests/zonemgr_test.py (original)
+++ branches/trac289/src/bin/zonemgr/tests/zonemgr_test.py Wed Aug 4 13:07:28 2010
@@ -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 tempfile
from zonemgr import *
+ZONE_NAME_CLASS1 = ("sd.cn.", "IN")
+ZONE_NAME_CLASS2 = ("tw.cn", "IN")
class ZonemgrTestException(Exception):
pass
@@ -32,28 +34,29 @@
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 @@
max = 3600
jitter = 900
time1 = time.time()
- self.zoneinfo._set_zone_timer(0, 3600, 900)
- time2 = time.time()
- zone_timeout = float(self.zoneinfo._zones_refresh_info[0]["next_refresh_time"])
+ self.zoneinfo._set_zone_timer(ZONE_NAME_CLASS1, 3600, 900)
+ time2 = time.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 @@
'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 @@
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 @@
'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.")
- 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)
+ self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"] = ZONE_REFRESHING
+ self.zoneinfo.zone_refresh_success(ZONE_NAME_CLASS1)
+ time2 = time.time()
+ 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.")
- 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"])
+ self.zoneinfo._zonemgr_refresh_info[ZONE_NAME_CLASS1]["zone_state"] = ZONE_REFRESHING
+ self.zoneinfo.zone_refresh_fail(ZONE_NAME_CLASS1)
+ time2 = time.time()
+ 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)
- 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)
- 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())
+ 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()
+ 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()
+ 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 @@
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 @@
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 @@
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
Modified: branches/trac289/src/bin/zonemgr/zonemgr.py.in
==============================================================================
--- branches/trac289/src/bin/zonemgr/zonemgr.py.in (original)
+++ branches/trac289/src/bin/zonemgr/zonemgr.py.in Wed Aug 4 13:07:28 2010
@@ -60,7 +60,7 @@
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 @@
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 @@
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)
-
- def _set_zone_retry_timer(self, zone_index):
+ self._set_zone_timer(zone_name_class, zone_refresh_time, (1 * zone_refresh_time) / 4)
+
+ 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)
-
- def _set_zone_notify_timer(self, zone_index):
+ self._set_zone_timer(zone_name_class, zone_retry_time, (1 * zone_retry_time) / 4)
+
+ 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)
-
- def zone_refresh_success(self, zone_name):
+ self._set_zone_timer(zone_name_class, 0, 0)
+
+ 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())
-
- def zone_refresh_fail(self, zone_name):
+ 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_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)
-
- def zone_handle_notify(self, zone_name, master, port):
+ self._set_zone_state(zone_name_class, ZONE_OK)
+ self._set_zone_retry_timer(zone_name_class)
+
+ 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
-
- 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
+ self._zonemgr_refresh_info[(zone_name, zone_class)] = zone_info
+
+ 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 _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 _get_zone_last_refresh_time(self, zone_index):
- return self._zones_refresh_info[zone_index]["last_refresh_time"]
-
- def _set_zone_last_refresh_time(self, zone_index, time):
- self._zones_refresh_info[zone_index]["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_soa_rdata(self, zone_name_class):
+ return self._zonemgr_refresh_info[zone_name_class]["zone_soa_rdata"]
+
+ 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_name_class):
+ return self._zonemgr_refresh_info[zone_name_class]["last_refresh_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_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 _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 _get_zone_state(self, zone_index):
- return self._zones_refresh_info[zone_index]["zone_state"]
-
- def _set_zone_state(self, zone_index, zone_state):
- self._zones_refresh_info[zone_index]["zone_state"] = zone_state
-
- def _get_zone_refresh_timeout(self, zone_index):
- return self._zones_refresh_info[zone_index]["refresh_timeout"]
-
- def _set_zone_refresh_timeout(self, zone_index, time):
- self._zones_refresh_info[zone_index]["refresh_timeout"] = time
-
- def _get_zone_next_refresh_time(self, zone_index):
- return self._zones_refresh_info[zone_index]["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_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_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_name_class):
+ return self._zonemgr_refresh_info[zone_name_class]["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_name_class):
+ return self._zonemgr_refresh_info[zone_name_class]["refresh_timeout"]
+
+ 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_name_class):
+ return self._zonemgr_refresh_info[zone_name_class]["next_refresh_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)
-
- zone_state = self._get_zone_state(i)
+ 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(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
-
- return minimum_index
+ # 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 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 @@
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 @@
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 @@
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 @@
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 @@
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()
More information about the bind10-changes
mailing list